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