0014673: Provide true support for Unicode symbols
[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(TCollection_ExtendedString (expr, Standard_True));
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         TCollection_ExtendedString aVal (arg[j], Standard_True);
1226         A->SetValue(i, aVal);
1227         j++;
1228       }
1229     }
1230     return 0; 
1231   }
1232   di << "TDataStd_ExtStringArray: Error\n";
1233   return 1; 
1234
1235
1236 //=======================================================================
1237 //function : SetExtStringArrayValue (DF, entry, index, value)
1238 //=======================================================================
1239 static Standard_Integer DDataStd_SetExtStringArrayValue (Draw_Interpretor&,
1240                                                          Standard_Integer,
1241                                                          const char** arg) 
1242 {
1243   // Get document.
1244   Handle(TDF_Data) DF;
1245   if (!DDF::GetDF(arg[1], DF))
1246     return 1;
1247
1248   // Get label.
1249   TDF_Label label; 
1250   if (!DDF::AddLabel(DF, arg[2], label))
1251     return 1;
1252  
1253   // Get index and value.
1254   Standard_Integer index = Draw::Atoi(arg[3]);
1255
1256   // Set new value.
1257   Handle(TDataStd_ExtStringArray) arr;
1258   if (label.FindAttribute(TDataStd_ExtStringArray::GetID(), arr))
1259   {
1260     TCollection_ExtendedString aVal(arg[4], Standard_True);
1261     arr->SetValue(index, aVal); 
1262     return 0;
1263   }
1264
1265   return 1;
1266
1267
1268 //=======================================================================
1269 //function : GetExtStringArray (DF, entry )
1270 //=======================================================================
1271 static Standard_Integer DDataStd_GetExtStringArray (Draw_Interpretor& di,
1272                                                     Standard_Integer nb, 
1273                                                     const char** arg) 
1274 {   
1275   if (nb >= 3) 
1276   {  
1277
1278     Handle(TDF_Data) DF;
1279     if (!DDF::GetDF(arg[1],DF))  return 1;  
1280     TDF_Label label;
1281     if( !DDF::FindLabel(DF, arg[2], label) ) {
1282       di << "No label for entry"  << "\n";
1283       return 1;
1284     }
1285     Standard_GUID aGuid;
1286     if(nb == 4) {
1287       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
1288         aGuid = Standard_GUID(arg[3]);
1289       else {
1290         di << "Wrong GUID format"  << "\n";
1291         return 1; 
1292       }
1293     } else
1294       aGuid = TDataStd_ExtStringArray::GetID();
1295     Handle(TDataStd_ExtStringArray) A;
1296     if ( !label.FindAttribute(aGuid, A) ) { 
1297       di << "There is no TDataStd_ExtStringArray  with the specified GUID at the label"  << "\n";
1298       return 1;
1299     }
1300
1301     for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
1302       di << A->Value(i);
1303       if(i<A->Upper())  
1304         di<<" ";
1305     }
1306     di<<"\n";
1307     return 0; 
1308   } 
1309   di << "DDataStd_GetExtStringArray: Error\n";
1310   return 1; 
1311
1312
1313 //=======================================================================
1314 //function : GetExtStringArrayValue (DF, entry, index)
1315 //=======================================================================
1316 static Standard_Integer DDataStd_GetExtStringArrayValue (Draw_Interpretor& di,
1317                                                          Standard_Integer, 
1318                                                          const char** arg) 
1319 {
1320   Handle(TDF_Data) DF;
1321   if (!DDF::GetDF(arg[1],DF))
1322       return 1;
1323
1324   TDF_Label label;
1325   if (!DDF::FindLabel(DF, arg[2], label)) {
1326     di << "No label for entry"  << "\n";
1327     return 1;
1328   }
1329  
1330   Handle(TDataStd_ExtStringArray) A;
1331   if ( !label.FindAttribute(TDataStd_ExtStringArray::GetID(), A) ) { 
1332     di << "There is no TDataStd_ExtStringArray under label"  << "\n";
1333     return 1;
1334   }
1335   
1336   Standard_Integer index = Draw::Atoi(arg[3]);
1337   if (index < A->Lower() || index > A->Upper()) {
1338     di << "Index is out of range\n";
1339     return 1;
1340   } else {
1341     const TCollection_ExtendedString& value = A->Value(index);
1342     di << value ;
1343   }
1344
1345   return 0; 
1346
1347
1348 //=======================================================================
1349 //function : ChangeExtStrArray (DF, entry, indx, val )
1350 //=======================================================================
1351 static Standard_Integer DDataStd_ChangeExtStrArray (Draw_Interpretor& di,
1352                                               Standard_Integer nb, 
1353                                               const char** arg) 
1354 {   
1355
1356   if( nb == 5 ) {  
1357     Handle(TDF_Data) DF;
1358     if (!DDF::GetDF(arg[1],DF))  return 1;  
1359     TDF_Label label;
1360     if( !DDF::FindLabel(DF, arg[2], label) ) {
1361       di << "No label for entry"  << "\n";
1362       return 1;
1363     }
1364  
1365     Handle(TDataStd_ExtStringArray) A;
1366     if ( !label.FindAttribute(TDataStd_ExtStringArray::GetID(), A) ) { 
1367       di << "There is no TDataStd_ExtStringArray at label"  << "\n";
1368       return 1;
1369     }
1370     Standard_Integer indx = Draw::Atoi(arg[3]);
1371     TCollection_ExtendedString val(arg[4]);
1372     Standard_Integer low = A->Lower(), up = A->Upper();
1373     if(low <= indx && indx <= up)
1374       A->SetValue(indx, val);//TColStd_HArray1OfExtendedString
1375     else {
1376       Handle(TColStd_HArray1OfExtendedString) Arr = A->Array();
1377       Handle(TColStd_HArray1OfExtendedString) arr;
1378       Standard_Integer i;
1379       if(indx > up) {
1380         up = indx;
1381         arr = new TColStd_HArray1OfExtendedString(low, up);
1382         for(i=low; i<= Arr->Upper(); i++)
1383           arr->SetValue(i, Arr->Value(i));
1384         for(i=Arr->Upper()+1; i<= up; i++) {
1385           if(i == up)
1386             arr->SetValue(i, val);
1387           else
1388             arr->SetValue(i, 0);
1389         }
1390       } else if(indx < up) {//clip array : indx to be negative
1391         up = abs(indx);
1392         arr = new TColStd_HArray1OfExtendedString(low, up);
1393         for(i=low; i< up; i++)
1394           arr->SetValue(i, Arr->Value(i));
1395         arr->SetValue(up, val);
1396       }
1397       A->ChangeArray(arr);
1398     }    
1399     return 0;
1400   }
1401   di << "DDataStd_ChangeExtStringArray: Error\n";
1402   return 0; 
1403
1404
1405
1406 //=======================================================================
1407 //function : DDataStd_KeepUTF
1408 //purpose  : SetUTFName (DF, fatherEntry, fileName)
1409 //=======================================================================
1410 static Standard_Integer DDataStd_KeepUTF (Draw_Interpretor& di,
1411                                                Standard_Integer nb, 
1412                                                const char** arg) 
1413 {
1414   if (nb == 4) {    
1415     Handle(TDF_Data) DF;
1416     if (!DDF::GetDF(arg[1],DF)) return 1;
1417     TDF_Label L;
1418     DDF::AddLabel(DF, arg[2], L);
1419     Standard_CString aFileName(arg[3]);
1420
1421 #ifdef _MSC_VER
1422       std::ifstream anIS (aFileName, std::ios::in | std::ios::binary);
1423 #else
1424       std::ifstream anIS (aFileName);
1425 #endif
1426     if (!anIS) {
1427       // Can not open file
1428       Message::SendFail() << "Error: can't open file " << aFileName;
1429       return 1;
1430     }
1431     char buf[1024];
1432     char *p;
1433     anIS.getline(buf, 1023,'\n');
1434     //    0xEFBBBF  -  prefix of UTF8 
1435     p = &buf[3]; //skip prefix
1436     TCollection_ExtendedString aES1(p, Standard_True);
1437     TDataStd_Name::Set(L.NewChild(), aES1);
1438  
1439
1440     while (anIS.good() && !anIS.eof()) {
1441       anIS.getline(buf, 1023,'\n');
1442       TCollection_ExtendedString aES2(buf, Standard_True);
1443       const TDF_Label& aLab = L.NewChild();
1444       TDataStd_Name::Set(aLab, aES2);
1445     }
1446     return 0;
1447   }
1448   di << "SetUTFName : String is not kept in DF\n";
1449   return 1;
1450 }
1451
1452 //=======================================================================
1453 //function : DDataStd_GetUTFtoFile
1454 //purpose  : GetUTF (DF, fatherEntry, fileName)
1455 //         : all strings from sub-labels of the <fatherEntry> concatenated
1456 //         : in one, converted to UTF8 and kept in the file
1457 //=======================================================================
1458 static Standard_Integer DDataStd_GetUTFtoFile (Draw_Interpretor& di,
1459                                                Standard_Integer nb, 
1460                                                const char** arg) 
1461 {
1462   if (nb == 4) {    
1463     Handle(TDF_Data) DF;
1464     if (!DDF::GetDF(arg[1],DF)) return 1;
1465     TDF_Label L;
1466     if (!DDF::FindLabel(DF,arg[2],L)) return 1;
1467
1468     TCollection_ExtendedString aES;
1469     Standard_Boolean aF = Standard_False;
1470     TDF_ChildIterator anIt(L);
1471     for(;anIt.More();anIt.Next()) {
1472       const TDF_Label& aLab = anIt.Value();
1473       if(!aLab.IsNull()) {
1474         Handle(TDataStd_Name) anAtt;
1475         if(aLab.FindAttribute(TDataStd_Name::GetID(), anAtt)) {
1476           if(anAtt->Get().Length()) { 
1477             if (aF)
1478               aES +='\n';
1479             aES +=anAtt->Get();
1480             aF = Standard_True;
1481           }
1482         }
1483       }
1484     }
1485
1486     if(!aES.Length()) {
1487       Message::SendFail() << "Data is not found in the Document";
1488       return 1;
1489     }
1490
1491     Standard_CString aFileName(arg[3]);
1492
1493 #ifdef _MSC_VER
1494     std::ofstream anOS (aFileName, std::ios::in | std::ios::binary | std::ios::ate);
1495 #else
1496     std::ofstream anOS (aFileName, std::ios::ate);
1497 #endif
1498     if (!anOS) {
1499       // A problem with the stream
1500 #ifdef OCCT_DEBUG
1501       std::cout << "Error: problem with the file stream, rdstate = " <<anOS.rdstate() <<std::endl;
1502 #endif
1503     }
1504     unsigned char prefix[4] = {0xEF,0xBB,0xBF, 0x00};
1505     anOS.write( (char*)&prefix[0], 3); 
1506     Standard_Integer  n = aES.LengthOfCString();
1507     Standard_PCharacter aCstr = (Standard_PCharacter) Standard::Allocate(n+1);
1508     n = aES.ToUTF8CString(aCstr);
1509     anOS.write( (char*)&aCstr[0], n); 
1510     anOS.close();
1511     return 0;
1512   }
1513   di << "GetUTF : Data is not extracted to the specified file \n";
1514   return 1;
1515 }
1516
1517 //=======================================================================
1518 //function : SetByteArray (DF, entry, isDelta, [-g Guid,] From, To, elmt1, elmt2, ...  )
1519 //=======================================================================
1520 static Standard_Integer DDataStd_SetByteArray (Draw_Interpretor& di,
1521                                               Standard_Integer nb, 
1522                                               const char** arg) 
1523 {   
1524   if (nb >= 6) {  
1525     Handle(TDF_Data) DF;
1526     if (!DDF::GetDF(arg[1],DF))  return 1; 
1527     TDF_Label label;
1528     DDF::AddLabel(DF, arg[2], label);
1529     Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
1530     Standard_GUID guid;
1531     Standard_Boolean isGuid(Standard_False);
1532     Standard_Character c1(arg[4][0]), c2(arg[4][1]);
1533     if(c1 == '-' && c2 == 'g') { //guid
1534       if (!Standard_GUID::CheckGUIDFormat(arg[5])) {
1535         di<<"DDataStd_SetByteArray: The format of GUID is invalid\n";
1536         return 1;
1537       }
1538       guid = Standard_GUID (arg[5]);
1539       isGuid = Standard_True;
1540     }
1541     Standard_Integer j(4);
1542     if(isGuid) j = 6;
1543     if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
1544       !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
1545       !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
1546     {
1547       di << "DDataStd_SetByteArray: From, To may be wrong\n";
1548       return 1;
1549     }
1550     Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
1551     di << "Array of Standard_Byte with bounds from = " << From  << " to = " << To  << "\n";
1552     Handle(TDataStd_ByteArray) A;
1553     if(!isGuid) 
1554       A = TDataStd_ByteArray::Set(label, From, To, isDelta);
1555     else 
1556       A = TDataStd_ByteArray::Set(label, guid, From, To, isDelta);
1557
1558     if ((!isGuid && nb > 6) || (isGuid && nb > 8)) {
1559       j = j + 2;
1560       for(Standard_Integer i = From; i<=To; ++i) {
1561         Standard_Integer ival = Draw::Atoi(arg[j]);
1562         if(ival < 0 || 255 < ival) {
1563           Message::SendFail() << "Bad value = " << ival;
1564           return 1;
1565         }
1566         A->SetValue(i, (Standard_Byte)ival); 
1567         j++;
1568       }
1569     }
1570     return 0; 
1571   }
1572   di << "DDataStd_SetByteArray: Error\n";
1573   return 1; 
1574
1575
1576 //=======================================================================
1577 //function : SetByteArrayValue (DF, entry, index, value)
1578 //=======================================================================
1579 static Standard_Integer DDataStd_SetByteArrayValue (Draw_Interpretor&,
1580                                                     Standard_Integer, 
1581                                                     const char** arg) 
1582 {
1583   // Get document.
1584   Handle(TDF_Data) DF;
1585   if (!DDF::GetDF(arg[1], DF))
1586     return 1;
1587
1588   // Get label.
1589   TDF_Label label; 
1590   if (!DDF::AddLabel(DF, arg[2], label))
1591     return 1;
1592  
1593   // Get index and value.
1594   Standard_Integer index = Draw::Atoi(arg[3]);
1595   Standard_Integer value = Draw::Atoi(arg[4]);
1596
1597   // Check the value.
1598   if(value < 0 || 255 < value) {
1599     Message::SendFail() << "Bad value = " << value;
1600     return 1;
1601   }
1602
1603   // Set new value.
1604   Handle(TDataStd_ByteArray) arr;
1605   if (label.FindAttribute(TDataStd_ByteArray::GetID(), arr))
1606   {
1607     arr->SetValue(index, (Standard_Byte) value); 
1608     return 0;
1609   }
1610
1611   return 1;
1612
1613
1614 //=======================================================================
1615 //function : SetBooleanArray (DF, entry, [-g Guid,] From, To, elmt1, elmt2, ...  )
1616 //=======================================================================
1617 static Standard_Integer DDataStd_SetBooleanArray (Draw_Interpretor& di,
1618                                                   Standard_Integer nb, 
1619                                                   const char** arg) 
1620 {
1621   if (nb >= 5) 
1622   {  
1623     Handle(TDF_Data) DF;
1624     if (!DDF::GetDF(arg[1],DF))
1625       return 1; 
1626
1627     TDF_Label label;
1628     DDF::AddLabel(DF, arg[2], label);
1629     Standard_GUID guid;
1630     Standard_Boolean isGuid(Standard_False);
1631     Standard_Character c1(arg[3][0]), c2(arg[3][1]);
1632     if(c1 == '-' && c2 == 'g') { //guid
1633       if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
1634         di<<"DDataStd_SetBooleanArray: The format of GUID is invalid\n";
1635         return 1;
1636       }
1637       guid = Standard_GUID (arg[4]);
1638       isGuid = Standard_True;
1639     }
1640     Standard_Integer j(3);
1641     if(isGuid) j = 5;
1642     if((strlen(arg[j]) > MAXLENGTH || strlen(arg[j+1]) > MAXLENGTH) || 
1643       !TCollection_AsciiString (arg[j]).IsIntegerValue() || 
1644       !TCollection_AsciiString (arg[j+1]).IsIntegerValue())
1645     {
1646       di << "DDataStd_SetBooleanArray: From, To may be wrong\n";
1647       return 1;
1648     }
1649     Standard_Integer From = Draw::Atoi(arg[j]), To = Draw::Atoi( arg[j+1] );
1650     di << "Array of Standard_Boolean with bounds from = " << From  << " to = " << To  << "\n";
1651     Handle(TDataStd_BooleanArray) A;
1652     if(!isGuid) 
1653       A = TDataStd_BooleanArray::Set(label, From, To);
1654     else 
1655       A = TDataStd_BooleanArray::Set(label, guid, From, To);
1656
1657     if ((!isGuid && nb > 5) || (isGuid && nb > 7)) {
1658       j = j + 2;
1659       for(Standard_Integer i = From; i<=To; i++) 
1660       {
1661         Standard_Integer ival = Draw::Atoi(arg[j]);
1662         if(ival > 1) 
1663         {
1664           Message::SendFail() << "Bad value (" <<i <<") = " << ival<< ". 0 or 1 is expected.";
1665           return 1;
1666         }
1667         A->SetValue(i, ival != 0); 
1668         j++;
1669       }
1670     }
1671     return 0; 
1672   }
1673   di << "DDataStd_SetBooleanArray: Error\n";
1674   return 1; 
1675
1676
1677 //=======================================================================
1678 //function : SetBooleanArrayValue (DF, entry, index, value)
1679 //=======================================================================
1680 static Standard_Integer DDataStd_SetBooleanArrayValue (Draw_Interpretor& di,
1681                                                        Standard_Integer,
1682                                                        const char** arg) 
1683 {
1684   // Get document.
1685   Handle(TDF_Data) DF;
1686   if (!DDF::GetDF(arg[1], DF))
1687     return 1;
1688
1689   // Get label.
1690   TDF_Label label; 
1691   if (!DDF::AddLabel(DF, arg[2], label))
1692     return 1;
1693  
1694   // Get index and value.
1695   Standard_Integer index = Draw::Atoi(arg[3]);
1696   Standard_Integer value = Draw::Atoi(arg[4]);
1697
1698   // Check the value.
1699   if (value != 0 && value != 1) {
1700     di << "DDataStd_SetBooleanArrayValue: Error! The value should be either 0 or 1.\n";
1701     return 1;
1702   }
1703
1704   // Set new value.
1705   Handle(TDataStd_BooleanArray) arr;
1706   if (label.FindAttribute(TDataStd_BooleanArray::GetID(), arr))
1707   {
1708     arr->SetValue(index, value != 0);
1709     return 0;
1710   }
1711
1712   return 1;
1713
1714
1715 //=======================================================================
1716 //function : DDataStd_SetExtStringList (DF, entry, [-g guid,] elmt1, elmt2, ...  )
1717 //=======================================================================
1718 static Standard_Integer DDataStd_SetExtStringList (Draw_Interpretor& di,
1719                                                  Standard_Integer nb, 
1720                                                  const char** arg) 
1721 {
1722   if (nb > 2) 
1723   {  
1724     Handle(TDF_Data) DF;
1725     if (!DDF::GetDF(arg[1],DF))
1726       return 1; 
1727
1728     TDF_Label label;
1729     DDF::AddLabel(DF, arg[2], label);
1730     Standard_GUID guid;
1731     Standard_Boolean isGuid(Standard_False);
1732     if(nb > 4) {
1733       Standard_Character c1(arg[3][0]), c2(arg[3][1]);
1734       if(c1 == '-' && c2 == 'g') { //guid
1735         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
1736           di<<"DDataStd_SetExtStringList: The format of GUID is invalid\n";
1737           return 1;
1738         }
1739         guid = Standard_GUID (arg[4]);
1740         isGuid = Standard_True;
1741       }
1742     }
1743     Standard_Integer j(0);
1744     Handle(TDataStd_ExtStringList) A;
1745     if(!isGuid) {
1746       A = TDataStd_ExtStringList::Set(label);
1747       j = 3;
1748     }
1749     else {
1750       A = TDataStd_ExtStringList::Set(label, guid);
1751       j = 5;
1752     }
1753     for(Standard_Integer i = j; i <= nb - 1; i++) 
1754     {
1755       TCollection_ExtendedString aValue(arg[i]);     
1756       A->Append(aValue); 
1757     }
1758     return 0; 
1759   }
1760   di << "DDataStd_SetExtStringList: Error\n";
1761   return 1; 
1762
1763 //
1764 //=======================================================================
1765 //function : DDataStd_SetReferenceList (DF, entry, [-g guid] elmt1, elmt2, ...  )
1766 //=======================================================================
1767 static Standard_Integer DDataStd_SetReferenceList (Draw_Interpretor& di,
1768                                                    Standard_Integer nb, 
1769                                                    const char** arg) 
1770 {
1771   if (nb > 2) 
1772   {  
1773     Handle(TDF_Data) DF;
1774     if (!DDF::GetDF(arg[1],DF))
1775       return 1; 
1776
1777     TDF_Label label;
1778     DDF::AddLabel(DF, arg[2], label);
1779     Standard_GUID guid;
1780     Standard_Boolean isGuid(Standard_False);
1781     if(nb > 4) {
1782       Standard_Character c1(arg[3][0]), c2(arg[3][1]);
1783       if(c1 == '-' && c2 == 'g') { //guid
1784         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
1785           di<<"DDataStd_SetReferenceList: The format of GUID is invalid\n";
1786           return 1;
1787         }
1788         guid = Standard_GUID (arg[4]);
1789         isGuid = Standard_True;
1790       }
1791     }
1792     Standard_Integer j(0);
1793     Handle(TDataStd_ReferenceList) A;
1794     if(!isGuid) {
1795       A = TDataStd_ReferenceList::Set(label);
1796       j = 3;
1797     }
1798     else {
1799       A = TDataStd_ReferenceList::Set(label, guid);
1800       j = 5;
1801     }
1802     for(Standard_Integer i = j; i <= nb - 1; i++) 
1803     {
1804       TDF_Label aValueLabel;
1805       DDF::AddLabel(DF, arg[i], aValueLabel);
1806       if(aValueLabel.IsNull()) continue;
1807       A->Append(aValueLabel); 
1808     }
1809     return 0; 
1810   }
1811   di << "DDataStd_SetReferenceList: Error\n";
1812   return 1; 
1813
1814
1815
1816 //=======================================================================
1817 //function : SetBooleanList (DF, entry, [-g Guid,] elmt1, elmt2, ...  )
1818 //=======================================================================
1819 static Standard_Integer DDataStd_SetBooleanList (Draw_Interpretor& di,
1820                                                  Standard_Integer nb, 
1821                                                  const char** arg) 
1822 {
1823   if (nb > 2) 
1824   {  
1825     Handle(TDF_Data) DF;
1826     if (!DDF::GetDF(arg[1],DF))
1827         return 1; 
1828
1829     TDF_Label label;
1830     DDF::AddLabel(DF, arg[2], label);
1831     Standard_GUID guid;
1832     Standard_Boolean isGuid(Standard_False);
1833     if(nb > 4) {
1834       Standard_Character c1(arg[3][0]), c2(arg[3][1]);
1835       if(c1 == '-' && c2 == 'g') { //guid
1836         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
1837           di<<"DDataStd_SetBooleanList: The format of GUID is invalid\n";
1838           return 1;
1839         }
1840         guid = Standard_GUID (arg[4]);
1841         isGuid = Standard_True;
1842       }
1843     }
1844     Standard_Integer j(0);
1845     Handle(TDataStd_BooleanList) A;
1846     if(!isGuid) {
1847       A = TDataStd_BooleanList::Set(label);
1848       j = 3;
1849     }
1850     else {
1851       A = TDataStd_BooleanList::Set(label, guid);
1852       j = 5;
1853     }
1854     for(Standard_Integer i = j; i <= nb - 1; i++) 
1855     {
1856       Standard_Integer ival = Draw::Atoi(arg[i]);
1857       if(ival > 1) 
1858       {
1859         Message::SendFail() << "Bad value = " << ival<< ". 0 or 1 is expected.";
1860         return 1;
1861       }
1862       A->Append (ival != 0);
1863     }
1864     return 0; 
1865   }
1866   di << "DDataStd_SetBooleanList: Error\n";
1867   return 1; 
1868
1869
1870 //=======================================================================
1871 //function : SetIntegerList (DF, entry, [-g guid] elmt1, elmt2, ...  )
1872 //=======================================================================
1873 static Standard_Integer DDataStd_SetIntegerList (Draw_Interpretor& di,
1874                                                  Standard_Integer nb, 
1875                                                  const char** arg) 
1876 {
1877   if (nb > 2) 
1878   {  
1879     Handle(TDF_Data) DF;
1880     if (!DDF::GetDF(arg[1],DF))
1881       return 1; 
1882
1883     TDF_Label label;
1884     DDF::AddLabel(DF, arg[2], label);
1885     Standard_GUID guid;
1886     Standard_Boolean isGuid(Standard_False);
1887     if(nb > 4) {
1888       Standard_Character c1(arg[3][0]), c2(arg[3][1]);
1889       if(c1 == '-' && c2 == 'g') { //guid
1890         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
1891           di<<"DDataStd_SetIntegerList: The format of GUID is invalid\n";
1892           return 1;
1893         }
1894         guid = Standard_GUID (arg[4]);
1895         isGuid = Standard_True;
1896       }
1897     }
1898     Standard_Integer j(0);
1899     Handle(TDataStd_IntegerList) A;
1900     if(!isGuid) {
1901       A = TDataStd_IntegerList::Set(label);
1902       j = 3;
1903     }
1904     else {
1905       A = TDataStd_IntegerList::Set(label, guid);
1906       j = 5;
1907     }
1908     for(Standard_Integer i = j; i <= nb - 1; i++) 
1909     {
1910       Standard_Integer ival = Draw::Atoi(arg[i]);
1911       A->Append(ival); 
1912     }
1913     return 0; 
1914   }
1915   di << "DDataStd_SetIntegerList: Error\n";
1916   return 1; 
1917
1918
1919 //=======================================================================
1920 //function : SetRealList (DF, entry, [-g guid,] elmt1, elmt2, ...  )
1921 //=======================================================================
1922 static Standard_Integer DDataStd_SetRealList (Draw_Interpretor& di,
1923                                               Standard_Integer nb, 
1924                                               const char** arg) 
1925 {
1926   if (nb > 2) 
1927   {  
1928     Handle(TDF_Data) DF;
1929     if (!DDF::GetDF(arg[1],DF))
1930       return 1; 
1931
1932     TDF_Label label;
1933     DDF::AddLabel(DF, arg[2], label);
1934     Standard_GUID guid;
1935     Standard_Boolean isGuid(Standard_False);
1936     if(nb > 4) {
1937       Standard_Character c1(arg[3][0]), c2(arg[3][1]);
1938       if(c1 == '-' && c2 == 'g') { //guid
1939         if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
1940           di<<"DDataStd_SetRealList: The format of GUID is invalid\n";
1941           return 1;
1942         }
1943         guid = Standard_GUID (arg[4]);
1944         isGuid = Standard_True;
1945       }
1946     }
1947     Standard_Integer j(0);
1948     Handle(TDataStd_RealList) A;
1949     if(!isGuid) {
1950       A = TDataStd_RealList::Set(label);
1951       j = 3;
1952     }
1953     else {
1954       A = TDataStd_RealList::Set(label, guid);
1955       j = 5;
1956     }
1957     for(Standard_Integer i = j; i <= nb - 1; i++) 
1958     {
1959       Standard_Real fval = Draw::Atof(arg[i]);
1960       A->Append(fval); 
1961     }
1962     return 0; 
1963   }
1964   di << "DDataStd_SetRealList: Error\n";
1965   return 1; 
1966
1967
1968 //=======================================================================
1969 //function : DDataStd_InsertBeforeExtStringList (DF, entry, index, value  )
1970 //=======================================================================
1971 static Standard_Integer DDataStd_InsertBeforeExtStringList (Draw_Interpretor& di,
1972                                                             Standard_Integer nb, 
1973                                                             const char** arg) 
1974 {
1975   if (nb == 5) 
1976   {  
1977     Handle(TDF_Data) DF;
1978     if (!DDF::GetDF(arg[1],DF))
1979         return 1; 
1980
1981     TDF_Label label;
1982     DDF::AddLabel(DF, arg[2], label);
1983     
1984     Handle(TDataStd_ExtStringList) A;
1985     if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
1986         return 1;
1987
1988     Standard_Integer index = Draw::Atoi(arg[3]);
1989     TCollection_ExtendedString value = arg[4];
1990
1991     if (A->InsertBefore(index, value))    
1992       return 0; 
1993     else
1994       return 1;
1995   }
1996   di << "DDataStd_InsertBeforeExtStringList: Error\n";
1997   return 1; 
1998
1999
2000 //=======================================================================
2001 //function : DDataStd_InsertAfterExtStringList (DF, entry, index, value  )
2002 //=======================================================================
2003 static Standard_Integer DDataStd_InsertAfterExtStringList (Draw_Interpretor& di,
2004                                                            Standard_Integer nb, 
2005                                                            const char** arg) 
2006 {
2007   if (nb == 5) 
2008   {  
2009     Handle(TDF_Data) DF;
2010     if (!DDF::GetDF(arg[1],DF))
2011         return 1; 
2012
2013     TDF_Label label;
2014     DDF::AddLabel(DF, arg[2], label);
2015     
2016     Handle(TDataStd_ExtStringList) A;
2017     if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
2018         return 1;
2019
2020     Standard_Integer index = Draw::Atoi(arg[3]);
2021     TCollection_ExtendedString value = arg[4];
2022
2023     if (A->InsertAfter(index, value))    
2024       return 0; 
2025     else
2026       return 1;
2027   }
2028   di << "DDataStd_InsertAfterExtStringList: Error\n";
2029   return 1; 
2030
2031
2032 //=======================================================================
2033 //function : DDataStd_RemoveExtStringList (DF, entry, index )
2034 //=======================================================================
2035 static Standard_Integer DDataStd_RemoveExtStringList (Draw_Interpretor& di,
2036                                                       Standard_Integer nb, 
2037                                                       const char** arg) 
2038 {
2039   if (nb == 4) 
2040   {  
2041     Handle(TDF_Data) DF;
2042     if (!DDF::GetDF(arg[1],DF))
2043         return 1; 
2044
2045     TDF_Label label;
2046     DDF::AddLabel(DF, arg[2], label);
2047     
2048     Handle(TDataStd_ExtStringList) A;
2049     if (!label.FindAttribute(TDataStd_ExtStringList::GetID(), A))
2050         return 1;
2051
2052     Standard_Integer index = Draw::Atoi(arg[3]);
2053
2054     if (A->Remove(index))    
2055       return 0; 
2056     else
2057       return 1;
2058   }
2059   di << "DDataStd_RemoveExtStringList: Error\n";
2060   return 1; 
2061
2062
2063 //=======================================================================
2064 //function : DDataStd_InsertBeforeBooleanList (DF, entry, index, value  )
2065 //=======================================================================
2066 static Standard_Integer DDataStd_InsertBeforeBooleanList (Draw_Interpretor& di,
2067                                                           Standard_Integer nb, 
2068                                                           const char** arg) 
2069 {
2070   if (nb == 5) 
2071   {  
2072     Handle(TDF_Data) DF;
2073     if (!DDF::GetDF(arg[1],DF))
2074         return 1; 
2075
2076     TDF_Label label;
2077     DDF::AddLabel(DF, arg[2], label);
2078     
2079     Handle(TDataStd_BooleanList) A;
2080     if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
2081         return 1;
2082
2083     Standard_Integer index = Draw::Atoi(arg[3]);
2084     Standard_Boolean value = Draw::Atoi(arg[4]) != 0;
2085
2086     if (A->InsertBefore(index, value))    
2087       return 0; 
2088     else
2089       return 1;
2090   }
2091   di << "DDataStd_InsertBeforeBooleanList: Error\n";
2092   return 1; 
2093
2094
2095 //=======================================================================
2096 //function : DDataStd_InsertAfterBooleanList (DF, entry, index, value  )
2097 //=======================================================================
2098 static Standard_Integer DDataStd_InsertAfterBooleanList (Draw_Interpretor& di,
2099                                                          Standard_Integer nb, 
2100                                                          const char** arg) 
2101 {
2102   if (nb == 5) 
2103   {  
2104     Handle(TDF_Data) DF;
2105     if (!DDF::GetDF(arg[1],DF))
2106         return 1; 
2107
2108     TDF_Label label;
2109     DDF::AddLabel(DF, arg[2], label);
2110     
2111     Handle(TDataStd_BooleanList) A;
2112     if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
2113         return 1;
2114
2115     Standard_Integer index = Draw::Atoi(arg[3]);
2116     Standard_Boolean value = Draw::Atoi(arg[4]) != 0;
2117
2118     if (A->InsertAfter(index, value))    
2119       return 0; 
2120     else
2121       return 1;
2122   }
2123   di << "DDataStd_InsertAfterBooleanList: Error\n";
2124   return 1; 
2125
2126
2127 //=======================================================================
2128 //function : DDataStd_RemoveBooleanList (DF, entry, index )
2129 //=======================================================================
2130 static Standard_Integer DDataStd_RemoveBooleanList (Draw_Interpretor& di,
2131                                                     Standard_Integer nb, 
2132                                                     const char** arg) 
2133 {
2134   if (nb == 4) 
2135   {  
2136     Handle(TDF_Data) DF;
2137     if (!DDF::GetDF(arg[1],DF))
2138         return 1; 
2139
2140     TDF_Label label;
2141     DDF::AddLabel(DF, arg[2], label);
2142     
2143     Handle(TDataStd_BooleanList) A;
2144     if (!label.FindAttribute(TDataStd_BooleanList::GetID(), A))
2145         return 1;
2146
2147     Standard_Integer index = Draw::Atoi(arg[3]);
2148
2149     if (A->Remove(index))    
2150       return 0; 
2151     else
2152       return 1;
2153   }
2154   di << "DDataStd_RemoveBooleanList: Error\n";
2155   return 1; 
2156
2157
2158 //=======================================================================
2159 //function : DDataStd_InsertBeforeIntegerList (DF, entry, index, value  )
2160 //=======================================================================
2161 static Standard_Integer DDataStd_InsertBeforeIntegerList (Draw_Interpretor& di,
2162                                                           Standard_Integer nb, 
2163                                                           const char** arg) 
2164 {
2165   if (nb == 5) 
2166   {  
2167     Handle(TDF_Data) DF;
2168     if (!DDF::GetDF(arg[1],DF))
2169         return 1; 
2170
2171     TDF_Label label;
2172     DDF::AddLabel(DF, arg[2], label);
2173     
2174     Handle(TDataStd_IntegerList) A;
2175     if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
2176         return 1;
2177
2178     Standard_Integer index = Draw::Atoi(arg[3]);
2179     Standard_Integer value = (Standard_Integer) Draw::Atoi(arg[4]);
2180
2181     if (A->InsertBeforeByIndex(index, value))    
2182       return 0; 
2183     else
2184       return 1;
2185   }
2186   di << "DDataStd_InsertBeforeIntegerList: Error\n";
2187   return 1; 
2188
2189
2190 //=======================================================================
2191 //function : DDataStd_InsertAfterIntegerList (DF, entry, index, value  )
2192 //=======================================================================
2193 static Standard_Integer DDataStd_InsertAfterIntegerList (Draw_Interpretor& di,
2194                                                          Standard_Integer nb, 
2195                                                          const char** arg) 
2196 {
2197   if (nb == 5) 
2198   {  
2199     Handle(TDF_Data) DF;
2200     if (!DDF::GetDF(arg[1],DF))
2201         return 1; 
2202
2203     TDF_Label label;
2204     DDF::AddLabel(DF, arg[2], label);
2205     
2206     Handle(TDataStd_IntegerList) A;
2207     if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
2208         return 1;
2209
2210     Standard_Integer index = Draw::Atoi(arg[3]);
2211     Standard_Integer value = (Standard_Integer) Draw::Atoi(arg[4]);
2212
2213     if (A->InsertAfterByIndex(index, value))    
2214       return 0; 
2215     else
2216       return 1;
2217   }
2218   di << "DDataStd_InsertAfterIntegerList: Error\n";
2219   return 1; 
2220
2221
2222 //=======================================================================
2223 //function : DDataStd_RemoveIntegerList (DF, entry, index )
2224 //=======================================================================
2225 static Standard_Integer DDataStd_RemoveIntegerList (Draw_Interpretor& di,
2226                                                     Standard_Integer nb, 
2227                                                     const char** arg) 
2228 {
2229   if (nb == 4) 
2230   {  
2231     Handle(TDF_Data) DF;
2232     if (!DDF::GetDF(arg[1],DF))
2233         return 1; 
2234
2235     TDF_Label label;
2236     DDF::AddLabel(DF, arg[2], label);
2237     
2238     Handle(TDataStd_IntegerList) A;
2239     if (!label.FindAttribute(TDataStd_IntegerList::GetID(), A))
2240         return 1;
2241
2242     Standard_Integer index = Draw::Atoi(arg[3]);
2243
2244     if (A->RemoveByIndex(index))    
2245       return 0; 
2246     else
2247       return 1;
2248   }
2249   di << "DDataStd_RemoveIntegerList: Error\n";
2250   return 1; 
2251
2252
2253 //=======================================================================
2254 //function : DDataStd_InsertBeforeRealList (DF, entry, index, value  )
2255 //=======================================================================
2256 static Standard_Integer DDataStd_InsertBeforeRealList (Draw_Interpretor& di,
2257                                                        Standard_Integer nb, 
2258                                                        const char** arg) 
2259 {
2260   if (nb == 5) 
2261   {  
2262     Handle(TDF_Data) DF;
2263     if (!DDF::GetDF(arg[1],DF))
2264         return 1; 
2265
2266     TDF_Label label;
2267     DDF::AddLabel(DF, arg[2], label);
2268     
2269     Handle(TDataStd_RealList) A;
2270     if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
2271         return 1;
2272
2273     Standard_Integer index = Draw::Atoi(arg[3]);
2274     Standard_Real value = (Standard_Real) Draw::Atof(arg[4]);
2275
2276     if (A->InsertBeforeByIndex(index, value))    
2277       return 0; 
2278     else
2279       return 1;
2280   }
2281   di << "DDataStd_InsertBeforeRealList: Error\n";
2282   return 1; 
2283
2284
2285 //=======================================================================
2286 //function : DDataStd_InsertAfterRealList (DF, entry, index, value  )
2287 //=======================================================================
2288 static Standard_Integer DDataStd_InsertAfterRealList (Draw_Interpretor& di,
2289                                                       Standard_Integer nb, 
2290                                                       const char** arg) 
2291 {
2292   if (nb == 5) 
2293   {  
2294     Handle(TDF_Data) DF;
2295     if (!DDF::GetDF(arg[1],DF))
2296         return 1; 
2297
2298     TDF_Label label;
2299     DDF::AddLabel(DF, arg[2], label);
2300     
2301     Handle(TDataStd_RealList) A;
2302     if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
2303         return 1;
2304
2305     Standard_Integer index = Draw::Atoi(arg[3]);
2306     Standard_Real value = (Standard_Real) Draw::Atof(arg[4]);
2307
2308     if (A->InsertAfterByIndex(index, value))    
2309       return 0; 
2310     else
2311       return 1;
2312   }
2313   di << "DDataStd_InsertAfterRealList: Error\n";
2314   return 1; 
2315
2316
2317 //=======================================================================
2318 //function : DDataStd_RemoveRealList (DF, entry, index )
2319 //=======================================================================
2320 static Standard_Integer DDataStd_RemoveRealList (Draw_Interpretor& di,
2321                                                  Standard_Integer nb, 
2322                                                  const char** arg) 
2323 {
2324   if (nb == 4) 
2325   {  
2326     Handle(TDF_Data) DF;
2327     if (!DDF::GetDF(arg[1],DF))
2328         return 1; 
2329
2330     TDF_Label label;
2331     DDF::AddLabel(DF, arg[2], label);
2332     
2333     Handle(TDataStd_RealList) A;
2334     if (!label.FindAttribute(TDataStd_RealList::GetID(), A))
2335         return 1;
2336
2337     Standard_Integer index = Draw::Atoi(arg[3]);
2338
2339     if (A->RemoveByIndex(index))    
2340       return 0; 
2341     else
2342       return 1;
2343   }
2344   di << "DDataStd_RemoveRealList: Error\n";
2345   return 1; 
2346
2347
2348 //=======================================================================
2349 //function : DDataStd_InsertBeforeReferenceList (DF, entry, index, value  )
2350 //=======================================================================
2351 static Standard_Integer DDataStd_InsertBeforeReferenceList (Draw_Interpretor& di,
2352                                                             Standard_Integer nb, 
2353                                                             const char** arg) 
2354 {
2355   if (nb == 5) 
2356   {  
2357     Handle(TDF_Data) DF;
2358     if (!DDF::GetDF(arg[1],DF))
2359         return 1; 
2360
2361     TDF_Label label;
2362     DDF::AddLabel(DF, arg[2], label);
2363     
2364     Handle(TDataStd_ReferenceList) A;
2365     if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
2366         return 1;
2367
2368     Standard_Integer index = Draw::Atoi(arg[3]);
2369
2370     TDF_Label refLabel;
2371     if (!DDF::AddLabel(DF, arg[4], refLabel))
2372         return 1;
2373
2374     if (A->InsertBefore(index, refLabel))    
2375       return 0; 
2376     else
2377       return 1;
2378   }
2379   di << "DDataStd_InsertBeforeReferenceList: Error\n";
2380   return 1; 
2381
2382
2383 //=======================================================================
2384 //function : DDataStd_InsertAfterReferenceList (DF, entry, index, value  )
2385 //=======================================================================
2386 static Standard_Integer DDataStd_InsertAfterReferenceList (Draw_Interpretor& di,
2387                                                            Standard_Integer nb, 
2388                                                            const char** arg) 
2389 {
2390   if (nb == 5) 
2391   {  
2392     Handle(TDF_Data) DF;
2393     if (!DDF::GetDF(arg[1],DF))
2394         return 1; 
2395
2396     TDF_Label label;
2397     DDF::AddLabel(DF, arg[2], label);
2398     
2399     Handle(TDataStd_ReferenceList) A;
2400     if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
2401         return 1;
2402
2403     Standard_Integer index = Draw::Atoi(arg[3]);
2404
2405     TDF_Label refLabel;
2406     if (!DDF::AddLabel(DF, arg[4], refLabel))
2407         return 1;
2408
2409     if (A->InsertAfter(index, refLabel))
2410       return 0; 
2411     else
2412       return 1;
2413   }
2414   di << "DDataStd_InsertAfterReferenceList: Error\n";
2415   return 1; 
2416
2417
2418 //=======================================================================
2419 //function : DDataStd_RemoveReferenceList (DF, entry, index )
2420 //=======================================================================
2421 static Standard_Integer DDataStd_RemoveReferenceList (Draw_Interpretor& di,
2422                                                       Standard_Integer nb, 
2423                                                       const char** arg) 
2424 {
2425   if (nb == 4) 
2426   {  
2427     Handle(TDF_Data) DF;
2428     if (!DDF::GetDF(arg[1],DF))
2429         return 1; 
2430
2431     TDF_Label label;
2432     DDF::AddLabel(DF, arg[2], label);
2433     
2434     Handle(TDataStd_ReferenceList) A;
2435     if (!label.FindAttribute(TDataStd_ReferenceList::GetID(), A))
2436         return 1;
2437
2438     Standard_Integer index = Draw::Atoi(arg[3]);
2439
2440     if (A->Remove(index))    
2441       return 0; 
2442     else
2443       return 1;
2444   }
2445   di << "DDataStd_RemoveReferenceList: Error\n";
2446   return 1; 
2447
2448
2449 //=======================================================================
2450 //function : GetByteArray (DF, entry [, guid] )
2451 //=======================================================================
2452 static Standard_Integer DDataStd_GetByteArray (Draw_Interpretor& di,
2453                                               Standard_Integer nb, 
2454                                               const char** arg) 
2455 {   
2456   if (nb >= 3) 
2457   {  
2458     Handle(TDF_Data) DF;
2459     if (!DDF::GetDF(arg[1],DF))  return 1;  
2460     TDF_Label label;
2461     if( !DDF::FindLabel(DF, arg[2], label) ) {
2462       di << "No label for entry"  << "\n";
2463       return 1;
2464     }
2465     Standard_GUID aGuid;
2466     if(nb == 4) {
2467       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
2468         aGuid = Standard_GUID(arg[3]);
2469       else {
2470         di << "Wrong GUID format"  << "\n";
2471         return 1; 
2472       }
2473     } else
2474       aGuid = TDataStd_ByteArray::GetID();
2475     Handle(TDataStd_ByteArray) A;
2476     if ( !label.FindAttribute(aGuid, A) ) { 
2477       di << "There is no TDataStd_ByteArray  with the specified GUID at the label"  << "\n";
2478       return 1;
2479     }
2480
2481     for(Standard_Integer i = A->Lower(); i<=A->Upper(); i++){
2482       di  <<  A->Value(i);
2483       if(i<A->Upper())  
2484         di<<" ";
2485     }
2486     di<<"\n";
2487     return 0; 
2488   }
2489   di << "DDataStd_GetByteArray: Error\n";
2490   return 1; 
2491
2492
2493 //=======================================================================
2494 //function : GetByteArrayValue (DF, entry, index)
2495 //=======================================================================
2496 static Standard_Integer DDataStd_GetByteArrayValue (Draw_Interpretor& di,
2497                                                     Standard_Integer, 
2498                                                     const char** arg) 
2499 {
2500   Handle(TDF_Data) DF;
2501   if (!DDF::GetDF(arg[1],DF))
2502       return 1;
2503
2504   TDF_Label label;
2505   if (!DDF::FindLabel(DF, arg[2], label)) {
2506     di << "No label for entry"  << "\n";
2507     return 1;
2508   }
2509  
2510   Handle(TDataStd_ByteArray) A;
2511   if ( !label.FindAttribute(TDataStd_ByteArray::GetID(), A) ) { 
2512     di << "There is no TDataStd_ByteArray under label"  << "\n";
2513     return 1;
2514   }
2515   
2516   Standard_Integer index = Draw::Atoi(arg[3]);
2517   if (index < A->Lower() || index > A->Upper()) {
2518     di << "Index is out of range\n";
2519     return 1;
2520   } else {
2521     di << A->Value(index) << "\n";
2522   }
2523
2524   return 0; 
2525
2526
2527 //=======================================================================
2528 //function : GetBooleanArray (DF, entry [, guid] )
2529 //=======================================================================
2530 static Standard_Integer DDataStd_GetBooleanArray (Draw_Interpretor& di,
2531                                                   Standard_Integer nb, 
2532                                                   const char** arg) 
2533 {   
2534   if (nb >= 3) 
2535   {
2536     Handle(TDF_Data) DF;
2537     if (!DDF::GetDF(arg[1],DF)) 
2538       return 1;  
2539
2540     TDF_Label label;
2541     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2542     {
2543       di << "No label for entry"  << "\n";
2544       return 1;
2545     }
2546     Standard_GUID aGuid;
2547     if(nb == 4) {
2548       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
2549         aGuid = Standard_GUID(arg[3]);
2550       else {
2551         di << "Wrong GUID format"  << "\n";
2552         return 1; 
2553       }
2554     } else
2555       aGuid = TDataStd_BooleanArray::GetID();
2556
2557     Handle(TDataStd_BooleanArray) A;
2558     if ( !label.FindAttribute(aGuid, A) ) 
2559     {
2560       di << "There is no TDataStd_BooleanArray at label"  << "\n";
2561       return 1;
2562     }
2563
2564     for (Standard_Integer i = A->Lower(); i<=A->Upper(); i++)
2565     {
2566       di << (Standard_Integer) A->Value(i);
2567       if (i < A->Upper())  
2568         di << " ";
2569     }
2570     di << "\n";
2571     return 0;
2572   }
2573   di << "DDataStd_GetBooleanArray: Error\n";
2574   return 1; 
2575 }
2576
2577 //=======================================================================
2578 //function : GetBooleanArrayValue (DF, entry, index)
2579 //=======================================================================
2580 static Standard_Integer DDataStd_GetBooleanArrayValue (Draw_Interpretor& di,
2581                                                        Standard_Integer, 
2582                                                        const char** arg) 
2583 {
2584   Handle(TDF_Data) DF;
2585   if (!DDF::GetDF(arg[1],DF))
2586       return 1;
2587
2588   TDF_Label label;
2589   if (!DDF::FindLabel(DF, arg[2], label)) {
2590     di << "No label for entry"  << "\n";
2591     return 1;
2592   }
2593  
2594   Handle(TDataStd_BooleanArray) A;
2595   if ( !label.FindAttribute(TDataStd_BooleanArray::GetID(), A) ) { 
2596     di << "There is no TDataStd_BooleanArray under label"  << "\n";
2597     return 1;
2598   }
2599   
2600   Standard_Integer index = Draw::Atoi(arg[3]);
2601   if (index < A->Lower() || index > A->Upper()) {
2602     di << "Index is out of range\n";
2603     return 1;
2604   } else {
2605     di << ((A->Value(index) == Standard_True) ? "True" : "False") << "\n";
2606   }
2607
2608   return 0; 
2609
2610
2611 //=======================================================================
2612 //function : ChangeByteArray (DF, entry, indx, val )
2613 //=======================================================================
2614 static Standard_Integer DDataStd_ChangeByteArray (Draw_Interpretor& di,
2615                                               Standard_Integer nb, 
2616                                               const char** arg) 
2617 {   
2618
2619   if( nb == 5 ) {  
2620     Handle(TDF_Data) DF;
2621     if (!DDF::GetDF(arg[1],DF))  return 1;  
2622     TDF_Label label;
2623     if( !DDF::FindLabel(DF, arg[2], label) ) {
2624       di << "No label for entry"  << "\n";
2625       return 1;
2626     }
2627  
2628     Handle(TDataStd_ByteArray) A;
2629     if ( !label.FindAttribute(TDataStd_ByteArray::GetID(), A) ) { 
2630       di << "There is no TDataStd_ByteArray at label"  << "\n";
2631       return 1;
2632     }
2633     Standard_Integer indx = Draw::Atoi(arg[3]);
2634     Standard_Integer ival  = Draw::Atoi(arg[4]);
2635     if (ival > 255 || ival < 0) {
2636         di << "DDataStd_ChangeByteArray: Bad value = " <<ival << "\n";
2637         return 1;
2638       }
2639     Standard_Integer low = A->Lower(), up = A->Upper();
2640     if(low <= indx && indx <= up)
2641       A->SetValue(indx, (Standard_Byte)ival);
2642     else {
2643       Handle(TColStd_HArray1OfByte) Arr = A->InternalArray();
2644       Handle(TColStd_HArray1OfByte) arr;
2645       Standard_Integer i;
2646       if(indx > up) {
2647         up = indx;
2648         arr = new TColStd_HArray1OfByte(low, up);
2649         for(i=low; i<= Arr->Upper(); i++)
2650           arr->SetValue(i, Arr->Value(i));
2651         for(i=Arr->Upper()+1; i<= up; i++) {
2652           if(i == up)
2653             arr->SetValue(i, (Standard_Byte)ival);
2654           else
2655             arr->SetValue(i, 0);
2656         }
2657       } else if(indx < up) {//clip array : indx to be negative
2658         up = abs(indx);
2659         arr = new TColStd_HArray1OfByte(low, up);
2660         for(i=low; i< up; i++)
2661           arr->SetValue(i, Arr->Value(i));
2662         arr->SetValue(up, (Standard_Byte)ival);
2663       }
2664       A->ChangeArray(arr);
2665     }
2666     return 0;
2667   }
2668   di << "DDataStd_ChangeByteArray: Error\n";
2669   return 1; 
2670 }
2671
2672 //=======================================================================
2673 //function : GetBooleanList (DF, entry [, guid])
2674 //=======================================================================
2675 static Standard_Integer DDataStd_GetBooleanList (Draw_Interpretor& di,
2676                                                  Standard_Integer nb, 
2677                                                  const char** arg) 
2678 {   
2679   if (nb >= 3) {
2680     Handle(TDF_Data) DF;
2681     if (!DDF::GetDF(arg[1],DF)) 
2682       return 1;  
2683
2684     TDF_Label label;
2685     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2686     {
2687       di << "No label for entry"  << "\n";
2688       return 1;
2689     }
2690     Standard_GUID aGuid;
2691     if(nb == 4) {
2692       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
2693         aGuid = Standard_GUID(arg[3]);
2694       else {
2695         di << "Wrong GUID format"  << "\n";
2696         return 1; 
2697       }
2698     } else
2699       aGuid = TDataStd_BooleanList::GetID();
2700
2701     Handle(TDataStd_BooleanList) A;
2702     if ( !label.FindAttribute(aGuid, A) ) 
2703     {
2704       di << "There is no TDataStd_BooleanList with the specified Guid at the label"  << "\n";
2705       return 1;
2706     }
2707
2708     const TDataStd_ListOfByte& bList = A->List();
2709     Standard_Boolean isEmpty = (bList.Extent() > 0) ? Standard_False : Standard_True;
2710     if(!isEmpty) {
2711       TDataStd_ListIteratorOfListOfByte itr(bList);
2712       for (; itr.More(); itr.Next())
2713       {
2714         di << (Standard_Integer) itr.Value() << " ";
2715       }
2716       di << "\n";
2717     } else 
2718       di << "List is empty\n";
2719     return 0; 
2720   }
2721   di << "DDataStd_GetBooleanList: Error\n";
2722   return 1; 
2723 }
2724
2725 //=======================================================================
2726 //function : GetIntegerList (DF, entry [, guid])
2727 //=======================================================================
2728 static Standard_Integer DDataStd_GetIntegerList (Draw_Interpretor& di,
2729                                                  Standard_Integer nb, 
2730                                                  const char** arg) 
2731
2732   if (nb >= 3) {
2733     Handle(TDF_Data) DF;
2734     if (!DDF::GetDF(arg[1],DF)) 
2735       return 1;  
2736
2737     TDF_Label label;
2738     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2739     {
2740       di << "No label for entry"  << "\n";
2741       return 1;
2742     }
2743     Standard_GUID aGuid;
2744     if(nb == 4) {
2745       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
2746         aGuid = Standard_GUID(arg[3]);
2747       else {
2748         di << "Wrong GUID format"  << "\n";
2749         return 1; 
2750       }
2751     } else
2752       aGuid = TDataStd_IntegerList::GetID();
2753
2754     Handle(TDataStd_IntegerList) A;
2755     if ( !label.FindAttribute(aGuid, A) ) 
2756     {
2757       di << "There is no TDataStd_IntegerList with the specified GUID at the label"  << "\n";
2758       return 1;
2759     }
2760
2761     const TColStd_ListOfInteger& iList = A->List();
2762     Standard_Boolean isEmpty = (iList.Extent() > 0) ? Standard_False : Standard_True;
2763     if(!isEmpty) {
2764       TColStd_ListIteratorOfListOfInteger itr(iList);
2765       for (; itr.More(); itr.Next())
2766       {
2767         di << itr.Value() << " ";
2768       }
2769       di << "\n";
2770     } else 
2771       di << "List is empty\n";
2772
2773     return 0; 
2774   }
2775   di << "DDataStd_GetIntegerList: Error\n";
2776   return 1; 
2777 }
2778
2779 //=======================================================================
2780 //function : GetRealList (DF, entry [, guid])
2781 //=======================================================================
2782 static Standard_Integer DDataStd_GetRealList (Draw_Interpretor& di,
2783                                               Standard_Integer nb, 
2784                                               const char** arg) 
2785 {   
2786   if (nb >= 3) {  
2787     Handle(TDF_Data) DF;
2788     if (!DDF::GetDF(arg[1],DF)) 
2789       return 1;  
2790
2791     TDF_Label label;
2792     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2793     {
2794       di << "No label for entry"  << "\n";
2795       return 1;
2796     }
2797     Standard_GUID aGuid;
2798     if(nb == 4) {
2799       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
2800         aGuid = Standard_GUID(arg[3]);
2801       else {
2802         di << "Wrong GUID format"  << "\n";
2803         return 1; 
2804       }
2805     } else
2806       aGuid = TDataStd_RealList::GetID();
2807
2808     Handle(TDataStd_RealList) A;
2809     if ( !label.FindAttribute(aGuid, A) ) 
2810     {
2811       di << "There is no TDataStd_RealList with the specified GUID at the label"  << "\n";
2812       return 1;
2813     }
2814
2815     const TColStd_ListOfReal& rList = A->List();
2816     Standard_Boolean isEmpty = (rList.Extent() > 0) ? Standard_False : Standard_True;
2817     if(!isEmpty) {
2818       TColStd_ListIteratorOfListOfReal itr(rList);
2819       for (; itr.More(); itr.Next())
2820       {
2821         di << itr.Value() << " ";
2822       }
2823       di << "\n";
2824     } else
2825       di << "List is empty\n";
2826     return 0; 
2827   }
2828   di << "DDataStd_GetRealList: Error\n";
2829   return 1; 
2830 }
2831
2832 //=======================================================================
2833 //function : DDataStd_GetExtStringList (DF, entry [, guid])
2834 //=======================================================================
2835 static Standard_Integer DDataStd_GetExtStringList (Draw_Interpretor& di,
2836                                                  Standard_Integer nb, 
2837                                                  const char** arg) 
2838 {
2839   if (nb >= 3) 
2840   {  
2841     Handle(TDF_Data) DF;
2842     if (!DDF::GetDF(arg[1],DF))
2843         return 1; 
2844
2845     TDF_Label label;
2846     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2847     {
2848       di << "No label for entry"  << "\n";
2849       return 1;
2850     }
2851     Standard_GUID aGuid;
2852     if(nb == 4) {
2853       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
2854         aGuid = Standard_GUID(arg[3]);
2855       else {
2856         di << "Wrong GUID format"  << "\n";
2857         return 1; 
2858       }
2859     } else
2860       aGuid = TDataStd_ExtStringList::GetID();
2861
2862     Handle(TDataStd_ExtStringList) A;
2863     if ( !label.FindAttribute(aGuid, A) ) 
2864     {
2865       di << "There is no TDataStd_ExtStringList at label"  << "\n";
2866       return 1;
2867     }
2868     
2869     const TDataStd_ListOfExtendedString& aList = A->List();
2870     Standard_Boolean isEmpty = (aList.Extent() > 0) ? Standard_False : Standard_True;
2871     if(!isEmpty) {
2872       TDataStd_ListIteratorOfListOfExtendedString itr(aList);   
2873       for (; itr.More(); itr.Next())
2874       {
2875         const TCollection_ExtendedString& aStr = itr.Value();
2876         di << aStr << " ";      
2877       }
2878       di << "\n";
2879     }
2880     else {
2881       di << "List is empty\n";
2882     }
2883     return 0; 
2884   }
2885   di << "DDataStd_GetExtStringList: Error\n";
2886   return 1; 
2887
2888
2889 //=======================================================================
2890 //function : DDataStd_GetReferenceList (DF, entry [, guid])
2891 //=======================================================================
2892 static Standard_Integer DDataStd_GetReferenceList (Draw_Interpretor& di,
2893                                                    Standard_Integer nb, 
2894                                                    const char** arg) 
2895 {
2896   if (nb >= 3) 
2897   {  
2898     Handle(TDF_Data) DF;
2899     if (!DDF::GetDF(arg[1],DF))
2900       return 1; 
2901
2902     TDF_Label label;
2903     if ( !DDF::FindLabel(DF, arg[2], label) ) 
2904     {
2905       di << "No label for entry"  << "\n";
2906       return 1;
2907     }
2908     Standard_GUID aGuid;
2909     if(nb == 4) {
2910       if (Standard_GUID::CheckGUIDFormat(arg[3])) 
2911         aGuid = Standard_GUID(arg[3]);
2912       else {
2913         di << "Wrong GUID format"  << "\n";
2914         return 1; 
2915       }
2916     } else
2917       aGuid = TDataStd_ReferenceList::GetID();
2918
2919     Handle(TDataStd_ReferenceList) A;
2920     if ( !label.FindAttribute(aGuid, A) ) 
2921     {
2922       di << "There is no TDataStd_ReferenceList [with the specified guid] at the label"  << "\n";
2923       return 1;
2924     }
2925
2926     const TDF_LabelList& aList = A->List();
2927     Standard_Boolean isEmpty = (aList.Extent() > 0) ? Standard_False : Standard_True;
2928     if(!isEmpty) {
2929       TDF_ListIteratorOfLabelList itr(aList);
2930       for (; itr.More(); itr.Next())
2931       {
2932         const TDF_Label& aLabel = itr.Value();
2933         if (!aLabel.IsNull()) {
2934           TCollection_AsciiString entry;
2935           TDF_Tool::Entry(aLabel, entry);
2936           di << entry.ToCString() << " ";
2937         }
2938       }
2939       di << "\n";
2940     } else 
2941       di << "List is empty\n";
2942     return 0;
2943   }
2944   di << "DDataStd_GetReferenceList: Error\n";
2945   return 1; 
2946
2947 //
2948 //=======================================================================
2949 //function : SetIntPackedMap (DF, entry, isDelta, key1, key2, ...
2950 //=======================================================================
2951
2952 static Standard_Integer DDataStd_SetIntPackedMap (Draw_Interpretor& di,
2953                                                   Standard_Integer nb, 
2954                                                   const char** arg) 
2955 {   
2956
2957   if (nb > 4) {
2958     Handle(TDF_Data) DF;
2959     if (!DDF::GetDF(arg[1],DF))  return 1; 
2960     TDF_Label aLabel;
2961     DDF::AddLabel(DF, arg[2], aLabel);
2962     Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
2963     Standard_Integer aNum = nb - 4;
2964     Handle(TDataStd_IntPackedMap) anAtt;
2965     if(!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt))
2966       anAtt = TDataStd_IntPackedMap::Set(aLabel, isDelta);
2967     if(anAtt.IsNull()) {
2968       di << "IntPackedMap attribute is not found or not set"  << "\n";
2969       return 1;}
2970     
2971     Standard_Integer j = 4;
2972     TColStd_PackedMapOfInteger aMap;
2973     for(Standard_Integer i = 1; i<=aNum; i++) {
2974       aMap.Add (Draw::Atoi(arg[j]));
2975       j++;
2976     }
2977     const Handle(TColStd_HPackedMapOfInteger)& aHMap = new TColStd_HPackedMapOfInteger(aMap);
2978     anAtt->ChangeMap(aHMap);
2979     std::cout << "Map extent = " << anAtt->Extent()<<std::endl;
2980     return 0; 
2981   }
2982   di << "DDataStd_SetIntPackedMap : Error\n";
2983   return 1;
2984
2985
2986 //=======================================================================
2987 //function : GetIntPackedMap (DF, entry )
2988 //=======================================================================
2989
2990 static Standard_Integer DDataStd_GetIntPackedMap (Draw_Interpretor& di,
2991                                                   Standard_Integer nb, 
2992                                                   const char** arg) 
2993 {   
2994
2995   if (nb == 3) {
2996     Handle(TDF_Data) DF;
2997     if (!DDF::GetDF(arg[1],DF))  return 1; 
2998     TDF_Label aLabel;
2999     DDF::AddLabel(DF, arg[2], aLabel);
3000     Handle(TDataStd_IntPackedMap) anAtt;
3001     if(!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt)) {
3002       di << "IntPackedMap attribute is not found or not set"  << "\n";
3003       return 1;}
3004 //
3005     const TColStd_PackedMapOfInteger& aMap = anAtt->GetMap();
3006     TColStd_MapIteratorOfPackedMapOfInteger itr(aMap);
3007     for (Standard_Integer j = 1; itr.More(); itr.Next(),j++){
3008       Standard_Integer aKey(itr.Key());
3009       di << aKey << " ";
3010       }
3011     return 0; 
3012   }
3013   di << "DDataStd_GetIntPackedMap : Error\n";
3014   return 1;
3015
3016
3017
3018 //=======================================================================
3019 //function : ChangeIntPackedMap_Add (DF, entry, Key1, Key2,... )
3020 //=======================================================================
3021 static Standard_Integer DDataStd_ChangeIntPackedMap_Add (Draw_Interpretor& di,
3022                                               Standard_Integer nb, 
3023                                               const char** arg) 
3024 {   
3025
3026   if( nb >= 4 ) {  
3027     Handle(TDF_Data) DF;
3028     if (!DDF::GetDF(arg[1],DF))  return 1;  
3029     TDF_Label label;
3030     if( !DDF::FindLabel(DF, arg[2], label) ) {
3031       di << "No label for entry"  << "\n";
3032       return 1;
3033     }
3034  
3035     Handle(TDataStd_IntPackedMap) A;
3036     if ( !label.FindAttribute(TDataStd_IntPackedMap::GetID(), A) ) { 
3037       di << "There is no TDataStd_IntPackedMap at label"  << "\n";
3038       return 1;
3039     }
3040     
3041     Standard_Integer i, aNum = nb - 3; 
3042     Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
3043     Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
3044     if(!aHMap.IsNull()) {
3045       ahMap->ChangeMap().Assign(aHMap->Map());
3046       for(i=1; i<=aNum;i++) {
3047         Standard_Integer val = Draw::Atoi(arg[i+2]);
3048         if(!ahMap->Map().Contains(val))
3049           ahMap->ChangeMap().Add(val);
3050       }
3051       
3052       A->ChangeMap(ahMap);
3053     }
3054     return 0;
3055   }
3056   di << "DDataStd_ChangeIntPackedMap_Add: Error\n";
3057   return 0; 
3058 }
3059
3060
3061 //=======================================================================
3062 //function : ChangeIntPackedMap_Rem (DF, entry, Key1, Key2,... )
3063 //=======================================================================
3064 static Standard_Integer DDataStd_ChangeIntPackedMap_Rem (Draw_Interpretor& di,
3065                                               Standard_Integer nb, 
3066                                               const char** arg) 
3067 {   
3068
3069   if( nb >= 4 ) {  
3070     Handle(TDF_Data) DF;
3071     if (!DDF::GetDF(arg[1],DF))  return 1;  
3072     TDF_Label label;
3073     if( !DDF::FindLabel(DF, arg[2], label) ) {
3074       di << "No label for entry"  << "\n";
3075       return 1;
3076     }
3077  
3078     Handle(TDataStd_IntPackedMap) A;
3079     if ( !label.FindAttribute(TDataStd_IntPackedMap::GetID(), A) ) { 
3080       di << "There is no TDataStd_IntPackedMap at label"  << "\n";
3081       return 1;
3082     }
3083     
3084     Standard_Integer i, aNum = nb - 3; 
3085     Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
3086     Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
3087     if(!aHMap.IsNull()) {
3088       ahMap->ChangeMap().Assign(aHMap->Map());
3089       for(i=1; i<=aNum;i++) {
3090         Standard_Integer val = Draw::Atoi(arg[i+2]);
3091         if(ahMap->Map().Contains(val))
3092           ahMap->ChangeMap().Remove(val);
3093       }
3094       
3095       A->ChangeMap(ahMap);
3096     }
3097     return 0;
3098   }
3099   di << "DDataStd_ChangeIntPackedMap_Rem: Error\n";
3100   return 0; 
3101 }
3102
3103 //=======================================================================
3104 //function : ChangeIntPackedMap_AddRem (DF, entry, Key1, Key2,... )
3105 //         : if Keyi exist in map - remove it, if no - add
3106 //=======================================================================
3107 static Standard_Integer DDataStd_ChangeIntPackedMap_AddRem (Draw_Interpretor& di,
3108                                               Standard_Integer nb, 
3109                                               const char** arg) 
3110 {   
3111
3112   if( nb >= 4 ) {  
3113     Handle(TDF_Data) DF;
3114     if (!DDF::GetDF(arg[1],DF))  return 1;  
3115     TDF_Label label;
3116     if( !DDF::FindLabel(DF, arg[2], label) ) {
3117       di << "No label for entry"  << "\n";
3118       return 1;
3119     }
3120  
3121     Handle(TDataStd_IntPackedMap) A;
3122     if ( !label.FindAttribute(TDataStd_IntPackedMap::GetID(), A) ) { 
3123       di << "There is no TDataStd_IntPackedMap at label"  << "\n";
3124       return 1;
3125     }
3126     
3127     Standard_Integer i, aNum = nb - 3; 
3128     Handle(TColStd_HPackedMapOfInteger) aHMap = A->GetHMap();
3129     Handle(TColStd_HPackedMapOfInteger) ahMap = new TColStd_HPackedMapOfInteger();
3130     if(!aHMap.IsNull()) {
3131       ahMap->ChangeMap().Assign(aHMap->Map());
3132       for(i=1; i<=aNum;i++) {
3133         Standard_Integer val = Draw::Atoi(arg[i+2]);
3134         if(!ahMap->Map().Contains(val))
3135           ahMap->ChangeMap().Add(val);
3136         else
3137           ahMap->ChangeMap().Remove(val);
3138       }
3139       
3140       A->ChangeMap(ahMap);
3141     }
3142     return 0;
3143   }
3144   di << "DDataStd_ChangeIntPackedMap_AddRem: Error\n";
3145   return 0; 
3146 }
3147
3148 //=======================================================================
3149 //function : SetIntPHugeMap (DF, entry, isDelta Num)
3150 //=======================================================================
3151
3152 static Standard_Integer DDataStd_SetIntPHugeMap (Draw_Interpretor& di,
3153                                                   Standard_Integer nb, 
3154                                                   const char** arg) 
3155 {   
3156
3157   if (nb > 4) {
3158     Handle(TDF_Data) DF;
3159     if (!DDF::GetDF(arg[1],DF))  return 1; 
3160     TDF_Label aLabel;
3161     DDF::AddLabel(DF, arg[2], aLabel);
3162     Standard_Boolean isDelta = Draw::Atoi(arg[3]) != 0;
3163     Standard_Integer aNum = Draw::Atoi(arg[4]);
3164     Handle(TDataStd_IntPackedMap) anAtt;
3165     if(!aLabel.FindAttribute(TDataStd_IntPackedMap::GetID(), anAtt))
3166       anAtt = TDataStd_IntPackedMap::Set(aLabel, isDelta);
3167     if(anAtt.IsNull()) {
3168       di << "IntPackedMap attribute is not found or not set"  << "\n";
3169       return 1;}
3170     
3171     TColStd_PackedMapOfInteger aMap;
3172     for(Standard_Integer i = 1; i<=aNum; i++) {
3173       aMap.Add (i);
3174     }
3175     const Handle(TColStd_HPackedMapOfInteger)& aHMap = new TColStd_HPackedMapOfInteger(aMap);
3176     anAtt->ChangeMap(aHMap);
3177     std::cout << "Map extent = " << anAtt->Extent()<<std::endl;
3178     return 0; 
3179   }
3180   di << "DDataStd_SetIntPHugeMap : Error\n";
3181   return 1;
3182 }
3183
3184 //=======================================================================
3185 //function : SetNDataIntegers (DF, entry , Num
3186 //=======================================================================
3187
3188 static Standard_Integer DDataStd_SetNDataIntegers2 (Draw_Interpretor& di,
3189                                               Standard_Integer nb, 
3190                                               const char** arg) 
3191 {   
3192
3193   if (nb ==4) {
3194     Handle(TDF_Data) DF;
3195     if (!DDF::GetDF(arg[1],DF))  return 1; 
3196     TDF_Label aLabel;
3197     DDF::AddLabel(DF, arg[2], aLabel);
3198     Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
3199     Handle(TDataStd_NamedData) anAtt;
3200     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3201       anAtt = TDataStd_NamedData::Set(aLabel);
3202     if(anAtt.IsNull()) {
3203       di << "NamedData attribute is not found or not set"  << "\n";
3204       return 1;}
3205   
3206     j = 1111;
3207     TCollection_ExtendedString aKey("Key_");
3208     anAtt->LoadDeferredData();
3209     for(Standard_Integer i = 1; i<=aNumP; i++) {
3210       TCollection_ExtendedString key = aKey + i;
3211       Standard_Integer aVal = j+i;
3212       anAtt->SetInteger(key, aVal); 
3213       j +=1;
3214     }    
3215     return 0; 
3216   }
3217   di << "DDataStd_SetNDataIntegers2 : Error\n";
3218   return 1;
3219
3220 //================
3221 //=======================================================================
3222 //function : SetNDataIntArrays2 (DF, entry , key, NumOfArElem )
3223 //=======================================================================
3224
3225 static Standard_Integer DDataStd_SetNDataIntAr2 (Draw_Interpretor& di,
3226                                               Standard_Integer nb, 
3227                                               const char** arg) 
3228 {   
3229
3230   if (nb == 5) {
3231     Handle(TDF_Data) DF;
3232     if (!DDF::GetDF(arg[1],DF))  return 1; 
3233     TDF_Label aLabel;
3234     DDF::AddLabel(DF, arg[2], aLabel);
3235  
3236     Standard_Integer j;
3237     TCollection_ExtendedString aKey(arg[3]);
3238     Standard_Integer aNum = Draw::Atoi(arg[4]);
3239     if (aNum <= 0) return 1;
3240     Handle(TDataStd_NamedData) anAtt;
3241     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3242       anAtt = TDataStd_NamedData::Set(aLabel);
3243     if(anAtt.IsNull()) {
3244       Message::SendFail() << "NamedData attribute is not found or not set";
3245       return 1;}
3246   
3247     j = 15;
3248     Handle(TColStd_HArray1OfInteger) anArr =  new TColStd_HArray1OfInteger(1, aNum);
3249     for(Standard_Integer i = 1; i<=aNum; i++) {
3250       Standard_Integer aVal = j++;
3251       anArr->SetValue(i, aVal);
3252       j++;
3253     }
3254     anAtt->LoadDeferredData();
3255     anAtt->SetArrayOfIntegers(aKey, anArr); 
3256     return 0; 
3257   }
3258   di << "DDataStd_SetNDataIntArrays2 : Error\n";
3259   return 1;
3260
3261
3262
3263 //=======================================================================
3264 //function :  SetAsciiString(DF, entry, String[, guid])
3265 //=======================================================================
3266
3267 static Standard_Integer DDataStd_SetAsciiString (Draw_Interpretor& di,
3268                                               Standard_Integer nb, 
3269                                               const char** arg) 
3270 {   
3271
3272   if (nb == 4 || nb == 5) {
3273     Handle(TDF_Data) DF;
3274     if (!DDF::GetDF(arg[1],DF))  return 1; 
3275     TDF_Label aLabel;
3276     DDF::AddLabel(DF, arg[2], aLabel);
3277     TCollection_AsciiString aString(arg[3]);
3278     Standard_GUID aGuid (TDataStd_AsciiString::GetID());
3279     if(nb == 5) {
3280       if (!Standard_GUID::CheckGUIDFormat(arg[4])) {
3281         di<<"DDataStd_SetAsciiString: The format of GUID is invalid\n";
3282         return 1;
3283       }
3284       aGuid = Standard_GUID (arg[4]);
3285     } 
3286
3287     Handle(TDataStd_AsciiString) anAtt = TDataStd_AsciiString::Set(aLabel, aGuid, aString);
3288     if(anAtt.IsNull()) {
3289       di << "AsciiString attribute is not found or not set"  << "\n";
3290       return 1;
3291     }
3292   
3293     std::cout << "String = " << anAtt->Get().ToCString() << " is kept in DF" << std::endl;
3294     return 0; 
3295   }
3296   di << "DDataStd_SetAsciiString : Error\n";
3297   return 1;
3298
3299 //
3300 //=======================================================================
3301 //function :  GetAsciiString(DF, entry[, guid] )
3302 //=======================================================================
3303
3304 static Standard_Integer DDataStd_GetAsciiString (Draw_Interpretor& di,
3305                                               Standard_Integer nb, 
3306                                               const char** arg) 
3307 {   
3308   if (nb == 3 || nb == 4) {
3309     Handle(TDF_Data) DF;
3310     if (!DDF::GetDF(arg[1],DF))  return 1; 
3311     TDF_Label aLabel;           
3312     DDF::FindLabel(DF, arg[2], aLabel);
3313     if(aLabel.IsNull()) di << "Label is not found"   << "\n";
3314     Standard_GUID aGuid (TDataStd_AsciiString::GetID());
3315     if(nb == 4) {
3316       if (!Standard_GUID::CheckGUIDFormat(arg[3])) {
3317         di<<"DDataStd_GetAsciiString: The format of GUID is invalid\n";
3318         return 1;
3319       }
3320       aGuid = Standard_GUID(arg[3]);
3321     }
3322     Handle(TDataStd_AsciiString) anAtt;
3323     if( !aLabel.FindAttribute(aGuid, anAtt) ) {
3324       Message::SendFail() << "AsciiString attribute is not found or not set";
3325       return 1;
3326     }
3327
3328 #ifdef DEB_DDataStd
3329       std::cout << "String = " << anAtt->Get().ToCString()  << std::endl;
3330 #endif
3331     di << anAtt->Get().ToCString();
3332     return 0; 
3333   }
3334   di << "DDataStd_GetAsciiString : Error\n";
3335   return 1;
3336
3337
3338 //=======================================================================
3339 //function : SetNDataIntegers (DF, entry , Num,  key1, val1, ...
3340 //=======================================================================
3341
3342 static Standard_Integer DDataStd_SetNDataIntegers (Draw_Interpretor& di,
3343                                               Standard_Integer nb, 
3344                                               const char** arg) 
3345 {   
3346
3347   if (nb >=6) {
3348     Handle(TDF_Data) DF;
3349     if (!DDF::GetDF(arg[1],DF))  return 1; 
3350     TDF_Label aLabel;
3351     DDF::AddLabel(DF, arg[2], aLabel);
3352 //
3353 //     TCollection_ExtendedString aString("123456789 0_abcde");
3354 //     Standard_Integer aPos = aString.Search(" ");
3355 //     std::cout << "From Start = " <<aPos<<std::endl;
3356 //     aPos = aString.SearchFromEnd(" ");
3357 //     std::cout << "From Start = " <<aPos<<std::endl;
3358 //     TCollection_ExtendedString aValue = aString.Split(aPos);
3359 //     std::cout << "Value = |"<<aValue<<std::endl;
3360 //     std::cout << "aKey = " << aString << "|"<<std::endl;
3361 // 
3362     Standard_Integer aNumP = Draw::Atoi(arg[3]), j;
3363     Handle(TDataStd_NamedData) anAtt;
3364     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3365       anAtt = TDataStd_NamedData::Set(aLabel);
3366     if(anAtt.IsNull()) {
3367       di << "NamedData attribute is not found or not set"  << "\n";
3368       return 1;}
3369   
3370     j = 4;
3371     anAtt->LoadDeferredData();
3372     for(Standard_Integer i = 1; i<=aNumP; i++) {
3373       TCollection_ExtendedString aKey(arg[j]);
3374       Standard_Integer aVal = Draw::Atoi(arg[j+1]);
3375       anAtt->SetInteger(aKey, aVal); 
3376       j +=2;
3377     }    
3378     return 0; 
3379   }
3380   di << "DDataStd_SetNDataIntegers : Error\n";
3381   return 1;
3382
3383
3384
3385 //=======================================================================
3386 //function :  GetNDIntegers(DF, entry )
3387 //=======================================================================
3388 static Standard_Integer DDataStd_GetNDIntegers (Draw_Interpretor& di,
3389                                                 Standard_Integer nb, 
3390                                                 const char** arg) 
3391 {   
3392
3393   if (nb == 3) {
3394     Handle(TDF_Data) DF;
3395     if (!DDF::GetDF(arg[1],DF))  return 1; 
3396     TDF_Label aLabel;
3397     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3398  
3399
3400     Handle(TDataStd_NamedData) anAtt;
3401     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3402     {
3403       Message::SendFail() << "NamedData attribute is not found or not set";
3404       return 1;
3405     }
3406
3407     std::cout <<std::endl;
3408     std::cout <<"NamedData attribute at Label = " << arg[2] <<std::endl;
3409     anAtt->LoadDeferredData();
3410     const TColStd_DataMapOfStringInteger& aMap = anAtt->GetIntegersContainer();
3411     TColStd_DataMapIteratorOfDataMapOfStringInteger itr(aMap);
3412     for (; itr.More(); itr.Next()){
3413       TCollection_ExtendedString aKey(itr.Key());
3414       Standard_Integer aValue = itr.Value();
3415       di << "Key = " << aKey << " Value = " << aValue << "\n";
3416       }
3417
3418     return 0; 
3419   }
3420   di << "DDataStd_GetNDIntegers : Error\n";
3421   return 1;
3422
3423
3424 //=======================================================================
3425 //function :  GetNDInteger(DF, entry, key [drawname])
3426 //=======================================================================
3427 static Standard_Integer DDataStd_GetNDInteger (Draw_Interpretor& di,
3428                                                Standard_Integer nb, 
3429                                                const char** arg) 
3430 {
3431
3432   if (nb >=4) {
3433     Handle(TDF_Data) DF;
3434     if (!DDF::GetDF(arg[1],DF))  return 1; 
3435     TDF_Label aLabel;
3436     if(!DDF::FindLabel(DF, arg[2], aLabel)) return 1;
3437  
3438
3439     Handle(TDataStd_NamedData) anAtt;
3440     if(!aLabel.FindAttribute(TDataStd_NamedData::GetID(), anAtt))
3441     {
3442       Message::SendFail() << "NamedData attribute is not found or not set";
3443       return 1;
3444     }
3445
3446     std::cout <<std::endl;
3447     std::cout <<"NamedData attribute at Label = " << arg[2] <<std::endl;    
3448     anAtt->LoadDeferredData();
3449     TCollection_ExtendedString aKey(arg[3], Standard_True);
3450     if(!anAtt->HasInteger(aKey)) {
3451       std::cout << "There is no data specified by Key = "<< arg[3]  << std::endl;
3452       return 1;
3453     } else {
3454       std::cout << "Key = "  << arg[3]  << " Value = " <<anAtt->GetInteger(aKey)<<std::endl;
3455       if(nb == 5) 
3456         Draw::Set(arg[4], anAtt->GetInteger(aKey));
3457       return 0; 
3458     }