src/DDataStd/DDataStd_BasicCommands.cxx

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