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