src/DDataStd/DDataStd_TreeCommands.cxx

   1 // Created on: 1999-11-05
   2 // Created by: Denis PASCAL
   3 // Copyright (c) 1999-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.ixx>
  18 #include <DDF.hxx>
  19
  20 #include <Draw.hxx>
  21 #include <Draw_Appli.hxx>
  22 #include <Draw_Drawable3D.hxx>
  23 #include <Draw_Interpretor.hxx>
  24
  25 #include <TDF_Data.hxx>
  26 #include <TDF.hxx>
  27 #include <TDF_Tool.hxx>
  28 #include <TDF_Label.hxx>
  29
  30 #include <DDataStd_TreeBrowser.hxx>
  31 #include <TDataStd_TreeNode.hxx>
  32 #include <TDataStd_ChildNodeIterator.hxx>
  33
  34 #include <Standard_GUID.hxx>
  35 #include <TCollection_AsciiString.hxx>
  36 #include <TCollection_ExtendedString.hxx>
  37
  38 #include <stdio.h>
  39
  40
  41 //=======================================================================
  42 //TreeNode : SetNode
  43 //purpose  : SetNode (DOC Entry [ID])
  44 //=======================================================================
  45
  46 static Standard_Integer DDataStd_SetNode (Draw_Interpretor& di,
  47                                           Standard_Integer  n,
  48                                           const char**            a)
  49 {
  50   Handle(TDF_Data) DF;
  51   if (!DDF::GetDF(a[1],DF)) return 1;
  52   TDF_Label L;
  53   Handle(TDataStd_TreeNode) TN;
  54   DDF::AddLabel(DF,a[2],L);
  55   if (n == 3) {
  56     TN = TDataStd_TreeNode::Set(L);
  57     DDF::ReturnLabel(di,TN->Label());
  58     return 0;
  59   } else if (n == 4) {
  60     if (!Standard_GUID::CheckGUIDFormat(a[3])) {
  61       di<<"DDataStd_SetNode: The format of GUID is invalid"<<"\n";
  62       return 1;
  63     }
  64     const Standard_GUID ID(a[3]);
  65     TN = TDataStd_TreeNode::Set(L, ID);
  66     DDF::ReturnLabel(di,TN->Label());
  67     return 0;
  68   }
  69   di << "DDataStd_SetNode : Error" << "\n";
  70   return 1;
  71 }
  72
  73 //=======================================================================
  74 //TreeNode : AppendNode
  75 //purpose  : AppendNode (DOC FatherEntry childEntry [fatherID])
  76 //=======================================================================
  77
  78 static Standard_Integer DDataStd_AppendNode (Draw_Interpretor& di,
  79                                              Standard_Integer  n,
  80                                              const char**            a)
  81 {
  82   if (n >= 4) {
  83     Handle(TDF_Data) DF;
  84     if (!DDF::GetDF(a[1],DF))return 1;
  85     Handle(TDataStd_TreeNode) father, child;
  86
  87     Standard_GUID ID;
  88     if (n==4)
  89       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
  90     else{
  91       if (!Standard_GUID::CheckGUIDFormat(a[4])) {
  92         di<<"DDataStd_AppendNode: The format of GUID is invalid"<<"\n";
  93         return 1;
  94       }
  95       const Standard_GUID varID(a[4]);
  96       ID=varID;
  97     }
  98
  99     if (!DDF::Find(DF,a[2],ID,father)) return 1;
 100
 101     TDF_Label L;
 102     DDF::AddLabel(DF,a[3],L);
 103     if ( (L.FindAttribute(ID,child))
 104        &&(!child->IsRoot()) ){
 105       di << "DDataStd_AppendNode : Error : childTreeNode don't detach" << "\n";
 106       return 1;
 107     }
 108     child = TDataStd_TreeNode::Set(L,ID);
 109     if (!father->Append(child)) return 1;
 110 #ifdef DEB
 111     di<<"AppendNode: OK"<<"\n";
 112 #endif
 113     return 0;
 114   }
 115   di << "DDataStd_AppendNode : Error" << "\n";
 116   return 1;
 117 }
 118
 119 //=======================================================================
 120 //TreeNode : PrependNode
 121 //purpose  : PrependNode (DOC FatherEntry childEntry [fatherID])
 122 //=======================================================================
 123
 124 static Standard_Integer DDataStd_PrependNode (Draw_Interpretor& di,
 125                                              Standard_Integer  n,
 126                                              const char**            a)
 127 {
 128   if (n >= 4) {
 129     Handle(TDF_Data) DF;
 130     if (!DDF::GetDF(a[1],DF))return 1;
 131     Handle(TDataStd_TreeNode) father, child;
 132
 133     Standard_GUID ID;
 134     if (n==4)
 135       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
 136     else{
 137       if (!Standard_GUID::CheckGUIDFormat(a[4])) {
 138         di<<"DDataStd_PrependNode: The format of GUID is invalid"<<"\n";
 139         return 1;
 140       }
 141       const Standard_GUID varID(a[4]);
 142       ID=varID;
 143     }
 144
 145     if (!DDF::Find(DF,a[2],ID,father)) return 1;
 146
 147     TDF_Label L;
 148     DDF::AddLabel(DF,a[3],L);
 149     if ( (L.FindAttribute(ID,child))
 150        &&(!child->IsRoot()) ){
 151       di << "DDataStd_PrependNode : Error : childTreeNode don't detach" << "\n";
 152       return 1;
 153     }
 154     child = TDataStd_TreeNode::Set(L,ID);
 155     if (!father->Prepend(child)) return 1;
 156 #ifdef DEB
 157     di<<"PrependNode: OK"<<"\n";
 158 #endif
 159     return 0;
 160   }
 161   di << "DDataStd_PrependNode : Error" << "\n";
 162   return 1;
 163 }
 164
 165 //=======================================================================
 166 //TreeNode : RootNode
 167 //purpose  : RootNode (DOC TreeNodeEntry [ID])
 168 //=======================================================================
 169
 170 static Standard_Integer DDataStd_RootNode (Draw_Interpretor& di,
 171                                            Standard_Integer  n,
 172                                            const char**            a)
 173 {
 174   if (n >= 3) {
 175     Handle(TDF_Data) DF;
 176     if (!DDF::GetDF(a[1],DF)) return 1;
 177     Handle(TDataStd_TreeNode) TN;
 178
 179     Standard_GUID ID;
 180     if (n==3)
 181       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
 182     else{
 183       if (!Standard_GUID::CheckGUIDFormat(a[3])) {
 184         di<<"DDataStd_RootNode: The format of GUID is invalid"<<"\n";
 185         return 1;
 186       }
 187       const Standard_GUID varID(a[3]);
 188       ID=varID;
 189     }
 190
 191     if (!DDF::Find(DF,a[2],ID,TN)) return 1;
 192     DDF::ReturnLabel(di,TN->Root()->Label());
 193     return 0;
 194   }
 195   di << "DDataStd_RootNode : Error" << "\n";
 196   return 1;
 197 }
 198
 199 //=======================================================================
 200 //TreeNode : InsertNodeBefore
 201 //purpose  : InsertNodeBefore (DOC TreeNodeEntry TreeNodeWhichHasToBeBefore [ID])
 202 //=======================================================================
 203
 204 static Standard_Integer DDataStd_InsertNodeBefore(Draw_Interpretor& di,
 205                                                   Standard_Integer  n,
 206                                                   const char**            a)
 207 {
 208   if (n >= 4) {
 209     Handle(TDF_Data) DF;
 210     if (!DDF::GetDF(a[1],DF)) return 1;
 211     Handle(TDataStd_TreeNode) current, TN;
 212
 213     Standard_GUID ID;
 214     if (n==4)
 215       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
 216     else{
 217       if (!Standard_GUID::CheckGUIDFormat(a[4])) {
 218         di<<"DDataStd_InsertNodeBefore: The format of GUID is invalid"<<"\n";
 219         return 1;
 220       }
 221       const Standard_GUID varID(a[4]);
 222       ID=varID;
 223     }
 224
 225     if (!DDF::Find(DF,a[2],ID,current)) return 1;
 226 //     if (!DDF::Find(DF,a[3],ID,TN)) return 1;
 227
 228     TDF_Label L;
 229     if (!DDF::FindLabel(DF,a[3],L)) return 1;
 230     TN = TDataStd_TreeNode::Set(L,ID);
 231     if (!current->InsertBefore(TN)) return 1;
 232     return 0;
 233   }
 234   di << "DDataStd_InsertBefore : Error" << "\n";
 235   return 1;
 236 }
 237
 238 //=======================================================================
 239 //TreeNode : InsertNodeAfter
 240 //purpose  : InsertNodeAfter (DOC TreeNodeEntry TreeNodeWhichHasToBeAfter [ID])
 241 //=======================================================================
 242
 243 static Standard_Integer DDataStd_InsertNodeAfter(Draw_Interpretor& di,
 244                                                  Standard_Integer  n,
 245                                                  const char**            a)
 246 {
 247   if (n >= 4) {
 248     Handle(TDF_Data) DF;
 249     if (!DDF::GetDF(a[1],DF)) return 1;
 250     Handle(TDataStd_TreeNode) current, TN;
 251
 252     Standard_GUID ID;
 253     if (n==4)
 254       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
 255     else{
 256       if (!Standard_GUID::CheckGUIDFormat(a[4])) {
 257         di<<"DDataStd_InsertNodeAfter: The format of GUID is invalid"<<"\n";
 258         return 1;
 259       }
 260       const Standard_GUID varID(a[4]);
 261       ID=varID;
 262     }
 263
 264     if (!DDF::Find(DF,a[2],ID,current)) return 1;
 265     //if (!DDF::Find(DF,a[3],TDataStd_TreeNode::GetDefaultTreeID(),TN)) return 1;
 266     TDF_Label L;
 267     if (!DDF::FindLabel(DF,a[3],L)) return 1;
 268     TN = TDataStd_TreeNode::Set(L);
 269     if (!current->InsertAfter(TN)) return 1;
 270     return 0;
 271   }
 272   di << "DDataStd_InsertNodeAfter : Error" << "\n";
 273   return 1;
 274 }
 275
 276 //=======================================================================
 277 //TreeNode : DetachNode
 278 //purpose  : DetachNode (DOC TreeNodeEntry [ID])
 279 //=======================================================================
 280
 281 static Standard_Integer DDataStd_DetachNode (Draw_Interpretor& di,Standard_Integer n, const char** a)
 282 {
 283   if (n >= 3) {
 284     Handle(TDF_Data) DF;
 285     if (!DDF::GetDF(a[1],DF)) return 1;
 286     Handle(TDataStd_TreeNode) TN;
 287
 288     Standard_GUID ID;
 289     if (n==3)
 290       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
 291     else{
 292       if (!Standard_GUID::CheckGUIDFormat(a[3])) {
 293         di<<"DDataStd_DetachNode: The format of GUID is invalid"<<"\n";
 294         return 1;
 295       }
 296       const Standard_GUID varID(a[3]);
 297       ID=varID;
 298     }
 299
 300     if (!DDF::Find(DF,a[2],ID,TN)) return 1;
 301     if (!TN->Remove())
 302       di << "Can't Detach the TreeNode" << "\n";
 303     return 0;
 304   }
 305   di << "DDataStd_DetachNode : Error" << "\n";
 306   return 1;
 307 }
 308
 309 //=======================================================================
 310 //function : TreeBrowse
 311 //purpose  :
 312 //  arg 1  : DF name
 313 //  arg 2  : Entry
 314 // [arg 3] : Browser name
 315 //=======================================================================
 316
 317 static Standard_Integer DDataStd_TreeBrowse (Draw_Interpretor& di,
 318                                                  Standard_Integer  n,
 319                                                  const char**            a)
 320 {
 321   if (n<3) return 1;
 322
 323   Handle(TDF_Data) DF;
 324   if (!DDF::GetDF (a[1], DF)) return 1;
 325
 326   TDF_Label lab;
 327   TDF_Tool::Label(DF,a[2],lab);
 328
 329   Handle(DDataStd_TreeBrowser) NewTreeNode = new DDataStd_TreeBrowser (lab);
 330   char *name = new char[50];
 331   if (n == 4) Sprintf(name,"treebrowser_%s",a[3]);
 332   else        Sprintf(name,"treebrowser_%s",a[1]);
 333
 334   Draw::Set(name, NewTreeNode);
 335   TCollection_AsciiString inst1("treebrowser ");
 336   inst1.AssignCat(name);
 337   di.Eval(inst1.ToCString());
 338   return 0;
 339 }
 340
 341
 342 //=======================================================================
 343 //function : OpenNode
 344 //purpose  :
 345 //  arg 1  : Browser name
 346 // [arg 2] : Label entry
 347 //=======================================================================
 348
 349 static Standard_Integer DDataStd_OpenNode (Draw_Interpretor& di,
 350                                            Standard_Integer  n,
 351                                            const char**            a)
 352 {
 353   if (n < 2) return 1;
 354
 355   Handle(DDataStd_TreeBrowser) browser =
 356     Handle(DDataStd_TreeBrowser)::DownCast (Draw::Get(a[1], Standard_True));
 357
 358   TDF_Label lab;
 359   if (n == 3) TDF_Tool::Label(browser->Label().Data(),a[2],lab);
 360
 361   if (n == 2 || lab.IsNull()) {
 362     TCollection_AsciiString list = browser->OpenRoot();
 363     di<<list.ToCString();
 364   }
 365   else {
 366     TCollection_AsciiString list = browser->OpenNode(lab);
 367     di<<list.ToCString();
 368   }
 369   return 0;
 370 }
 371
 372 //=======================================================================
 373 //TreeNode : ChildNodeIterate
 374 //purpose  : ChildNodeIterate Doc TreeNode AllLevels [ID]
 375 //=======================================================================
 376
 377 static Standard_Integer DDataStd_ChildNodeIterate (Draw_Interpretor& di,
 378                                                    Standard_Integer  n,
 379                                                    const char**            a)
 380 {
 381   if (n >= 4) {
 382     Handle(TDF_Data) DF;
 383     if (!DDF::GetDF(a[1],DF)) return 1;
 384     const Standard_Boolean AllLevels(Draw::Atoi(a[3]));
 385     Handle(TDataStd_TreeNode) TN, Value;
 386
 387     Standard_GUID ID;
 388     if (n==4)
 389       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
 390     else{
 391       if (!Standard_GUID::CheckGUIDFormat(a[4])) {
 392         di<<"DDataStd_ChildNodeIterate: The format of GUID is invalid"<<"\n";
 393         return 1;
 394       }
 395       const Standard_GUID varID(a[4]);
 396       ID=varID;
 397     }
 398
 399     if (!DDF::Find(DF, a[2], ID, TN)) return 1;
 400     //di<<"TDataStd_ChildNodeIterator: "<<"\n";
 401     TDataStd_ChildNodeIterator itr(TN, AllLevels);
 402     for (; itr.More(); itr.Next()) {
 403       Value = itr.Value();
 404       TCollection_AsciiString entry;
 405       TDF_Tool::Entry(Value->Label(), entry);
 406       di<<entry<<"\n";
 407       //di<<entry;
 408       //if(itr.More()==Standard_True)
 409         //di<<" ";
 410     }
 411     di<<"\n";
 412     return 0;
 413   }
 414   di << "DDataStd_ChildNodeIterate : Error" << "\n";
 415   return 1;
 416 }
 417
 418 static TDataStd_ChildNodeIterator cni;
 419
 420 //=======================================================================
 421 //TreeNode : InitChildNodeIterator
 422 //purpose  : InitChildNodeIterator Doc TreeNode AllLevels [ID]
 423 //=======================================================================
 424
 425 static Standard_Integer DDataStd_InitChildNodeIterator (Draw_Interpretor& di,
 426                                                         Standard_Integer  n,
 427                                                         const char**            a)
 428 {
 429   if (n >= 4) {
 430     Handle(TDF_Data) DF;
 431     if (!DDF::GetDF(a[1],DF)) return 1;
 432     Handle(TDataStd_TreeNode) TN, Value;
 433
 434     Standard_GUID ID;
 435     if (n==4)
 436       ID=Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
 437     else{
 438       if (!Standard_GUID::CheckGUIDFormat(a[4])) {
 439         di<<"DDataStd_ChildNodeIterator: The format of GUID is invalid"<<"\n";
 440         return 1;
 441       }
 442       const Standard_GUID varID(a[4]);
 443       ID=varID;
 444     }
 445
 446     if (!DDF::Find(DF, a[2], ID, TN)) return 1;
 447     const Standard_Boolean AllLevels(Draw::Atoi(a[3]));
 448     cni.Initialize(TN, AllLevels);
 449     return 0;
 450   }
 451   di << "DDataStd_InitChildNodeIterator : Error" << "\n";
 452   return 1;
 453 }
 454
 455 //=======================================================================
 456 //TreeNode : ChildNodeMore
 457 //purpose  : ChildNodeMore
 458 //=======================================================================
 459
 460 static Standard_Integer DDataStd_ChildNodeMore (Draw_Interpretor& di,
 461                                                 Standard_Integer  /*n*/,
 462                                                 const char**            /*a*/)
 463 {
 464   if (cni.More()) {
 465     //cout<<"TRUE"<<endl;
 466     di<<"TRUE"<<"\n";
 467   }
 468   else {
 469     //cout<<"FALSE"<<endl;
 470     di<<"FALSE"<<"\n";
 471   }
 472   return 0;
 473 }
 474
 475 //=======================================================================
 476 //TreeNode : ChildNodeNext
 477 //purpose  : ChildNodeNext
 478 //=======================================================================
 479
 480 static Standard_Integer DDataStd_ChildNodeNext (Draw_Interpretor& /*di*/,
 481                                                 Standard_Integer  /*n*/,
 482                                                 const char**            /*a*/)
 483 {
 484   cni.Next();
 485   return 0;
 486 }
 487
 488 //=======================================================================
 489 //TreeNode : ChildNodeNextBrother
 490 //purpose  : ChildNodeNext Brother
 491 //=======================================================================
 492
 493 static Standard_Integer DDataStd_ChildNodeNextBrother (Draw_Interpretor& /*di*/,
 494                                                        Standard_Integer  /*n*/,
 495                                                        const char**            /*a*/)
 496 {
 497   cni.NextBrother();
 498   return 0;
 499 }
 500
 501 //=======================================================================
 502 //TreeNode : ChildNodeValue
 503 //purpose  : ChildNodeValue
 504 //=======================================================================
 505
 506 static Standard_Integer DDataStd_ChildNodeValue (Draw_Interpretor& di,
 507                                                  Standard_Integer  /*n*/,
 508                                                  const char**            /*a*/)
 509 {
 510   TCollection_AsciiString entry;
 511   TDF_Tool::Entry(cni.Value()->Label(), entry);
 512   //cout<<entry<<endl;
 513   di  <<entry<<"\n";
 514   return 0;
 515 }
 516
 517 //=======================================================================
 518 //TreeNode : TreeCommands
 519 //purpose  :
 520 //=======================================================================
 521
 522 void DDataStd::TreeCommands (Draw_Interpretor& theCommands)
 523 {
 524   static Standard_Boolean done = Standard_False;
 525   if (done) return;
 526   done = Standard_True;
 527
 528   const char* g = "DData : Standard Attribute Commands";
 529
 530   // SET
 531
 532   theCommands.Add ("SetNode",
 533                    "SetNode (DOC Entry [GUID])",
 534                    __FILE__, DDataStd_SetNode, g);
 535
 536   // EDIT
 537
 538   theCommands.Add ("AppendNode",
 539                    "AppendNode (DOC FatherEntry childEntry [fatherGUID])",
 540                    __FILE__, DDataStd_AppendNode, g);
 541
 542   theCommands.Add ("PrependNode",
 543                    "PrependNode (DOC FatherEntry childEntry [fatherGUID])",
 544                    __FILE__, DDataStd_PrependNode, g);
 545
 546   theCommands.Add ("InsertNodeBefore",
 547                    "InsertNodeBefore (DOC TreeNodeEntry TreeNodeWhichHasToBeBefore [GUID])",
 548                    __FILE__, DDataStd_InsertNodeBefore, g);
 549
 550   theCommands.Add ("InsertNodeAfter",
 551                    "InsertNodeAfter (DOC TreeNodeEntry TreeNodeWhichHasToBeAfter [GUID])",
 552                    __FILE__, DDataStd_InsertNodeAfter, g);
 553
 554   theCommands.Add ("DetachNode",
 555                    "DetachNode (DOC TreeNodeEntry [GUID])",
 556                    __FILE__, DDataStd_DetachNode, g);
 557
 558   theCommands.Add ("RootNode",
 559                    "RootNode (DOC TreeNodeEntry [GUID])",
 560                    __FILE__, DDataStd_RootNode, g);
 561
 562
 563   // TREE BROWSER
 564
 565   theCommands.Add ("TreeBrowse",
 566                    "TreeBrowse dfname entry [browsername]",
 567                    __FILE__, DDataStd_TreeBrowse, g);
 568
 569   theCommands.Add ("OpenNode",
 570                    "PRIVATE COMMAND FOR TREE BROWSER!\nReturns the list of sub-TreeNodes : OpenTreeNode browsername [entry]",
 571                    __FILE__, DDataStd_OpenNode, g);
 572
 573
 574
 575   // TREE ITERATOR
 576
 577   theCommands.Add ("ChildNodeIterate",
 578                    "ChildNodeIterate Doc TreeNode AllLevels [GUID]",
 579                    __FILE__, DDataStd_ChildNodeIterate, g);
 580
 581   theCommands.Add ("InitChildNodeIterator",
 582                    "InitChildNodeIterator Doc TreeNode AllLevels [GUID]",
 583                    __FILE__, DDataStd_InitChildNodeIterator, g);
 584
 585   theCommands.Add ("ChildNodeMore",
 586                    "ChildNodeMore",
 587                    __FILE__, DDataStd_ChildNodeMore, g);
 588
 589   theCommands.Add ("ChildNodeNext",
 590                    "ChildNodeNext",
 591                    __FILE__, DDataStd_ChildNodeNext, g);
 592
 593   theCommands.Add ("ChildNodeNextBrother",
 594                    "ChildNodeNextBrother",
 595                    __FILE__, DDataStd_ChildNodeNextBrother, g);
 596
 597   theCommands.Add ("ChildNodeValue",
 598                    "ChildNodeValue",
 599                    __FILE__, DDataStd_ChildNodeValue, g);
 600
 601 }