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