0027932: Improvement of standard attributes usability.
[occt.git] / src / DDataStd / DDataStd_BasicCommands.cxx
1 // Created on: 1997-07-30
2 // Created by: Denis PASCAL
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <DDataStd.hxx>
18
19 #include <Standard_PCharacter.hxx>
20
21 #include <DDF.hxx>
22 #include <Draw_Interpretor.hxx>
23 #include <Draw_Appli.hxx>
24 #include <DrawTrSurf.hxx>
25
26 #include <DDF.hxx>
27
28 #include <TDF_Data.hxx>
29 #include <TDF_Label.hxx>
30 #include <TDF_Tool.hxx>
31 #include <TDF_AttributeSequence.hxx>
32 #include <TDF_AttributeList.hxx>
33 #include <TDF_ListIteratorOfAttributeList.hxx>
34
35 #include <DBRep.hxx>
36 #include <TopAbs.hxx>
37 #include <TopoDS.hxx>
38 #include <TopoDS_Vertex.hxx>
39 #include <TopoDS_Edge.hxx>
40 #include <TopoDS_Wire.hxx>
41 #include <TopoDS_Face.hxx>
42 #include <TopoDS_Shell.hxx>
43 #include <TopoDS_Solid.hxx>
44 #include <TopoDS_Shape.hxx>
45
46 #include <gp_Pnt.hxx>
47 #include <gp_Dir.hxx>
48 #include <gp_Pln.hxx>
49
50 #include <TCollection_AsciiString.hxx>
51 #include <TColStd_HArray1OfReal.hxx>
52
53 // LES ATTRIBUTES
54 #include <TDataStd.hxx>
55 #include <TDataStd_Comment.hxx>
56 #include <TDataStd_Name.hxx>
57 #include <TDataStd_Integer.hxx>
58 #include <TDataStd_Real.hxx>
59 #include <TDF_Reference.hxx>
60 #include <TDataStd_UAttribute.hxx>
61 #include <TDataStd_IntegerArray.hxx>
62 #include <TDataStd_BooleanArray.hxx>
63 #include <TDataStd_RealArray.hxx>
64 #include <TDataStd_BooleanList.hxx>
65 #include <TDataStd_IntegerList.hxx>
66 #include <TDataStd_RealList.hxx>
67 #include <TDataStd_Variable.hxx>
68 #include <TDataStd_ExtStringArray.hxx>
69 #include <TDF_ChildIterator.hxx>
70 #include <TDF_Tool.hxx>
71
72 #include <TDataStd_NamedData.hxx>
73 #include <TColStd_DataMapOfStringInteger.hxx>
74 #include <TColStd_DataMapIteratorOfDataMapOfStringInteger.hxx>
75 #include <TDataStd_DataMapOfStringReal.hxx>
76 #include <TDataStd_DataMapIteratorOfDataMapOfStringReal.hxx>
77 #include <TDataStd_DataMapOfStringByte.hxx>
78 #include <TDataStd_DataMapIteratorOfDataMapOfStringByte.hxx>
79 #include <TDataStd_DataMapOfStringString.hxx>
80 #include <TDataStd_DataMapIteratorOfDataMapOfStringString.hxx>
81 #include <TDataStd_DataMapOfStringHArray1OfInteger.hxx>
82 #include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger.hxx>
83 #include <TDataStd_DataMapOfStringHArray1OfReal.hxx>
84 #include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal.hxx>
85 #include <TColStd_HArray1OfInteger.hxx>
86 #include <TColStd_HArray1OfReal.hxx>
87 #include <TDataStd_AsciiString.hxx>
88 #include <TDataStd_IntPackedMap.hxx>
89 #include <TColStd_HPackedMapOfInteger.hxx>
90 #include <TColStd_PackedMapOfInteger.hxx>
91 #include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
92 #include <TDataStd_ByteArray.hxx>
93 #include <TDataStd_ListIteratorOfListOfByte.hxx>
94 #include <TColStd_ListIteratorOfListOfInteger.hxx>
95 #include <TColStd_ListIteratorOfListOfReal.hxx>
96 #include <TDataStd_ReferenceArray.hxx>
97 #include <TDataStd_ExtStringList.hxx>
98 #include <TDataStd_ReferenceList.hxx>
99 #include <TDF_ListIteratorOfLabelList.hxx>
100 #include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
101 #define DEB_DDataStd
102
103 //=======================================================================
104 //function : DDataStd_SetInteger
105 //purpose  : SetInteger (DF, entry, value, [,guid])
106 //=======================================================================
107
108 static Standard_Integer DDataStd_SetInteger (Draw_Interpretor& di,
109                                               Standard_Integer nb, 
110                                               const char** arg) 
111 {     
112   if (nb >= 4) {    
113     Handle(TDF_Data) DF;
114     if (!DDF::GetDF(arg[1],DF)) return 1;
115     TDF_Label L;
116     DDF::AddLabel(DF, arg[2], L);
117         if(nb == 4) 
118       TDataStd_Integer::Set(L,Draw::Atoi(arg[3]));  
119         else {  
120           if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
121         di<<"DDataStd_SetInteger: The format of GUID is invalid\n";
122         return 1;
123           }
124           Standard_GUID guid(arg[4]);
125           TDataStd_Integer::Set(L, guid, Draw::Atoi(arg[3]));  
126      }
127     return 0;
128   }
129   di << "DDataStd_SetInteger : Error\n";
130   return 1;
131 }
132
133 //=======================================================================
134 //function : DDataStd_SetReal
135 //purpose  : SetReal (DF, entry, value [,guid])
136 //=======================================================================
137
138 static Standard_Integer DDataStd_SetReal (Draw_Interpretor& di,
139                                            Standard_Integer nb, 
140                                            const char** arg) 
141 {   
142   if (nb >= 4) {    
143     Handle(TDF_Data) DF;
144     if (!DDF::GetDF(arg[1],DF)) return 1;
145     TDF_Label L;
146     DDF::AddLabel(DF, arg[2], L);
147         if(nb == 4) 
148       TDataStd_Real::Set(L,Draw::Atof(arg[3]));  
149         else {  
150           if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
151         di<<"DDataStd_SetReal: The format of GUID is invalid\n";
152         return 1;
153           }
154           Standard_GUID guid(arg[4]); 
155           TDataStd_Real::Set(L, guid, Draw::Atof(arg[3]));  
156      }
157         return 0;
158         }
159   di << "DDataStd_SetReal : Error\n";
160   return 1;
161 }
162
163
164
165 //=======================================================================
166 //function : DDataStd_SetReference
167 //purpose  : SetReference (DF, entry, reference)
168 //=======================================================================
169
170 static Standard_Integer DDataStd_SetReference (Draw_Interpretor& di,
171                                                Standard_Integer nb, 
172                                                const char** arg) 
173 {   
174   if (nb == 4) {    
175     Handle(TDF_Data) DF;
176     if (!DDF::GetDF(arg[1],DF)) return 1;
177     TDF_Label L;
178     DDF::AddLabel(DF, arg[2], L);  
179     TDF_Label LREF;
180     if (!DDF::FindLabel(DF,arg[3],LREF)) return 1;
181     TDF_Reference::Set(L,LREF);  
182     return 0;
183   } 
184   di << "DDataStd_SetReference : Error\n";
185   return 1;
186 }
187
188
189 //=======================================================================
190 //function : DDataStd_SetComment
191 //purpose  : SetComment (DF, entry, Comment)
192 //=======================================================================
193
194 static Standard_Integer DDataStd_SetComment (Draw_Interpretor& di,
195                                                Standard_Integer nb, 
196                                                const char** arg) 
197 {   
198   if (nb == 4) {    
199     Handle(TDF_Data) DF;
200     if (!DDF::GetDF(arg[1],DF)) return 1;
201     TDF_Label L;
202     DDF::AddLabel(DF, arg[2], L);
203     TDataStd_Comment::Set(L,TCollection_ExtendedString(arg[3],Standard_True));  
204     return 0;
205   }
206   di << "DDataStd_SetComment : Error\n";
207   return 1;
208 }
209
210 //=======================================================================
211 //function : DDataStd_GetInteger
212 //purpose  : GetReal (DF, entry, [drawname][, guid])
213 //=======================================================================
214
215 static Standard_Integer DDataStd_GetInteger (Draw_Interpretor& di,
216                                               Standard_Integer nb, 
217                                               const char** arg) 
218 {     
219   if (nb == 3 || nb == 4 || nb == 5) {
220     Handle(TDF_Data) DF;
221     if (!DDF::GetDF(arg[1],DF)) return 1;
222     Handle(TDataStd_Integer) A;
223         Standard_GUID aGuid;
224         Standard_GUID aNullGuid("00000000-0000-0000-0000-000000000000");
225         Standard_Boolean isdrawname(Standard_False);
226         if(nb < 5 ) {
227       if(nb == 4) { //DF, entry, guid
228             if (Standard_GUID::CheckGUIDFormat(arg[3])) 
229           aGuid = Standard_GUID(arg[3]);
230           }
231           if(Standard_GUID::IsEqual(aGuid, aNullGuid)) {
232             isdrawname = Standard_True;
233             aGuid = TDataStd_Integer::GetID();
234           }
235         } else if(nb == 5) {
236           isdrawname = Standard_True; 
237           if (Standard_GUID::CheckGUIDFormat(arg[4])) 
238         aGuid = Standard_GUID(arg[4]);
239           else {
240         di<<"DDataStd_GetInteger: The format of GUID is invalid\n";
241         return 1;
242           }
243         } 
244                   
245     if (!DDF::Find(DF,arg[2],aGuid,A)) return 1;
246     if (nb == 4 && isdrawname) Draw::Set(arg[3],A->Get());
247     else         Draw::Set(arg[2],A->Get());
248     di << A->Get();
249     return 0;
250   }
251   di << "DDataStd_GetInteger : Error\n";
252   return 1;
253 }
254
255 //=======================================================================
256 //function : DDataStd_GetReal
257 //purpose  : GetReal (DF, entry, [drawname][, guid])
258 //=======================================================================
259
260 static Standard_Integer DDataStd_GetReal (Draw_Interpretor& di,
261                                           Standard_Integer nb, 
262                                           const char** arg) 
263 {  
264   if (nb == 3 || nb == 4 || nb == 5) {
265     Handle(TDF_Data) DF;
266     if (!DDF::GetDF(arg[1],DF)) return 1;
267     Handle(TDataStd_Real) A;
268         Standard_GUID aGuid;
269     Standard_GUID aNullGuid("00000000-0000-0000-0000-000000000000");
270         Standard_Boolean isdrawname(Standard_False);
271     if(nb < 5 ) {
272           if(nb == 4) {
273             if (Standard_GUID::CheckGUIDFormat(arg[3])) 
274           aGuid = Standard_GUID(arg[3]);
275           }
276           if(Standard_GUID::IsEqual(aGuid, aNullGuid)) {
277             isdrawname = Standard_True;
278             aGuid = TDataStd_Real::GetID();
279           }
280         }
281         else if(nb == 5) {
282           isdrawname = Standard_True; 
283           if (Standard_GUID::CheckGUIDFormat(arg[4])) 
284         aGuid = Standard_GUID(arg[4]);
285           else {
286         di<<"DDataStd_GetReal: The format of GUID is invalid\n";
287         return 1;
288           }
289         } 
290     if (!DDF::Find(DF,arg[2],aGuid,A)) return 1;
291     if (nb == 4 && isdrawname) Draw::Set(arg[3],A->Get());
292     else         Draw::Set(arg[2],A->Get());
293     di << A->Get();
294     return 0;
295   }
296   di << "DDataStd_GetReal : Error\n";
297   return 1;
298 }
299
300
301 //=======================================================================
302 //function : DDataStd_GetReference
303 //purpose  : GetShape (DF, entry)
304 //=======================================================================
305
306 static Standard_Integer DDataStd_GetReference (Draw_Interpretor& di,
307                                                Standard_Integer nb, 
308                                                const char** arg) 
309 {  
310   if (nb == 3) {
311     Handle(TDF_Data) DF;
312     if (!DDF::GetDF(arg[1],DF)) return 1;
313     Handle(TDF_Reference) REF;
314     if (!DDF::Find(DF,arg[2],TDF_Reference::GetID(),REF)) return 1;
315     TCollection_AsciiString entry; TDF_Tool::Entry(REF->Get(),entry);
316     di << entry.ToCString();
317     return 0;
318   }
319   di << "DDataStd_GetReference : Error\n";
320   return 1;
321 }
322
323 //=======================================================================
324 //function : DDataStd_GetComment
325 //purpose  : GetShape (DF, entry)
326 //=======================================================================
327
328 static Standard_Integer DDataStd_GetComment (Draw_Interpretor& di,
329                                           Standard_Integer nb, 
330                                           const char** arg) 
331
332   if (nb == 3) {
333     Handle(TDF_Data) DF;
334     if (!DDF::GetDF(arg[1],DF)) return 1;
335     Handle(TDataStd_Comment) A;
336     if (!DDF::Find(DF,arg[2],TDataStd_Comment::GetID(),A)) return 1;
337     TCollection_AsciiString s(A->Get(),'?');
338     di << A->Get().ToExtString();
339     return 0;
340   }
341   di << "DDataStd_GetComment : Error\n";
342   return 1;
343 }
344
345
346
347 //=======================================================================
348 //function :
349 //purpose  : Self (document,label)
350 //=======================================================================
351
352 static Standard_Integer DDataStd_Self (Draw_Interpretor& di,
353                                        Standard_Integer nb, 
354                                        const char** arg) 
355 {    
356   TCollection_AsciiString s;  
357   if (nb == 3) {  
358     Handle(TDF_Data) DF;
359     if (!DDF::GetDF(arg[1],DF)) return 1;
360     TDF_Label L;
361     if (!DDF::FindLabel(DF,arg[2],L)) return 1; 
362 //    TDataStd::MakeSelfContained(L,removed);
363 //    if (removed.IsEmpty()) cout << "noone attriburte removed" << endl;
364 //    for (TDF_ListIteratorOfAttributeList it(removed);it.More();it.Next()) {
365 //      TDF_Tool::Entry(it.Value()->Label(),s); cout  << s << " ";
366 //      cout << endl;
367 //    }
368     return 0;
369   } 
370   di << "Self : Error\n";
371   return 0;
372 }
373
374
375
376 //=======================================================================
377 //function : SetUObject (DF, entry, ObjectID)
378 //=======================================================================
379 // static Standard_Integer DDataStd_SetUObject (Draw_Interpretor&,
380 //                                            Standard_Integer nb, 
381 //                                            const char** arg) 
382 // {   
383 //   if( nb == 4 ) {
384 //     Handle(TDF_Data) DF;
385 //     if (!DDF::GetDF(arg[1],DF))  return 1;
386 //     TDF_Label label;
387 //     DDF::AddLabel(DF, arg[2], label);
388
389 //     Standard_GUID guid(arg[3]);  //"00000000-0000-0000-1111-000000000000");
390 //     TDataStd_UObject::Set(label, guid);
391 //     return 0;
392 //   }
393
394 //   cout << "Wrong arguments"  << endl;  
395 //   return 1;
396 // } 
397
398 //=======================================================================
399 //function : SetUAttribute (DF, entry, LocalID)
400 //=======================================================================
401 static Standard_Integer DDataStd_SetUAttribute (Draw_Interpretor& di,
402                                                 Standard_Integer nb, 
403                                                 const char** arg) 
404 {   
405   if( nb == 4 ) { 
406     Handle(TDF_Data) DF;
407     if (!DDF::GetDF(arg[1],DF))  return 1; 
408     TDF_Label label;
409     DDF::AddLabel(DF, arg[2], label);
410
411     Standard_GUID guid(arg[3]);  //"00000000-0000-0000-2222-000000000000");
412     TDataStd_UAttribute::Set(label, guid);
413     return 0; 
414   }
415
416   di << "Wrong arguments"  << "\n";  
417   return 1; 
418
419
420 //=======================================================================
421 //function : GetUAttribute (DF, entry, LoaclID)
422 //=======================================================================
423 static Standard_Integer DDataStd_GetUAttribute (Draw_Interpretor& di,
424                                                 Standard_Integer nb, 
425                                                 const char** arg) 
426 {   
427   if( nb == 4 ) {  
428     Handle(TDF_Data) DF;
429     if (!DDF::GetDF(arg[1],DF)) return 1; 
430     TDF_Label label;
431     if( !DDF::FindLabel(DF, arg[2], label) ) {
432      di << "No label for entry"  << "\n";
433      return 1;
434     }
435     Standard_GUID guid(arg[3]);  //"00000000-0000-0000-2222-000000000000");
436
437     Handle(TDataStd_UAttribute) UA;    
438     if( !label.FindAttribute(guid, UA) ) {
439       di << "No UAttribute Attribute on label"   << "\n";
440     }
441     else {
442       char *aStrGUID = new char[37];
443       UA->ID().ToCString(aStrGUID);
444       di << aStrGUID;
445     }
446     return 0;  
447   }
448
449   di << "Wrong arguments"  << "\n";  
450   return 1;  
451
452
453
454 //=======================================================================
455 //function : CheckUObject (DF, entry, ObjectID)
456 //=======================================================================
457 // static Standard_Integer DDataStd_CheckUObject (Draw_Interpretor&,
458 //                                           Standard_Integer nb, 
459 //                                           const char** arg) 
460 // {   
461 //   if( nb == 4 ) {   
462 //     Handle(TDF_Data) DF;
463 //     if (!DDF::GetDF(arg[1],DF)) return 1;  
464 //     TDF_Label label;
465 //     if( !DDF::FindLabel(DF, arg[2], label) ) { 
466 //      cout << "No label for entry"  << endl;
467 //      return 1; 
468 //     }
469 //     Handle(TDataStd_Object) O;
470 //     Handle(TDataStd_UObject) UO;    
471 //     Standard_GUID guidUO(arg[3]);
472
473 //     if( !label.FindAttribute( TDataStd_Object::GetID(), O) ) {
474 //       cout << "No Object Attribute on label"   << endl;
475 //     }
476 //     else { 
477 //       cout << "UObject is found with ObjectID = ";
478 //       O->Find(label, guidUO, UO);
479 //       UO->ObjectID().ShallowDump(cout);
480 //       cout << endl; 
481 //     }
482 //     return 0;   
483 //   }
484
485 //   cout << "Wrong arguments"  << endl;  
486 //   return 1;  
487 // }
488
489
490 //=======================================================================
491 //function : SetIntArray (DF, entry , isDelta, From, To,  elmt1, elmt2, ...
492 //=======================================================================
493 static Standard_Integer DDataStd_SetIntArray (Draw_Interpretor& di,
494                                               Standard_Integer nb,
495                                               const char** arg) 
496 {
497   Handle(TDF_Data) DF;
498   if (!DDF::GetDF(arg[1],DF))  return 1; 
499   TDF_Label label;
500   DDF::AddLabel(DF, arg[2], label);
501   Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
502   Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
503   di << "Array of Standard_Integer with bounds from = " << From  << " to = " << To  << "\n";
504   Handle(TDataStd_IntegerArray) A = TDataStd_IntegerArray::Set(label, From, To, isDelta);
505   
506   if (nb > 6) {
507     j = 6;
508     for(Standard_Integer i = From; i<=To; i++) {
509       A->SetValue(i, Draw::Atoi(arg[j]) ); 
510       j++;
511     }
512   }
513
514   return 0; 
515
516
517 //=======================================================================
518 //function : SetIntArrayValue (DF, entry, index, value)
519 //=======================================================================
520 static Standard_Integer DDataStd_SetIntArrayValue (Draw_Interpretor&,
521                                                    Standard_Integer,
522                                                    const char** arg) 
523 {
524   // Get document.
525   Handle(TDF_Data) DF;
526   if (!DDF::GetDF(arg[1], DF))
527     return 1;
528
529   // Get label.
530   TDF_Label label; 
531   if (!DDF::AddLabel(DF, arg[2], label))
532     return 1;
533  
534   // Get index and value.
535   Standard_Integer index = Draw::Atoi(arg[3]);
536   Standard_Integer value = Draw::Atoi(arg[4]);
537
538   // Set new value.
539   Handle(TDataStd_IntegerArray) arr;
540   if (label.FindAttribute(TDataStd_IntegerArray::GetID(), arr))
541   {
542     arr->SetValue(index, value); 
543     return 0;
544   }
545
546   return 1;
547
548
549 //=======================================================================
550 //function : GetIntArray (DF, entry )
551 //=======================================================================
552 static Standard_Integer DDataStd_GetIntArray (Draw_Interpretor& di,
553                                               Standard_Integer, 
554                                               const char** arg) 
555 {   
556
557
558   Handle(TDF_Data) DF;
559   if (!DDF::GetDF(arg[1],DF))  return 1;  
560   TDF_Label label;
561   if( !DDF::FindLabel(DF, arg[2], label) ) {
562     di << "No label for entry"  << "\n";
563     return 1;
564   }
565  
566   Handle(TDataStd_IntegerArray) A;
567   if ( !label.FindAttribute(TDataStd_IntegerArray::GetID(), A) ) { 
568     di << "There is no TDataStd_IntegerArray under label"  << "\n";
569     return 1;
570   }
571   
572   for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
573     //cout <<  A->Value(i)   << endl;
574     di  <<  A->Value(i);
575     if(i<A->Upper())  
576      di<<" ";
577   }
578   di<<"\n";
579   return 0; 
580
581
582 //=======================================================================
583 //function : GetIntArrayValue (DF, entry, index)
584 //=======================================================================
585 static Standard_Integer DDataStd_GetIntArrayValue (Draw_Interpretor& di,
586                                                    Standard_Integer, 
587                                                    const char** arg) 
588 {
589   Handle(TDF_Data) DF;
590   if (!DDF::GetDF(arg[1],DF))
591       return 1;
592
593   TDF_Label label;
594   if (!DDF::FindLabel(DF, arg[2], label)) {
595     di << "No label for entry"  << "\n";
596     return 1;
597   }
598  
599   Handle(TDataStd_IntegerArray) A;
600   if ( !label.FindAttribute(TDataStd_IntegerArray::GetID(), A) ) { 
601     di << "There is no TDataStd_IntegerArray under label"  << "\n";
602     return 1;
603   }
604   
605   Standard_Integer index = Draw::Atoi(arg[3]);
606   if (index < A->Lower() || index > A->Upper()) {
607     di << "Index is out of range\n";
608     return 1;
609   } else {
610     di << A->Value(index) << "\n";
611   }
612
613   return 0; 
614
615
616 //=======================================================================
617 //function : ChangeIntArray (DF, entry, indx, val )
618 //=======================================================================
619 static Standard_Integer DDataStd_ChangeIntArray (Draw_Interpretor& di,
620                                               Standard_Integer nb, 
621                                               const char** arg) 
622 {   
623
624   if( nb == 5 ) {  
625     Handle(TDF_Data) DF;
626     if (!DDF::GetDF(arg[1],DF))  return 1;  
627     TDF_Label label;
628     if( !DDF::FindLabel(DF, arg[2], label) ) {
629       di << "No label for entry"  << "\n";
630       return 1;
631     }
632  
633     Handle(TDataStd_IntegerArray) A;
634     if ( !label.FindAttribute(TDataStd_IntegerArray::GetID(), A) ) { 
635       di << "There is no TDataStd_IntegerArray at label"  << "\n";
636       return 1;
637     }
638     Standard_Integer indx = Draw::Atoi(arg[3]);
639     Standard_Integer val  = Draw::Atoi(arg[4]);
640     Standard_Integer low = A->Lower(), up = A->Upper();
641     if(low <= indx && indx <= up)
642       A->SetValue(indx, val);
643     else {
644       Handle(TColStd_HArray1OfInteger) Arr = A->Array();
645       Handle(TColStd_HArray1OfInteger) arr;
646       Standard_Integer i;
647       if(indx > up) {
648         up = indx;
649         arr = new TColStd_HArray1OfInteger(low, up);
650         for(i=low; i<= Arr->Upper(); i++)
651           arr->SetValue(i, Arr->Value(i));
652         for(i=Arr->Upper()+1; i<= up; i++) {
653           if(i == up)
654             arr->SetValue(i, val);
655           else
656             arr->SetValue(i, 0);
657         }
658       } else if(indx < up) {//clip array : indx to be negative
659         up = abs(indx);
660         arr = new TColStd_HArray1OfInteger(low, up);
661         for(i=low; i< up; i++)
662           arr->SetValue(i, Arr->Value(i));
663         arr->SetValue(up, val);
664       }
665       A->ChangeArray(arr);
666     }
667     return 0;
668   }
669   di << "DDataStd_ChangeIntArray: Error\n";
670   return 0; 
671
672
673 //=======================================================================
674 //function : SetIntArrayT (DF, entry , isDelta, From, To) - for testing
675 //         : huge arrays
676 //=======================================================================
677 static Standard_Integer DDataStd_SetIntArrayTest (Draw_Interpretor& di,
678                                               Standard_Integer, 
679                                               const char** arg) 
680 {   
681
682
683   Handle(TDF_Data) DF;
684   if (!DDF::GetDF(arg[1],DF))  return 1; 
685   TDF_Label label;
686   DDF::AddLabel(DF, arg[2], label);
687   Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
688   Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
689   di << "Array of Standard_Integer with bounds from = " << From  << " to = " << To  << "\n";
690   Handle(TDataStd_IntegerArray) A = TDataStd_IntegerArray::Set(label, From, To, isDelta);
691   
692   j = 6;
693   Standard_Integer k = 100;
694   for(Standard_Integer i = From; i<=To; i++) {
695     A->SetValue(i, ++k); 
696     j++;
697   }
698
699   return 0; 
700
701
702 //=======================================================================
703 //function : SetRealArray (DF, entry , isDelta, From, To,  elmt1, elmt2, ...
704 //=======================================================================
705 static Standard_Integer DDataStd_SetRealArray (Draw_Interpretor& di,
706                                                Standard_Integer nb, 
707                                                const char** arg) 
708 {   
709
710
711   Handle(TDF_Data) DF;
712   if (!DDF::GetDF(arg[1],DF))  return 1;  
713   TDF_Label label; 
714   DDF::AddLabel(DF, arg[2], label);
715   Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
716  
717   Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
718   di << " Array of Standard_Real with bounds from = " << From  << " to = " << To  << "\n";
719   Handle(TDataStd_RealArray) A = TDataStd_RealArray::Set(label, From, To, isDelta);
720   
721   if (nb > 6) {
722     j = 6;
723     for(Standard_Integer i = From; i<=To; i++) {
724       A->SetValue(i, Draw::Atof(arg[j]) );
725       j++;
726     }
727   }
728
729   return 0;  
730
731
732 //=======================================================================
733 //function : SetRealArrayValue (DF, entry, index value)
734 //=======================================================================
735 static Standard_Integer DDataStd_SetRealArrayValue (Draw_Interpretor&,
736                                                     Standard_Integer, 
737                                                     const char** arg) 
738 {
739   // Get document.
740   Handle(TDF_Data) DF;
741   if (!DDF::GetDF(arg[1], DF))
742     return 1;
743
744   // Get label.
745   TDF_Label label; 
746   if (!DDF::AddLabel(DF, arg[2], label))
747     return 1;
748  
749   // Get index and value.
750   Standard_Integer index = Draw::Atoi(arg[3]);
751   Standard_Real    value = Draw::Atof(arg[4]);
752
753   // Set new value.
754   Handle(TDataStd_RealArray) realArray;
755   if (label.FindAttribute(TDataStd_RealArray::GetID(), realArray))
756   {
757     realArray->SetValue(index, value); 
758     return 0;
759   }
760
761   return 1;
762
763
764 //=======================================================================
765 //function : GetRealArray (DF, entry )
766 //=======================================================================
767 static Standard_Integer DDataStd_GetRealArray (Draw_Interpretor& di,
768                                                Standard_Integer, 
769                                                const char** arg) 
770 {   
771
772   Handle(TDF_Data) DF;
773   if (!DDF::GetDF(arg[1],DF))  return 1;  
774   TDF_Label label;
775   if( !DDF::FindLabel(DF, arg[2], label) ) { 
776     di << "No label for entry"  << "\n";
777     return 1; 
778   }
779  
780   Handle(TDataStd_RealArray) A;
781   if ( !label.FindAttribute(TDataStd_RealArray::GetID(), A) ) { 
782     di << "There is no TDataStd_RealArray under label"  << "\n";
783     return 1; 
784   }
785   
786   for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
787     //cout <<  A->Value(i)   << endl; 
788     di   <<  A->Value(i);
789     if(i<A->Upper())  
790      di<<" ";
791   }  
792   di<<"\n";
793
794   return 0;  
795
796
797 //=======================================================================
798 //function : GetRealArrayValue (DF, entry, index)
799 //=======================================================================
800 static Standard_Integer DDataStd_GetRealArrayValue (Draw_Interpretor& di,
801                                                     Standard_Integer, 
802                                                     const char** arg) 
803 {
804   Handle(TDF_Data) DF;
805   if (!DDF::GetDF(arg[1],DF))
806       return 1;
807
808   TDF_Label label;
809   if (!DDF::FindLabel(DF, arg[2], label)) {
810     di << "No label for entry"  << "\n";
811     return 1;
812   }
813  
814   Handle(TDataStd_RealArray) A;
815   if ( !label.FindAttribute(TDataStd_RealArray::GetID(), A) ) { 
816     di << "There is no TDataStd_RealArray under label"  << "\n";
817     return 1;
818   }
819   
820   Standard_Integer index = Draw::Atoi(arg[3]);
821   if (index < A->Lower() || index > A->Upper()) {
822     di << "Index is out of range\n";
823     return 1;
824   } else {
825     di << A->Value(index) << "\n";
826   }
827
828   return 0; 
829
830
831 //=======================================================================
832 //function : ChangeRealArray (DF, entry, indx, val )
833 //=======================================================================
834 static Standard_Integer DDataStd_ChangeRealArray (Draw_Interpretor& di,
835                                                   Standard_Integer nb, 
836                                                   const char** arg) 
837 {   
838
839   if( nb == 5 ) {  
840     Handle(TDF_Data) DF;
841     if (!DDF::GetDF(arg[1],DF))  return 1;  
842     TDF_Label label;
843     if( !DDF::FindLabel(DF, arg[2], label) ) {
844       di << "No label for entry"  << "\n";
845       return 1;
846     }
847  
848     Handle(TDataStd_RealArray) A;
849     if ( !label.FindAttribute(TDataStd_RealArray::GetID(), A) ) { 
850       di << "There is no TDataStd_RealArray at label"  << "\n";
851       return 1;
852     }
853     Standard_Integer indx = Draw::Atoi(arg[3]);
854     Standard_Real val  = Draw::Atof(arg[4]);
855     Standard_Integer low = A->Lower(), up = A->Upper();
856     if(low <= indx && indx <= up)
857       A->SetValue(indx, val);
858     else {
859       Handle(TColStd_HArray1OfReal) Arr = A->Array();
860       Handle(TColStd_HArray1OfReal) arr;
861       Standard_Integer i;
862       if(indx > up) {
863         up = indx;
864         arr = new TColStd_HArray1OfReal(low, up);
865         for(i=low; i<= Arr->Upper(); i++)
866           arr->SetValue(i, Arr->Value(i));
867         for(i=Arr->Upper()+1; i<= up; i++) {
868           if(i == up)
869             arr->SetValue(i, val);
870           else
871             arr->SetValue(i, 0);
872         }
873       } else if(indx < up) {//clip array : indx to be negative
874         up = abs(indx);
875         arr = new TColStd_HArray1OfReal(low, up);
876         for(i=low; i< up; i++)
877           arr->SetValue(i, Arr->Value(i));
878         arr->SetValue(up, val);
879       }
880       A->ChangeArray(arr);
881     }
882     return 0;
883   }
884   di << "DDataStd_ChangeRealArray: Error\n";
885   return 0; 
886
887
888 //=======================================================================
889 //function : SetVariable (DF, entry, isConstant[0/1], units)
890 //=======================================================================
891 static Standard_Integer DDataStd_SetVariable (Draw_Interpretor& di,
892                                               Standard_Integer nb, 
893                                               const char** arg)
894 {
895   if (nb == 5)
896   {
897     Handle(TDF_Data) DF;
898     if (!DDF::GetDF(arg[1],DF))  return 1; 
899     TDF_Label label;
900     DDF::AddLabel(DF, arg[2], label);
901
902     Handle(TDataStd_Variable) aV = TDataStd_Variable::Set(label);
903
904     const char* aUnits = arg[4];
905     aV->Unit(Standard_CString(aUnits));
906
907     aV->Constant (Draw::Atoi(arg[3]) != 0);
908     return 0; 
909   }
910
911   di << "Wrong arguments\n";  
912   return 1; 
913
914
915 //=======================================================================
916 //function : GetVariable (DF, entry, [isConstant], [units])
917 //=======================================================================
918 static Standard_Integer DDataStd_GetVariable (Draw_Interpretor& di,
919                                               Standard_Integer nb, 
920                                               const char** arg)
921 {
922   if (nb == 5)
923   {
924     Handle(TDF_Data) DF;
925     if (!DDF::GetDF(arg[1],DF))  return 1; 
926     TDF_Label label;
927     DDF::AddLabel(DF, arg[2], label);
928
929     Handle(TDataStd_Variable) aV;
930     if (!label.FindAttribute(TDataStd_Variable::GetID(), aV))
931     {
932       di << "TDataStd_Variable: no such attribute\n";
933     }
934
935     Draw::Set(arg[3],TCollection_AsciiString(Standard_Integer(aV->IsConstant())).ToCString());
936     Draw::Set(arg[4],aV->Unit().ToCString());
937     return 0; 
938   }
939
940   di << "Wrong arguments\n";  
941   return 1; 
942
943
944 #include <TDataStd_Relation.hxx>
945 #include <TDataStd_Variable.hxx>
946 //=======================================================================
947 //function : SetRelation (DF, entry, expression, var1[, var2, ...])
948 //=======================================================================
949 static Standard_Integer DDataStd_SetRelation (Draw_Interpretor& di,
950                                               Standard_Integer nb, const char** arg) 
951 {
952   if (nb >= 5)
953   {
954     Handle(TDF_Data) DF;
955     if (!DDF::GetDF(arg[1],DF)) return 1;
956     TDF_Label label;
957     DDF::AddLabel(DF, arg[2], label);
958
959     Standard_CString expr (arg[3]);
960     Handle(TDataStd_Relation) aR = TDataStd_Relation::Set(label);
961     aR->SetRelation(expr);
962     Handle(TDataStd_Variable) aV;
963
964     for (Standard_Integer i = 4; i < nb; i++)
965     {
966       if (!DDF::FindLabel(DF, arg[i], label))
967       {
968         di << "No label for entry" << arg[i] << "\n";
969         return 1;
970       }
971       if (!label.FindAttribute(TDataStd_Variable::GetID(), aV))
972       {
973         di << "No TDataStd_Variable Attribute on label\n";
974         return 1;
975       }
976       aR->GetVariables().Append(aV);
977     }
978     return 0;
979   }
980   di << "Usage: SetRelation (DF, entry, expression, var1[, var2, ...])\n";
981   return 1;
982 }
983
984 //=======================================================================
985 //function : DumpRelation (DF, entry)
986 //=======================================================================
987 static Standard_Integer DDataStd_DumpRelation (Draw_Interpretor& di,
988                                                Standard_Integer nb, const char** arg) 
989 {
990   if (nb == 3)
991   {
992     Handle(TDF_Data) DF;
993     if (!DDF::GetDF(arg[1],DF)) return 1;
994
995     TDF_Label label;
996     if (!DDF::FindLabel(DF, arg[2], label))
997     {
998       di << "No label for entry " << arg[2] << "\n";
999       return 1;
1000     }
1001     Handle(TDataStd_Relation) aR;
1002     if (!label.FindAttribute(TDataStd_Relation::GetID(), aR))
1003     {
1004       di << "No TDataStd_Relation Attribute on label " << arg[2] << "\n";
1005       return 1;
1006     }
1007
1008     di << "Relation: expression = \"" << aR->GetRelation()
1009        << "\" variables list = (";
1010
1011     Handle(TDF_Attribute) aV;
1012     TCollection_AsciiString anEntry;
1013
1014     TDF_ListIteratorOfAttributeList it;
1015     for (it.Initialize(aR->GetVariables()); it.More(); it.Next())
1016     {
1017       aV = it.Value(); 
1018       if (!aV.IsNull())
1019       {
1020         label = aV->Label();
1021         TDF_Tool::Entry(label, anEntry);
1022         di << anEntry.ToCString() << " ";
1023       }
1024     }
1025     di << ")";
1026     return 0;
1027   }
1028   di << "Usage: DumpRelation (DF, entry)\n";
1029   return 1;
1030 }
1031
1032 #include <TFunction_Function.hxx>
1033 //=======================================================================
1034 //function : SetFunction (DF, entry, guid, failure)
1035 //=======================================================================
1036 static Standard_Integer DDataStd_SetFunction (Draw_Interpretor& di,
1037                                               Standard_Integer nb, const char** arg)
1038 {
1039   if (nb == 5)
1040   {
1041     Handle(TDF_Data) DF;
1042     if (!DDF::GetDF(arg[1],DF))  return 1;
1043     TDF_Label label;
1044     DDF::AddLabel(DF, arg[2], label);
1045
1046     Standard_GUID guid (arg[3]);
1047     Handle(TFunction_Function) aF = TFunction_Function::Set(label, guid);
1048
1049     int fail = Draw::Atoi(arg[4]);
1050     aF->SetFailure(fail);
1051
1052     return 0;
1053   }
1054
1055   di << "Wrong arguments"  << "\n";
1056   return 1;
1057 }
1058
1059 //=======================================================================
1060 //function : GetFunction (DF, entry, guid(out), failure(out))
1061 //=======================================================================
1062 static Standard_Integer DDataStd_GetFunction (Draw_Interpretor& di,
1063                                               Standard_Integer nb, const char** arg) 
1064 {   
1065   if (nb == 5)
1066   {  
1067     Handle(TDF_Data) DF;
1068     if (!DDF::GetDF(arg[1],DF)) return 1; 
1069     TDF_Label label;
1070     if (!DDF::FindLabel(DF, arg[2], label))
1071     {
1072      di << "No label for entry"  << "\n";
1073      return 1;
1074     }
1075
1076     Handle(TFunction_Function) aF;    
1077     if (!label.FindAttribute(TFunction_Function::GetID(), aF))
1078     {
1079       di << "No TFunction_Function Attribute on label\n";
1080     }
1081     else
1082     {
1083       char *aStrGUID = new char[37];
1084       aF->GetDriverGUID().ToCString(aStrGUID);
1085       Draw::Set(arg[3],aStrGUID);
1086
1087       Draw::Set(arg[4],TCollection_AsciiString(aF->GetFailure()).ToCString());
1088     }
1089     return 0;  
1090   }
1091
1092   di << "Wrong arguments"  << "\n";  
1093   return 1;  
1094
1095
1096 //=======================================================================
1097 //function : SetExtStringArray (DF, entry , isDelta, From, To,  elmt1, elmt2, ...
1098 //=======================================================================
1099 static Standard_Integer DDataStd_SetExtStringArray (Draw_Interpretor& di,
1100                                                                             Standard_Integer nb, 
1101                                                                             const char** arg) 
1102 {   
1103   Handle(TDF_Data) DF;
1104   if (!DDF::GetDF(arg[1],DF))  return 1; 
1105   TDF_Label label;
1106   DDF::AddLabel(DF, arg[2], label);
1107   Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
1108
1109   Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
1110   di << "Array of ExtString with bounds from = " << From  << " to = " << To  << "\n";
1111   Handle(TDataStd_ExtStringArray) A = TDataStd_ExtStringArray::Set(label, From, To, isDelta);
1112   
1113   if (nb > 6) {
1114     j = 6;
1115     for(Standard_Integer i = From; i<=To; i++) {
1116       A->SetValue(i, arg[j] ); 
1117       j++;
1118     }
1119   }
1120
1121   return 0; 
1122
1123
1124 //=======================================================================
1125 //function : SetExtStringArrayValue (DF, entry, index, value)
1126 //=======================================================================
1127 static Standard_Integer DDataStd_SetExtStringArrayValue (Draw_Interpretor&,
1128                                                          Standard_Integer,
1129                                                          const char** arg) 
1130 {
1131   // Get document.
1132   Handle(TDF_Data) DF;
1133   if (!DDF::GetDF(arg[1], DF))
1134     return 1;
1135
1136   // Get label.
1137   TDF_Label label; 
1138   if (!DDF::AddLabel(DF, arg[2], label))
1139     return 1;
1140  
1141   // Get index and value.
1142   Standard_Integer index = Draw::Atoi(arg[3]);
1143
1144   // Set new value.
1145   Handle(TDataStd_ExtStringArray) arr;
1146   if (label.FindAttribute(TDataStd_ExtStringArray::GetID(), arr))
1147   {
1148     arr->SetValue(index, arg[4]); 
1149     return 0;
1150   }
1151
1152   return 1;
1153
1154
1155 //=======================================================================
1156 //function : GetExtStringArray (DF, entry )
1157 //=======================================================================
1158 static Standard_Integer DDataStd_GetExtStringArray (Draw_Interpretor& di,
1159                                                     Standard_Integer, 
1160                                                     const char** arg) 
1161 {   
1162
1163
1164   Handle(TDF_Data) DF;
1165   if (!DDF::GetDF(arg[1],DF))  return 1;  
1166   TDF_Label label;
1167   if( !DDF::FindLabel(DF, arg[2], label) ) {
1168     di << "No label for entry"  << "\n";
1169     return 1;
1170   }
1171  
1172   Handle(TDataStd_ExtStringArray) A;
1173   if ( !label.FindAttribute(TDataStd_ExtStringArray::GetID(), A) ) { 
1174     di << "There is no TDataStd_ExtStringArray under label"  << "\n";
1175     return 1;
1176   }
1177   
1178   for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
1179     TCollection_AsciiString anAsciiString(A->Value(i),'?');
1180     di << anAsciiString.ToCString();
1181     if(i<A->Upper())  
1182       di<<" ";
1183   }
1184   di<<"\n";
1185   return 0; 
1186
1187
1188 //=======================================================================
1189 //function : GetExtStringArrayValue (DF, entry, index)
1190 //=======================================================================
1191 static Standard_Integer DDataStd_GetExtStringArrayValue (Draw_Interpretor& di,
1192                                                          Standard_Integer, 
1193                                                          const char** arg) 
1194 {
1195   Handle(TDF_Data) DF;
1196   if (!DDF::GetDF(arg[1],DF))
1197       return 1;
1198
1199   TDF_Label label;
1200   if (!DDF::FindLabel(DF, arg[2], label)) {
1201     di << "No label for entry"  << "\n";
1202     return 1;
1203   }
1204  
1205   Handle(TDataStd_ExtStringArray) A;
1206   if ( !label.FindAttribute(TDataStd_ExtStringArray::GetID(), A) ) { 
1207     di << "There is no TDataStd_ExtStringArray under label"  << "\n";
1208     return 1;
1209   }
1210   
1211   Standard_Integer index = Draw::Atoi(arg[3]);
1212   if (index < A->Lower() || index > A->Upper()) {
1213     di << "Index is out of range\n";
1214     return 1;
1215   } else {
1216     const TCollection_ExtendedString& value = A->Value(index);
1217     di << value ;
1218   }
1219
1220   return 0; 
1221
1222
1223 //=======================================================================
1224 //function : ChangeExtStrArray (DF, entry, indx, val )
1225 //=======================================================================
1226 static Standard_Integer DDataStd_ChangeExtStrArray (Draw_Interpretor& di,
1227                                               Standard_Integer nb, 
1228                                               const char** arg) 
1229 {   
1230
1231   if( nb == 5 ) {  
1232     Handle(TDF_Data) DF;
1233     if (!DDF::GetDF(arg[1],DF))  return 1;  
1234     TDF_Label label;
1235     if( !DDF::FindLabel(DF, arg[2], label) ) {
1236       di << "No label for entry"  << "\n";
1237       return 1;
1238     }
1239  
1240     Handle(TDataStd_ExtStringArray) A;
1241     if ( !label.FindAttribute(TDataStd_ExtStringArray::GetID(), A) ) { 
1242       di << "There is no TDataStd_ExtStringArray at label"  << "\n";
1243       return 1;
1244     }
1245     Standard_Integer indx = Draw::Atoi(arg[3]);
1246     TCollection_ExtendedString val(arg[4]);
1247     Standard_Integer low = A->Lower(), up = A->Upper();
1248     if(low <= indx && indx <= up)
1249       A->SetValue(indx, val);//TColStd_HArray1OfExtendedString
1250     else {
1251       Handle(TColStd_HArray1OfExtendedString) Arr = A->Array();
1252       Handle(TColStd_HArray1OfExtendedString) arr;
1253       Standard_Integer i;
1254       if(indx > up) {
1255         up = indx;
1256         arr = new TColStd_HArray1OfExtendedString(low, up);
1257         for(i=low; i<= Arr->Upper(); i++)
1258           arr->SetValue(i, Arr->Value(i));
1259         for(i=Arr->Upper()+1; i<= up; i++) {
1260           if(i == up)
1261             arr->SetValue(i, val);
1262           else
1263             arr->SetValue(i, 0);
1264         }
1265       } else if(indx < up) {//clip array : indx to be negative
1266         up = abs(indx);
1267         arr = new TColStd_HArray1OfExtendedString(low, up);
1268         for(i=low; i< up; i++)
1269           arr->SetValue(i, Arr->Value(i));
1270         arr->SetValue(up, val);
1271       }
1272       A->ChangeArray(arr);
1273     }    
1274     return 0;
1275   }
1276   di << "DDataStd_ChangeExtStringArray: Error\n";
1277   return 0; 
1278
1279
1280
1281 //=======================================================================
1282 //function : DDataStd_KeepUTF
1283 //purpose  : SetUTFName (DF, fatherEntry, fileName)
1284 //=======================================================================
1285 static Standard_Integer DDataStd_KeepUTF (Draw_Interpretor& di,
1286                                                Standard_Integer nb, 
1287                                                const char** arg) 
1288 {
1289   if (nb == 4) {    
1290     Handle(TDF_Data) DF;
1291     if (!DDF::GetDF(arg[1],DF)) return 1;
1292     TDF_Label L;
1293     DDF::AddLabel(DF, arg[2], L);
1294     Standard_CString aFileName(arg[3]);
1295
1296 #ifdef _MSC_VER
1297       ifstream anIS (aFileName, ios::in | ios::binary);
1298 #else
1299       ifstream anIS (aFileName);
1300 #endif
1301     if (!anIS) {
1302       // Can not open file
1303       cout << "Error: can't open file " << aFileName <<endl;;
1304       return 1;
1305     }
1306     char buf[1024];
1307     char *p;
1308     anIS.getline(buf, 1023,'\n');
1309     //    0xEFBBBF  -  prefix of UTF8 
1310     p = &buf[3]; //skip prefix
1311     TCollection_ExtendedString aES1(p, Standard_True);
1312     TDataStd_Name::Set(L.NewChild(), aES1);
1313  
1314
1315     while (anIS.good() && !anIS.eof()) {
1316       anIS.getline(buf, 1023,'\n');
1317       TCollection_ExtendedString aES2(buf, Standard_True);
1318       const TDF_Label& aLab = L.NewChild();
1319       TDataStd_Name::Set(aLab, aES2);
1320     }
1321     return 0;
1322   }
1323   di << "SetUTFName : String is not kept in DF\n";
1324   return 1;
1325 }
1326
1327 //=======================================================================
1328 //function : DDataStd_GetUTFtoFile
1329 //purpose  : GetUTF (DF, fatherEntry, fileName)
1330 //         : all strings from sub-labels of the <fatherEntry> concatenated
1331 //         : in one, converted to UTF8 and kept in the file
1332 //=======================================================================
1333 static Standard_Integer DDataStd_GetUTFtoFile (Draw_Interpretor& di,
1334                                                Standard_Integer nb, 
1335                                                const char** arg) 
1336 {
1337   if (nb == 4) {    
1338     Handle(TDF_Data) DF;
1339     if (!DDF::GetDF(arg[1],DF)) return 1;
1340     TDF_Label L;
1341     if (!DDF::FindLabel(DF,arg[2],L)) return 1;
1342
1343     TCollection_ExtendedString aES;
1344     Standard_Boolean aF = Standard_False;
1345     TDF_ChildIterator anIt(L);
1346     for(;anIt.More();anIt.Next()) {
1347       const TDF_Label& aLab = anIt.Value();
1348       if(!aLab.IsNull()) {
1349         Handle(TDataStd_Name) anAtt;
1350         if(aLab.FindAttribute(TDataStd_Name::GetID(), anAtt)) {
1351           if(anAtt->Get().Length()) { 
1352             if (aF)
1353               aES +='\n';         
1354             aES +=anAtt->Get(); 
1355             aF = Standard_True;
1356           }
1357         }
1358       }
1359     }
1360
1361     if(!aES.Length()) {
1362       cout << "Data is not found in the Document" <<endl;
1363       return 1;
1364     }
1365
1366     Standard_CString aFileName(arg[3]);
1367
1368 #ifdef _MSC_VER
1369     ofstream anOS (aFileName, ios::in | ios::binary | ios::ate);
1370 #else
1371     ofstream anOS (aFileName, ios::ate);
1372 #endif
1373     if (!anOS) {
1374       // A problem with the stream
1375 #ifdef OCCT_DEBUG
1376       cout << "Error: problem with the file stream, rdstate = " <<anOS.rdstate() <<endl;
1377 #endif
1378     }
1379     unsigned char prefix[4] = {0xEF,0xBB,0xBF, 0x00};
1380     anOS.write( (char*)&prefix[0], 3); 
1381     Standard_Integer  n = aES.LengthOfCString();
1382     Standard_PCharacter aCstr = (Standard_PCharacter) Standard::Allocate(n+1);
1383     n = aES.ToUTF8CString(aCstr);
1384     anOS.write( (char*)&aCstr[0], n); 
1385     anOS.close();
1386     return 0;
1387   }
1388   di << "GetUTF : Data is not extracted to the specified file \n";
1389   return 1;
1390 }
1391
1392 //=======================================================================
1393 //function : SetByteArray (DF, entry, isDelta, From, To, elmt1, elmt2, ...  )
1394 //=======================================================================
1395 static Standard_Integer DDataStd_SetByteArray (Draw_Interpretor& di,
1396                                               Standard_Integer nb, 
1397                                               const char** arg) 
1398 {   
1399   if (nb >= 6) {  
1400     Handle(TDF_Data) DF;
1401     if (!DDF::GetDF(arg[1],DF))  return 1; 
1402     TDF_Label label;
1403     DDF::AddLabel(DF, arg[2], label);
1404     Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
1405     Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
1406     di << "Array of Standard_Byte with bounds from = " << From  << " to = " << To  << "\n";
1407     Handle(TDataStd_ByteArray) A = TDataStd_ByteArray::Set(label, From, To, isDelta);
1408     
1409     if (nb > 6) {
1410       j = 6;
1411       for(Standard_Integer i = From; i<=To; ++i) {
1412         Standard_Integer ival = Draw::Atoi(arg[j]);
1413         if(ival < 0 || 255 < ival) {
1414           cout << "Bad value = " << ival<< endl;
1415           return 1;
1416         }
1417         A->SetValue(i, (Standard_Byte)ival); 
1418         j++;
1419       }
1420     }
1421     return 0; 
1422   }
1423   di << "DDataStd_SetByteArray: Error\n";
1424   return 1; 
1425
1426
1427 //=======================================================================
1428 //function : SetByteArrayValue (DF, entry, index, value)
1429 //=======================================================================
1430 static Standard_Integer DDataStd_SetByteArrayValue (Draw_Interpretor&,
1431                                                     Standard_Integer, 
1432                                                     const char** arg) 
1433 {
1434   // Get document.
1435   Handle(TDF_Data) DF;
1436   if (!DDF::GetDF(arg[1], DF))
1437     return 1;
1438
1439   // Get label.
1440   TDF_Label label; 
1441   if (!DDF::AddLabel(DF, arg[2], label))
1442     return 1;
1443  
1444   // Get index and value.
1445   Standard_Integer index = Draw::Atoi(arg[3]);
1446   Standard_Integer value = Draw::Atoi(arg[4]);
1447
1448   // Check the value.
1449   if(value < 0 || 255 < value) {
1450     cout << "Bad value = " << value << endl;
1451     return 1;
1452   }
1453
1454   // Set new value.
1455   Handle(TDataStd_ByteArray) arr;
1456   if (label.FindAttribute(TDataStd_ByteArray::GetID(), arr))
1457   {
1458     arr->SetValue(index, (Standard_Byte) value); 
1459     return 0;
1460   }
1461
1462   return 1;
1463
1464
1465 //=======================================================================
1466 //function : SetBooleanArray (DF, entry, isDelta, From, To, elmt1, elmt2, ...  )
1467 //=======================================================================
1468 static Standard_Integer DDataStd_SetBooleanArray (Draw_Interpretor& di,
1469                                                   Standard_Integer nb, 
1470                                                   const char** arg) 
1471 {
1472   if (nb >= 6) 
1473   {  
1474     Handle(TDF_Data) DF;
1475     if (!DDF::GetDF(arg[1],DF))
1476         return 1; 
1477
1478     TDF_Label label;
1479     DDF::AddLabel(DF, arg[2], label);
1480     Standard_Integer From = Draw::Atoi(arg[4]), To = Draw::Atoi( arg[5] ), j;
1481     di << "Array of Standard_Boolean with bounds from = " << From  << " to = " << To  << "\n";
1482     Handle(TDataStd_BooleanArray) A = TDataStd_BooleanArray::Set(label, From, To);
1483     
1484     if (nb > 6) {
1485       j = 6;
1486       for(Standard_Integer i = From; i<=To; i++) 
1487       {
1488         Standard_Integer ival = Draw::Atoi(arg[j]);
1489         if(ival > 1) 
1490         {
1491           cout << "Bad value = " << ival<< ". 0 or 1 is expected." << endl;
1492           return 1;
1493         }
1494         A->SetValue(i, ival != 0); 
1495         j++;
1496       }
1497     }
1498     return 0; 
1499   }
1500   di << "DDataStd_SetBooleanArray: Error\n";
1501   return 1; 
1502
1503
1504 //=======================================================================
1505 //function : SetBooleanArrayValue (DF, entry, index, value)
1506 //=======================================================================
1507 static Standard_Integer DDataStd_SetBooleanArrayValue (Draw_Interpretor& di,
1508                                                        Standard_Integer,
1509                                                        const char** arg) 
1510 {
1511   // Get document.
1512   Handle(TDF_Data) DF;
1513   if (!DDF::GetDF(arg[1], DF))
1514     return 1;
1515
1516   // Get label.
1517   TDF_Label label; 
1518   if (!DDF::AddLabel(DF, arg[2], label))
1519     return 1;
1520  
1521   // Get index and value.
1522   Standard_Integer index = Draw::Atoi(arg[3]);
1523   Standard_Integer value = Draw::Atoi(arg[4]);
1524
1525   // Check the value.
1526   if (value != 0 && value != 1) {
1527     di << "DDataStd_SetBooleanArrayValue: Error! The value should be either 0 or 1.\n";
1528     return 1;
1529   }
1530
1531   // Set new value.
1532   Handle(TDataStd_BooleanArray) arr;
1533   if (label.FindAttribute(TDataStd_BooleanArray::GetID(), arr))
1534   {
1535     arr->SetValue(index, value != 0);
1536     return 0;
1537   }
1538
1539   return 1;
1540
1541
1542 //=======================================================================
1543 //function : DDataStd_SetExtStringList (DF, entry, elmt1, elmt2, ...  )
1544 //=======================================================================
1545 static Standard_Integer DDataStd_SetExtStringList (Draw_Interpretor& di,
1546                                                  Standard_Integer nb, 
1547                                                  const char** arg) 
1548 {
1549   if (nb > 2) 
1550   {  
1551     Handle(TDF_Data) DF;
1552     if (!DDF::GetDF(arg[1],DF))
1553         return 1; 
1554
1555     TDF_Label label;
1556     DDF::AddLabel(DF, arg[2], label);
1557     Handle(TDataStd_ExtStringList) A = TDataStd_ExtStringList::Set(label);
1558     for(Standard_Integer i = 3; i <= nb - 1; i++) 
1559     {
1560       TCollection_ExtendedString aValue(arg[i]);     
1561       A->Append(aValue); 
1562     }
1563     return 0; 
1564   }
1565   di << "DDataStd_SetExtStringList: Error\n";
1566   return 1; 
1567
1568 //
1569 //=======================================================================
1570 //function : DDataStd_SetReferenceList (DF, entry, elmt1, elmt2, ...  )
1571 //=======================================================================
1572 static Standard_Integer DDataStd_SetReferenceList (Draw_Interpretor& di,
1573                                                    Standard_Integer nb, 
1574                                                    const char** arg) 
1575 {
1576   if (nb > 2) 
1577   {  
1578     Handle(TDF_Data) DF;
1579     if (!DDF::GetDF(arg[1],DF))
1580         return 1; 
1581
1582     TDF_Label label;
1583     DDF::AddLabel(DF, arg[2], label);
1584     if(!label.IsNull()) {
1585       Handle(TDataStd_ReferenceList) A = TDataStd_ReferenceList::Set(label);
1586       for(Standard_Integer i = 3; i <= nb - 1; i++) 
1587       {
1588         TDF_Label aValueLabel;
1589         DDF::AddLabel(DF, arg[i], aValueLabel);
1590         if(aValueLabel.IsNull()) continue;
1591         A->Append(aValueLabel); 
1592       }
1593       return 0; 
1594     }
1595   }
1596   di << "DDataStd_SetReferenceList: Error\n";
1597   return 1; 
1598
1599
1600
1601 //=======================================================================
1602 //function : SetBooleanList (DF, entry, elmt1, elmt2, ...  )
1603 //=======================================================================
1604 static Standard_Integer DDataStd_SetBooleanList (Draw_Interpretor& di,
1605                                                  Standard_Integer nb, 
1606                                                  const char** arg) 
1607 {
1608   if (nb > 2) 
1609   {  
1610     Handle(TDF_Data) DF;
1611     if (!DDF::GetDF(arg[1],DF))
1612         return 1; 
1613
1614     TDF_Label label;
1615     DDF::AddLabel(DF, arg[2], label);
1616     Handle(TDataStd_BooleanList) A = TDataStd_BooleanList::Set(label);
1617     for(Standard_Integer i = 3; i <= nb - 1; i++) 
1618     {
1619       Standard_Integer ival = Draw::Atoi(arg[i]);
1620       if(ival > 1) 
1621       {
1622         cout << "Bad value = " << ival<< ". 0 or 1 is expected." << endl;
1623         return 1;
1624       }
1625       A->Append (ival != 0);
1626     }
1627     return 0; 
1628   }
1629   di << "DDataStd_SetBooleanList: Error\n";
1630   return 1; 
1631
1632
1633 //=======================================================================
1634 //function : SetIntegerList (DF, entry, elmt1, elmt2, ...  )
1635 //=======================================================================
1636 static Standard_Integer DDataStd_SetIntegerList (Draw_Interpretor& di,
1637                                                  Standard_Integer nb, 
1638                                                  const char** arg) 
1639 {
1640   if (nb > 2) 
1641   {  
1642     Handle(TDF_Data) DF;
1643     if (!DDF::GetDF(arg[1],DF))
1644         return 1; 
1645
1646     TDF_Label label;
1647     DDF::AddLabel(DF, arg[2], label);
1648     Handle(TDataStd_IntegerList) A = TDataStd_IntegerList::Set(label);
1649     for(Standard_Integer i = 3; i <= nb - 1; i++) 
1650     {
1651       Standard_Integer ival = Draw::Atoi(arg[i]);
1652       A->Append(ival); 
1653     }
1654     return 0; 
1655   }
1656   di << "DDataStd_SetIntegerList: Error\n";
1657   return 1; 
1658
1659
1660 //=======================================================================
1661 //function : SetRealList (DF, entry, elmt1, elmt2, ...  )
1662 //=======================================================================
1663 static Standard_Integer DDataStd_SetRealList (Draw_Interpretor& di,
1664                                               Standard_Integer nb, 
1665                                               const char** arg) 
1666 {
1667   if (nb > 2) 
1668   {  
1669     Handle(TDF_Data) DF;
1670     if (!DDF::GetDF(arg[1],DF))
1671         return 1; 
1672
1673     TDF_Label label;
1674     DDF::AddLabel(DF, arg[2], label);
1675     Handle(TDataStd_RealList) A = TDataStd_RealList::Set(label);
1676     for(Standard_Integer i = 3; i <= nb - 1; i++) 
1677     {
1678       Standard_Real fval = Draw::Atof(arg[i]);
1679       A->Append(fval); 
1680     }
1681     return 0; 
1682   }
1683   di << "DDataStd_SetRealList: Error\n";
1684   return 1; 
1685
1686
1687 //=======================================================================
1688 //function : DDataStd_InsertBeforeExtStringList (DF, entry, index, value  )
1689 //=======================================================================
1690 static Standard_Integer DDataStd_InsertBeforeExtStringList (Draw_Interpretor& di,
1691                                                             Standard_Integer nb, 
1692                                                             const char** arg) 
1693 {
1694   if (nb == 5) 
1695   {  
1696     Handle(TDF_Data) DF;
1697     if (!DDF::GetDF(arg[1],DF))
1698         return 1; 
1699
1700     TDF_Label label;
1701     DDF::AddLabel(DF, arg[2], label);
1702     
1703     Handle(TDataStd_ExtStringList) A;
1704     if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
1705         return 1;
1706
1707     Standard_Integer index = Draw::Atoi(arg[3]);
1708     TCollection_ExtendedString value = arg[4];
1709
1710     if (A->InsertBefore(index, value))    
1711       return 0; 
1712     else
1713       return 1;
1714   }
1715   di << "DDataStd_InsertBeforeExtStringList: Error\n";
1716   return 1; 
1717
1718
1719 //=======================================================================
1720 //function : DDataStd_InsertAfterExtStringList (DF, entry, index, value  )
1721 //=======================================================================
1722 static Standard_Integer DDataStd_InsertAfterExtStringList (Draw_Interpretor& di,
1723                                                            Standard_Integer nb, 
1724                                                            const char** arg) 
1725 {
1726   if (nb == 5) 
1727   {  
1728     Handle(TDF_Data) DF;
1729     if (!DDF::GetDF(arg[1],DF))
1730         return 1; 
1731
1732     TDF_Label label;
1733     DDF::AddLabel(DF, arg[2], label);
1734     
1735     Handle(TDataStd_ExtStringList) A;
1736     if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
1737         return 1;
1738
1739     Standard_Integer index = Draw::Atoi(arg[3]);
1740     TCollection_ExtendedString value = arg[4];
1741
1742     if (A->InsertAfter(index, value))    
1743       return 0; 
1744     else
1745       return 1;
1746   }
1747   di << "DDataStd_InsertAfterExtStringList: Error\n";
1748   return 1; 
1749
1750
1751 //=======================================================================
1752 //function : DDataStd_RemoveExtStringList (DF, entry, index )
1753 //=======================================================================
1754 static Standard_Integer DDataStd_RemoveExtStringList (Draw_Interpretor& di,
1755                                                       Standard_Integer nb, 
1756                                                       const char** arg) 
1757 {
1758   if (nb == 4) 
1759   {  
1760     Handle(TDF_Data) DF;
1761     if (!DDF::GetDF(arg[1],DF))
1762         return 1; 
1763
1764     TDF_Label label;
1765     DDF::AddLabel(DF, arg[2], label);
1766     
1767     Handle(TDataStd_ExtStringList) A;
1768     if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
1769         return 1;
1770
1771     Standard_Integer index = Draw::Atoi(arg[3]);
1772
1773     if (A->Remove(index))    
1774       return 0; 
1775     else
1776       return 1;
1777   }
1778   di << "DDataStd_RemoveExtStringList: Error\n";
1779   return 1; 
1780
1781
1782 //=======================================================================
1783 //function : DDataStd_InsertBeforeBooleanList (DF, entry, index, value  )
1784 //=======================================================================
1785 static Standard_Integer DDataStd_InsertBeforeBooleanList (Draw_Interpretor& di,
1786                                                           Standard_Integer nb, 
1787                                                           const char** arg) 
1788 {
1789   if (nb == 5) 
1790   {  
1791     Handle(TDF_Data) DF;
1792     if (!DDF::GetDF(arg[1],DF))
1793         return 1; 
1794
1795     TDF_Label label;
1796     DDF::AddLabel(DF, arg[2], label);
1797     
1798     Handle(TDataStd_BooleanList) A;
1799     if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
1800         return 1;
1801
1802     Standard_Integer index = Draw::Atoi(arg[3]);
1803     Standard_Boolean value = Draw::Atoi(arg[4]) != 0;
1804
1805     if (A->InsertBefore(index, value))    
1806       return 0; 
1807     else
1808       return 1;
1809   }
1810   di << "DDataStd_InsertBeforeBooleanList: Error\n";
1811   return 1; 
1812
1813
1814 //=======================================================================
1815 //function : DDataStd_InsertAfterBooleanList (DF, entry, index, value  )
1816 //=======================================================================
1817 static Standard_Integer DDataStd_InsertAfterBooleanList (Draw_Interpretor& di,
1818                                                          Standard_Integer nb, 
1819                                                          const char** arg) 
1820 {
1821   if (nb == 5) 
1822   {  
1823     Handle(TDF_Data) DF;
1824     if (!DDF::GetDF(arg[1],DF))
1825         return 1; 
1826
1827     TDF_Label label;
1828     DDF::AddLabel(DF, arg[2], label);
1829     
1830     Handle(TDataStd_BooleanList) A;
1831     if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
1832         return 1;
1833
1834     Standard_Integer index = Draw::Atoi(arg[3]);
1835     Standard_Boolean value = Draw::Atoi(arg[4]) != 0;
1836
1837     if (A->InsertAfter(index, value))    
1838       return 0; 
1839     else
1840       return 1;
1841   }
1842   di << "DDataStd_InsertAfterBooleanList: Error\n";
1843   return 1; 
1844
1845
1846 //=======================================================================
1847 //function : DDataStd_RemoveBooleanList (DF, entry, index )
1848 //=======================================================================
1849 static Standard_Integer DDataStd_RemoveBooleanList (Draw_Interpretor& di,
1850                                                     Standard_Integer nb, 
1851                                                     const char** arg) 
1852 {
1853   if (nb == 4) 
1854   {  
1855     Handle(TDF_Data) DF;
1856     if (!DDF::GetDF(arg[1],DF))
1857         return 1; 
1858
1859     TDF_Label label;
1860     DDF::AddLabel(DF, arg[2], label);
1861     
1862     Handle(TDataStd_BooleanList) A;
1863     if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
1864         return 1;
1865
1866     Standard_Integer index = Draw::Atoi(arg[3]);
1867
1868     if (A->Remove(index))    
1869       return 0; 
1870     else
1871       return 1;
1872   }
1873   di << "DDataStd_RemoveBooleanList: Error\n";
1874   return 1; 
1875
1876
1877 //=======================================================================
1878 //function : DDataStd_InsertBeforeIntegerList (DF, entry, index, value  )
1879 //=======================================================================
1880 static Standard_Integer DDataStd_InsertBeforeIntegerList (Draw_Interpretor& di,
1881                                                           Standard_Integer nb, 
1882                                                           const char** arg) 
1883 {
1884   if (nb == 5) 
1885   {  
1886     Handle(TDF_Data) DF;
1887     if (!DDF::GetDF(arg[1],DF))
1888         return 1; 
1889
1890     TDF_Label label;
1891     DDF::AddLabel(DF, arg[2], label);
1892     
1893     Handle(TDataStd_IntegerList) A;
1894     if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
1895         return 1;
1896
1897     Standard_Integer index = Draw::Atoi(arg[3]);
1898     Standard_Integer value = (Standard_Integer) Draw::Atoi(arg[4]);
1899
1900     if (A->InsertBeforeByIndex(index, value))    
1901       return 0; 
1902     else
1903       return 1;
1904   }
1905   di << "DDataStd_InsertBeforeIntegerList: Error\n";
1906   return 1; 
1907
1908
1909 //=======================================================================
1910 //function : DDataStd_InsertAfterIntegerList (DF, entry, index, value  )
1911 //=======================================================================
1912 static Standard_Integer DDataStd_InsertAfterIntegerList (Draw_Interpretor& di,
1913                                                          Standard_Integer nb, 
1914                                                          const char** arg) 
1915 {
1916   if (nb == 5) 
1917   {  
1918     Handle(TDF_Data) DF;
1919     if (!DDF::GetDF(arg[1],DF))
1920         return 1; 
1921
1922     TDF_Label label;
1923     DDF::AddLabel(DF, arg[2], label);
1924     
1925     Handle(TDataStd_IntegerList) A;
1926     if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
1927         return 1;
1928
1929     Standard_Integer index = Draw::Atoi(arg[3]);
1930     Standard_Integer value = (Standard_Integer) Draw::Atoi(arg[4]);
1931
1932     if (A->InsertAfterByIndex(index, value))    
1933       return 0; 
1934     else
1935       return 1;
1936   }
1937   di << "DDataStd_InsertAfterIntegerList: Error\n";
1938   return 1; 
1939
1940
1941 //=======================================================================
1942 //function : DDataStd_RemoveIntegerList (DF, entry, index )
1943 //=======================================================================
1944 static Standard_Integer DDataStd_RemoveIntegerList (Draw_Interpretor& di,
1945                                                     Standard_Integer nb, 
1946                                                     const char** arg) 
1947 {
1948   if (nb == 4) 
1949   {  
1950     Handle(TDF_Data) DF;
1951     if (!DDF::GetDF(arg[1],DF))
1952         return 1; 
1953
1954     TDF_Label label;
1955     DDF::AddLabel(DF, arg[2], label);
1956     
1957     Handle(TDataStd_IntegerList) A;
1958     if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
1959         return 1;
1960
1961     Standard_Integer index = Draw::Atoi(arg[3]);
1962
1963     if (A->RemoveByIndex(index))    
1964       return 0; 
1965     else
1966       return 1;
1967   }
1968   di << "DDataStd_RemoveIntegerList: Error\n";
1969   return 1; 
1970
1971
1972 //=======================================================================
1973 //function : DDataStd_InsertBeforeRealList (DF, entry, index, value  )
1974 //=======================================================================
1975 static Standard_Integer DDataStd_InsertBeforeRealList (Draw_Interpretor& di,
1976                                                        Standard_Integer nb, 
1977                                                        const char** arg) 
1978 {
1979   if (nb == 5) 
1980   {  
1981     Handle(TDF_Data) DF;
1982     if (!DDF::GetDF(arg[1],DF))
1983         return 1; 
1984
1985     TDF_Label label;
1986     DDF::AddLabel(DF, arg[2], label);
1987     
1988     Handle(TDataStd_RealList) A;
1989     if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
1990         return 1;
1991
1992     Standard_Integer index = Draw::Atoi(arg[3]);
1993     Standard_Real value = (Standard_Real) Draw::Atof(arg[4]);
1994
1995     if (A->InsertBeforeByIndex(index, value))    
1996       return 0; 
1997     else
1998       return 1;
1999   }
2000   di << "DDataStd_InsertBeforeRealList: Error\n";
2001   return 1; 
2002
2003
2004 //=======================================================================
2005 //function : DDataStd_InsertAfterRealList (DF, entry, index, value  )
2006 //=======================================================================
2007 static Standard_Integer DDataStd_InsertAfterRealList (Draw_Interpretor& di,
2008                                                       Standard_Integer nb, 
2009                                                       const char** arg) 
2010 {
2011   if (nb == 5) 
2012   {  
2013     Handle(TDF_Data) DF;
2014     if (!DDF::GetDF(arg[1],DF))
2015         return 1; 
2016
2017     TDF_Label label;
2018     DDF::AddLabel(DF, arg[2], label);
2019     
2020     Handle(TDataStd_RealList) A;
2021     if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
2022         return 1;
2023
2024     Standard_Integer index = Draw::Atoi(arg[3]);
2025     Standard_Real value = (Standard_Real) Draw::Atof(arg[4]);
2026
2027     if (A->InsertAfterByIndex(index, value))    
2028       return 0; 
2029     else
2030       return 1;
2031   }
2032   di << "DDataStd_InsertAfterRealList: Error\n";
2033   return 1; 
2034
2035
2036 //=======================================================================
2037 //function : DDataStd_RemoveRealList (DF, entry, index )
2038 //=======================================================================
2039 static Standard_Integer DDataStd_RemoveRealList (Draw_Interpretor& di,
2040                                                  Standard_Integer nb, 
2041                                                  const char** arg) 
2042 {
2043   if (nb == 4) 
2044   {  
2045     Handle(TDF_Data) DF;
2046     if (!DDF::GetDF(arg[1],DF))
2047         return 1; 
2048
2049     TDF_Label label;
2050     DDF::AddLabel(DF, arg[2], label);
2051     
2052     Handle(TDataStd_RealList) A;
2053     if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
2054         return 1;
2055
2056     Standard_Integer index = Draw::Atoi(arg[3]);
2057
2058     if (A->RemoveByIndex(index))    
2059       return 0; 
2060     else
2061       return 1;
2062   }
2063   di << "DDataStd_RemoveRealList: Error\n";
2064   return 1; 
2065
2066
2067 //=======================================================================
2068 //function : DDataStd_InsertBeforeReferenceList (DF, entry, index, value  )
2069 //=======================================================================
2070 static Standard_Integer DDataStd_InsertBeforeReferenceList (Draw_Interpretor& di,
2071                                                             Standard_Integer nb, 
2072                                                             const char** arg) 
2073 {
2074   if (nb == 5) 
2075   {  
2076     Handle(TDF_Data) DF;
2077     if (!DDF::GetDF(arg[1],DF))
2078         return 1; 
2079
2080     TDF_Label label;
2081     DDF::AddLabel(DF, arg[2], label);
2082     
2083     Handle(TDataStd_ReferenceList) A;
2084     if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
2085         return 1;
2086
2087     Standard_Integer index = Draw::Atoi(arg[3]);
2088
2089     TDF_Label refLabel;
2090     if (!DDF::AddLabel(DF, arg[4], refLabel))
2091         return 1;
2092
2093     if (A->InsertBefore(index, refLabel))    
2094       return 0; 
2095     else
2096       return 1;
2097   }
2098   di << "DDataStd_InsertBeforeReferenceList: Error\n";
2099   return 1; 
2100
2101
2102 //=======================================================================
2103 //function : DDataStd_InsertAfterReferenceList (DF, entry, index, value  )
2104 //=======================================================================
2105 static Standard_Integer DDataStd_InsertAfterReferenceList (Draw_Interpretor& di,
2106                                                            Standard_Integer nb, 
2107                                                            const char** arg) 
2108 {
2109   if (nb == 5) 
2110   {  
2111     Handle(TDF_Data) DF;
2112     if (!DDF::GetDF(arg[1],DF))
2113         return 1; 
2114
2115     TDF_Label label;
2116     DDF::AddLabel(DF, arg[2], label);
2117     
2118     Handle(TDataStd_ReferenceList) A;
2119     if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
2120         return 1;
2121
2122     Standard_Integer index = Draw::Atoi(arg[3]);
2123
2124     TDF_Label refLabel;
2125     if (!DDF::AddLabel(DF, arg[4], refLabel))
2126         return 1;
2127
2128     if (A->InsertAfter(index, refLabel))
2129       return 0; 
2130     else
2131       return 1;
2132   }
2133   di << "DDataStd_InsertAfterReferenceList: Error\n";
2134   return 1; 
2135
2136
2137 //=======================================================================
2138 //function : DDataStd_RemoveReferenceList (DF, entry, index )
2139 //=======================================================================
2140 static Standard_Integer DDataStd_RemoveReferenceList (Draw_Interpretor& di,
2141                                                       Standard_Integer nb, 
2142                                                       const char** arg) 
2143 {
2144   if (nb == 4) 
2145   {  
2146     Handle(TDF_Data) DF;
2147     if (!DDF::GetDF(arg[1],DF))
2148         return 1; 
2149
2150     TDF_Label label;
2151     DDF::AddLabel(DF, arg[2], label);
2152     
2153     Handle(TDataStd_ReferenceList) A;
2154     if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
2155         return 1;
2156
2157     Standard_Integer index = Draw::Atoi(arg[3]);
2158
2159     if (A->Remove(index))    
2160       return 0; 
2161     else
2162       return 1;
2163   }
2164   di << "DDataStd_RemoveReferenceList: Error\n";
2165   return 1; 
2166
2167
2168 //=======================================================================
2169 //function : GetByteArray (DF, entry )
2170 //=======================================================================
2171 static Standard_Integer DDataStd_GetByteArray (Draw_Interpretor& di,
2172                                               Standard_Integer, 
2173                                               const char** arg) 
2174 {   
2175
2176
2177   Handle(TDF_Data) DF;
2178   if (!DDF::GetDF(arg[1],DF))  return 1;  
2179   TDF_Label label;
2180   if( !DDF::FindLabel(DF, arg[2], label) ) {
2181     di << "No label for entry"  << "\n";
2182     return 1;
2183   }
2184  
2185   Handle(TDataStd_ByteArray) A;
2186   if ( !label.FindAttribute(TDataStd_ByteArray::GetID(), A) ) { 
2187     di << "There is no TDataStd_ByteArray at label"  << "\n";
2188     return 1;
2189   }
2190   
2191   for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
2192     //cout <<  A->Value(i)   << endl;
2193     di  <<  A->Value(i);
2194     if(i<A->Upper())  
2195      di<<" ";
2196   }
2197   di<<"\n";
2198   return 0; 
2199
2200
2201 //=======================================================================
2202 //function : GetByteArrayValue (DF, entry, index)
2203 //=======================================================================
2204 static Standard_Integer DDataStd_GetByteArrayValue (Draw_Interpretor& di,
2205                                                     Standard_Integer, 
2206                                                     const char** arg) 
2207 {
2208   Handle(TDF_Data) DF;
2209   if (!DDF::GetDF(arg[1],DF))
2210       return 1;
2211
2212   TDF_Label label;
2213   if (!DDF::FindLabel(DF, arg[2], label)) {
2214     di << "No label for entry"  << "\n";
2215     return 1;
2216   }
2217  
2218   Handle(TDataStd_ByteArray) A;
2219   if ( !label.FindAttribute(TDataStd_ByteArray::GetID(), A) ) { 
2220     di << "There is no TDataStd_ByteArray under label"  << "\n";
2221     return 1;
2222   }
2223   
2224   Standard_Integer index = Draw::Atoi(arg[3]);
2225   if (index < A->Lower() || index > A->Upper()) {
2226     di << "Index is out of range\n";
2227     return 1;
2228   } else {
2229     di << A->Value(index) << "\n";
2230   }
2231
2232   return 0; 
2233
2234
2235 //=======================================================================
2236 //function : GetBooleanArray (DF, entry )
2237 //=======================================================================
2238 static Standard_Integer DDataStd_GetBooleanArray (Draw_Interpretor& di,
2239                                                   Standard_Integer, 
2240                                                   const char** arg) 
2241 {   
2242   Handle(TDF_Data) DF;
2243   if (!DDF::GetDF(arg[1],DF)) 
2244       return 1;  
2245
2246   TDF_Label label;
2247   if ( !DDF::FindLabel(DF, arg[2], label) ) 
2248   {
2249     di << "No label for entry"  << "\n";
2250     return 1;
2251   }
2252  
2253   Handle(TDataStd_BooleanArray) A;
2254   if ( !label.FindAttribute(TDataStd_BooleanArray::GetID(), A) ) 
2255   {
2256     di << "There is no TDataStd_BooleanArray at label"  << "\n";
2257     return 1;
2258   }
2259   
2260   for (Standard_Integer i = A->Lower(); i<=A->Upper(); i++)
2261   {
2262     di << (Standard_Integer) A->Value(i);
2263     if (i < A->Upper())  
2264      di << " ";
2265   }
2266   di << "\n";
2267   return 0; 
2268 }
2269
2270 //=======================================================================
2271 //function : GetBooleanArrayValue (DF, entry, index)
2272 //=======================================================================
2273 static Standard_Integer DDataStd_GetBooleanArrayValue (Draw_Interpretor& di,
2274                                                        Standard_Integer, 
2275                                                        const char** arg) 
2276 {
2277   Handle(TDF_Data) DF;
2278   if (!DDF::GetDF(arg[1],DF))
2279       return 1;
2280
2281   TDF_Label label;
2282   if (!DDF::FindLabel(DF, arg[2], label)) {
2283     di << "No label for entry"  << "\n";
2284     return 1;
2285   }
2286  
2287   Handle(TDataStd_BooleanArray) A;
2288   if ( !label.FindAttribute(TDataStd_BooleanArray::GetID(), A) ) { 
2289     di << "There is no TDataStd_BooleanArray under label"  << "\n";
2290     return 1;
2291   }
2292   
2293   Standard_Integer index = Draw::Atoi(arg[3]);
2294   if (index < A->Lower() || index > A->Upper()) {
2295     di << "Index is out of range\n";
2296     return 1;
2297   } else {
2298     di << ((A->Value(index) == Standard_True) ? "True" : "False") << "\n";
2299   }
2300
2301   return 0; 
2302
2303
2304 //=======================================================================
2305 //function : ChangeByteArray (DF, entry, indx, val )
2306 //=======================================================================
2307 static Standard_Integer DDataStd_ChangeByteArray (Draw_Interpretor& di,
2308                                               Standard_Integer nb, 
2309                                               const char** arg) 
2310 {   
2311
2312   if( nb == 5 ) {  
2313     Handle(TDF_Data) DF;
2314     if (!DDF::GetDF(arg[1],DF))  return 1;  
2315     TDF_Label label;
2316     if( !DDF::FindLabel(DF, arg[2], label) ) {
2317       di << "No label for entry"  << "\n";
2318       return 1;
2319     }
2320  
2321     Handle(TDataStd_ByteArray) A;
2322     if ( !label.FindAttribute(TDataStd_ByteArray::GetID(), A) ) { 
2323       di << "There is no TDataStd_ByteArray at label"  << "\n";
2324       return 1;
2325     }
2326     Standard_Integer indx = Draw::Atoi(arg[3]);
2327     Standard_Integer ival  = Draw::Atoi(arg[4]);
2328     if (ival > 255 || ival < 0) {
2329         di << "DDataStd_ChangeByteArray: Bad value = " <<ival << "\n";
2330         return 1;
2331       }
2332     Standard_Integer low = A->Lower(), up = A->Upper();
2333     if(low <= indx && indx <= up)
2334       A->SetValue(indx, (Standard_Byte)ival);
2335     else {
2336       Handle(TColStd_HArray1OfByte) Arr = A->InternalArray();
2337       Handle(TColStd_HArray1OfByte) arr;
2338       Standard_Integer i;
2339       if(indx > up) {
2340         up = indx;
2341         arr = new TColStd_HArray1OfByte(low, up);
2342         for(i=low; i<= Arr->Upper(); i++)
2343           arr->SetValue(i, Arr->Value(i));
2344         for(i=Arr->Upper()+1; i<= up; i++) {
2345           if(i == up)
2346             arr->SetValue(i, (Standard_Byte)ival);
2347           else
2348             arr->SetValue(i, 0);
2349         }
2350       } else if(indx < up) {//clip array : indx to be negative
2351         up = abs(indx);
2352         arr = new TColStd_HArray1OfByte(low, up);
2353         for(i=low; i< up; i++)
2354           arr->SetValue(i, Arr->Value(i));
2355         arr->SetValue(up, (Standard_Byte)ival);
2356       }
2357       A->ChangeArray(arr);
2358     }
2359     return 0;
2360   }
2361   di << "DDataStd_ChangeByteArray: Error\n";
2362   return 1; 
2363 }
2364
2365 //=======================================================================
2366 //function : GetBooleanList (DF, entry )
2367 //=======================================================================
2368 static Standard_Integer DDataStd_GetBooleanList (Draw_Interpretor& di,
2369                                                  Standard_Integer nb, 
2370                                                  const char** arg) 
2371 {   
2372   if (nb == 3) {
2373     Handle(TDF_Data) DF;
2374     if (!DDF::GetDF(arg[1],DF)) 
2375       return 1;  
2376
2377     TDF_Label label;
2378     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2379     {
2380       di << "No label for entry"  << "\n";
2381       return 1;
2382     }
2383  
2384     Handle(TDataStd_BooleanList) A;
2385     if ( !label.FindAttribute(TDataStd_BooleanList::GetID(), A) ) 
2386     {
2387       di << "There is no TDataStd_BooleanList at label"  << "\n";
2388       return 1;
2389     }
2390   
2391     const TDataStd_ListOfByte& bList = A->List();
2392     Standard_Boolean isEmpty = (bList.Extent() > 0) ? Standard_False : Standard_True;
2393     if(!isEmpty) {
2394       TDataStd_ListIteratorOfListOfByte itr(bList);
2395       for (; itr.More(); itr.Next())
2396       {
2397         di << (Standard_Integer) itr.Value() << " ";
2398       }
2399       di << "\n";
2400     } else 
2401        di << "List is empty\n";
2402     return 0; 
2403   }
2404   di << "DDataStd_GetBooleanList: Error\n";
2405   return 1; 
2406 }
2407
2408 //=======================================================================
2409 //function : GetIntegerList (DF, entry )
2410 //=======================================================================
2411 static Standard_Integer DDataStd_GetIntegerList (Draw_Interpretor& di,
2412                                                  Standard_Integer nb, 
2413                                                  const char** arg) 
2414
2415   if (nb == 3) {
2416     Handle(TDF_Data) DF;
2417     if (!DDF::GetDF(arg[1],DF)) 
2418       return 1;  
2419
2420     TDF_Label label;
2421     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2422     {
2423       di << "No label for entry"  << "\n";
2424       return 1;
2425     }
2426  
2427     Handle(TDataStd_IntegerList) A;
2428     if ( !label.FindAttribute(TDataStd_IntegerList::GetID(), A) ) 
2429     {
2430       di << "There is no TDataStd_IntegerList at label"  << "\n";
2431       return 1;
2432     }
2433   
2434     const TColStd_ListOfInteger& iList = A->List();
2435     Standard_Boolean isEmpty = (iList.Extent() > 0) ? Standard_False : Standard_True;
2436     if(!isEmpty) {
2437       TColStd_ListIteratorOfListOfInteger itr(iList);
2438       for (; itr.More(); itr.Next())
2439       {
2440         di << itr.Value() << " ";
2441       }
2442       di << "\n";
2443     } else 
2444       di << "List is empty\n";
2445
2446     return 0; 
2447   }
2448   di << "DDataStd_GetIntegerList: Error\n";
2449   return 1; 
2450 }
2451
2452 //=======================================================================
2453 //function : GetRealList (DF, entry )
2454 //=======================================================================
2455 static Standard_Integer DDataStd_GetRealList (Draw_Interpretor& di,
2456                                               Standard_Integer nb, 
2457                                               const char** arg) 
2458 {   
2459   if (nb == 3) {  
2460     Handle(TDF_Data) DF;
2461     if (!DDF::GetDF(arg[1],DF)) 
2462       return 1;  
2463
2464     TDF_Label label;
2465     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2466     {
2467       di << "No label for entry"  << "\n";
2468       return 1;
2469     }
2470  
2471     Handle(TDataStd_RealList) A;
2472     if ( !label.FindAttribute(TDataStd_RealList::GetID(), A) ) 
2473     {
2474       di << "There is no TDataStd_RealList at label"  << "\n";
2475       return 1;
2476     }
2477   
2478     const TColStd_ListOfReal& rList = A->List();
2479     Standard_Boolean isEmpty = (rList.Extent() > 0) ? Standard_False : Standard_True;
2480     if(!isEmpty) {
2481       TColStd_ListIteratorOfListOfReal itr(rList);
2482       for (; itr.More(); itr.Next())
2483       {
2484         di << itr.Value() << " ";
2485       }
2486       di << "\n";
2487     } else
2488       di << "List is empty\n";
2489     return 0; 
2490   }
2491   di << "DDataStd_GetRealList: Error\n";
2492   return 1; 
2493 }
2494
2495 //=======================================================================
2496 //function : DDataStd_GetExtStringList (DF, entry)
2497 //=======================================================================
2498 static Standard_Integer DDataStd_GetExtStringList (Draw_Interpretor& di,
2499                                                  Standard_Integer nb, 
2500                                                  const char** arg) 
2501 {
2502   if (nb == 3) 
2503   {  
2504     Handle(TDF_Data) DF;
2505     if (!DDF::GetDF(arg[1],DF))
2506         return 1; 
2507
2508     TDF_Label label;
2509     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2510     {
2511       di << "No label for entry"  << "\n";
2512       return 1;
2513     }
2514
2515     Handle(TDataStd_ExtStringList) A;
2516     if ( !label.FindAttribute(TDataStd_ExtStringList::GetID(), A) ) 
2517     {
2518       di << "There is no TDataStd_ExtStringList at label"  << "\n";
2519       return 1;
2520     }
2521     
2522     const TDataStd_ListOfExtendedString& aList = A->List();
2523     Standard_Boolean isEmpty = (aList.Extent() > 0) ? Standard_False : Standard_True;
2524     if(!isEmpty) {
2525       TDataStd_ListIteratorOfListOfExtendedString itr(aList);   
2526       for (; itr.More(); itr.Next())
2527       {
2528         const TCollection_ExtendedString& aStr = itr.Value();
2529         di << aStr << " ";      
2530       }
2531       di << "\n";
2532     }
2533     else {
2534       di << "List is empty\n";
2535     }
2536     return 0; 
2537   }
2538   di << "DDataStd_GetExtStringList: Error\n";
2539   return 1; 
2540
2541
2542 //=======================================================================
2543 //function : DDataStd_GetReferenceList (DF, entry )
2544 //=======================================================================
2545 static Standard_Integer DDataStd_GetReferenceList (Draw_Interpretor& di,
2546                                                    Standard_Integer nb, 
2547                                                    const char** arg) 
2548 {
2549   if (nb == 3) 
2550   {  
2551     Handle(TDF_Data) DF;
2552     if (!DDF::GetDF(arg[1],DF))
2553         return 1; 
2554
2555     TDF_Label label;
2556     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2557     {
2558       di << "No label for entry"  << "\n";
2559       return 1;
2560     }
2561     
2562     Handle(TDataStd_ReferenceList) A;
2563     if ( !label.FindAttribute(TDataStd_ReferenceList::GetID(), A) ) 
2564     {
2565       di << "There is no TDataStd_ReferenceList at label"  << "\n";
2566       return 1;
2567     }
2568     
2569     const TDF_LabelList& aList = A->List();
2570     Standard_Boolean isEmpty = (aList.Extent() > 0) ? Standard_False : Standard_True;
2571     if(!isEmpty) {
2572       TDF_ListIteratorOfLabelList itr(aList);
2573       for (; itr.More(); itr.Next())
2574       {
2575         const TDF_Label& aLabel = itr.Value();
2576         if (!aLabel.IsNull()) {
2577           TCollection_AsciiString entry;
2578           TDF_Tool::Entry(aLabel, entry);
2579           di << entry.ToCString() << " ";
2580         }
2581       }
2582       di << "\n";
2583     } else 
2584       di << "List is empty\n";
2585     return 0;
2586   }
2587   di << "DDataStd_GetReferenceList: Error\n";
2588   return 1; 
2589
2590 //
2591 //=======================================================================
2592 //function : SetIntPackedMap (DF, entry, isDelta, key1, key2, ...
2593 //=======================================================================
2594
2595 static Standard_Integer DDataStd_SetIntPackedMap (Draw_Interpretor& di,
2596                                                   Standard_Integer nb, 
2597                                                   const char** arg) 
2598 {   
2599
2600   if (nb > 4) {
2601     Handle(TDF_Data) DF;
2602     if (!DDF::GetDF(arg[1],DF))  return 1; 
2603     TDF_Label aLabel;
2604     DDF::AddLabel(DF, arg[2], aLabel);
2605     Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
2606     Standard_Integer aNum = nb - 4;
2607     Handle(TDataStd_IntPackedMap) anAtt;
2608     if(!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt))
2609       anAtt = TDataStd_IntPackedMap::Set(aLabel, isDelta);
2610     if(anAtt.IsNull()) {
2611       di << "IntPackedMap attribute is not found or not set"  << "\n";
2612       return 1;}
2613     
2614     Standard_Integer j = 4;
2615     TColStd_PackedMapOfInteger aMap;
2616     for(Standard_Integer i = 1; i<=aNum; i++) {
2617       aMap.Add (Draw::Atoi(arg[j]));
2618       j++;
2619     }
2620     const Handle(TColStd_HPackedMapOfInteger)& aHMap = new TColStd_HPackedMapOfInteger(aMap);
2621     anAtt->ChangeMap(aHMap);
2622     cout << "Map extent = " << anAtt->Extent()<<endl;
2623     return 0; 
2624   }
2625   di << "DDataStd_SetIntPackedMap : Error\n";
2626   return 1;
2627
2628
2629 //=======================================================================
2630 //function : GetIntPackedMap (DF, entry )
2631 //=======================================================================
2632
2633 static Standard_Integer DDataStd_GetIntPackedMap (Draw_Interpretor& di,
2634                                                   Standard_Integer nb, 
2635                                                   const char** arg) 
2636 {   
2637
2638   if (nb == 3) {
2639     Handle(TDF_Data) DF;
2640     if (!DDF::GetDF(arg[1],DF))  return 1; 
2641     TDF_Label aLabel;
2642     DDF::AddLabel(DF, arg[2], aLabel);
2643     Handle(TDataStd_IntPackedMap) anAtt;
2644     if(!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt)) {
2645       di << "IntPackedMap attribute is not found or not set"  << "\n";
2646       return 1;}
2647 //
2648     const TColStd_PackedMapOfInteger& aMap = anAtt->GetMap();
2649     TColStd_MapIteratorOfPackedMapOfInteger itr(aMap);
2650     for (Standard_Integer j = 1; itr.More(); itr.Next(),j++){
2651       Standard_Integer aKey(itr.Key());
2652       di << aKey << " ";
2653       }
2654     return 0; 
2655   }
2656   di << "DDataStd_GetIntPackedMap : Error\n";
2657   return 1;
2658
2659
2660
2661 //=======================================================================
2662 //function : ChangeIntPackedMap_Add (DF, entry, Key1, Key2,... )
2663 //=======================================================================
2664 static Standard_Integer DDataStd_ChangeIntPackedMap_Add (Draw_Interpretor& di,
2665                                               Standard_Integer nb, 
2666                                               const char** arg) 
2667 {   
2668
2669   if( nb >= 4 ) {  
2670     Handle(TDF_Data) DF;
2671     if (!DDF::GetDF(arg[1],DF))  return 1;  
2672     TDF_Label label;
2673     if( !DDF::FindLabel(DF, arg[2], label) ) {
2674       di << "No label for entry"  << "\n";
2675       return 1;
2676     }
2677  
2678     Handle(TDataStd_IntPackedMap) A;
2679     if ( !label.FindAttribute(TDataStd_IntPackedMap::GetID(), A) ) { 
2680       di << "There is no TDataStd_IntPackedMap at label"  << "\n";
2681       return 1;
2682     }
2683     
2684     Standard_Integer i, aNum = nb - 3; 
2685     Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
2686     Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
2687     if(!aHMap.IsNull()) {
2688       ahMap->ChangeMap().Assign(aHMap->Map());
2689       for(i=1; i<=aNum;i++) {
2690         Standard_Integer val = Draw::Atoi(arg[i+2]);
2691         if(!ahMap->Map().Contains(val))
2692           ahMap->ChangeMap().Add(val);
2693       }
2694       
2695       A->ChangeMap(ahMap);
2696     }
2697     return 0;
2698   }
2699   di << "DDataStd_ChangeIntPackedMap_Add: Error\n";
2700   return 0; 
2701 }
2702
2703
2704 //=======================================================================
2705 //function : ChangeIntPackedMap_Rem (DF, entry, Key1, Key2,... )
2706 //=======================================================================
2707 static Standard_Integer DDataStd_ChangeIntPackedMap_Rem (Draw_Interpretor& di,
2708                                               Standard_Integer nb, 
2709                                               const char** arg) 
2710 {   
2711
2712   if( nb >= 4 ) {  
2713     Handle(TDF_Data) DF;
2714     if (!DDF::GetDF(arg[1],DF))  return 1;  
2715     TDF_Label label;
2716     if( !DDF::FindLabel(DF, arg[2], label) ) {
2717       di << "No label for entry"  << "\n";
2718       return 1;
2719     }
2720  
2721     Handle(TDataStd_IntPackedMap) A;
2722     if ( !label.FindAttribute(TDataStd_IntPackedMap::GetID(), A) ) { 
2723       di << "There is no TDataStd_IntPackedMap at label"  << "\n";
2724       return 1;
2725     }
2726     
2727     Standard_Integer i, aNum = nb - 3; 
2728     Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
2729     Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
2730     if(!aHMap.IsNull()) {
2731       ahMap->ChangeMap().Assign(aHMap->Map());
2732       for(i=1; i<=aNum;i++) {
2733         Standard_Integer val = Draw::Atoi(arg[i+2]);
2734         if(ahMap->Map().Contains(val))
2735           ahMap->ChangeMap().Remove(val);
2736       }
2737       
2738       A->ChangeMap(ahMap);
2739     }
2740     return 0;
2741   }
2742   di << "DDataStd_ChangeIntPackedMap_Rem: Error\n";
2743   return 0; 
2744 }
2745
2746 //=======================================================================
2747 //function : ChangeIntPackedMap_AddRem (DF, entry, Key1, Key2,... )
2748 //         : if Keyi exist in map - remove it, if no - add
2749 //=======================================================================
2750 static Standard_Integer DDataStd_ChangeIntPackedMap_AddRem (Draw_Interpretor& di,
2751                                               Standard_Integer nb, 
2752                                               const char** arg) 
2753 {   
2754
2755   if( nb >= 4 ) {  
2756     Handle(TDF_Data) DF;
2757     if (!DDF::GetDF(arg[1],DF))  return 1;  
2758     TDF_Label label;
2759     if( !DDF::FindLabel(DF, arg[2], label) ) {
2760       di << "No label for entry"  << "\n";
2761       return 1;
2762     }
2763  
2764     Handle(TDataStd_IntPackedMap) A;
2765     if ( !label.FindAttribute(TDataStd_IntPackedMap::GetID(), A) ) { 
2766       di << "There is no TDataStd_IntPackedMap at label"  << "\n";
2767       return 1;
2768     }
2769     
2770     Standard_Integer i, aNum = nb - 3; 
2771     Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
2772     Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
2773     if(!aHMap.IsNull()) {
2774       ahMap->ChangeMap().Assign(aHMap->Map());
2775       for(i=1; i<=aNum;i++) {
2776         Standard_Integer val = Draw::Atoi(arg[i+2]);
2777         if(!ahMap->Map().Contains(val))
2778           ahMap->ChangeMap().Add(val);
2779         else
2780           ahMap->ChangeMap().Remove(val);
2781       }
2782       
2783       A->ChangeMap(ahMap);
2784     }
2785     return 0;
2786   }
2787   di << "DDataStd_ChangeIntPackedMap_AddRem: Error\n";
2788   return 0; 
2789 }
2790
2791 //=======================================================================
2792 //function : SetIntPHugeMap (DF, entry, isDelta Num)
2793 //=======================================================================
2794
2795 static Standard_Integer DDataStd_SetIntPHugeMap (Draw_Interpretor& di,
2796                                                   Standard_Integer nb, 
2797                                                   const char** arg) 
2798 {   
2799
2800   if (nb > 4) {
2801     Handle(TDF_Data) DF;
2802     if (!DDF::GetDF(arg[1],DF))  return 1; 
2803     TDF_Label aLabel;
2804     DDF::AddLabel(DF, arg[2], aLabel);
2805     Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
2806     Standard_Integer aNum = Draw::Atoi(arg[4]);
2807     Handle(TDataStd_IntPackedMap) anAtt;
2808     if(!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt))
2809       anAtt = TDataStd_IntPackedMap::Set(aLabel, isDelta);
2810     if(anAtt.IsNull()) {
2811       di << "IntPackedMap attribute is not found or not set"  << "\n";
2812       return 1;}
2813     
2814     TColStd_PackedMapOfInteger aMap;
2815     for(Standard_Integer i = 1; i<=aNum; i++) {
2816       aMap.Add (i);
2817     }
2818     const Handle(TColStd_HPackedMapOfInteger)& aHMap = new TColStd_HPackedMapOfInteger(aMap);
2819     anAtt->ChangeMap(aHMap);
2820     cout << "Map extent = " << anAtt->Extent()<<endl;
2821     return 0; 
2822   }
2823   di << "DDataStd_SetIntPHugeMap : Error\n";
2824   return 1;
2825 }
2826
2827 //=======================================================================
2828 //function : SetNDataIntegers (DF, entry , Num
2829 //=======================================================================
2830
2831 static Standard_Integer DDataStd_SetNDataIntegers2 (Draw_Interpretor& di,
2832                                               Standard_Integer nb, 
2833                                               const char** arg) 
2834 {   
2835
2836   if (nb ==4) {
2837     Handle(TDF_Data) DF;
2838     if (!DDF::GetDF(arg[1],DF))  return 1; 
2839     TDF_Label aLabel;
2840     DDF::AddLabel(DF, arg[2], aLabel);
2841     Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
2842     Handle(TDataStd_NamedData) anAtt;
2843     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
2844       anAtt = TDataStd_NamedData::Set(aLabel);
2845     if(anAtt.IsNull()) {
2846       di << "NamedData attribute is not found or not set"  << "\n";
2847       return 1;}
2848   
2849     j = 1111;
2850     TCollection_ExtendedString aKey("Key_");
2851     for(Standard_Integer i = 1; i<=aNumP; i++) {
2852       TCollection_ExtendedString key = aKey + i;
2853       Standard_Integer aVal = j+i;
2854       anAtt->SetInteger(key, aVal); 
2855       j +=1;
2856     }    
2857     return 0; 
2858   }
2859   di << "DDataStd_SetNDataIntegers2 : Error\n";
2860   return 1;
2861
2862 //================
2863 //=======================================================================
2864 //function : SetNDataIntArrays2 (DF, entry , key, NumOfArElem )
2865 //=======================================================================
2866
2867 static Standard_Integer DDataStd_SetNDataIntAr2 (Draw_Interpretor& di,
2868                                               Standard_Integer nb, 
2869                                               const char** arg) 
2870 {   
2871
2872   if (nb == 5) {
2873     Handle(TDF_Data) DF;
2874     if (!DDF::GetDF(arg[1],DF))  return 1; 
2875     TDF_Label aLabel;
2876     DDF::AddLabel(DF, arg[2], aLabel);
2877  
2878     Standard_Integer j;
2879     TCollection_ExtendedString aKey(arg[3]);
2880     Standard_Integer aNum = Draw::Atoi(arg[4]);
2881     if (aNum <= 0) return 1;
2882     Handle(TDataStd_NamedData) anAtt;
2883     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
2884       anAtt = TDataStd_NamedData::Set(aLabel);
2885     if(anAtt.IsNull()) {
2886       cout<< "NamedData attribute is not found or not set"  << endl;
2887       return 1;}
2888   
2889     j = 15;
2890     Handle(TColStd_HArray1OfInteger) anArr =  new TColStd_HArray1OfInteger(1, aNum);
2891     for(Standard_Integer i = 1; i<=aNum; i++) {
2892       Standard_Integer aVal = j++;
2893       anArr->SetValue(i, aVal);
2894       j++;
2895     }
2896     anAtt->SetArrayOfIntegers(aKey, anArr); 
2897     return 0; 
2898   }
2899   di << "DDataStd_SetNDataIntArrays2 : Error\n";
2900   return 1;
2901
2902
2903
2904 //=======================================================================
2905 //function :  SetAsciiString(DF, entry, String[, guid])
2906 //=======================================================================
2907
2908 static Standard_Integer DDataStd_SetAsciiString (Draw_Interpretor& di,
2909                                               Standard_Integer nb, 
2910                                               const char** arg) 
2911 {   
2912
2913   if (nb == 4 || nb == 5) {
2914     Handle(TDF_Data) DF;
2915     if (!DDF::GetDF(arg[1],DF))  return 1; 
2916     TDF_Label aLabel;
2917     DDF::AddLabel(DF, arg[2], aLabel);
2918     TCollection_AsciiString aString(arg[3]);
2919         Standard_GUID aGuid (TDataStd_AsciiString::GetID());
2920         if(nb == 5) {
2921           if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
2922         di<<"DDataStd_SetAsciiString: The format of GUID is invalid\n";
2923         return 1;
2924           }
2925           aGuid = Standard_GUID (arg[4]);
2926         } 
2927
2928     Handle(TDataStd_AsciiString) anAtt = TDataStd_AsciiString::Set(aLabel, aGuid, aString);
2929     if(anAtt.IsNull()) {
2930       di << "AsciiString attribute is not found or not set"  << "\n";
2931       return 1;
2932         }
2933   
2934     cout << "String = " << anAtt->Get().ToCString() << " is kept in DF" << endl;
2935     return 0; 
2936   }
2937   di << "DDataStd_SetAsciiString : Error\n";
2938   return 1;
2939
2940 //
2941 //=======================================================================
2942 //function :  GetAsciiString(DF, entry[, guid] )
2943 //=======================================================================
2944
2945 static Standard_Integer DDataStd_GetAsciiString (Draw_Interpretor& di,
2946                                               Standard_Integer nb, 
2947                                               const char** arg) 
2948 {   
2949   if (nb == 3 || nb == 4) {
2950     Handle(TDF_Data) DF;
2951     if (!DDF::GetDF(arg[1],DF))  return 1; 
2952     TDF_Label aLabel;           
2953     DDF::FindLabel(DF, arg[2], aLabel);
2954     if(aLabel.IsNull()) di << "Label is not found"   << "\n";
2955     Standard_GUID aGuid (TDataStd_AsciiString::GetID());
2956     if(nb == 4) {
2957       if (!Standard_GUID::CheckGUIDFormat(arg[3])) {
2958         di<<"DDataStd_GetAsciiString: The format of GUID is invalid\n";
2959         return 1;
2960           }
2961           aGuid = Standard_GUID(arg[3]);
2962         }
2963         Handle(TDataStd_AsciiString) anAtt;
2964         if( !aLabel.FindAttribute(aGuid, anAtt) ) {
2965       cout << "AsciiString attribute is not found or not set"  << endl;
2966           return 1;
2967         }
2968
2969 #ifdef DEB_DDataStd
2970       cout << "String = " << anAtt->Get().ToCString()  << endl;
2971 #endif
2972     di << anAtt->Get().ToCString();
2973     return 0; 
2974   }
2975   di << "DDataStd_GetAsciiString : Error\n";
2976   return 1;
2977
2978
2979 //=======================================================================
2980 //function : SetNDataIntegers (DF, entry , Num,  key1, val1, ...
2981 //=======================================================================
2982
2983 static Standard_Integer DDataStd_SetNDataIntegers (Draw_Interpretor& di,
2984                                               Standard_Integer nb, 
2985                                               const char** arg) 
2986 {   
2987
2988   if (nb >=6) {
2989     Handle(TDF_Data) DF;
2990     if (!DDF::GetDF(arg[1],DF))  return 1; 
2991     TDF_Label aLabel;
2992     DDF::AddLabel(DF, arg[2], aLabel);
2993 //
2994 //     TCollection_ExtendedString aString("123456789 0_abcde");
2995 //     Standard_Integer aPos = aString.Search(" ");
2996 //     cout << "From Start = " <<aPos<<endl;
2997 //     aPos = aString.SearchFromEnd(" ");
2998 //     cout << "From Start = " <<aPos<<endl;
2999 //     TCollection_ExtendedString aValue = aString.Split(aPos);
3000 //     cout << "Value = |"<<aValue<<endl;
3001 //     cout << "aKey = " << aString << "|"<<endl;
3002 // 
3003     Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
3004     Handle(TDataStd_NamedData) anAtt;
3005     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3006       anAtt = TDataStd_NamedData::Set(aLabel);
3007     if(anAtt.IsNull()) {
3008       di << "NamedData attribute is not found or not set"  << "\n";
3009       return 1;}
3010   
3011     j = 4;
3012     for(Standard_Integer i = 1; i<=aNumP; i++) {
3013       TCollection_ExtendedString aKey(arg[j]);
3014       Standard_Integer aVal = Draw::Atoi(arg[j+1]);
3015       anAtt->SetInteger(aKey, aVal); 
3016       j +=2;
3017     }    
3018     return 0; 
3019   }
3020   di << "DDataStd_SetNDataIntegers : Error\n";
3021   return 1;
3022
3023
3024
3025 //=======================================================================
3026 //function :  GetNDIntegers(DF, entry )
3027 //=======================================================================
3028 static Standard_Integer DDataStd_GetNDIntegers (Draw_Interpretor& di,
3029                                                 Standard_Integer nb, 
3030                                                 const char** arg) 
3031 {   
3032
3033   if (nb == 3) {
3034     Handle(TDF_Data) DF;
3035     if (!DDF::GetDF(arg[1],DF))  return 1; 
3036     TDF_Label aLabel;
3037     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3038  
3039
3040     Handle(TDataStd_NamedData) anAtt;
3041     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3042       cout << "NamedData attribute is not found or not set"  << endl;
3043       return 1;}
3044     cout <<endl;
3045     cout <<"NamedData attribute at Label = " << arg[2] <<endl;
3046     const TColStd_DataMapOfStringInteger& aMap = anAtt->GetIntegersContainer();
3047     TColStd_DataMapIteratorOfDataMapOfStringInteger itr(aMap);
3048     for (; itr.More(); itr.Next()){
3049       TCollection_ExtendedString aKey(itr.Key());
3050       TCollection_AsciiString aStr(aKey,'?');
3051       Standard_Integer aValue = itr.Value();
3052        cout << "Key = "  << aStr.ToCString() << " Value = " <<aValue<<endl;;
3053       }
3054
3055     return 0; 
3056   }
3057   di << "DDataStd_GetNDIntegers : Error\n";
3058   return 1;
3059
3060
3061 //=======================================================================
3062 //function :  GetNDInteger(DF, entry, key [drawname])
3063 //=======================================================================
3064 static Standard_Integer DDataStd_GetNDInteger (Draw_Interpretor& di,
3065                                                 Standard_Integer nb, 
3066                                                 const char** arg) 
3067 {   
3068
3069   if (nb >=4) {
3070     Handle(TDF_Data) DF;
3071     if (!DDF::GetDF(arg[1],DF))  return 1; 
3072     TDF_Label aLabel;
3073     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3074  
3075
3076     Handle(TDataStd_NamedData) anAtt;
3077     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3078       cout << "NamedData attribute is not found or not set"  << endl;
3079       return 1;}
3080
3081     cout <<endl;
3082     cout <<"NamedData attribute at Label = " << arg[2] <<endl;    
3083     if(!anAtt->HasInteger(arg[3])) {
3084       cout << "There is no data specified by Key = "<< arg[3]  << endl;
3085       return 1;
3086     } else {
3087       cout << "Key = "  << arg[3]  << " Value = " <<anAtt->GetInteger(arg[3])<<endl;
3088       if(nb == 5) 
3089         Draw::Set(arg[4], anAtt->GetInteger(arg[3]));
3090       return 0; 
3091     }
3092   }
3093   di << "DDataStd_SetNDataIntegers : Error\n";
3094   return 1;
3095
3096
3097 //========================== REALS ======================================
3098 //=======================================================================
3099 //function : SetNDataReals (DF, entry , Num,  key1, val1, ...
3100 //=======================================================================
3101
3102 static Standard_Integer DDataStd_SetNDataReals (Draw_Interpretor& di,
3103                                               Standard_Integer nb, 
3104                                               const char** arg) 
3105 {   
3106
3107   if (nb >=6) {
3108     Handle(TDF_Data) DF;
3109     if (!DDF::GetDF(arg[1],DF))  return 1; 
3110     TDF_Label aLabel;
3111     DDF::AddLabel(DF, arg[2], aLabel);
3112  
3113     Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
3114     Handle(TDataStd_NamedData) anAtt;
3115     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3116       anAtt = TDataStd_NamedData::Set(aLabel);
3117     if(anAtt.IsNull()) {
3118       cout << "NamedData attribute is not found or not set"  << endl;;
3119       return 1;}
3120   
3121     j = 4;
3122     for(Standard_Integer i = 1; i<=aNumP; i++) {
3123       TCollection_ExtendedString aKey(arg[j]);
3124       Standard_Real aVal = Draw::Atof(arg[j+1]);
3125       anAtt->SetReal(aKey, aVal); 
3126       j +=2;
3127     }    
3128     return 0; 
3129   }
3130   di << "DDataStd_SetNDataReals : Error\n";
3131   return 1;
3132
3133
3134 //=======================================================================
3135 //function :  GetNDReals(DF, entry )
3136 //=======================================================================
3137 static Standard_Integer DDataStd_GetNDReals (Draw_Interpretor& di,
3138                                                 Standard_Integer nb, 
3139                                                 const char** arg) 
3140 {   
3141
3142   if (nb == 3) {
3143     Handle(TDF_Data) DF;
3144     if (!DDF::GetDF(arg[1],DF))  return 1; 
3145     TDF_Label aLabel;
3146     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3147  
3148     cout <<endl;
3149     cout <<"NamedData attribute at Label = " << arg[2] <<endl;
3150     Handle(TDataStd_NamedData) anAtt;
3151     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3152       cout << "NamedData attribute is not found or not set"  << endl;
3153       return 1;}
3154     
3155     const TDataStd_DataMapOfStringReal& aMap = anAtt->GetRealsContainer();
3156     TDataStd_DataMapIteratorOfDataMapOfStringReal itr(aMap);
3157     for (; itr.More(); itr.Next()){
3158       TCollection_ExtendedString aKey(itr.Key());
3159       TCollection_AsciiString aStr(aKey,'?');
3160       Standard_Real aValue = itr.Value();
3161        cout << "Key = "  << aStr.ToCString() << " Value = " <<aValue<<endl;
3162       }
3163     return 0; 
3164   }
3165   di << "DDataStd_GetNDReals : Error\n";
3166   return 1;
3167
3168
3169 //=======================================================================
3170 //function :  GetNDReal(DF, entry, key [drawname])
3171 //=======================================================================
3172 static Standard_Integer DDataStd_GetNDReal (Draw_Interpretor& di,
3173                                                 Standard_Integer nb, 
3174                                                 const char** arg) 
3175 {   
3176
3177   if (nb >=4) {
3178     Handle(TDF_Data) DF;
3179     if (!DDF::GetDF(arg[1],DF))  return 1; 
3180     TDF_Label aLabel;
3181     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3182  
3183
3184     Handle(TDataStd_NamedData) anAtt;
3185     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3186       cout << "NamedData attribute is not found or not set"  << endl;
3187       return 1;}
3188
3189     cout <<endl;
3190     cout <<"NamedData attribute at Label = " << arg[2] <<endl;    
3191     if(!anAtt->HasReal(arg[3])) {
3192       cout << "There is no data specified by Key = "<< arg[3]  << endl;
3193       return 1;
3194     } else {
3195       cout << "Key = "  << arg[3]  << " Value = " <<anAtt->GetReal(arg[3])<<endl;
3196       if(nb == 5) 
3197         Draw::Set(arg[4], anAtt->GetReal(arg[3]));
3198       return 0; 
3199     }
3200   }
3201   di << "DDataStd_GetNDReal : Error\n";
3202   return 1;
3203
3204
3205 //======================= Strings =======================================
3206 //=======================================================================
3207 //function : SetNDataStrings (DF, entry , Num,  key1, val1, ...
3208 //=======================================================================
3209
3210 static Standard_Integer DDataStd_SetNDataStrings (Draw_Interpretor& di,
3211                                                   Standard_Integer nb, 
3212                                                   const char** arg) 
3213 {   
3214
3215   if (nb >=6) {
3216     Handle(TDF_Data) DF;
3217     if (!DDF::GetDF(arg[1],DF))  return 1; 
3218     TDF_Label aLabel;
3219     DDF::AddLabel(DF, arg[2], aLabel);
3220  
3221     Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
3222     Handle(TDataStd_NamedData) anAtt;
3223     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3224       anAtt = TDataStd_NamedData::Set(aLabel);
3225     if(anAtt.IsNull()) {
3226       di << "NamedData attribute is not found or not set"  << "\n";
3227       return 1;}
3228   
3229     j = 4;
3230     for(Standard_Integer i = 1; i<=aNumP; i++) {
3231       TCollection_ExtendedString aKey(arg[j]);
3232       TCollection_ExtendedString aVal(arg[j+1]);
3233       anAtt->SetString(aKey, aVal); 
3234       j +=2;
3235     }    
3236     return 0; 
3237   }
3238   di << "DDataStd_SetNDataStrings : Error\n";
3239   return 1;
3240
3241
3242 //=======================================================================
3243 //function :  GetNDStrings(DF, entry )
3244 //=======================================================================
3245 static Standard_Integer DDataStd_GetNDStrings (Draw_Interpretor& di,
3246                                                 Standard_Integer nb, 
3247                                                 const char** arg) 
3248 {   
3249
3250   if (nb == 3) {
3251     Handle(TDF_Data) DF;
3252     if (!DDF::GetDF(arg[1],DF))  return 1; 
3253     TDF_Label aLabel;
3254     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3255  
3256
3257     Handle(TDataStd_NamedData) anAtt;
3258     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3259       cout << "NamedData attribute is not found or not set"  << endl;
3260       return 1;}
3261     cout <<endl;
3262     cout <<"NamedData attribute at Label = " << arg[2] <<endl;    
3263     const TDataStd_DataMapOfStringString& aMap = anAtt->GetStringsContainer();
3264     TDataStd_DataMapIteratorOfDataMapOfStringString itr(aMap);
3265     for (; itr.More(); itr.Next()){
3266       TCollection_ExtendedString aKey(itr.Key());
3267       TCollection_AsciiString aStr(aKey,'?');
3268       TCollection_ExtendedString aVal(itr.Value());
3269       TCollection_AsciiString aStrValue(aVal,'?');
3270       cout << "Key = "  << aStr.ToCString() << " Value = " <<aStrValue.ToCString()<< endl;
3271       }
3272     return 0; 
3273   }
3274   di << "DDataStd_GetNDStrings : Error\n";
3275   return 1;
3276
3277
3278 //=======================================================================
3279 //function :  GetNDString(DF, entry, key [drawname])
3280 //=======================================================================
3281 static Standard_Integer DDataStd_GetNDString (Draw_Interpretor& di,
3282                                               Standard_Integer nb, 
3283                                               const char** arg) 
3284 {   
3285
3286   if (nb >=4) {
3287     Handle(TDF_Data) DF;
3288     if (!DDF::GetDF(arg[1],DF))  return 1; 
3289     TDF_Label aLabel;
3290     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3291  
3292
3293     Handle(TDataStd_NamedData) anAtt;
3294     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3295       di << "NamedData attribute is not found or not set"  << "\n";
3296       return 1;}
3297
3298     cout <<endl;
3299     cout <<"NamedData attribute at Label = " << arg[2] <<endl;    
3300     if(!anAtt->HasString(arg[3])) {
3301       cout << "There is no data specified by Key = "<< arg[3]  << endl;
3302       return 1;
3303     } else {
3304       TCollection_AsciiString aValue (anAtt->GetString(arg[3]), '?');
3305       cout << "Key = "  << arg[3]  << " Value = " << aValue.ToCString() << endl;
3306       if(nb == 5) 
3307         Draw::Set(arg[4], aValue.ToCString());
3308       return 0; 
3309     }
3310   }
3311   di << "DDataStd_GetNDString : Error\n";
3312   return 1;
3313
3314
3315 //=========================== Bytes =====================================
3316 //=======================================================================
3317 //function : SetNDataBytes (DF, entry , Num,  key1, val1, ...
3318 //=======================================================================
3319
3320 static Standard_Integer DDataStd_SetNDataBytes (Draw_Interpretor& di,
3321                                                 Standard_Integer nb, 
3322                                                 const char** arg) 
3323 {   
3324
3325   if (nb >=6) {
3326     Handle(TDF_Data) DF;
3327     if (!DDF::GetDF(arg[1],DF))  return 1; 
3328     TDF_Label aLabel;
3329     DDF::AddLabel(DF, arg[2], aLabel);
3330  
3331     Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
3332     Handle(TDataStd_NamedData) anAtt;
3333     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3334       anAtt = TDataStd_NamedData::Set(aLabel);
3335     if(anAtt.IsNull()) {
3336       cout << "NamedData attribute is not found or not set"  << endl;
3337       return 1;}
3338   
3339     j = 4;
3340     for(Standard_Integer i = 1; i<=aNumP; i++) {
3341       TCollection_ExtendedString aKey(arg[j]);
3342       Standard_Byte aVal = (Standard_Byte)Draw::Atoi(arg[j+1]);
3343       anAtt->SetByte(aKey, aVal); 
3344       j +=2;
3345     }    
3346     return 0; 
3347   }
3348   di << "DDataStd_SetNDataBytes : Error\n";
3349   return 1;
3350
3351
3352 //=======================================================================
3353 //function :  GetNDBytes(DF, entry )
3354 //=======================================================================
3355 static Standard_Integer DDataStd_GetNDBytes (Draw_Interpretor& di,
3356                                                 Standard_Integer nb, 
3357                                                 const char** arg) 
3358 {   
3359
3360   if (nb == 3) {
3361     Handle(TDF_Data) DF;
3362     if (!DDF::GetDF(arg[1],DF))  return 1; 
3363     TDF_Label aLabel;
3364     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3365  
3366
3367     Handle(TDataStd_NamedData) anAtt;
3368     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3369       cout << "NamedData attribute is not found or not set"  << endl;
3370       return 1;}
3371     cout <<endl;
3372     cout <<"NamedData attribute at Label = " << arg[2] <<endl;      
3373     const TDataStd_DataMapOfStringByte& aMap = anAtt->GetBytesContainer();
3374     TDataStd_DataMapIteratorOfDataMapOfStringByte itr(aMap);
3375     for (; itr.More(); itr.Next()){
3376       TCollection_ExtendedString aKey(itr.Key());
3377       TCollection_AsciiString aStr(aKey,'?');
3378       Standard_Byte aValue = itr.Value();
3379       cout << "Key = "  << aStr.ToCString() << " Value = " <<aValue<<endl;
3380       }
3381     return 0; 
3382   }
3383   di << "DDataStd_GetNDBytes : Error\n";
3384   return 1;
3385
3386
3387 //=======================================================================
3388 //function :  GetNDByte(DF, entry, key [drawname])
3389 //=======================================================================
3390 static Standard_Integer DDataStd_GetNDByte (Draw_Interpretor& di,
3391                                                 Standard_Integer nb, 
3392                                                 const char** arg) 
3393 {   
3394
3395   if (nb >=4) {
3396     Handle(TDF_Data) DF;
3397     if (!DDF::GetDF(arg[1],DF))  return 1; 
3398     TDF_Label aLabel;
3399     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3400  
3401
3402     Handle(TDataStd_NamedData) anAtt;
3403     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt)) {
3404       cout << "NamedData attribute is not found or not set"  << endl;
3405       return 1;}
3406
3407     cout <<endl;
3408     cout <<"NamedData attribute at Label = " << arg[2] <<endl;      
3409     if(!anAtt->HasByte(arg[3])) {
3410       cout << "There is no data specified by Key = "<< arg[3]  << endl;
3411       return 1;
3412     } else {
3413       cout << "Key = "  << arg[3]  << " Value = " <<anAtt->GetByte(arg[3])<< endl;
3414       if(nb == 5) 
3415         Draw::Set(arg[4], anAtt->GetByte(arg[3]));
3416       return 0; 
3417     }
3418   }
3419   di << "DDataStd_GetNDByte : Error\n";
3420   return 1;
3421
3422 //======================== IntArrays ====================================
3423 //=======================================================================
3424 //function : SetNDataIntArrays (DF, entry , key, NumOfArElem, val1, val2,...  )
3425 //=======================================================================
3426
3427 static Standard_Integer DDataStd_SetNDataIntAr (Draw_Interpretor& di,
3428                                               Standard_Integer nb, 
3429                                               const char** arg) 
3430 {   
3431
3432   if (nb >=6) {
3433     Handle(TDF_Data) DF;
3434     if (!DDF::GetDF(arg[1],DF))  return 1; 
3435     TDF_Label aLabel;
3436     DDF::AddLabel(DF, arg[2], aLabel);
3437  
3438     Standard_Integer j;
3439     TCollection_ExtendedString aKey(arg[3]);
3440     Standard_Integer aNum = Draw::Atoi(arg[4]);
3441     if (aNum <= 0) return 1;
3442     Handle(TDataStd_NamedData) anAtt;
3443     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3444       anAtt = TDataStd_NamedData::Set(aLabel);
3445     if(anAtt.IsNull()) {
3446       cout<< "NamedData attribute is not found or not set"  << endl;
3447       return 1;}
3448