src/DDataStd/DDataStd_BasicCommands.cxx

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