OCCT

// Created on: 1999-11-05
// Created by: Denis PASCAL
// Copyright (c) 1999-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <DDataStd.hxx>
#include <DDataStd_TreeBrowser.hxx>
#include <DDF.hxx>
#include <Draw_Appli.hxx>
#include <Draw_Interpretor.hxx>
#include <Message.hxx>
#include <TCollection_AsciiString.hxx>
#include <TDataStd_ChildNodeIterator.hxx>
#include <TDataStd_TreeNode.hxx>
#include <TDF_Data.hxx>
#include <TDF_Label.hxx>
#include <TDF_Tool.hxx>

#include <cstdio>

//=======================================================================
// TreeNode : SetNode
// purpose  : SetNode (DOC Entry [ID])
//=======================================================================
static int DDataStd_SetNode(Draw_Interpretor& di, int n, const char** a)
{
  occ::handle<TDF_Data> DF;
  if (!DDF::GetDF(a[1], DF))
  {
    return 1;
  }
  TDF_Label                      L;
  occ::handle<TDataStd_TreeNode> TN;
  DDF::AddLabel(DF, a[2], L);
  if (n == 3)
  {
    TN = TDataStd_TreeNode::Set(L);
    DDF::ReturnLabel(di, TN->Label());
    return 0;
  }
  else if (n == 4)
  {
    if (!Standard_GUID::CheckGUIDFormat(a[3]))
    {
      di << "DDataStd_SetNode: The format of GUID is invalid\n";
      return 1;
    }
    const Standard_GUID ID(a[3]);
    TN = TDataStd_TreeNode::Set(L, ID);
    DDF::ReturnLabel(di, TN->Label());
    return 0;
  }
  di << "DDataStd_SetNode : Error\n";
  return 1;
}

//=======================================================================
// TreeNode : AppendNode
// purpose  : AppendNode (DOC FatherEntry childEntry [fatherID])
//=======================================================================

static int DDataStd_AppendNode(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 4)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    occ::handle<TDataStd_TreeNode> father, child;

    Standard_GUID ID;
    if (n == 4)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[4]))
      {
        di << "DDataStd_AppendNode: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[4]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, father))
    {
      return 1;
    }

    TDF_Label L;
    DDF::AddLabel(DF, a[3], L);
    if ((L.FindAttribute(ID, child)) && (!child->IsRoot()))
    {
      di << "DDataStd_AppendNode : Error : childTreeNode don't detach\n";
      return 1;
    }
    child = TDataStd_TreeNode::Set(L, ID);
    if (!father->Append(child))
    {
      return 1;
    }
#ifdef OCCT_DEBUG
    di << "AppendNode: OK\n";
#endif
    return 0;
  }
  di << "DDataStd_AppendNode : Error\n";
  return 1;
}

//=======================================================================
// TreeNode : PrependNode
// purpose  : PrependNode (DOC FatherEntry childEntry [fatherID])
//=======================================================================

static int DDataStd_PrependNode(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 4)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    occ::handle<TDataStd_TreeNode> father, child;

    Standard_GUID ID;
    if (n == 4)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[4]))
      {
        di << "DDataStd_PrependNode: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[4]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, father))
    {
      return 1;
    }

    TDF_Label L;
    DDF::AddLabel(DF, a[3], L);
    if ((L.FindAttribute(ID, child)) && (!child->IsRoot()))
    {
      di << "DDataStd_PrependNode : Error : childTreeNode don't detach\n";
      return 1;
    }
    child = TDataStd_TreeNode::Set(L, ID);
    if (!father->Prepend(child))
    {
      return 1;
    }
#ifdef OCCT_DEBUG
    di << "PrependNode: OK\n";
#endif
    return 0;
  }
  di << "DDataStd_PrependNode : Error\n";
  return 1;
}

//=======================================================================
// TreeNode : RootNode
// purpose  : RootNode (DOC TreeNodeEntry [ID])
//=======================================================================

static int DDataStd_RootNode(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 3)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    occ::handle<TDataStd_TreeNode> TN;

    Standard_GUID ID;
    if (n == 3)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[3]))
      {
        di << "DDataStd_RootNode: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[3]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, TN))
    {
      return 1;
    }
    DDF::ReturnLabel(di, TN->Root()->Label());
    return 0;
  }
  di << "DDataStd_RootNode : Error\n";
  return 1;
}

//=======================================================================
// TreeNode : InsertNodeBefore
// purpose  : InsertNodeBefore (DOC TreeNodeEntry TreeNodeWhichHasToBeBefore [ID])
//=======================================================================

static int DDataStd_InsertNodeBefore(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 4)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    occ::handle<TDataStd_TreeNode> current, TN;

    Standard_GUID ID;
    if (n == 4)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[4]))
      {
        di << "DDataStd_InsertNodeBefore: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[4]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, current))
    {
      return 1;
    }
    //     if (!DDF::Find(DF,a[3],ID,TN)) return 1;

    TDF_Label L;
    if (!DDF::FindLabel(DF, a[3], L))
    {
      return 1;
    }
    TN = TDataStd_TreeNode::Set(L, ID);
    if (!current->InsertBefore(TN))
    {
      return 1;
    }
    return 0;
  }
  di << "DDataStd_InsertBefore : Error\n";
  return 1;
}

//=======================================================================
// TreeNode : InsertNodeAfter
// purpose  : InsertNodeAfter (DOC TreeNodeEntry TreeNodeWhichHasToBeAfter [ID])
//=======================================================================

static int DDataStd_InsertNodeAfter(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 4)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    occ::handle<TDataStd_TreeNode> current, TN;

    Standard_GUID ID;
    if (n == 4)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[4]))
      {
        di << "DDataStd_InsertNodeAfter: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[4]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, current))
    {
      return 1;
    }
    // if (!DDF::Find(DF,a[3],TDataStd_TreeNode::GetDefaultTreeID(),TN)) return 1;
    TDF_Label L;
    if (!DDF::FindLabel(DF, a[3], L))
    {
      return 1;
    }
    TN = TDataStd_TreeNode::Set(L);
    if (!current->InsertAfter(TN))
    {
      return 1;
    }
    return 0;
  }
  di << "DDataStd_InsertNodeAfter : Error\n";
  return 1;
}

//=======================================================================
// TreeNode : DetachNode
// purpose  : DetachNode (DOC TreeNodeEntry [ID])
//=======================================================================

static int DDataStd_DetachNode(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 3)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    occ::handle<TDataStd_TreeNode> TN;

    Standard_GUID ID;
    if (n == 3)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[3]))
      {
        di << "DDataStd_DetachNode: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[3]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, TN))
    {
      return 1;
    }
    if (!TN->Remove())
    {
      di << "Can't Detach the TreeNode\n";
    }
    return 0;
  }
  di << "DDataStd_DetachNode : Error\n";
  return 1;
}

//=======================================================================
// function : TreeBrowse
// purpose  :
//  arg 1  : DF name
//  arg 2  : Entry
// [arg 3] : Browser name
//=======================================================================

static int DDataStd_TreeBrowse(Draw_Interpretor& di, int n, const char** a)
{
  if (n < 3)
  {
    return 1;
  }

  occ::handle<TDF_Data> DF;
  if (!DDF::GetDF(a[1], DF))
  {
    return 1;
  }

  TDF_Label lab;
  TDF_Tool::Label(DF, a[2], lab);

  occ::handle<DDataStd_TreeBrowser> NewTreeNode = new DDataStd_TreeBrowser(lab);
  char*                             name        = new char[50];
  if (n == 4)
  {
    Sprintf(name, "treebrowser_%s", a[3]);
  }
  else
  {
    Sprintf(name, "treebrowser_%s", a[1]);
  }

  Draw::Set(name, NewTreeNode);
  TCollection_AsciiString inst1("treebrowser ");
  inst1.AssignCat(name);
  di.Eval(inst1.ToCString());
  return 0;
}

//=======================================================================
// function : OpenNode
// purpose  :
//  arg 1  : Browser name
// [arg 2] : Label entry
//=======================================================================

static int DDataStd_OpenNode(Draw_Interpretor& di, int n, const char** a)
{
  if (n < 2)
  {
    return 1;
  }

  occ::handle<DDataStd_TreeBrowser> browser =
    occ::down_cast<DDataStd_TreeBrowser>(Draw::GetExisting(a[1]));
  if (browser.IsNull())
  {
    Message::SendFail() << "Syntax error: browser '" << a[1] << "' not found";
    return 1;
  }

  TDF_Label lab;
  if (n == 3)
  {
    TDF_Tool::Label(browser->Label().Data(), a[2], lab);
  }

  if (n == 2 || lab.IsNull())
  {
    TCollection_AsciiString list = browser->OpenRoot();
    di << list.ToCString();
  }
  else
  {
    TCollection_AsciiString list = browser->OpenNode(lab);
    di << list.ToCString();
  }
  return 0;
}

//=======================================================================
// TreeNode : ChildNodeIterate
// purpose  : ChildNodeIterate Doc TreeNode AllLevels [ID]
//=======================================================================

static int DDataStd_ChildNodeIterate(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 4)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    const bool                     AllLevels = (Draw::Atoi(a[3]) != 0);
    occ::handle<TDataStd_TreeNode> TN, Value;

    Standard_GUID ID;
    if (n == 4)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[4]))
      {
        di << "DDataStd_ChildNodeIterate: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[4]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, TN))
    {
      return 1;
    }
    // di<<"TDataStd_ChildNodeIterator: \n";
    TDataStd_ChildNodeIterator itr(TN, AllLevels);
    for (; itr.More(); itr.Next())
    {
      Value = itr.Value();
      TCollection_AsciiString entry;
      TDF_Tool::Entry(Value->Label(), entry);
      di << entry << "\n";
      // di<<entry;
      // if(itr.More()==true)
      // di<<" ";
    }
    di << "\n";
    return 0;
  }
  di << "DDataStd_ChildNodeIterate : Error\n";
  return 1;
}

static TDataStd_ChildNodeIterator cni;

//=======================================================================
// TreeNode : InitChildNodeIterator
// purpose  : InitChildNodeIterator Doc TreeNode AllLevels [ID]
//=======================================================================

static int DDataStd_InitChildNodeIterator(Draw_Interpretor& di, int n, const char** a)
{
  if (n >= 4)
  {
    occ::handle<TDF_Data> DF;
    if (!DDF::GetDF(a[1], DF))
    {
      return 1;
    }
    occ::handle<TDataStd_TreeNode> TN, Value;

    Standard_GUID ID;
    if (n == 4)
    {
      ID = Standard_GUID(TDataStd_TreeNode::GetDefaultTreeID());
    }
    else
    {
      if (!Standard_GUID::CheckGUIDFormat(a[4]))
      {
        di << "DDataStd_ChildNodeIterator: The format of GUID is invalid\n";
        return 1;
      }
      const Standard_GUID varID(a[4]);
      ID = varID;
    }

    if (!DDF::Find(DF, a[2], ID, TN))
    {
      return 1;
    }
    const bool AllLevels = (Draw::Atoi(a[3]) != 0);
    cni.Initialize(TN, AllLevels);
    return 0;
  }
  di << "DDataStd_InitChildNodeIterator : Error\n";
  return 1;
}

//=================================================================================================

static int DDataStd_ChildNodeMore(Draw_Interpretor& di, int /*n*/, const char** /*a*/)
{
  if (cni.More())
  {
    di << "TRUE\n";
  }
  else
  {
    di << "FALSE\n";
  }
  return 0;
}

//=================================================================================================

static int DDataStd_ChildNodeNext(Draw_Interpretor& /*di*/, int /*n*/, const char** /*a*/)
{
  cni.Next();
  return 0;
}

//=================================================================================================

static int DDataStd_ChildNodeNextBrother(Draw_Interpretor& /*di*/, int /*n*/, const char** /*a*/)
{
  cni.NextBrother();
  return 0;
}

//=================================================================================================

static int DDataStd_ChildNodeValue(Draw_Interpretor& di, int /*n*/, const char** /*a*/)
{
  TCollection_AsciiString entry;
  TDF_Tool::Entry(cni.Value()->Label(), entry);
  di << entry << "\n";
  return 0;
}

//=================================================================================================

void DDataStd::TreeCommands(Draw_Interpretor& theCommands)
{
  static bool done = false;
  if (done)
  {
    return;
  }
  done = true;

  const char* g = "DData : Standard Attribute Commands";

  // SET

  theCommands.Add("SetNode", "SetNode (DOC Entry [GUID])", __FILE__, DDataStd_SetNode, g);

  // EDIT

  theCommands.Add("AppendNode",
                  "AppendNode (DOC FatherEntry childEntry [fatherGUID])",
                  __FILE__,
                  DDataStd_AppendNode,
                  g);

  theCommands.Add("PrependNode",
                  "PrependNode (DOC FatherEntry childEntry [fatherGUID])",
                  __FILE__,
                  DDataStd_PrependNode,
                  g);

  theCommands.Add("InsertNodeBefore",
                  "InsertNodeBefore (DOC TreeNodeEntry TreeNodeWhichHasToBeBefore [GUID])",
                  __FILE__,
                  DDataStd_InsertNodeBefore,
                  g);

  theCommands.Add("InsertNodeAfter",
                  "InsertNodeAfter (DOC TreeNodeEntry TreeNodeWhichHasToBeAfter [GUID])",
                  __FILE__,
                  DDataStd_InsertNodeAfter,
                  g);

  theCommands.Add("DetachNode",
                  "DetachNode (DOC TreeNodeEntry [GUID])",
                  __FILE__,
                  DDataStd_DetachNode,
                  g);

  theCommands.Add("RootNode",
                  "RootNode (DOC TreeNodeEntry [GUID])",
                  __FILE__,
                  DDataStd_RootNode,
                  g);

  // TREE BROWSER

  theCommands.Add("TreeBrowse",
                  "TreeBrowse dfname entry [browsername]",
                  __FILE__,
                  DDataStd_TreeBrowse,
                  g);

  theCommands.Add("OpenNode",
                  "PRIVATE COMMAND FOR TREE BROWSER!\nReturns the list of sub-TreeNodes : "
                  "OpenTreeNode browsername [entry]",
                  __FILE__,
                  DDataStd_OpenNode,
                  g);

  // TREE ITERATOR

  theCommands.Add("ChildNodeIterate",
                  "ChildNodeIterate Doc TreeNode AllLevels [GUID]",
                  __FILE__,
                  DDataStd_ChildNodeIterate,
                  g);

  theCommands.Add("InitChildNodeIterator",
                  "InitChildNodeIterator Doc TreeNode AllLevels [GUID]",
                  __FILE__,
                  DDataStd_InitChildNodeIterator,
                  g);

  theCommands.Add("ChildNodeMore", "ChildNodeMore", __FILE__, DDataStd_ChildNodeMore, g);

  theCommands.Add("ChildNodeNext", "ChildNodeNext", __FILE__, DDataStd_ChildNodeNext, g);

  theCommands.Add("ChildNodeNextBrother",
                  "ChildNodeNextBrother",
                  __FILE__,
                  DDataStd_ChildNodeNextBrother,
                  g);

  theCommands.Add("ChildNodeValue", "ChildNodeValue", __FILE__, DDataStd_ChildNodeValue, g);
}