src/SALOMEDS/SALOMEDS_AttributeTreeNode_i.cxx

   1 //  SALOME SALOMEDS : data structure of SALOME and sources of Salome data server
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : SALOMEDS_AttributeTreeNode_i.cxx
  25 //  Author : Yves FRICAUD
  26 //  Module : SALOME
  27 //  $Header$
  28
  29 #include <TDocStd_Document.hxx>
  30 #include <TDF_Tool.hxx>
  31
  32 #include "SALOMEDS_AttributeTreeNode_i.hxx"
  33 #include "SALOMEDS.hxx"
  34
  35 #include "utilities.h"
  36
  37 using namespace std;
  38
  39 static Handle(TDataStd_TreeNode) GetNode(SALOMEDS::AttributeTreeNode_ptr value,
  40                                          const Handle(TDataStd_TreeNode)& aNode)
  41 {
  42   Handle(TDataStd_TreeNode) aResult = new TDataStd_TreeNode;
  43   CORBA::String_var aString = CORBA::string_dup(value->Label());
  44   TDF_Label aLabel;
  45   TDF_Tool::Label(aNode->Label().Data(), TCollection_AsciiString(aString), aLabel, 0);
  46   if (aLabel.IsNull()) {
  47     MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such label")
  48     MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such label")
  49     return aResult;
  50   }
  51   if (!aLabel.FindAttribute(aNode->ID(), aResult)) {
  52     MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such attribute")
  53     MESSAGE("SALOMEDS_AttributeTreeNode_i class: no such attribute")
  54   }
  55   return aResult;
  56 }
  57
  58 void SALOMEDS_AttributeTreeNode_i::SetFather(SALOMEDS::AttributeTreeNode_ptr theValue) {
  59   SALOMEDS::Locker lock;
  60
  61   CheckLocked();
  62   _myAttr->SetFather(GetNode(theValue,_myAttr));
  63 }
  64
  65 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasFather() {
  66   SALOMEDS::Locker lock;
  67
  68   return _myAttr->HasFather();
  69 }
  70
  71 SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetFather() {
  72   SALOMEDS::Locker lock;
  73
  74   SALOMEDS_AttributeTreeNode_i* aTreeNode =
  75     new SALOMEDS_AttributeTreeNode_i(_myAttr->Father(),_mySObject);
  76   return aTreeNode->_this();
  77 }
  78
  79 void SALOMEDS_AttributeTreeNode_i::SetPrevious(SALOMEDS::AttributeTreeNode_ptr theValue) {
  80   SALOMEDS::Locker lock;
  81
  82   CheckLocked();
  83   _myAttr->SetPrevious(GetNode(theValue,_myAttr));
  84 }
  85
  86 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasPrevious() {
  87   SALOMEDS::Locker lock;
  88
  89   return _myAttr->HasPrevious();
  90 }
  91
  92 SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetPrevious() {
  93   SALOMEDS::Locker lock;
  94
  95   SALOMEDS_AttributeTreeNode_i* aTreeNode =
  96     new SALOMEDS_AttributeTreeNode_i(_myAttr->Previous(),_mySObject);
  97   return aTreeNode->_this();
  98 }
  99
 100 void SALOMEDS_AttributeTreeNode_i::SetNext(SALOMEDS::AttributeTreeNode_ptr theValue) {
 101   SALOMEDS::Locker lock;
 102
 103   CheckLocked();
 104   _myAttr->SetNext(GetNode(theValue,_myAttr));
 105 }
 106
 107 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasNext() {
 108   SALOMEDS::Locker lock;
 109
 110   return _myAttr->HasNext();
 111 }
 112
 113 SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetNext() {
 114   SALOMEDS::Locker lock;
 115
 116   SALOMEDS_AttributeTreeNode_i* aTreeNode =
 117     new SALOMEDS_AttributeTreeNode_i(_myAttr->Next(),_mySObject);
 118   return aTreeNode->_this();
 119 }
 120
 121 void SALOMEDS_AttributeTreeNode_i::SetFirst(SALOMEDS::AttributeTreeNode_ptr theValue) {
 122   SALOMEDS::Locker lock;
 123
 124   CheckLocked();
 125   _myAttr->SetFirst(GetNode(theValue,_myAttr));
 126 }
 127
 128 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::HasFirst() {
 129   SALOMEDS::Locker lock;
 130
 131   return _myAttr->HasFirst();
 132 }
 133
 134 SALOMEDS::AttributeTreeNode_ptr SALOMEDS_AttributeTreeNode_i::GetFirst() {
 135   SALOMEDS::Locker lock;
 136
 137   SALOMEDS_AttributeTreeNode_i* aTreeNode =
 138     new SALOMEDS_AttributeTreeNode_i(_myAttr->First(),_mySObject);
 139   return aTreeNode->_this();
 140 }
 141
 142 void SALOMEDS_AttributeTreeNode_i::SetTreeID(const char* value) {
 143   SALOMEDS::Locker lock;
 144
 145   CheckLocked();
 146   _myAttr->SetTreeID(Standard_GUID(_myAttr->ID()));
 147 }
 148
 149 char* SALOMEDS_AttributeTreeNode_i::GetTreeID() {
 150   SALOMEDS::Locker lock;
 151
 152   char aGUID[40];
 153   _myAttr->ID().ToCString(aGUID);
 154   return CORBA::string_dup(aGUID);
 155 }
 156
 157 void SALOMEDS_AttributeTreeNode_i::Append(SALOMEDS::AttributeTreeNode_ptr theValue) {
 158   SALOMEDS::Locker lock;
 159
 160   CheckLocked();
 161   _myAttr->Append(GetNode(theValue,_myAttr));
 162 }
 163
 164 void SALOMEDS_AttributeTreeNode_i::Prepend(SALOMEDS::AttributeTreeNode_ptr theValue) {
 165   SALOMEDS::Locker lock;
 166
 167   CheckLocked();
 168   _myAttr->Prepend(GetNode(theValue,_myAttr));
 169 }
 170
 171 void SALOMEDS_AttributeTreeNode_i::InsertBefore(SALOMEDS::AttributeTreeNode_ptr theValue) {
 172   SALOMEDS::Locker lock;
 173
 174   CheckLocked();
 175   _myAttr->InsertBefore(GetNode(theValue,_myAttr));
 176 }
 177
 178 void SALOMEDS_AttributeTreeNode_i::InsertAfter(SALOMEDS::AttributeTreeNode_ptr theValue) {
 179   SALOMEDS::Locker lock;
 180
 181   CheckLocked();
 182   _myAttr->InsertAfter(GetNode(theValue,_myAttr));
 183 }
 184
 185 void SALOMEDS_AttributeTreeNode_i::Remove() {
 186   SALOMEDS::Locker lock;
 187
 188   CheckLocked();
 189   _myAttr->Remove();
 190 }
 191
 192 CORBA::Long SALOMEDS_AttributeTreeNode_i::Depth() {
 193   SALOMEDS::Locker lock;
 194
 195   return _myAttr->Depth();
 196 }
 197
 198 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsRoot() {
 199   SALOMEDS::Locker lock;
 200
 201   return _myAttr->IsRoot();
 202 }
 203
 204 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsDescendant(SALOMEDS::AttributeTreeNode_ptr theValue) {
 205   SALOMEDS::Locker lock;
 206
 207   return _myAttr->IsDescendant(GetNode(theValue,_myAttr));
 208 }
 209
 210 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsFather(SALOMEDS::AttributeTreeNode_ptr theValue) {
 211   SALOMEDS::Locker lock;
 212
 213   return _myAttr->IsFather(GetNode(theValue,_myAttr));
 214 }
 215
 216 CORBA::Boolean SALOMEDS_AttributeTreeNode_i::IsChild(SALOMEDS::AttributeTreeNode_ptr theValue) {
 217   SALOMEDS::Locker lock;
 218
 219   return _myAttr->IsChild(GetNode(theValue,_myAttr));
 220 }
 221
 222 char* SALOMEDS_AttributeTreeNode_i::Label() {
 223   TCollection_AsciiString aLabelName;
 224   TDF_Tool::Entry(_myAttr->Label(),aLabelName);
 225   return CORBA::string_dup(aLabelName.ToCString());
 226 }
 227
 228 char* SALOMEDS_AttributeTreeNode_i::Store() {
 229   SALOMEDS::Locker lock;
 230
 231   char* aStr[4];
 232
 233   if (HasFather()) aStr[0] = GetFather()->Label(); else aStr[0] = "!";
 234   if (HasPrevious()) aStr[1] = GetPrevious()->Label(); else aStr[1] = "!";
 235   if (HasNext()) aStr[2] = GetNext()->Label(); else aStr[2] = "!";
 236   if (HasFirst()) aStr[3] = GetFirst()->Label(); else aStr[3] = "!";
 237
 238   int aLength = 4;
 239   aLength += strlen(aStr[0]) + strlen(aStr[1]) + strlen(aStr[2]) + strlen(aStr[3]);
 240   CORBA::String_var aResult = new char[aLength];
 241   sprintf(aResult, "%s %s %s %s", aStr[0], aStr[1], aStr[2], aStr[3]);
 242   return aResult._retn();
 243 }
 244
 245 void SALOMEDS_AttributeTreeNode_i::Restore(const char* value) {
 246   SALOMEDS::Locker lock;
 247
 248   Handle(TDataStd_TreeNode) aNode = Handle(TDataStd_TreeNode)::DownCast(_myAttr);
 249   Handle(TDF_Data) DF = TDocStd_Document::Get(_myAttr->Label())->GetData();
 250
 251   char* aCopy = strdup(value);
 252   char* adr = strtok(aCopy, " ");
 253
 254   TDF_Label aLabel;
 255   Handle(TDataStd_TreeNode) aDepNode;
 256
 257   if (adr && adr[0] != '!') {
 258     TDF_Tool::Label(DF, adr, aLabel, 1);
 259     if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID());
 260     aNode->SetFather(aDepNode);
 261   }
 262
 263   adr = strtok(NULL, " ");
 264   if (adr && adr[0] != '!') {
 265     TDF_Tool::Label(DF, adr, aLabel, 1);
 266     if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID());
 267     aNode->SetPrevious(aDepNode);
 268   }
 269
 270   adr = strtok(NULL, " ");
 271   if (adr && adr[0] != '!') {
 272     TDF_Tool::Label(DF, adr, aLabel, 1);
 273     if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID());
 274     aNode->SetNext(aDepNode);
 275   }
 276
 277   adr = strtok(NULL, " ");
 278   if (adr && adr[0] != '!') {
 279     TDF_Tool::Label(DF, adr, aLabel, 1);
 280     if (!aLabel.FindAttribute(aNode->ID(), aDepNode)) aDepNode = TDataStd_TreeNode::Set(aLabel, aNode->ID());
 281     aNode->SetFirst(aDepNode);
 282   }
 283 }