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