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