0022898: IGES import fails in german environment
[occt.git] / src / DNaming / DNaming_ModelingCommands.cxx
1 // Created on: 2010-01-15
2 // Created by: Sergey ZARITCHNY
3 // Copyright (c) 2010-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20 #include <Draw.hxx>
21 #include <Draw_Interpretor.hxx>
22 #include <Standard_ErrorHandler.hxx>
23 #include <DNaming.hxx>
24 #include <DBRep.hxx>
25
26 #include <BRepTools.hxx>
27 #include <BRep_Builder.hxx>
28 #include <gp_Trsf.hxx>
29 #include <TopAbs.hxx>
30 #include <TopoDS.hxx>
31 #include <TopoDS_Shape.hxx>
32 #include <TopoDS_Iterator.hxx>
33 #include <TopExp_Explorer.hxx>
34 #include <TopTools_MapOfShape.hxx>
35 #include <TopTools_MapIteratorOfMapOfShape.hxx>
36 #include <TopTools_MapOfOrientedShape.hxx>
37 #include <TopTools_DataMapOfOrientedShapeShape.hxx>
38 #include <TopTools_ListOfShape.hxx>
39 #include <TopTools_ListIteratorOfListOfShape.hxx>
40 #include <TCollection_AsciiString.hxx>
41 #include <Standard_GUID.hxx>
42
43 #include <DDF.hxx>
44 #include <DDocStd.hxx>
45 #include <TDF_TagSource.hxx>
46 #include <TDF_Tool.hxx>
47 #include <TDF_Reference.hxx>
48 #include <TDF_ChildIterator.hxx>
49 #include <TDF_ChildIDIterator.hxx>
50 #include <TDF_MapIteratorOfLabelMap.hxx>
51 #include <TDataStd_Real.hxx>
52 #include <TDataStd_Integer.hxx>
53 #include <TDataStd_TreeNode.hxx>
54 #include <TDataStd_Name.hxx>
55 #include <TDataStd_UAttribute.hxx>
56 #include <TFunction_Function.hxx>
57 #include <TFunction_Logbook.hxx>
58 #include <TFunction_Driver.hxx>
59 #include <TFunction_DriverTable.hxx>
60 #include <TNaming_NamedShape.hxx>
61 #include <TNaming_Selector.hxx>
62 #include <TNaming_Builder.hxx>
63 #include <TNaming_Naming.hxx>
64 #include <TNaming_Name.hxx>
65 #include <TDocStd_Document.hxx>
66
67 #include <DNaming_BoxDriver.hxx>
68 #include <DNaming_CylinderDriver.hxx>
69 #include <DNaming_SelectionDriver.hxx>
70 #include <DNaming_BooleanOperationDriver.hxx>
71 #include <DNaming_FilletDriver.hxx>
72 #include <DNaming_TransformationDriver.hxx>
73 #include <DNaming_PrismDriver.hxx>
74 #include <DNaming_RevolutionDriver.hxx>
75 #include <DNaming_SphereDriver.hxx>
76 #include <DNaming_PointDriver.hxx>
77 #include <DNaming_Line3DDriver.hxx>
78 #ifdef WNT
79 #define EXCEPTION ...
80 #else
81 #define EXCEPTION Standard_Failure
82 #endif          
83 #include <ModelDefinitions.hxx>
84 //#define DEBUG
85 //=======================================================================
86 static Handle(TDataStd_UAttribute) AddObject(const Handle(TDocStd_Document)& aDoc)
87 {
88   Handle(TDataStd_TreeNode) aRootNode =  TDataStd_TreeNode::Set(aDoc->Main());
89   const TDF_Label& aLabel = TDF_TagSource::NewChild(aDoc->Main());
90
91   Handle(TDataStd_UAttribute) anObj = TDataStd_UAttribute::Set(aLabel,GEOMOBJECT_GUID);
92   Handle(TDataStd_TreeNode) aNode = TDataStd_TreeNode::Set(aLabel);
93   aRootNode->Append(aNode);
94   return anObj;
95 }
96 //=======================================================================
97 //function : DNaming_AddObject
98 //purpose  : AddObject D [Name]
99 //           - adds new object (UAttribute) under main label
100 //=======================================================================
101 static Standard_Integer  DNaming_AddObject(Draw_Interpretor& di,
102                                               Standard_Integer nb, 
103                                               const char** a)
104 {
105   if(nb > 1) {
106     Handle(TDocStd_Document) aDoc;  
107     if (!DDocStd::GetDocument(a[1],aDoc)) return 1; 
108     Handle(TDataStd_UAttribute) anObj = AddObject (aDoc);
109     if(!anObj.IsNull()) {
110       if(nb == 3) 
111         TDataStd_Name::Set(anObj->Label(), a[2]);    
112       DDF::ReturnLabel(di, anObj->Label());
113       return 0;
114     }
115   }
116   di << "DNaming_AddObject: Error" << "\n";
117   return 1;
118 }
119
120 #include <NCollection_DataMap.hxx>
121 typedef NCollection_DataMap <TCollection_AsciiString, 
122   Standard_GUID> DataMapOfAStringGUID;
123   static Standard_Boolean isBuilt(Standard_False);
124   static DataMapOfAStringGUID aDMap;
125 //=======================================================================
126 static Standard_Boolean GetFuncGUID(Standard_CString aKey,Standard_GUID& GUID)
127 {
128   Standard_Boolean aRes(Standard_False);
129   
130   if(!isBuilt) {
131     aDMap.Bind("PntXYZ", PNTXYZ_GUID);
132     aDMap.Bind("PntRLT", PNTRLT_GUID);
133     aDMap.Bind("Line3D", LINE3D_GUID);
134     aDMap.Bind("Box",   BOX_GUID);//+
135     aDMap.Bind("Sph",   SPH_GUID);//+
136     aDMap.Bind("Cyl",   CYL_GUID);//+
137     aDMap.Bind("Cut",   CUT_GUID);//+
138     aDMap.Bind("Fuse",  FUSE_GUID);//+
139     aDMap.Bind("Comm",  COMMON_GUID);//+
140     aDMap.Bind("Prism", PRISM_GUID);//+
141     aDMap.Bind("FulRevol", FULREVOL_GUID);//+
142     aDMap.Bind("SecRevol", SECREVOL_GUID);//+
143     aDMap.Bind("PMirr", PMIRR_GUID);//+
144     aDMap.Bind("PTxyz", PTXYZ_GUID);//+
145     aDMap.Bind("PTALine", PTALINE_GUID);//+
146     aDMap.Bind("PRLine", PRRLINE_GUID);//+
147     aDMap.Bind("Fillet",FILLT_GUID);//+
148     aDMap.Bind("Attach",ATTCH_GUID);//+
149     aDMap.Bind("XAttach",XTTCH_GUID);//+
150     isBuilt = Standard_True;
151   }
152
153   if(aDMap.IsBound(aKey)) {
154     GUID = aDMap.Find(aKey);
155     aRes = Standard_True;
156   }
157   return aRes;
158 }
159 //=======================================================================
160 static Handle(TFunction_Driver) GetDriver(const TCollection_AsciiString& name)
161 {
162   Handle(TFunction_Driver) aDrv;
163   if(name == "Box") 
164     aDrv = new DNaming_BoxDriver();
165   else if(name == "Cyl") 
166     aDrv = new DNaming_CylinderDriver();
167   else if(name == "Sph") 
168     aDrv = new DNaming_SphereDriver();
169   else if(name == "Cut") 
170     aDrv = new DNaming_BooleanOperationDriver();
171   else if(name == "Fuse") 
172     aDrv = new DNaming_BooleanOperationDriver();
173   else if(name == "Comm") 
174     aDrv = new DNaming_BooleanOperationDriver();
175   else if(name == "Prism") 
176     aDrv = new DNaming_PrismDriver();
177   else if(name == "FulRevol") 
178     aDrv = new DNaming_RevolutionDriver();
179   else if(name == "SecRevol") 
180     aDrv = new DNaming_RevolutionDriver();
181   else if(name == "PTxyz") 
182     aDrv = new DNaming_TransformationDriver();
183   else if(name == "PTALine") 
184     aDrv = new DNaming_TransformationDriver();
185   else if(name == "PRLine") 
186     aDrv = new DNaming_TransformationDriver();
187   else if(name == "PMirr") 
188     aDrv = new DNaming_TransformationDriver();
189   else if(name == "Fillet") 
190     aDrv = new DNaming_FilletDriver();
191   else if(name == "Attach") 
192     aDrv = new DNaming_SelectionDriver();
193   else if(name == "XAttach") 
194     aDrv = new DNaming_SelectionDriver();
195   else if(name == "PntXYZ") 
196     aDrv = new DNaming_PointDriver();
197   else if(name == "PntRLT") 
198     aDrv = new DNaming_PointDriver();
199 else if(name == "Line3D") 
200     aDrv = new DNaming_Line3DDriver();
201   else 
202     cout << "the specified driver is not supported" <<endl;
203   return aDrv;
204 }
205 //=======================================================================
206 //function : DNaming_AddDriver
207 //purpose  : "AddDriver Doc Name1 Name2 ..."
208 //=======================================================================
209 static Standard_Integer DNaming_AddDriver (Draw_Interpretor& theDI,
210                                         Standard_Integer theNb, 
211                                         const char** theArg)
212 {
213   if (theNb >= 3) {
214     Handle(TDocStd_Document) aDoc;   
215     Standard_CString aDocS(theArg[1]);
216     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
217     Handle(TFunction_DriverTable) aFunctionDrvTable = TFunction_DriverTable::Get();
218     for(int i = 2; i < theNb; i++) {
219       Standard_GUID drvGUID;
220       if(!GetFuncGUID(theArg[i],drvGUID)) continue;      
221       aFunctionDrvTable->AddDriver(drvGUID, GetDriver(theArg[i]));
222 #ifdef DEBUG
223       cout << "DNaming_AddDriver : " << theArg[i] << " driver is added" <<endl;
224 #endif
225     }
226     return 0;
227   }
228   cout << "DNaming_AddDriver : Error" << endl;
229   return 1;  
230 }
231
232 //=======================================================================
233 static Handle(TFunction_Function) SetFunctionDS(const TDF_Label& objLabel, 
234                                              const Standard_GUID& funGUID)
235 {
236   //set function
237   const TDF_Label& aLabel = TDF_TagSource::NewChild(objLabel);
238   Handle(TFunction_Function) aFun = TFunction_Function::Set(aLabel,funGUID);
239
240   Handle(TDataStd_TreeNode) aNode =  TDataStd_TreeNode::Set(aLabel);
241   Handle(TDataStd_TreeNode) objNode;
242   objLabel.FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), objNode);
243   if(!objNode.IsNull()) 
244     objNode->Append(aNode);
245   
246   //set function data sub-structure
247   const TDF_Label& aLab1 = TDF_TagSource::NewChild(aLabel);
248   Handle(TDataStd_TreeNode) aNode1 =  TDataStd_TreeNode::Set(aLab1);
249   TDataStd_Name::Set(aLab1, "Arguments");
250   if(!aNode.IsNull()) 
251     aNode->Append(aNode1);
252   
253   const TDF_Label& aLab2 = TDF_TagSource::NewChild(aLabel);
254   Handle(TDataStd_TreeNode) aNode2 =  TDataStd_TreeNode::Set(aLab2);
255   TDataStd_Name::Set(aLab2, "Result");
256   if(!aNode.IsNull()) 
257     aNode->Append(aNode2);
258   return aFun;
259 }
260 //=======================================================================
261 //function : DNaming_AddFunction
262 //purpose  : AddFunction D ObjEntry FunNane 
263 //         :  - adds new function specified by FunName to an object
264 //         :  specified by ObjEntry 
265 //=======================================================================
266 static Standard_Integer  DNaming_AddFunction(Draw_Interpretor& di,
267                                               Standard_Integer nb, 
268                                               const char** a)
269 {
270   if(nb == 4) {
271     Handle(TDocStd_Document) aDoc;  
272     if (!DDocStd::GetDocument(a[1],aDoc)) return 1; 
273     TDF_Label objLabel;
274     if (!DDF::FindLabel(aDoc->GetData(),a[2], objLabel)) return 1;
275
276     Handle(TDataStd_UAttribute) anObj;
277     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) {
278       di << "DNaming_AddFunction: Object is not found at the specified label: "<< a[2] << "\n";
279       return 1;
280     }
281     Standard_GUID funGUID;
282     if(!GetFuncGUID(a[3],funGUID)) {
283       di << "DNaming_AddFunction: the specified function is not supported: "<< a[3] << "\n";
284       return 1;
285     }
286     Handle(TFunction_Function) aFun = SetFunctionDS(objLabel, funGUID);
287     if(!aFun.IsNull()) {
288       TCollection_AsciiString aFName = TCollection_AsciiString(a[3]) + "_Function";
289       TDataStd_Name::Set(aFun->Label(), aFName);
290       TDF_Reference::Set(objLabel, aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here
291       DDF::ReturnLabel(di, aFun->Label());
292       return 0;
293     }
294   }
295   di << "DNaming_AddObject: Error" << "\n";
296   return 1;
297 }
298
299
300 //=======================================================================
301 //function : DNaming_AddBox
302 //purpose  : "AddBox Doc dx dy dz"
303 //=======================================================================
304 static Standard_Integer DNaming_AddBox (Draw_Interpretor& theDI,
305                                          Standard_Integer theNb, 
306                                          const char** theArg)
307 {
308   if (theNb >= 4) {
309
310     Handle(TDocStd_Document) aDocument;
311     Standard_CString aDocS(theArg[1]);
312     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
313     Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
314     if(anObj.IsNull()) return 1;
315     Standard_GUID funGUID;
316     if(!GetFuncGUID("Box",funGUID)) return 1;
317
318     Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
319     if(aFun.IsNull()) return 1;
320     TDataStd_Name::Set(aFun->Label(), "Box_Function");
321     
322     TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
323     Standard_Real dx,dy,dz;
324     dx = Draw::Atof(theArg[2]);
325     dy = Draw::Atof(theArg[3]);
326     dz = Draw::Atof(theArg[4]);
327
328     DNaming::GetReal(aFun,BOX_DX)->Set(dx);
329     DNaming::GetReal(aFun,BOX_DY)->Set(dy);
330     DNaming::GetReal(aFun,BOX_DZ)->Set(dz);
331     
332     DDF::ReturnLabel(theDI, anObj->Label());
333     return 0;
334   }
335   cout << "DNaming_AddBox : Error" << endl;
336   return 1;  
337 }
338
339 //=======================================================================
340 static Handle(TFunction_Function) GetFunction(const TDF_Label& objLabel, const Standard_GUID& funGUID) {
341   Handle(TFunction_Function) aFun;
342   Handle(TDataStd_TreeNode) aNode;
343   objLabel.FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), aNode);
344   if(aNode.IsNull()) return aFun;
345   if(!aNode->HasFirst()) return aFun;
346   else 
347     aNode = aNode->First();
348   while(!aNode.IsNull()) {      
349     if(aNode->FindAttribute(TFunction_Function::GetID(), aFun)) {
350       const Standard_GUID& aGUID = aFun->GetDriverGUID();
351       if(aGUID == funGUID) break;
352       else aFun.Nullify();
353     }
354     aNode = aNode->Next();
355   }
356   return aFun; 
357 }
358 //=======================================================================
359 //function : DNaming_BoxDX
360 //purpose  : "BoxDX Doc BoxLabel NewDX"
361 //=======================================================================
362
363 static Standard_Integer DNaming_BoxDX (Draw_Interpretor& theDI,
364                                         Standard_Integer theNb, 
365                                         const char** theArg)
366 {
367   if (theNb == 4) {
368     Handle(TDocStd_Document) aDoc;   
369     Standard_CString aDocS(theArg[1]);
370     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
371     TDF_Label objLabel;
372     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
373
374     Handle(TDataStd_UAttribute) anObj;
375     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
376     Standard_GUID funGUID;
377     if(!GetFuncGUID("Box",funGUID)) return 1;       
378
379     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
380     if(!aFun.IsNull()) {
381       Standard_Real value = Draw::Atof(theArg[3]);
382       DNaming::GetReal(aFun,BOX_DX)->Set(value);
383       DDF::ReturnLabel(theDI, DNaming::GetReal(aFun,BOX_DX)->Label());
384       return 0;
385     }
386   }
387   cout << "DNaming_BoxDX : Error" << endl;
388   return 1;  
389 }
390
391 //=======================================================================
392 //function : DNaming_BoxDY
393 //purpose  : "BoxDY Doc BoxLabel NewDY"
394 //=======================================================================
395
396 static Standard_Integer DNaming_BoxDY (Draw_Interpretor& theDI,
397                                         Standard_Integer theNb, 
398                                         const char** theArg)
399 {
400   if (theNb == 4) {
401     Handle(TDocStd_Document) aDoc;   
402     Standard_CString aDocS(theArg[1]);
403     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
404     TDF_Label objLabel;
405     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
406     
407     Handle(TDataStd_UAttribute) anObj;
408     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
409     Standard_GUID funGUID;
410     if(!GetFuncGUID("Box",funGUID)) return 1;       
411     
412     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
413     if(!aFun.IsNull()) {
414       Standard_Real value = Draw::Atof(theArg[3]);
415       DNaming::GetReal(aFun,BOX_DY)->Set(value);
416       DDF::ReturnLabel(theDI, DNaming::GetReal(aFun,BOX_DY)->Label());
417       return 0;
418     }
419   }
420   cout << "DNaming_BoxDY : Error" << endl;
421   return 1;  
422 }
423
424 //=======================================================================
425 //function : DNaming_BoxDZ
426 //purpose  : "BoxDZ Doc BoxLabel NewDZ"
427 //=======================================================================
428
429 static Standard_Integer DNaming_BoxDZ (Draw_Interpretor& theDI,
430                                         Standard_Integer theNb, 
431                                         const char** theArg)
432 {
433   if (theNb == 4) {
434     Handle(TDocStd_Document) aDoc;   
435     Standard_CString aDocS(theArg[1]);
436     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
437     TDF_Label objLabel;
438     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
439     
440     Handle(TDataStd_UAttribute) anObj;
441     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
442     Standard_GUID funGUID;
443     if(!GetFuncGUID("Box",funGUID)) return 1;       
444     
445     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
446     if(!aFun.IsNull()) {
447       Standard_Real value = Draw::Atof(theArg[3]);
448       DNaming::GetReal(aFun,BOX_DZ)->Set(value);
449       DDF::ReturnLabel(theDI, DNaming::GetReal(aFun,BOX_DZ)->Label());
450       return 0;
451     }
452   }
453   cout << "DNaming_BoxDZ : Error" << endl;
454   return 1;  
455 }
456
457 //=======================================================================
458 static TFunction_Logbook& GetLogBook ()
459 {
460   static TFunction_Logbook myLog;
461   return myLog;
462 }
463 //=======================================================================
464 //function : Compute
465 //purpose  : Performs the calling to a driver with the given Function ID.
466 //=======================================================================
467 static Standard_Integer ComputeFunction(const Handle(TFunction_Function)& theFun, 
468                                         TFunction_Logbook& theLog)
469 {
470   Handle(TFunction_DriverTable) aTable = TFunction_DriverTable::Get();
471   Handle(TFunction_Driver) aDriver;
472   Standard_Integer aRes(-1);
473   if (aTable->FindDriver(theFun->GetDriverGUID(),aDriver))
474       {
475         aDriver->Init(theFun->Label());
476         aRes = aDriver->Execute(theLog);
477       }
478   else
479     aRes = 1;
480   return aRes;
481 }
482
483
484 //=======================================================================
485 //function : DNaming_SolveFlatFrom
486 //purpose  : Performs sequential recomputation of all Aux Object starting from the specified.
487 //         : "SolveFlatFrom Doc FistAuxObjLabel"
488 //=======================================================================
489
490 static Standard_Integer DNaming_SolveFlatFrom (Draw_Interpretor& theDI,
491                                         Standard_Integer theNb, 
492                                         const char** theArg)
493 {
494   if (theNb == 3) {
495     Handle(TDocStd_Document) aDoc;   
496     Standard_CString aDocS(theArg[1]);
497     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
498     TDF_Label ObjLabel;
499     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], ObjLabel)) return 1;
500     const TDF_Label& FatherLab = ObjLabel.Father();
501     if(FatherLab.IsNull())
502       goto ERR;
503     TCollection_AsciiString entry;   
504     TDF_Tool::Entry(FatherLab, entry);
505 #ifdef DEBUG
506     cout << "DNaming_SolveFlatFrom: Father label = " << entry << endl;
507 #endif
508     Standard_Boolean found(Standard_False);
509     TDF_ChildIterator it(FatherLab, Standard_False);  
510     for(;it.More(); it.Next()) {
511       const TDF_Label& aLabel = it.Value();
512       if(!found) {
513         if(aLabel == ObjLabel) {
514           found = Standard_True;        
515         } else 
516           continue;
517       }
518       const TDF_Label& funLabel = aLabel.FindChild(FUNCTION_ARGUMENTS_LABEL, Standard_True);
519       Handle(TFunction_Function) aFun;
520       funLabel.FindAttribute(TFunction_Function::GetID(), aFun);
521       if(aFun.IsNull()) {
522         cout << "DNaming_SolveFlatFrom:: Null function is found!" << endl;
523         continue;
524       } 
525       else {
526         TDF_Tool::Entry(funLabel, entry);
527         try {
528           Standard_Integer aRes = ComputeFunction(aFun, GetLogBook());
529           if(aRes != 0) {
530             cout << "DNaming_SolveFlatFrom: Driver failed at label = " << entry << endl;
531             return 1;
532           }
533 #ifdef DEBUG
534           cout <<"DNaming_SolveFlatFrom : function from label " << entry << " is recomputed" << endl;
535 #endif
536         } catch (EXCEPTION) {
537           cout <<"DNaming_SolveFlatFrom : Exception computing function at label " << entry << endl;
538         }
539       }
540     }
541     return 0;
542   }   
543  ERR:
544   cout << "DNaming_SolveFlatFrom : Error" << endl;
545   return 1;  
546 }
547
548 //=======================================================================
549 //function : DNaming_InitLogBook
550 //purpose  : "InitLogBook Doc "
551 //=======================================================================
552 static Standard_Integer DNaming_InitLogBook (Draw_Interpretor& theDI,
553                                              Standard_Integer theNb, 
554                                              const char** theArg)
555 {
556   if (theNb == 2) {
557     Handle(TDocStd_Document) aDoc;   
558     Standard_CString aDocS(theArg[1]);
559     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;  
560     if(GetLogBook().IsEmpty()) {
561 #ifdef DEBUG
562       cout << "DNaming_InitLogBook : is empty" <<endl;
563 #endif
564     }
565     else {
566       GetLogBook().Clear();
567 #ifdef DEBUG
568       cout << "DNaming_InitLogBook : cleaned" <<endl;
569 #endif
570     }
571     return 0;
572   }
573   cout << "DNaming_InitLogBook : Error - No document ==> " <<theNb <<endl;
574   return 1;  
575 }
576
577 //=======================================================================
578 //function : DNaming_CheckLogBook
579 //purpose  : "CheckLogBook Doc"
580 //=======================================================================
581 static Standard_Integer DNaming_CheckLogBook (Draw_Interpretor& theDI,
582                                              Standard_Integer theNb, 
583                                              const char** theArg)
584 {
585   if (theNb == 2) {
586     Handle(TDocStd_Document) aDoc;   
587     Standard_CString aDocS(theArg[1]);
588     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;  
589     if(GetLogBook().IsEmpty())
590       cout << "DNaming_CheckLogBook : is empty" <<endl;
591     else {
592       TDF_LabelMap aMap;
593       aMap = GetLogBook().GetValid();
594       TDF_MapIteratorOfLabelMap it(aMap);
595       TCollection_AsciiString entry;
596       cout << "DNaming_CheckLogBook : LogBook current state:" <<endl;
597       for (;it.More();it.Next()) {
598         TDF_Tool::Entry(it.Key(), entry);
599         cout << entry <<endl;
600       }
601     }
602     return 0;
603   }
604   cout << "DNaming_CheckLogBook : Error - No document ==> " <<theNb <<endl;
605   return 1;  
606 }
607
608 //=======================================================================
609 //function : DNaming_ComputeFun
610 //purpose  : "ComputeFun Doc FunctionLabel"
611 //=======================================================================
612 static Standard_Integer DNaming_ComputeFun (Draw_Interpretor& theDI,
613                                         Standard_Integer theNb, 
614                                         const char** theArg)
615 {
616   if (theNb == 3) {
617     Handle(TDocStd_Document) aDoc;   
618     Standard_CString aDocS(theArg[1]);
619     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
620     TDF_Label funLabel;
621     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], funLabel)) return 1;
622     
623     Handle(TFunction_Function) aFun;
624     funLabel.FindAttribute(TFunction_Function::GetID(), aFun);
625     if(aFun.IsNull()) return 1;
626     if(!aFun.IsNull()) {
627       Standard_Integer aRes = ComputeFunction(aFun, GetLogBook());
628       if(aRes != 0) {
629          cout << "DNaming_ComputeFun : No Driver or Driver failed" << endl;
630          return 1;
631        }
632 #ifdef DEBUG
633       cout <<"DNaming_ComputeFun : function from label " << theArg[2] << " is recomputed" << endl;
634 #endif
635       return 0;
636     }
637   }
638   cout << "DNaming_ComputeFun : Error" << endl;
639   return 1;  
640 }
641
642 //=======================================================================
643 //function : DNaming_AttachShape
644 //purpose  : "AttachShape Doc Shape Context [Container [KeepOrientation [Geometry]]]"
645 //=======================================================================
646 static Standard_Integer DNaming_AttachShape (Draw_Interpretor& di,
647                                             Standard_Integer nb, 
648                                             const char** a)
649 {
650   if (nb >= 4) {
651     Handle(TDocStd_Document) aDoc;   
652     Standard_CString aDocS(a[1]);
653     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
654     Standard_CString aSS(a[2]);
655     const TopoDS_Shape& aShape = DBRep::Get(aSS); //shape to be attached
656     if(aShape.IsNull()) return 1;
657
658     Handle(TDataStd_UAttribute) aContainer, aContext; 
659     if (!DDocStd::Find(aDoc, a[3], GEOMOBJECT_GUID, aContext)) return 1;
660     if(nb > 4) 
661       DDocStd::Find(aDoc, a[4], GEOMOBJECT_GUID, aContainer);
662
663     if(aContainer.IsNull()) aContainer = aContext;
664
665     Handle(TDataStd_UAttribute) anObj = AddObject (aDoc);
666     if(!anObj.IsNull()) {
667       Handle(TDataStd_TreeNode) aNode,RNode;
668       anObj->Label().FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), aNode);
669       if(aNode.IsNull())
670         aNode = TDataStd_TreeNode::Set(anObj->Label());
671       aNode->Remove();
672       if(aContainer->Label().FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), RNode))
673         RNode->Append(aNode);
674       TDataStd_Name::Set(anObj->Label(), "Auxiliary_Object");
675       Standard_GUID funGUID;
676       if(GetFuncGUID("Attach",funGUID)) {
677         Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
678         if(!aFun.IsNull()) {
679           TDataStd_Name::Set(aFun->Label(), "ISelection");        
680           TDF_Label aResultLabel =  aFun->Label().FindChild(FUNCTION_RESULT_LABEL, Standard_True); 
681           TDF_Reference::Set(anObj->Label(), aResultLabel ); //result of the object
682           aResultLabel.ForgetAllAttributes(Standard_True);
683           Standard_Boolean aKeepOrientation(Standard_False);
684           if (nb >= 6) 
685             aKeepOrientation = (Standard_Boolean) Draw::Atoi(a[5]);
686           Standard_Boolean aGeometry(Standard_False);
687           if (nb == 7) 
688             aGeometry = (Standard_Boolean) Draw::Atoi(a[6]);
689           Handle(TNaming_NamedShape) aCont =  DNaming::GetObjectValue(aContext);
690 #ifdef DEBUG
691           if(aCont.IsNull() || aCont->IsEmpty())
692             cout <<"Wrong Context ..." <<endl;
693 #endif
694           try{
695             TopoDS_Shape aCONTEXT = aCont->Get();       
696             TNaming_Selector aSelector(aResultLabel);
697             if(!aSelector.Select(aShape, aCONTEXT, aGeometry, aKeepOrientation))
698               return 1;
699           }catch (...) {
700             cout << "EXCEPTION: SELECTION_IMPOSSIBLE" <<endl;
701           }
702     
703           if(!aCont.IsNull()) {
704 #ifdef DEBUG
705             TCollection_AsciiString entry;
706             TDF_Tool::Entry(aCont->Label(), entry);
707             cout << "ContextNS Label = " << entry <<endl;
708 #endif
709             Handle(TFunction_Function) aCntFun;
710             if(aCont->Label().Father().FindAttribute(TFunction_Function::GetID(), aCntFun)) { //Fun:2 ==> result
711               // First argument of Selection function refers to father function (of context object) 
712               // to which selection is attached (because sel obj. itself already has refrence to result NS
713               TDF_Reference::Set(aFun->Label().FindChild(FUNCTION_ARGUMENTS_LABEL).FindChild(ATTACH_ARG), 
714                                  aCntFun->Label()); //ref to function produced Context shape
715               
716             }
717           }
718           
719           DDF::ReturnLabel(di, anObj->Label());
720           return 0;
721         }
722       }
723     } //###
724   }
725   cout << "DNaming_AttachShape : Error" << endl;
726   return 1;  
727 }
728
729 //=======================================================================
730 //function : DNaming_XAttachShape
731 //purpose  : "AttachShape Doc Shape Context [KeepOrientation [Geometry]]"
732 //=======================================================================
733 static Standard_Integer DNaming_XAttachShape (Draw_Interpretor& di,
734                                             Standard_Integer nb, 
735                                             const char** a)
736 {
737   if (nb >= 4) {
738     Handle(TDocStd_Document) aDoc;   
739     Standard_CString aDocS(a[1]);
740     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
741     Standard_CString aSS(a[2]);
742     const TopoDS_Shape& aShape = DBRep::Get(aSS);
743     if(aShape.IsNull()) return 1;
744
745     Handle(TDataStd_UAttribute) aContext; 
746     if (!DDocStd::Find(aDoc, a[3], GEOMOBJECT_GUID, aContext)) return 1;
747     
748     Handle(TDataStd_UAttribute) anObj = AddObject (aDoc);
749     if(!anObj.IsNull()) {
750       TDataStd_Name::Set(anObj->Label(), "Auxiliary_Object");
751       Standard_GUID funGUID;
752       if(GetFuncGUID("XAttach",funGUID)) {
753         Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
754         if(!aFun.IsNull()) {
755           TDataStd_Name::Set(aFun->Label(), "XSelection");        
756           TDF_Label aResultLabel =  aFun->Label().FindChild(FUNCTION_RESULT_LABEL, Standard_True); 
757           TDF_Reference::Set(anObj->Label(), aResultLabel ); //result
758           aResultLabel.ForgetAllAttributes(Standard_True);
759           Standard_Boolean aKeepOrientation(Standard_False);
760           if (nb >= 5) 
761             aKeepOrientation = (Standard_Boolean) Draw::Atoi(a[4]);
762           Standard_Boolean aGeometry(Standard_False);
763           if (nb == 6) 
764             aGeometry = (Standard_Boolean) Draw::Atoi(a[5]);
765           Handle(TNaming_NamedShape) aCont =  DNaming::GetObjectValue(aContext);
766
767           if(aCont.IsNull() || aCont->IsEmpty())
768             cout <<"Wrong Context ..." <<endl;
769           else {
770             TopoDS_Shape aCONTEXT = aCont->Get();
771             try{
772               TNaming_Selector aSelector(aResultLabel);
773               if(!aSelector.Select(aShape, aCONTEXT, aGeometry, aKeepOrientation))
774                 return 1;
775             } catch (...) {
776               cout << "EXCEPTION: SELECTION_IMPOSSIBLE" <<endl;
777             }
778     
779             TDF_Reference::Set(aFun->Label().FindChild(FUNCTION_ARGUMENTS_LABEL).FindChild(ATTACH_ARG), 
780                                aContext->Label()); //ref to Context object
781
782             DDF::ReturnLabel(di, anObj->Label());
783             return 0;
784           }       
785         }
786       }
787     }
788   }
789   cout << "DNaming_XAttachShape : Error" << endl;
790   return 1;  
791 }
792
793 //=======================================================================
794 //function : DNaming_AddCyl
795 //purpose  : "AddCyl Doc Radius Height Axis
796 //=======================================================================
797 static Standard_Integer DNaming_AddCylinder (Draw_Interpretor& theDI,
798                                              Standard_Integer theNb, 
799                                              const char** theArg)
800 {
801   if (theNb == 5) {
802
803     Handle(TDocStd_Document) aDocument;
804     Standard_CString aDocS(theArg[1]);
805     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
806     Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
807     if(anObj.IsNull()) return 1;
808     Standard_GUID funGUID;
809     if(!GetFuncGUID("Cyl",funGUID)) return 1;
810
811     Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
812     if(aFun.IsNull()) return 1;
813     TDataStd_Name::Set(aFun->Label(), "Cyl_Function");
814     
815     TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
816
817     Standard_Real aR, aH;
818     aR = Draw::Atof(theArg[2]);
819     aH = Draw::Atof(theArg[3]);
820
821     Handle(TDataStd_UAttribute) Axis; 
822     if (!DDocStd::Find(aDocument, theArg[4], GEOMOBJECT_GUID, Axis)) return 1;
823     DNaming::GetReal(aFun,CYL_RADIUS)->Set(aR);
824     DNaming::GetReal(aFun,CYL_HEIGHT)->Set(aH);
825     DNaming::SetObjectArg(aFun, CYL_AXIS, Axis); 
826     
827     DDF::ReturnLabel(theDI, anObj->Label());
828     return 0;
829   }
830   cout << "DNaming_AddCylinder : Error" << endl;
831   return 1;  
832 }
833
834 //=======================================================================
835 //function : DNaming_CylRad
836 //purpose  : "CylRad Doc CylLabel NewRad"
837 //=======================================================================
838
839 static Standard_Integer DNaming_CylRad (Draw_Interpretor& theDI,
840                                         Standard_Integer theNb, 
841                                         const char** theArg)
842 {
843   if (theNb == 4) {
844     Handle(TDocStd_Document) aDoc;   
845     Standard_CString aDocS(theArg[1]);
846     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
847     TDF_Label objLabel;
848     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
849     
850     Handle(TDataStd_UAttribute) anObj;
851     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
852     Standard_GUID funGUID;
853     if(!GetFuncGUID("Cyl",funGUID)) return 1;       
854     
855     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
856     if(!aFun.IsNull()) {
857       Standard_Real value = Draw::Atof(theArg[3]);
858       DNaming::GetReal(aFun,CYL_RADIUS)->Set(value);
859       DDF::ReturnLabel(theDI, DNaming::GetReal(aFun,CYL_RADIUS)->Label());
860       return 0;
861     }
862   }
863   cout << "DNaming_CylRadius : Error" << endl;
864   return 1;  
865 }
866
867 //=======================================================================
868 //function : DNaming_AddFuse
869 //purpose  : "AddFuse Doc Object Tool"
870 //=======================================================================
871
872  static Standard_Integer DNaming_AddFuse (Draw_Interpretor& theDI,
873                                           Standard_Integer theNb, 
874                                           const char** theArg)
875  {
876    if (theNb == 4) {
877
878     Handle(TDocStd_Document) aDocument;
879     Standard_CString aDocS(theArg[1]);
880     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
881
882     Handle(TDataStd_UAttribute) anObject, aTool;
883     if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, anObject)) return 1;
884     if (!DDocStd::Find(aDocument, theArg[3], GEOMOBJECT_GUID, aTool)) return 1;
885     Standard_GUID funGUID;
886     if(!GetFuncGUID("Fuse",funGUID)) return 1;
887     Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
888     if(aFun.IsNull()) return 1;
889     TDataStd_Name::Set(aFun->Label(), "Fuse");
890     
891     TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
892     DNaming::SetObjectArg(aFun, BOOL_TOOL, aTool); 
893     DDF::ReturnLabel(theDI, aFun->Label());
894     return 0;
895   }
896    cout << "DModel_AddFuse : Error" << endl;
897    return 1;  
898  }
899
900
901 //=======================================================================
902 //function : DNaming_AddCut
903 //purpose  : "AddCut Doc Object Tool"
904 //=======================================================================
905
906  static Standard_Integer DNaming_AddCut (Draw_Interpretor& theDI,
907                                           Standard_Integer theNb, 
908                                           const char** theArg)
909  {
910    if (theNb == 4) {
911
912     Handle(TDocStd_Document) aDocument;   
913     Standard_CString aDocS(theArg[1]);
914     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
915
916     Handle(TDataStd_UAttribute) anObject, aTool;
917     if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, anObject)) return 1;
918     if (!DDocStd::Find(aDocument, theArg[3], GEOMOBJECT_GUID, aTool)) return 1;
919     Standard_GUID funGUID;
920     if(!GetFuncGUID("Cut",funGUID)) return 1;
921     Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
922     if(aFun.IsNull()) return 1;
923     TDataStd_Name::Set(aFun->Label(), "Cut");
924     
925     TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
926     DNaming::SetObjectArg(aFun, BOOL_TOOL, aTool); 
927     DDF::ReturnLabel(theDI, aFun->Label());
928     return 0;
929   }
930    cout << "DModel_AddCut : Error" << endl;
931    return 1;  
932  }
933
934 //=======================================================================
935 //function : DNaming_AddCommon
936 //purpose  : "AddCommon Doc Object Tool"
937 //=======================================================================
938
939  static Standard_Integer DNaming_AddCommon (Draw_Interpretor& theDI,
940                                           Standard_Integer theNb, 
941                                           const char** theArg)
942  {
943    if (theNb == 4) {
944
945     Handle(TDocStd_Document) aDocument;   
946     Standard_CString aDocS(theArg[1]);
947     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
948
949     Handle(TDataStd_UAttribute) anObject, aTool;
950     if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, anObject)) return 1;
951     if (!DDocStd::Find(aDocument, theArg[3], GEOMOBJECT_GUID, aTool)) return 1;
952     Standard_GUID funGUID;
953     if(!GetFuncGUID("Comm",funGUID)) return 1;
954     Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
955     if(aFun.IsNull()) return 1;
956     TDataStd_Name::Set(aFun->Label(), "Common");
957     
958     TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
959     DNaming::SetObjectArg(aFun, BOOL_TOOL, aTool); 
960     DDF::ReturnLabel(theDI, aFun->Label());
961     return 0;
962   }
963    cout << "DModel_AddComm : Error" << endl;
964    return 1;  
965  }
966
967 //=======================================================================
968 //function : DNaming_AddFillet
969 //purpose  : "AddFillet Doc Object Radius Path "
970 //=======================================================================
971 static Standard_Integer DNaming_AddFillet (Draw_Interpretor& theDI,
972                                            Standard_Integer theNb, 
973                                            const char** theArg)
974 {
975   if (theNb < 5) {
976     cout<<"DNaming_AddFillet(): Wrong number of arguments"<<endl;
977     return 1;
978   }
979
980   Handle(TDocStd_Document) aDocument;   
981   Standard_CString aDocS(theArg[1]);
982   if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
983
984   Handle(TDataStd_UAttribute) anObject;
985   if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, anObject)) return 1;
986   Standard_GUID funGUID;
987   if(!GetFuncGUID("Fillet",funGUID)) return 1;
988   Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
989   if(aFun.IsNull()) return 1;
990   TDataStd_Name::Set(aFun->Label(), "Fillet");
991
992   TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
993
994   Standard_Real aRadius = Draw::Atof(theArg[3]);
995   DNaming::GetReal(aFun,FILLET_RADIUS)->Set(aRadius);  
996
997   Handle(TDataStd_UAttribute) aPath;
998   if (!DDocStd::Find(aDocument, theArg[4], GEOMOBJECT_GUID, aPath)) return 1;
999   DNaming::SetObjectArg(aFun, FILLET_PATH, aPath); 
1000   DDF::ReturnLabel(theDI, aFun->Label());
1001   return 0;
1002 }
1003
1004 //=======================================================================
1005 //function : DNaming_TranslatePar
1006 //purpose  : "TranslatePar Doc ShapeEntry dx dy dz"
1007 //=======================================================================
1008 static Standard_Integer DNaming_PTranslateDXYZ (Draw_Interpretor& di,
1009                                                 Standard_Integer nb, 
1010                                                 const char** a)
1011 {
1012   if (nb > 3) {
1013 #ifdef DEBUG
1014     cout << "NB = " << nb <<endl;
1015 #endif
1016     Handle(TDocStd_Document) aDocument;   
1017     Standard_CString aDocS(a[1]);
1018     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1; 
1019     
1020     Handle(TDataStd_UAttribute) anObject;// aShape;
1021     if (!DDocStd::Find(aDocument, a[2], GEOMOBJECT_GUID, anObject)) return 1;
1022
1023     Standard_GUID funGUID;
1024     if(!GetFuncGUID("PTxyz",funGUID)) return 1;
1025     Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
1026     if(aFun.IsNull()) return 1;
1027     TDataStd_Name::Set(aFun->Label(), "ParTranslation");
1028     
1029     Standard_Real aDx=0., aDy=0., aDz=0.;
1030     aDx = Draw::Atof(a[3]);
1031     //cout << "DX = " << aDx<<endl;
1032     if(nb > 4) {
1033       aDy = Draw::Atof(a[4]);
1034       //cout << "DY = " << aDy<<endl;
1035       if(nb > 5) {
1036         aDz = Draw::Atof(a[5]);
1037         //cout << "DZ = " << aDz<<endl;
1038       }
1039     }
1040
1041     DNaming::GetReal(aFun,PTRANSF_DX)->Set(aDx);  
1042     DNaming::GetReal(aFun,PTRANSF_DY)->Set(aDy);  
1043     DNaming::GetReal(aFun,PTRANSF_DZ)->Set(aDz);  
1044     TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL));
1045     DDF::ReturnLabel(di, aFun->Label());
1046     return 0;
1047   }
1048   cout << "DNaming_Translate : Error" << endl;
1049   return 1;  
1050 }
1051 //=======================================================================
1052 //function : DNaming_PTranslateLine
1053 //purpose  : "PTranslateAlongLine Doc ShapeEntry Line off"
1054 //=======================================================================
1055 static Standard_Integer DNaming_PTranslateLine (Draw_Interpretor& di,
1056                                                 Standard_Integer nb, 
1057                                                 const char** a)
1058 {
1059   if (nb > 4) {
1060 #ifdef DEBUG
1061     cout << "NB = " << nb <<endl;
1062 #endif
1063     Handle(TDocStd_Document) aDocument;   
1064     Standard_CString aDocS(a[1]);
1065     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
1066  
1067     Handle(TDataStd_UAttribute) anObject, aLine;// aShape, aLine;
1068     if (!DDocStd::Find(aDocument, a[2], GEOMOBJECT_GUID, anObject)) return 1;
1069     if (!DDocStd::Find(aDocument, a[3], GEOMOBJECT_GUID, aLine)) return 1;
1070
1071     Standard_GUID funGUID;
1072     if(!GetFuncGUID("PTALine",funGUID)) return 1;
1073     Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
1074     if(aFun.IsNull()) return 1;
1075     TDataStd_Name::Set(aFun->Label(), "ParTranslationAlongLine");
1076         
1077     Standard_Real anOff = 0.;
1078     anOff =  Draw::Atof(a[4]);
1079     DNaming::GetReal(aFun,PTRANSF_OFF)->Set(anOff);
1080   
1081     DNaming::SetObjectArg(aFun, PTRANSF_LINE, aLine); 
1082     TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL));
1083
1084     DDF::ReturnLabel(di, aFun->Label());
1085     return 0;
1086   }
1087   cout << "DNaming_PTranslateAlongLine : Error" << endl;
1088   return 1;  
1089 }
1090
1091 //=======================================================================
1092 //function : DNaming_PRotateLine
1093 //purpose  : "PRotateRoundLine Doc ShapeEntry Line Angle"
1094 //=======================================================================
1095 static Standard_Integer DNaming_PRotateLine(Draw_Interpretor& di,
1096                                              Standard_Integer nb, 
1097                                              const char** a)
1098 {
1099   if (nb > 4) {
1100     Handle(TDocStd_Document) aDocument;
1101     Standard_CString aDocS(a[1]);
1102     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1; 
1103
1104     Handle(TDataStd_UAttribute) anObject, aLine;// aShape, aLine;
1105     if (!DDocStd::Find(aDocument, a[2], GEOMOBJECT_GUID, anObject)) return 1;
1106     if (!DDocStd::Find(aDocument, a[3], GEOMOBJECT_GUID, aLine)) return 1;
1107
1108     Standard_GUID funGUID;
1109     if(!GetFuncGUID("PRLine",funGUID)) return 1;
1110     Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
1111     if(aFun.IsNull()) return 1;
1112     TDataStd_Name::Set(aFun->Label(), "ParRotationAroundLine");
1113         
1114     DNaming::SetObjectArg(aFun, PTRANSF_LINE, aLine); 
1115     TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL));
1116
1117     Standard_Real anAngle = 0.;
1118     anAngle =  Draw::Atof(a[4]);
1119     Standard_Real aK = 2*M_PI/360;
1120     anAngle = anAngle * aK;
1121     DNaming::GetReal(aFun,PTRANSF_ANG)->Set(anAngle);
1122
1123     DDF::ReturnLabel(di, aFun->Label());
1124     return 0;    
1125   }
1126   cout << "DNaming_PRotateRoundLine : Error" << endl;
1127   return 1;  
1128 }
1129
1130 //=======================================================================
1131 //function : DNaming_PMirrorObject
1132 //purpose  : "PMirror Doc ShapeEntry PlaneObj"
1133 //=======================================================================
1134 static Standard_Integer DNaming_PMirrorObject(Draw_Interpretor& di,
1135                                               Standard_Integer nb, 
1136                                               const char** a)
1137 {
1138   if (nb > 3) {
1139     Handle(TDocStd_Document) aDocument;   
1140     Standard_CString aDocS(a[1]);
1141     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1; 
1142     
1143     Handle(TDataStd_UAttribute) anObject, aPlane;
1144     if (!DDocStd::Find(aDocument, a[2], GEOMOBJECT_GUID, anObject)) return 1;
1145     if (!DDocStd::Find(aDocument, a[3], GEOMOBJECT_GUID, aPlane)) return 1;
1146
1147     Standard_GUID funGUID;
1148     if(!GetFuncGUID("PMirr",funGUID)) return 1;
1149     Handle(TFunction_Function) aFun = SetFunctionDS(anObject->Label(), funGUID);
1150     if(aFun.IsNull()) return 1;
1151     TDataStd_Name::Set(aFun->Label(), "ParMirror");
1152            
1153     DNaming::SetObjectArg(aFun, PTRANSF_PLANE, aPlane); 
1154     TDF_Reference::Set(anObject->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL));
1155     
1156     DDF::ReturnLabel(di, aFun->Label());
1157     return 0;
1158   }
1159   cout << "DNaming_PMirrorObject : Error" << endl;
1160   return 1;  
1161 }
1162 //=======================================================================
1163 //function : DModel_AddPrism
1164 //purpose  : "AddPrism Doc BasisLabel Height Reverse(0/1)"
1165 //=======================================================================
1166 static Standard_Integer DNaming_AddPrism (Draw_Interpretor& theDI,
1167                                          Standard_Integer theNb, 
1168                                          const char** theArg)
1169 {
1170   if (theNb < 5 ) {
1171     cout<<"DNaming_AddPrism(): Wrong number of arguments"<<endl;
1172     return 1;
1173   }
1174 //
1175   Handle(TDocStd_Document) aDocument;   
1176   Standard_CString aDocS(theArg[1]);
1177   if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
1178  
1179   Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
1180   if(anObj.IsNull()) return 1;
1181   Standard_GUID funGUID;
1182   if(!GetFuncGUID("Prism",funGUID)) return 1;
1183   Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
1184   if(aFun.IsNull()) return 1;
1185   TDataStd_Name::Set(aFun->Label(), "Prism_Function");
1186   TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
1187
1188   // arguments
1189   Handle(TDataStd_UAttribute) aBasisObj;
1190   if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, aBasisObj)) return 1;
1191   DNaming::SetObjectArg(aFun, PRISM_BASIS, aBasisObj); 
1192   Standard_Real height = Draw::Atof(theArg[3]);
1193   DNaming::GetReal(aFun,PRISM_HEIGHT)->Set(height);
1194   Standard_Integer reverse = Draw::Atoi(theArg[4]);
1195   DNaming::GetInteger(aFun,PRISM_DIR)->Set(reverse);
1196   DDF::ReturnLabel(theDI, anObj->Label());
1197   return 0;
1198 }  
1199
1200 //=======================================================================
1201 //function : DNaming_PrismHeight
1202 //purpose  : "PrismHeight Doc PrismLabel NewHeight"
1203 //=======================================================================
1204 static Standard_Integer DNaming_PrismHeight (Draw_Interpretor& theDI,
1205                                             Standard_Integer theNb, 
1206                                             const char** theArg)
1207 {
1208   if (theNb == 4) {
1209     Handle(TDocStd_Document) aDoc;   
1210     Standard_CString aDocS(theArg[1]);
1211     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
1212     TDF_Label objLabel;
1213     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
1214     
1215     Handle(TDataStd_UAttribute) anObj;
1216     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
1217     Standard_GUID funGUID;
1218     if(!GetFuncGUID("Prism",funGUID)) return 1;       
1219     
1220     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
1221     if(!aFun.IsNull()) {
1222       Standard_Real value = Draw::Atof(theArg[3]);
1223       DNaming::GetReal(aFun, PRISM_HEIGHT)->Set(value);
1224       DDF::ReturnLabel(theDI, DNaming::GetReal(aFun,PRISM_HEIGHT)->Label());
1225       return 0;
1226     }
1227     
1228   }
1229   cout << "DNaming_PrismHeight : Error" << endl;
1230   return 1;  
1231 }
1232
1233
1234 //=======================================================================
1235 //function : DModel_AddRevol
1236 //purpose  : "AddRevol Doc BasisLabel  AxisLabel [Angle [Reverse(0/1)]] "
1237 //         : if Angle is presented - sectioned revolution, else - full
1238 //=======================================================================
1239 static Standard_Integer DNaming_AddRevol (Draw_Interpretor& theDI,
1240                                           Standard_Integer theNb, 
1241                                           const char** theArg)
1242 {
1243   if (theNb < 4 ) {
1244     cout<<"DNaming_AddRevol(): Wrong number of arguments"<<endl;
1245     return 1;
1246   }
1247
1248   Handle(TDocStd_Document) aDocument;   
1249   Standard_CString aDocS(theArg[1]);
1250   if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
1251
1252   Handle(TDataStd_UAttribute) aBasisObj;
1253   if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, aBasisObj)) return 1;
1254
1255   Handle(TDataStd_UAttribute) anAxObj;
1256   if (!DDocStd::Find(aDocument, theArg[3], GEOMOBJECT_GUID, anAxObj)) return 1;
1257
1258   Standard_Boolean aFull = Standard_True;
1259   Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
1260   if(anObj.IsNull()) return 1;
1261   if(theNb > 4 ) 
1262    aFull = Standard_False;
1263   Standard_GUID funGUID;
1264   if(aFull) {
1265     if(!GetFuncGUID("FulRevol",funGUID)) return 1;
1266   }
1267   else 
1268     if(!GetFuncGUID("SecRevol",funGUID)) return 1;
1269   Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
1270   if(aFun.IsNull()) return 1;
1271   if(aFull)
1272     TDataStd_Name::Set(aFun->Label(), "FulRevol_Function");
1273   else
1274     TDataStd_Name::Set(aFun->Label(), "SecRevol_Function");
1275   TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
1276   DNaming::SetObjectArg(aFun, REVOL_BASIS, aBasisObj); 
1277   DNaming::SetObjectArg(aFun, REVOL_AXIS, anAxObj); 
1278
1279   if(theNb > 4 ) {  
1280     Standard_Real angle = Draw::Atof(theArg[4]);
1281     Standard_Real aK = 2*M_PI/360;
1282     angle = angle * aK;
1283     DNaming::GetReal(aFun,REVOL_ANGLE)->Set(angle);
1284     if( theNb == 6) {
1285       Standard_Integer reverse = Draw::Atoi(theArg[5]);
1286       DNaming::GetInteger(aFun, REVOL_REV)->Set(reverse);
1287     }
1288   }
1289   DDF::ReturnLabel(theDI, anObj->Label());
1290   return 0;
1291 }
1292
1293 //=======================================================================
1294 //function : DNaming_RevolutionAngle
1295 //purpose  : "RevolutionAngle Doc RevolutionLabel NewAngle"
1296 //=======================================================================
1297 static Standard_Integer DNaming_RevolutionAngle (Draw_Interpretor& theDI,
1298                                             Standard_Integer theNb, 
1299                                             const char** theArg)
1300 {
1301   if (theNb == 4) {
1302     Handle(TDocStd_Document) aDoc;   
1303     Standard_CString aDocS(theArg[1]);
1304     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
1305     TDF_Label objLabel;
1306     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
1307     
1308     Handle(TDataStd_UAttribute) anObj;
1309     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
1310     Standard_GUID funGUID;
1311     if(!GetFuncGUID("SecRevol",funGUID)) return 1;       
1312     
1313     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
1314     if(!aFun.IsNull()) {
1315       Standard_Real value = Draw::Atof(theArg[3]);
1316       DNaming::GetReal(aFun, REVOL_ANGLE)->Set(value);
1317       DDF::ReturnLabel(theDI, DNaming::GetReal(aFun,REVOL_ANGLE)->Label());
1318       return 0;
1319     }    
1320   }
1321   cout << "DNaming_RevolutionAngle : Error" << endl;
1322   return 1;  
1323 }
1324
1325 //=======================================================================
1326 //function : DNaming_AddSphere
1327 //purpose  : "AddSphere Doc CenterLabel Radius "
1328 //=======================================================================
1329 static Standard_Integer DNaming_AddSphere (Draw_Interpretor& theDI,
1330                                           Standard_Integer theNb, 
1331                                           const char** theArg)
1332 {
1333   if (theNb != 4) {
1334     cout<<"DNaming_AddSphere(): Wrong number of arguments"<<endl;
1335     return 1;
1336   }
1337   Handle(TDocStd_Document) aDocument;   
1338   Standard_CString aDocS(theArg[1]);
1339   if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
1340
1341   Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
1342   if(anObj.IsNull()) return 1;
1343   Standard_GUID funGUID;
1344   if(!GetFuncGUID("Sph",funGUID)) return 1;
1345   Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
1346   if(aFun.IsNull()) return 1;
1347   TDataStd_Name::Set(aFun->Label(), "Sphere_Function");
1348   TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
1349  
1350   Handle(TDataStd_UAttribute) aCenterObj;
1351   if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, aCenterObj)) return 1;
1352   DNaming::SetObjectArg(aFun, SPHERE_CENTER, aCenterObj);
1353
1354   Standard_Real aRadius = Draw::Atof(theArg[3]);
1355   DNaming::GetReal(aFun,SPHERE_RADIUS)->Set(aRadius);
1356   
1357   DDF::ReturnLabel(theDI, anObj->Label());
1358   return 0;
1359 }
1360
1361 //=======================================================================
1362 //function : DNaming_SphereRadius
1363 //purpose  : "SphereRadius Doc SphLabel NewRadius"
1364 //=======================================================================
1365 static Standard_Integer DNaming_SphereRadius (Draw_Interpretor& theDI,
1366                                              Standard_Integer theNb, 
1367                                              const char** theArg)
1368 {
1369   if (theNb == 4) {
1370     Handle(TDocStd_Document) aDoc;   
1371     Standard_CString aDocS(theArg[1]);
1372     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
1373     TDF_Label objLabel;
1374     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
1375
1376     Handle(TDataStd_UAttribute) anObj;
1377     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
1378     Standard_GUID funGUID;
1379     if(!GetFuncGUID("Sph",funGUID)) return 1;       
1380
1381     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
1382     if(!aFun.IsNull()) {
1383       Standard_Real value = Draw::Atof(theArg[3]);
1384       DNaming::GetReal(aFun, SPHERE_RADIUS)->Set(value);
1385       DDF::ReturnLabel(theDI, DNaming::GetReal(aFun, SPHERE_RADIUS)->Label());
1386       return 0;
1387     }
1388   }
1389
1390   cout << "DNaming_SphRadius : Error" << endl;
1391   return 1;  
1392 }
1393 //=======================================================================
1394 //function : DNaming_AddPoint
1395 //purpose  : "AddPoint Doc x y z"
1396 //=======================================================================
1397 static Standard_Integer DNaming_AddPoint (Draw_Interpretor& theDI,
1398                                          Standard_Integer theNb, 
1399                                          const char** theArg)
1400 {
1401   if (theNb >= 4) {
1402
1403     Handle(TDocStd_Document) aDocument;
1404     Standard_CString aDocS(theArg[1]);
1405     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
1406     Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
1407     if(anObj.IsNull()) return 1;
1408     Standard_GUID funGUID;
1409     if(!GetFuncGUID("PntXYZ",funGUID)) return 1;
1410
1411     Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
1412     if(aFun.IsNull()) return 1;
1413     TDataStd_Name::Set(aFun->Label(), "PntXYZ_Function");
1414     
1415     TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
1416     Standard_Real x,y,z;
1417     x = Draw::Atof(theArg[2]);
1418     y = Draw::Atof(theArg[3]);
1419     z = Draw::Atof(theArg[4]);
1420
1421     DNaming::GetReal(aFun,PNT_DX)->Set(x);
1422     DNaming::GetReal(aFun,PNT_DY)->Set(y);
1423     DNaming::GetReal(aFun,PNT_DZ)->Set(z);
1424     
1425     DDF::ReturnLabel(theDI, anObj->Label());
1426     return 0;
1427   }
1428   cout << "DNaming_AddPoint : Error" << endl;
1429   return 1;  
1430 }
1431
1432 //=======================================================================
1433 //function : DNaming_AddPointRlt
1434 //purpose  : "AddPointRlt Doc RefPnt dx dy dz"
1435 //=======================================================================
1436 static Standard_Integer DNaming_AddPointRlt (Draw_Interpretor& theDI,
1437                                          Standard_Integer theNb, 
1438                                          const char** theArg)
1439 {
1440   if (theNb >= 5) {
1441
1442     Handle(TDocStd_Document) aDocument;
1443     Standard_CString aDocS(theArg[1]);
1444     if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
1445     Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
1446     if(anObj.IsNull()) return 1;
1447     Standard_GUID funGUID;
1448     if(!GetFuncGUID("PntRLT",funGUID)) return 1;
1449
1450     Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
1451     if(aFun.IsNull()) return 1;
1452     TDataStd_Name::Set(aFun->Label(), "PntRLT_Function");
1453     
1454     TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
1455
1456     Handle(TDataStd_UAttribute) aRefPnt;
1457     if (!DDocStd::Find(aDocument, theArg[2], GEOMOBJECT_GUID, aRefPnt)) return 1;
1458
1459     Standard_Real dx,dy,dz;
1460     dx = Draw::Atof(theArg[3]);
1461     dy = Draw::Atof(theArg[4]);
1462     dz = Draw::Atof(theArg[5]);
1463
1464     DNaming::GetReal(aFun,PNT_DX)->Set(dx);
1465     DNaming::GetReal(aFun,PNT_DY)->Set(dy);
1466     DNaming::GetReal(aFun,PNT_DZ)->Set(dz);
1467
1468     DNaming::SetObjectArg(aFun, PNTRLT_REF, aRefPnt); 
1469
1470     DDF::ReturnLabel(theDI, anObj->Label());
1471     return 0;
1472   }
1473   cout << "DNaming_AddPoint : Error" << endl;
1474   return 1;  
1475 }
1476
1477 //=======================================================================
1478 //function : DNaming_PntOffset
1479 //purpose  : "PntOffset Doc PntLabel newDX newDY newDZ "
1480 //=======================================================================
1481
1482 static Standard_Integer DNaming_PntOffset (Draw_Interpretor& theDI,
1483                                            Standard_Integer theNb, 
1484                                            const char** theArg)
1485 {
1486   if (theNb == 6) {
1487     Handle(TDocStd_Document) aDoc;   
1488     Standard_CString aDocS(theArg[1]);
1489     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
1490     TDF_Label objLabel;
1491     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], objLabel)) return 1;
1492     
1493     Handle(TDataStd_UAttribute) anObj;
1494     if(!objLabel.FindAttribute(GEOMOBJECT_GUID, anObj)) return 1;       
1495     Standard_GUID funGUID;
1496
1497     if(!GetFuncGUID("PntXYZ",funGUID)) {
1498       if(!GetFuncGUID("PntRLT",funGUID))
1499         return 1;       
1500     }
1501     
1502     Handle(TFunction_Function) aFun = GetFunction(objLabel,funGUID);
1503     if(!aFun.IsNull()) {
1504       Standard_Real value(0.0);
1505       Standard_Boolean isDX = (strcmp(theArg[3],"skip"));
1506       if(isDX) {
1507         value = Draw::Atof(theArg[3]);
1508         DNaming::GetReal(aFun,PNT_DX)->Set(value);
1509       }
1510       Standard_Boolean isDY = (strcmp(theArg[4],"skip"));
1511       if(isDY) {
1512         value = Draw::Atof(theArg[4]);
1513         DNaming::GetReal(aFun,PNT_DY)->Set(value);
1514       }
1515       Standard_Boolean isDZ = (strcmp(theArg[5],"skip"));
1516       if(isDZ) {
1517         value = Draw::Atof(theArg[5]);
1518         DNaming::GetReal(aFun,PNT_DZ)->Set(value);
1519       }
1520       if(isDX || isDY || isDZ)
1521         DDF::ReturnLabel(theDI, objLabel);
1522       else
1523         cout <<"DNaming_PntOffset : Nothing changed" << endl; 
1524       return 0;
1525     }
1526   }
1527   cout << "DNaming_PntOffset : Error" << endl;
1528   return 1;  
1529 }
1530
1531 //=======================================================================
1532 //function : DNaming_AddLine3D
1533 //purpose  : "AddLine3D Doc CurveType(0|1) Pnt1Lab Pnt2Lab [Pnt3Lab [Pnt4Lab [...]]]"
1534 //         : Type = 0 - open, Type = 1 - closed
1535 //=======================================================================
1536 static Standard_Integer DNaming_Line3D (Draw_Interpretor& theDI,
1537                                           Standard_Integer theNb, 
1538                                           const char** theArg)
1539 {
1540   if (theNb < 5) {
1541     cout<<"DNaming_AddLine3D: Wrong number of arguments"<<endl;
1542     return 1;
1543   }
1544   Handle(TDocStd_Document) aDocument;   
1545   Standard_CString aDocS(theArg[1]);
1546   if (!DDocStd::GetDocument(aDocS, aDocument)) return 1;
1547
1548   Handle(TDataStd_UAttribute) anObj = AddObject(aDocument);
1549   if(anObj.IsNull()) return 1;
1550   Standard_GUID funGUID;
1551   if(!GetFuncGUID("Line3D",funGUID)) return 1;
1552   Handle(TFunction_Function) aFun = SetFunctionDS(anObj->Label(), funGUID);
1553   if(aFun.IsNull()) return 1;
1554   TDataStd_Name::Set(aFun->Label(), "Line3D_Function");
1555   TDF_Reference::Set(anObj->Label(), aFun->Label().FindChild(FUNCTION_RESULT_LABEL)); //result is here 
1556  
1557   Standard_Integer aType = Draw::Atoi(theArg[2]);
1558   DNaming::GetInteger(aFun,LINE3D_TYPE)->Set(aType);
1559   
1560 //LINE3D_PNTNB
1561   //set Pnts
1562   Standard_Integer aPos = LINE3D_TYPE;
1563   for(Standard_Integer i=3; i < theNb; i++) {
1564     Handle(TDataStd_UAttribute) aPntObj;
1565     if (!DDocStd::Find(aDocument, theArg[i], GEOMOBJECT_GUID, aPntObj)) return 1;
1566     aPos++;
1567     DNaming::SetObjectArg(aFun, aPos, aPntObj);
1568   }
1569
1570   DNaming::GetInteger(aFun,LINE3D_PNTNB)->Set(aPos - 1);//set number of points
1571
1572   DDF::ReturnLabel(theDI, anObj->Label());
1573   return 0;
1574 }
1575 // ***
1576 //==========================================================================================
1577 inline static void MapOfOrientedShapes(const TopoDS_Shape& S, TopTools_MapOfOrientedShape& M)
1578 {
1579   M.Add(S);
1580   TopoDS_Iterator It(S,Standard_True,Standard_True);
1581   while (It.More()) {
1582     MapOfOrientedShapes(It.Value(),M);
1583     It.Next();
1584   }
1585 }
1586 //==========================================================================================
1587 static void MapOfOrientedShapes(const TopoDS_Shape& S1, const TopoDS_Shape& S2, 
1588                                     TopTools_MapOfOrientedShape& M) {
1589
1590   TopoDS_Iterator it(S2,Standard_True,Standard_True);
1591   while (it.More()) {
1592     if(it.Value().ShapeType() == S1.ShapeType()) 
1593       M.Add(it.Value());
1594     it.Next();
1595   }
1596 }
1597
1598 //==========================================================================================
1599 static void MapOfShapes(const TopoDS_Shape& S1, const TopoDS_Shape& S2, 
1600                                     TopTools_MapOfShape& M) {
1601
1602   TopoDS_Iterator it(S2,Standard_True,Standard_True);
1603   while (it.More()) {
1604     if(it.Value().ShapeType() == S1.ShapeType()) 
1605       M.Add(it.Value());
1606     it.Next();
1607   }
1608 }
1609 //==========================================================================================
1610 inline static void CollectShapes(const TopoDS_Shape& S, TopTools_ListOfShape& List)
1611 {
1612   List.Append(S);
1613   TopoDS_Iterator It(S,Standard_True,Standard_True);
1614   while (It.More()) {
1615     CollectShapes(It.Value(),List);
1616     It.Next();
1617   }
1618 }
1619
1620 //==========================================================================================
1621 inline static void CollectMultShapes(const TopoDS_Shape& S, TopTools_ListOfShape& List)
1622 {  
1623   TopAbs_ShapeEnum aType = S.ShapeType();
1624   Standard_Integer aStop (TopAbs_SHAPE);
1625   for(Standard_Integer i = (Standard_Integer)aType +1; i < aStop; i++) {
1626     BRep_Builder aBuilder;
1627     TopoDS_Compound aCompound;
1628     aBuilder.MakeCompound(aCompound);
1629     TopExp_Explorer exp(S,(TopAbs_ShapeEnum)i);
1630     for (;exp.More();exp.Next()) 
1631       aBuilder.Add(aCompound, exp.Current());
1632     List.Append(aCompound);
1633   }
1634 }
1635 //==========================================================================================
1636 static Standard_Boolean MakeSelection (const Handle(TDataStd_UAttribute)& Obj, 
1637                                        const TopoDS_Shape& Selection, 
1638                                        const Handle(TDataStd_UAttribute)& ContextObj, 
1639                                        const Standard_Boolean Geometry, 
1640                                        const Standard_Boolean KeepOrientation)
1641 {
1642   if(!Obj.IsNull()) {
1643     Handle(TDataStd_TreeNode) aNode,RNode;
1644     Obj->Label().FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), aNode);
1645     if(aNode.IsNull())
1646       aNode = TDataStd_TreeNode::Set(Obj->Label());
1647     aNode->Remove();
1648     Handle(TDataStd_UAttribute) aContainer = ContextObj;
1649     if(aContainer->Label().FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), RNode))
1650       RNode->Append(aNode);
1651     TDataStd_Name::Set(Obj->Label(), "Auxiliary_Object");
1652     Standard_GUID funGUID;
1653     if(GetFuncGUID("Attach",funGUID)) {
1654       Handle(TFunction_Function) aFun = SetFunctionDS(Obj->Label(), funGUID);
1655       if(!aFun.IsNull()) {
1656         TDataStd_Name::Set(aFun->Label(), "ISelection");          
1657         TDF_Label aResultLabel =  aFun->Label().FindChild(FUNCTION_RESULT_LABEL, Standard_True); 
1658         TDF_Reference::Set(Obj->Label(), aResultLabel ); //result of the object
1659         aResultLabel.ForgetAllAttributes(Standard_True);
1660         Handle(TNaming_NamedShape) aNS = DNaming::GetObjectValue( ContextObj);  
1661         try{
1662           const TopoDS_Shape& aContext = aNS->Get();
1663           TNaming_Selector aSelector(aResultLabel);
1664           if(!aSelector.Select(Selection, aContext, Geometry, KeepOrientation))
1665             return Standard_False;
1666         }catch (...) {
1667           cout << "EXCEPTION: SELECTION_IMPOSSIBLE" <<endl;
1668         }
1669
1670         if(!aNS.IsNull()) {
1671
1672             //TCollection_AsciiString entry;
1673             //TDF_Tool::Entry(aNS->Label(), entry);
1674             //cout << "ContextNS Label = " << entry <<endl;
1675           Handle(TFunction_Function) aCntFun;
1676           if(aNS->Label().Father().FindAttribute(TFunction_Function::GetID(), aCntFun)) { //Fun:2 ==> result
1677               // First argument of Selection function refers to father function (of context object) 
1678               // to which selection is attached (because sel obj. itself already has refrence to result NS
1679             TDF_Reference::Set(aFun->Label().FindChild(FUNCTION_ARGUMENTS_LABEL).FindChild(ATTACH_ARG), 
1680                                aCntFun->Label()); //ref to function produced Context shape
1681             
1682           }
1683         }         
1684         return Standard_True;
1685       }
1686     }
1687   }
1688   return Standard_False;
1689 }
1690
1691 //==========================================================================================
1692 static Standard_Boolean MakeXSelection (const Handle(TDataStd_UAttribute)& Obj, 
1693                                        const TopoDS_Shape& Selection, 
1694                                        const Handle(TDataStd_UAttribute)& ContextObj, 
1695                                        const Standard_Boolean Geometry, 
1696                                        const Standard_Boolean KeepOrientation)
1697 {
1698   if(!Obj.IsNull()) {
1699 /*    Handle(TDataStd_TreeNode) aNode,RNode;
1700     Obj->Label().FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), aNode);
1701     if(aNode.IsNull())
1702       aNode = TDataStd_TreeNode::Set(Obj->Label());
1703     aNode->Remove();
1704     Handle(TDataStd_UAttribute) aContainer = ContextObj;
1705     if(aContainer->Label().FindAttribute(TDataStd_TreeNode::GetDefaultTreeID(), RNode))
1706       RNode->Append(aNode);
1707 */
1708     TDataStd_Name::Set(Obj->Label(), "Auxiliary_Object");
1709     Standard_GUID funGUID;
1710     if(GetFuncGUID("XAttach",funGUID)) {
1711       Handle(TFunction_Function) aFun = SetFunctionDS(Obj->Label(), funGUID);
1712       if(!aFun.IsNull()) {
1713         TDataStd_Name::Set(aFun->Label(), "XSelection");          
1714         TDF_Label aResultLabel =  aFun->Label().FindChild(FUNCTION_RESULT_LABEL, Standard_True); 
1715         TDF_Reference::Set(Obj->Label(), aResultLabel ); //result of the object
1716         aResultLabel.ForgetAllAttributes(Standard_True);
1717
1718         Handle(TNaming_NamedShape) aNS = DNaming::GetObjectValue( ContextObj);  
1719         try{
1720           const TopoDS_Shape& aContext = aNS->Get();
1721           TNaming_Selector aSelector(aResultLabel);
1722           if(!aSelector.Select(Selection, aContext, Geometry, KeepOrientation))
1723             return Standard_False;
1724         }catch (...) {
1725           cout << "EXCEPTION: SELECTION_IMPOSSIBLE" <<endl;
1726         }
1727
1728         if(!aNS.IsNull()) {
1729
1730             //TCollection_AsciiString entry;
1731             //TDF_Tool::Entry(aNS->Label(), entry);
1732             //cout << "ContextNS Label = " << entry <<endl;
1733           Handle(TFunction_Function) aCntFun;
1734           if(aNS->Label().Father().FindAttribute(TFunction_Function::GetID(), aCntFun)) { //Fun:2 ==> result
1735               // First argument of Selection function refers to father function (of context object) 
1736               // to which selection is attached (because sel obj. itself already has refrence to result NS
1737             TDF_Reference::Set(aFun->Label().FindChild(FUNCTION_ARGUMENTS_LABEL).FindChild(ATTACH_ARG), 
1738                                aCntFun->Label()); //ref to function produced Context shape
1739             
1740           }
1741         }         
1742         return Standard_True;
1743       }
1744     }
1745   }
1746   return Standard_False;
1747 }
1748 //=======================================================================
1749 inline static TCollection_ExtendedString compareShapes(const TopoDS_Shape& theShape1,
1750                                                        const TopoDS_Shape& theShape2,
1751                                                        const Standard_Boolean keepOrientation) 
1752 {
1753   TCollection_ExtendedString aResult("");
1754
1755   if((theShape1.ShapeType() != TopAbs_COMPOUND) &&
1756      theShape2.ShapeType() == TopAbs_COMPOUND) {
1757     if(keepOrientation) {
1758       TopTools_MapOfOrientedShape M;
1759       MapOfOrientedShapes(theShape1, theShape2, M);
1760       if(M.Contains(theShape1)) {
1761         aResult+=" Warning => Type migration to Compound";
1762         return aResult;
1763       }
1764     } else {
1765       TopTools_MapOfShape M;
1766       MapOfShapes(theShape1, theShape2, M);
1767       if(M.Contains(theShape1)) {
1768         aResult+=" Warning => Type migration to Compound";
1769         return aResult;
1770       }
1771     }
1772   }
1773   Standard_Boolean isComma=Standard_False;
1774   if(theShape1.ShapeType() != theShape2.ShapeType()) {
1775     aResult+=" Type was changed:";
1776     aResult+=" Initial type = "; aResult+= TCollection_ExtendedString(theShape1.ShapeType());
1777     aResult+="; Resulting type = "; aResult+= TCollection_ExtendedString(theShape2.ShapeType());
1778     isComma = Standard_True;
1779   } else if(theShape1.TShape() != theShape2.TShape()) {
1780     aResult+=" TShape was changed";
1781     isComma = Standard_True;
1782   } else if(theShape1.Location()!=theShape2.Location()) {
1783     aResult+=" Location was changed";
1784     isComma = Standard_True;
1785   }
1786
1787   if(keepOrientation) { 
1788     if(theShape1.Orientation()!=theShape2.Orientation() && theShape1.ShapeType() != TopAbs_VERTEX) {
1789       if(theShape2.ShapeType() != TopAbs_COMPOUND) {
1790         if(isComma)
1791           aResult+=",";
1792         aResult+=" Orientation was changed";
1793       }
1794       else {
1795         TopoDS_Iterator it(theShape2);
1796         for(;it.More(); it.Next()) {
1797           if(it.Value().IsSame(theShape1))
1798             if(theShape1.Orientation()!=it.Value().Orientation()) {
1799               if(isComma)
1800                 aResult+=",";
1801               aResult+=" Orientation was changed";
1802             }
1803         }
1804       }
1805     }
1806   }
1807   return aResult;
1808 }
1809
1810 //=======================================================================
1811 inline static TCollection_ExtendedString compareShapes(const TopoDS_Shape& theShape, 
1812                                                        //theShape - Compound of Multiple selection
1813                                                        const TopTools_MapOfOrientedShape& aMap)
1814 {
1815   TCollection_ExtendedString aResult("");
1816   if(theShape.ShapeType() != TopAbs_COMPOUND) {
1817     aResult+="the specified shape is not COMPOUND";
1818   } else {
1819     TopoDS_Iterator it(theShape);
1820     for(;it.More();it.Next()) {
1821       const TopoDS_Shape& newShape = it.Value();
1822       if(!aMap.Contains(newShape)) {
1823         aResult+=" Not in the context";
1824       }
1825     }
1826   }
1827   return aResult;
1828 }
1829 //=======================================================================
1830 //function : IntegerToShapeEnum
1831 //purpose  :
1832 //=======================================================================
1833
1834 static TCollection_AsciiString ShapeEnumToString (const TopAbs_ShapeEnum   type)
1835 {
1836   switch(type)
1837     {
1838     case  TopAbs_COMPOUND  : return TCollection_AsciiString("COMPOUND");
1839     case  TopAbs_COMPSOLID : return TCollection_AsciiString("COMPSOLID");
1840     case  TopAbs_SOLID     : return TCollection_AsciiString("SOLID");
1841     case  TopAbs_SHELL     : return TCollection_AsciiString("SHELL");
1842     case  TopAbs_FACE      : return TCollection_AsciiString("FACE");
1843     case  TopAbs_WIRE      : return TCollection_AsciiString("WIRE");
1844     case  TopAbs_EDGE      : return TCollection_AsciiString("EDGE");
1845     case  TopAbs_VERTEX    : return TCollection_AsciiString("VERTEX");
1846     case  TopAbs_SHAPE     : return TCollection_AsciiString("SHAPE");
1847     }
1848   return TCollection_AsciiString("SHAPE");
1849 }
1850 //=======================================================================
1851 //function : DNaming_TestSingle
1852 //purpose  : "TestSingleSelection Doc ObjectLabel [Orientation [Xselection [Geometry]]]"
1853 //         : returns DDF::ReturnLabel of a first Aux object
1854 //=======================================================================
1855 static Standard_Integer DNaming_TestSingle (Draw_Interpretor& theDI,
1856                                                     Standard_Integer theNb, 
1857                                                     const char** theArg)
1858 {
1859   if (theNb >= 3) {
1860     Handle(TDocStd_Document) aDoc;   
1861     Standard_CString aDocS(theArg[1]);
1862     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
1863     TDF_Label ObjLabel;
1864     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], ObjLabel)) return 1;
1865
1866     Handle(TDataStd_UAttribute) aCntObj;
1867     if(!ObjLabel.FindAttribute(GEOMOBJECT_GUID, aCntObj)) return 1;       
1868     Standard_Boolean Orientation(Standard_False);
1869     Standard_Boolean XSelection(Standard_False);
1870     Standard_Boolean Geometry(Standard_False);
1871     if(theNb == 4)
1872       Orientation = (Standard_Boolean)Draw::Atoi(theArg[3]);
1873     if(theNb == 5)
1874       XSelection = (Standard_Boolean)Draw::Atoi(theArg[4]);
1875     if (theNb == 6) 
1876       Geometry = (Standard_Boolean) Draw::Atoi(theArg[5]);
1877     Handle(TNaming_NamedShape) aNS = DNaming::GetObjectValue( aCntObj);
1878
1879     if(!aNS.IsNull() && !aNS->IsEmpty()) {
1880       const TopoDS_Shape&  aRootShape = aNS->Get();
1881       //TopTools_MapOfOrientedShape aMap0;
1882       //MapOfOrientedShapes(aRootShape, aMap0);
1883       TopTools_ListOfShape aList, aFailedList;
1884       CollectShapes(aRootShape, aList);
1885       if(aList.Extent())
1886         aList.RemoveFirst();
1887       Standard_Boolean isFirst(Standard_True);
1888       Handle(TDataStd_UAttribute) FirstAuxObj;
1889       TopTools_ListIteratorOfListOfShape it(aList);
1890       for(; it.More(); it.Next()) {
1891         const TopoDS_Shape& aCurShape = it.Value();
1892         if(aCurShape.IsNull()) continue;
1893         if(aCurShape.ShapeType() == TopAbs_EDGE) {
1894           if (BRep_Tool::Degenerated(TopoDS::Edge(aCurShape)))
1895             continue;
1896         }
1897         Handle(TDataStd_UAttribute) auxObj = AddObject (aDoc);
1898         if(isFirst) {
1899           FirstAuxObj = auxObj;
1900           isFirst = Standard_False;
1901           TCollection_AsciiString entry;
1902           TDF_Tool::Entry(FirstAuxObj->Label(), entry);
1903 #ifdef DEBUG
1904           cout << "First Selection function at " << entry <<endl;
1905 #endif
1906         }
1907         Standard_Boolean isSelected (Standard_False);
1908         try {
1909           OCC_CATCH_SIGNALS
1910             {
1911               if(!XSelection)
1912                 isSelected = MakeSelection(auxObj, aCurShape, aCntObj, Geometry, Orientation);
1913               else
1914                 isSelected = MakeXSelection(auxObj, aCurShape, aCntObj, Geometry, Orientation);
1915             }
1916         }
1917         catch (Standard_Failure) {
1918           Handle(Standard_Failure) aFailure =  Standard_Failure::Caught();
1919           cout << "%%%INFO:Error: ::TestSingleSelection failed :";
1920           if (!aFailure.IsNull()) 
1921             cout << aFailure->GetMessageString() << endl;
1922           else
1923             cout << "%%%INFO:Error: ::TestSingleSelection : Standard_Failure with null caught failure"<< endl;
1924         }
1925         catch(...) {
1926           cout << "%%%INFO:Error: ::TestSingleSelection selection failed : unknown exception type";
1927         }
1928         TCollection_AsciiString entry;
1929         TDF_Tool::Entry(auxObj->Label(), entry);
1930         TCollection_ExtendedString aResult("");
1931         if(isSelected) {
1932           const Handle(TNaming_NamedShape)& aSelNS =  DNaming::GetObjectValue(auxObj);
1933           if(!aSelNS.IsNull() && !aSelNS->IsEmpty()) {
1934             const TopoDS_Shape& aSelectedShape = aSelNS->Get();
1935             aResult += compareShapes(aCurShape, aSelectedShape,Orientation);
1936             TDF_ChildIDIterator itn(auxObj->Label(),TNaming_Naming::GetID(), Standard_True);
1937             for(;itn.More();itn.Next()) {
1938               Handle(TNaming_Naming) aNaming = Handle(TNaming_Naming)::DownCast(itn.Value());
1939               if(!aNaming.IsNull()) {
1940                 const TNaming_Name& aName = aNaming->GetName();
1941                 if(aName.Type() == TNaming_UNKNOWN) {
1942                   aResult += " Selection at label = ";
1943                   aResult +=  entry;
1944                   aResult += " has UNKNOWN name type, shape type = ";
1945                   aResult += ShapeEnumToString(aCurShape.ShapeType());
1946                 }
1947                   
1948               }
1949             }
1950           }
1951         } else {
1952           aResult += " Selection at label = ";
1953           aResult +=  entry;
1954           aResult += " failed, shape type = ";
1955           aResult += ShapeEnumToString(aCurShape.ShapeType());
1956           aFailedList.Append(aCurShape);
1957         }
1958         if(aResult.Length()) {
1959           if(aResult.Search("Warning") == -1)
1960             cout << "Failed units: " << aResult << " at " << entry << endl;
1961           else 
1962             cout << aResult << " at " << entry << endl;
1963           TDataStd_Name::Set(auxObj->Label(), aResult);
1964         }
1965       } 
1966       if(aFailedList.Extent()) {
1967         cout << "Failed units are kept at: ";
1968         TopTools_ListIteratorOfListOfShape it1(aFailedList);
1969         for(; it1.More(); it1.Next()) {
1970           const TDF_Label& aLabel = TDF_TagSource::NewChild(aDoc->Main());
1971           
1972           TNaming_Builder B(aLabel);
1973           B.Generated(it1.Value());
1974           TCollection_AsciiString entry;
1975           TDF_Tool::Entry(aLabel, entry);
1976           cout << "\t" <<entry <<endl;
1977         }
1978       }
1979       if(!FirstAuxObj.IsNull())
1980         DDF::ReturnLabel(theDI, FirstAuxObj->Label());
1981       return 0;
1982     }
1983   }
1984
1985   cout << "DNaming_TestSingle : Error" << endl;
1986   return 1;  
1987 }
1988
1989 //=======================================================================
1990 //function : DNaming_Multiple
1991 //purpose  : "TestMultipleSelection Doc ObjectLabel [Orientation [Xselection [Geometry]]]"
1992 //         : returns DDF::ReturnLabel of a first Aux object
1993 //=======================================================================
1994 static Standard_Integer DNaming_Multiple (Draw_Interpretor& theDI,
1995                                                     Standard_Integer theNb, 
1996                                                     const char** theArg)
1997 {
1998   if (theNb >= 3) {
1999     Handle(TDocStd_Document) aDoc;   
2000     Standard_CString aDocS(theArg[1]);
2001     if (!DDocStd::GetDocument(aDocS, aDoc)) return 1;
2002     TDF_Label ObjLabel;
2003     if (!DDF::FindLabel(aDoc->GetData(),theArg[2], ObjLabel)) return 1;
2004
2005     Handle(TDataStd_UAttribute) aCntObj;
2006     if(!ObjLabel.FindAttribute(GEOMOBJECT_GUID, aCntObj)) return 1;       
2007     Standard_Boolean Orientation(Standard_False);
2008     Standard_Boolean XSelection(Standard_False);
2009     Standard_Boolean Geometry(Standard_False);
2010     if(theNb == 4)
2011       Orientation = (Standard_Boolean)Draw::Atoi(theArg[3]);
2012     if(theNb == 5)
2013       XSelection = (Standard_Boolean)Draw::Atoi(theArg[4]);
2014     if (theNb == 6) 
2015       Geometry = (Standard_Boolean) Draw::Atoi(theArg[5]);
2016     Handle(TNaming_NamedShape) aNS = DNaming::GetObjectValue( aCntObj);
2017
2018     if(!aNS.IsNull() && !aNS->IsEmpty()) {
2019       const TopoDS_Shape&  aRootShape = aNS->Get();
2020       TopTools_MapOfOrientedShape aMap0;
2021       MapOfOrientedShapes(aRootShape, aMap0);
2022       TopTools_ListOfShape aList, aFailedList;
2023       CollectMultShapes(aRootShape, aList);
2024
2025       Standard_Boolean isFirst(Standard_True);
2026       Handle(TDataStd_UAttribute) FirstAuxObj;
2027       TopTools_ListIteratorOfListOfShape it(aList);
2028       for(; it.More(); it.Next()) {
2029         const TopoDS_Shape& aCurShape = it.Value();
2030         if(aCurShape.IsNull()) continue;
2031         if(aCurShape.ShapeType() == TopAbs_EDGE) {
2032           if (BRep_Tool::Degenerated(TopoDS::Edge(aCurShape)))
2033             continue;
2034         }//
2035         Handle(TDataStd_UAttribute) auxObj = AddObject (aDoc);
2036         if(isFirst) {
2037           FirstAuxObj = auxObj;
2038           isFirst = Standard_False;
2039 #ifdef DEBUG
2040           TCollection_AsciiString entry;
2041           TDF_Tool::Entry(FirstAuxObj->Label(), entry);
2042           cout << "First Selection function at " << entry <<endl;
2043 #endif
2044         }
2045         Standard_Boolean isSelected (Standard_False);
2046         try {
2047           OCC_CATCH_SIGNALS
2048             {
2049               if(!XSelection)
2050                 isSelected = MakeSelection(auxObj, aCurShape, aCntObj, Geometry, Orientation);
2051               else
2052                 isSelected = MakeXSelection(auxObj, aCurShape, aCntObj, Geometry, Orientation);
2053             }
2054         }
2055         catch (Standard_Failure) {
2056           Handle(Standard_Failure) aFailure =  Standard_Failure::Caught();
2057           cout << "%%%INFO:Error: ::TestSingleSelection failed :";
2058           if (!aFailure.IsNull()) 
2059             cout << aFailure->GetMessageString() << endl;
2060           else
2061             cout << "%%%INFO:Error: ::TestSingleSelection : Standard_Failure with null caught failure"<< endl;
2062         }
2063         catch(...) {
2064           cout << "%%%INFO:Error: ::TestSingleSelection selection failed : unknown exception type";
2065         }
2066         TCollection_AsciiString entry;
2067         TDF_Tool::Entry(auxObj->Label(), entry);
2068         TCollection_ExtendedString aResult("");
2069         if(isSelected) {
2070           const Handle(TNaming_NamedShape)& aSelNS =  DNaming::GetObjectValue(auxObj);
2071           if(!aSelNS.IsNull() && !aSelNS->IsEmpty()) {
2072             const TopoDS_Shape& aSelectedShape = aSelNS->Get();
2073             aResult += compareShapes(aSelectedShape, aMap0);
2074             TDF_ChildIDIterator itn(auxObj->Label(),TNaming_Naming::GetID(), Standard_True);
2075             for(;itn.More();itn.Next()) {
2076               Handle(TNaming_Naming) aNaming = Handle(TNaming_Naming)::DownCast(itn.Value());
2077               if(!aNaming.IsNull()) {
2078                 const TNaming_Name& aName = aNaming->GetName();
2079                 if(aName.Type() == TNaming_UNKNOWN) {
2080                   aResult += " Selection at label = ";
2081                   aResult +=  entry;
2082                   aResult += " has UNKNOWN name type, shape type = ";
2083                   aResult += ShapeEnumToString(aCurShape.ShapeType());
2084                 }
2085                   
2086               }
2087             }
2088           }
2089         } else {
2090           aResult += " Selection at label = ";
2091           aResult +=  entry;
2092           aResult += " failed, shape type = ";
2093           aResult += ShapeEnumToString(aCurShape.ShapeType());
2094           aFailedList.Append(aCurShape);
2095         }
2096         if(aResult.Length())
2097           cout << "Failed units: " << aResult << endl;
2098       }
2099  
2100       if(aFailedList.Extent()) {
2101         TopTools_ListIteratorOfListOfShape it1(aFailedList);
2102         for(; it1.More(); it1.Next()) {
2103           const TDF_Label& aLabel = TDF_TagSource::NewChild(aDoc->Main());
2104           
2105           TNaming_Builder B(aLabel);
2106           B.Generated(it1.Value());
2107         }
2108       }
2109       if(!FirstAuxObj.IsNull())
2110         DDF::ReturnLabel(theDI, FirstAuxObj->Label());
2111       return 0;
2112     }
2113   }
2114
2115   cout << "DNaming_TestMultiple : Error" << endl;
2116   return 1;  
2117 }
2118
2119 //=======================================================================
2120 //function : ModelingCommands
2121 //purpose  : 
2122 //=======================================================================
2123
2124 void DNaming::ModelingCommands (Draw_Interpretor& theCommands)
2125 {  
2126
2127   static Standard_Boolean done = Standard_False;
2128   if (done) return;
2129   done = Standard_True;
2130   const char* g2 = "Naming modeling commands" ;
2131
2132   theCommands.Add ("AddObject", 
2133                    "AddObject D",
2134                    __FILE__, DNaming_AddObject, g2);
2135
2136   theCommands.Add ("AddFunction", 
2137                    "AddFunction D ObjEntry FunNane[Box|Sph|Cyl|Cut|Fuse|Prism|Revol|PMove|Fillet|Attach|XAttach]",
2138                    __FILE__, DNaming_AddFunction, g2);
2139
2140   theCommands.Add ("AddBox", "AddBox Doc dx dy dz",      __FILE__, DNaming_AddBox, g2);
2141   
2142   theCommands.Add ("BoxDX",  "BoxDX Doc BoxLabel NewDX", __FILE__, DNaming_BoxDX, g2);  
2143   
2144   theCommands.Add ("BoxDY",  "BoxDY Doc BoxLabel NewDY", __FILE__, DNaming_BoxDY, g2);  
2145   
2146   theCommands.Add ("BoxDZ",  "BoxDZ Doc BoxLabel NewDZ", __FILE__, DNaming_BoxDZ, g2);
2147   
2148   theCommands.Add ("ComputeFun", "ComputeFun Doc FunLabel", __FILE__, DNaming_ComputeFun, g2);
2149   
2150   theCommands.Add ("InitLogBook", "InitLogBook Doc",        __FILE__, DNaming_InitLogBook, g2);
2151
2152   theCommands.Add ("AddDriver", 
2153                    "AddDriver Doc Name [Box|Sph|Cyl|Cut|Fuse|Prism|Revol|PTxyz|PTALine|PRLine|PMirr|Fillet|Attach|XAttach]",
2154                    __FILE__, DNaming_AddDriver, g2);
2155
2156   theCommands.Add ("AttachShape", 
2157                    "AttachShape Doc Shape Context [Container [KeepOrientation [Geometry]]]",
2158                    __FILE__, DNaming_AttachShape, g2);
2159
2160   theCommands.Add ("XAttachShape", 
2161                    "XAttachShape Doc Shape Context [KeepOrientation [Geometry]]",
2162                    __FILE__, DNaming_XAttachShape, g2);  
2163
2164   theCommands.Add ("AddCyl", "AddCyl Doc Radius Height Axis", __FILE__, DNaming_AddCylinder, g2);
2165
2166   theCommands.Add ("CylRad", "CylRad Doc CylLabel NewRad",    __FILE__, DNaming_CylRad, g2);
2167
2168
2169   theCommands.Add ("AddFuse", "AddFuse Doc Object Tool",     __FILE__, DNaming_AddFuse, g2);  
2170
2171   theCommands.Add ("AddCut",   "AddCut Doc Object Tool",     __FILE__, DNaming_AddCut, g2);  
2172
2173   theCommands.Add ("AddCommon", "AddCommon Doc Object Tool",  __FILE__, DNaming_AddCommon, g2);  
2174
2175   theCommands.Add ("AddFillet", 
2176                    "AddFillet Doc Object Radius Path [SurfaceType(0-Rational;1-QuasiAngular;2-Polynomial)]",
2177                    __FILE__, DNaming_AddFillet, g2);
2178
2179   theCommands.Add ("PTranslateDXYZ", "PTranslateDXYZ Doc ShapeEntry dx dy dz",
2180                    __FILE__, DNaming_PTranslateDXYZ, g2);
2181
2182   theCommands.Add ("PTranslateAlongLine", "PTranslateAlongLine Doc ShapeEntry  Line off",
2183                    __FILE__, DNaming_PTranslateLine, g2);
2184
2185   theCommands.Add ("PRotateRoundLine", "PRotateRoundLine Doc ShapeEntry Line Angle",
2186                    __FILE__, DNaming_PRotateLine, g2);
2187
2188   theCommands.Add ("PMirror", "PMirror Doc ShapeEntry PlaneObj",
2189                    __FILE__, DNaming_PMirrorObject, g2);
2190
2191
2192   theCommands.Add ("AddPrism", "AddPrism Doc BasisLabel Height Reverse(0/1) ",
2193                    __FILE__, DNaming_AddPrism, g2);
2194
2195   theCommands.Add ("PrismHeight", "PrismHeight Doc PrismLabel NewHeight",
2196                    __FILE__, DNaming_PrismHeight, g2);
2197
2198   theCommands.Add ("AddRevol", "AddRevol Doc BasisLabel  AxisLabel [Angle [Reverse(0/1)]] ",
2199                    __FILE__, DNaming_AddRevol, g2);
2200
2201   theCommands.Add ("RevolutionAngle", "RevolutionAngle Doc RevolutionLabel NewAngle",
2202                    __FILE__, DNaming_RevolutionAngle, g2);
2203
2204   theCommands.Add ("AddSphere", "AddSphere Doc CenterLabel Radius ",
2205                    __FILE__, DNaming_AddSphere, g2);
2206
2207   theCommands.Add ("SphereRadius", "SphereRadius Doc SphereLabel NewRadius",
2208                    __FILE__, DNaming_SphereRadius, g2);
2209   
2210   theCommands.Add ("TestSingleSelection", 
2211                     "TestSingleSelection Doc ObjectLabel [Orientation [Xselection [Geometry]]]",
2212                    __FILE__, DNaming_TestSingle, g2);
2213
2214   theCommands.Add ("SolveFlatFrom", "SolveFlatFrom Doc FistAuxObjLabel",
2215                    __FILE__, DNaming_SolveFlatFrom, g2);
2216
2217   theCommands.Add ("CheckLogBook", "CheckLogBook Doc",  __FILE__, DNaming_CheckLogBook, g2);
2218
2219   theCommands.Add ("TestMultipleSelection", 
2220                    "TestMultipleSelection Doc ObjectLabel [Orientation [Xselection [Geometry]]]",
2221                    __FILE__, DNaming_Multiple, g2);
2222
2223   theCommands.Add ("AddPoint", "AddPoint Doc x y z", __FILE__, DNaming_AddPoint, g2);
2224
2225   theCommands.Add ("AddPointRlt", "AddPointRlt Doc RefPntObj dx dy dz",
2226                    __FILE__, DNaming_AddPointRlt, g2);
2227
2228   theCommands.Add ("PntOffset", "PntOffset Doc PntLabel newDX|skip newDY|skip newDZ|skip",
2229                    __FILE__, DNaming_PntOffset, g2);
2230
2231   theCommands.Add ("AddLine3D", "AddLine3D Doc CurveType(0|1) Pnt1 Pnt2 [Pnt3 [Pnt4 [...]]]",
2232                    __FILE__, DNaming_Line3D, g2);
2233 }
2234
2235