1 // Copyright (C) 2014-2020 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #include "Model_AttributeTables.h"
22 #include <ModelAPI_Data.h>
23 #include <ModelAPI_Object.h>
25 #include <TColStd_ListIteratorOfListOfInteger.hxx>
26 #include <TDataStd_RealArray.hxx>
27 #include <TDataStd_BooleanArray.hxx>
28 #include <TDataStd_IntegerArray.hxx>
29 #include <TDataStd_ExtStringArray.hxx>
31 #include <TColStd_HArray1OfReal.hxx>
32 #include <TColStd_HArray1OfByte.hxx>
33 #include <TColStd_HArray1OfInteger.hxx>
34 #include <TColStd_HArray1OfExtendedString.hxx>
38 // returns the array attribute GUID for the given type
39 #define MY_ARRAY_ID(type) \
40 ((type) == ModelAPI_AttributeTables::DOUBLE ? TDataStd_RealArray::GetID(): \
41 ((type) == ModelAPI_AttributeTables::BOOLEAN ? TDataStd_BooleanArray::GetID(): \
42 ((type) == ModelAPI_AttributeTables::INTEGER? TDataStd_IntegerArray::GetID(): \
43 TDataStd_ExtStringArray::GetID())))
45 int Model_AttributeTables::rows()
50 int Model_AttributeTables::columns()
55 int Model_AttributeTables::tables()
60 void Model_AttributeTables::setSize(const int theRows, const int theColumns, const int theTables)
62 if (theRows != myRows || theColumns != myCols || theTables != myTables) {
63 owner()->data()->sendAttributeUpdated(this);
64 int aSize = myRows * myCols * myTables;
65 int aNewSize = theRows * theColumns * theTables;
66 if (aSize == 0 && aNewSize == 0) {
68 } else if (aNewSize == 0) {
70 myLab.ForgetAttribute(MY_ARRAY_ID(myType));
73 Handle(TColStd_HArray1OfReal) anOldDouble, aNewDouble =
74 (myType == ModelAPI_AttributeTables::DOUBLE) ?
75 new TColStd_HArray1OfReal(0, aNewSize - 1) : Handle(TColStd_HArray1OfReal)();
76 bool* anOldBool = 0; // an not work with internal arrays because of different indexing
77 Handle(TDataStd_BooleanArray) aBoolArray; // an existing array
78 Handle(TColStd_HArray1OfInteger) anOldInt, aNewInt =
79 (myType == ModelAPI_AttributeTables::INTEGER) ?
80 new TColStd_HArray1OfInteger(0, aNewSize - 1) : Handle(TColStd_HArray1OfInteger)();
81 Handle(TColStd_HArray1OfExtendedString) anOldStr, aNewStr =
82 (myType == ModelAPI_AttributeTables::STRING) ?
83 new TColStd_HArray1OfExtendedString(0, aNewSize - 1) :
84 Handle(TColStd_HArray1OfExtendedString)();
85 if (aSize != 0) { // copy the previous values into new positions, otherwise default values
86 Handle(TDF_Attribute) anArray;
87 myLab.FindAttribute(MY_ARRAY_ID(myType), anArray);
89 case ModelAPI_AttributeTables::DOUBLE:
90 anOldDouble = Handle(TDataStd_RealArray)::DownCast(anArray)->Array();
92 case ModelAPI_AttributeTables::BOOLEAN: {
93 anOldBool = new bool[aSize];
94 aBoolArray = Handle(TDataStd_BooleanArray)::DownCast(anArray);
95 for(int a = 0; a < aSize; a++)
96 anOldBool[a] = aBoolArray->Value(a);
97 aBoolArray->Init(0, aNewSize - 1);
100 case ModelAPI_AttributeTables::INTEGER:
101 anOldInt = Handle(TDataStd_IntegerArray)::DownCast(anArray)->Array();
103 case ModelAPI_AttributeTables::STRING:
104 anOldStr = Handle(TDataStd_ExtStringArray)::DownCast(anArray)->Array();
107 } else if (myType == ModelAPI_AttributeTables::BOOLEAN) {
108 aBoolArray = TDataStd_BooleanArray::Set(myLab, 0, aNewSize - 1);
110 for(int aTable = 0; aTable < theTables; aTable++) {
111 for(int aColumn = 0; aColumn < theColumns; aColumn++) {
112 for(int aRow = 0; aRow < theRows; aRow++) {
114 int anIndex = aTable * theRows * theColumns + aRow * theColumns + aColumn;
115 bool aRestore = aTable < myTables && aColumn < myCols && aRow < myRows;
117 anOldIndex = aTable * myRows * myCols + aRow * myCols + aColumn;
119 case ModelAPI_AttributeTables::DOUBLE: {
120 aNewDouble->SetValue(anIndex, aRestore ? anOldDouble->Value(anOldIndex) : 0.);
123 case ModelAPI_AttributeTables::BOOLEAN: {
124 aBoolArray->SetValue(anIndex, aRestore ? anOldBool[anOldIndex] : Standard_False);
127 case ModelAPI_AttributeTables::INTEGER: {
128 aNewInt->SetValue(anIndex, aRestore ? anOldInt->Value(anOldIndex) : 0);
131 case ModelAPI_AttributeTables::STRING: {
132 aNewStr->SetValue(anIndex, aRestore ? anOldStr->Value(anOldIndex) : "");
139 // store the new array
141 case ModelAPI_AttributeTables::DOUBLE:
142 TDataStd_RealArray::Set(myLab, 0, aNewSize - 1)->ChangeArray(aNewDouble);
144 case ModelAPI_AttributeTables::BOOLEAN: // nothing to do: array was set in "else" of restore
146 case ModelAPI_AttributeTables::INTEGER:
147 TDataStd_IntegerArray::Set(myLab, 0, aNewSize - 1)->ChangeArray(aNewInt);
149 case ModelAPI_AttributeTables::STRING:
150 TDataStd_ExtStringArray::Set(myLab, 0, aNewSize - 1)->ChangeArray(aNewStr);
154 // store the new sizes
157 myTables = theTables;
159 myProp->Append(int(myType)); // default
160 myProp->Append(myTables);
161 myProp->Append(myRows);
162 myProp->Append(myCols);
163 owner()->data()->sendAttributeUpdated(this);
167 void Model_AttributeTables::setType(ModelAPI_AttributeTables::ValueType theType)
169 if (myType != theType) {
170 // remove the old attr
171 int aSize = myRows * myCols * myTables;
173 myLab.ForgetAttribute(MY_ARRAY_ID(myType));
175 int aTables = myTables;
176 myTables = 0; // to let setSize know that there is no old array
177 setSize(myRows, myCols, aTables);
180 owner()->data()->sendAttributeUpdated(this);
185 const ModelAPI_AttributeTables::ValueType& Model_AttributeTables::type() const
190 void Model_AttributeTables::setValue(const ModelAPI_AttributeTables::Value theValue,
191 const int theRow, const int theColumn, const int theTable)
193 int anIndex = theTable * myRows * myCols + theRow * myCols + theColumn;
194 Handle(TDF_Attribute) anArray;
195 myLab.FindAttribute(MY_ARRAY_ID(myType), anArray);
197 case ModelAPI_AttributeTables::DOUBLE: {
198 Handle(TDataStd_RealArray)::DownCast(anArray)->SetValue(anIndex, theValue.myDouble);
201 case ModelAPI_AttributeTables::BOOLEAN: {
202 Handle(TDataStd_BooleanArray)::DownCast(anArray)->SetValue(anIndex, theValue.myBool);
205 case ModelAPI_AttributeTables::INTEGER: {
206 Handle(TDataStd_IntegerArray)::DownCast(anArray)->SetValue(anIndex, theValue.myInt);
209 case ModelAPI_AttributeTables::STRING: {
210 Handle(TDataStd_ExtStringArray)::DownCast(anArray)->SetValue(anIndex, theValue.myStr.c_str());
214 owner()->data()->sendAttributeUpdated(this);
217 ModelAPI_AttributeTables::Value Model_AttributeTables::value(
218 const int theRow, const int theColumn, const int theTable)
220 ModelAPI_AttributeTables::Value aResult;
221 int anIndex = theTable * myRows * myCols + theRow * myCols + theColumn;
222 Handle(TDF_Attribute) anArray;
223 myLab.FindAttribute(MY_ARRAY_ID(myType), anArray);
225 case ModelAPI_AttributeTables::DOUBLE: {
226 aResult.myDouble = Handle(TDataStd_RealArray)::DownCast(anArray)->Value(anIndex);
229 case ModelAPI_AttributeTables::BOOLEAN: {
230 aResult.myBool = Handle(TDataStd_BooleanArray)::DownCast(anArray)->Value(anIndex) ==
234 case ModelAPI_AttributeTables::INTEGER: {
235 aResult.myInt = Handle(TDataStd_IntegerArray)::DownCast(anArray)->Value(anIndex);
238 case ModelAPI_AttributeTables::STRING: {
239 aResult.myStr = TCollection_AsciiString(Handle(TDataStd_ExtStringArray)::DownCast(anArray)->
240 Value(anIndex)).ToCString();
247 std::string Model_AttributeTables::valueStr(
248 const int theRow, const int theColumn, const int theTable)
250 std::ostringstream aStr;
252 case ModelAPI_AttributeTables::DOUBLE:
253 aStr<<value(theRow, theColumn, theTable).myDouble;
255 case ModelAPI_AttributeTables::BOOLEAN:
256 aStr<<(value(theRow, theColumn, theTable).myBool ? "True" :"False");
258 case ModelAPI_AttributeTables::INTEGER:
259 aStr<<value(theRow, theColumn, theTable).myInt;
261 case ModelAPI_AttributeTables::STRING:
262 aStr<<value(theRow, theColumn, theTable).myStr;
268 //==================================================================================================
269 Model_AttributeTables::Model_AttributeTables(TDF_Label& theLabel)
275 void Model_AttributeTables::reinit()
277 // check the attribute could be already presented in this doc (after load document)
279 myLab.FindAttribute(TDataStd_IntegerList::GetID(), myProp) == Standard_True;
280 if (!myIsInitialized) {
281 myProp = TDataStd_IntegerList::Set(myLab);
282 myProp->Append(int(Model_AttributeTables::DOUBLE)); // default
287 TColStd_ListIteratorOfListOfInteger aListIter(myProp->List());
288 myType = ModelAPI_AttributeTables::ValueType(aListIter.Value());
290 myTables = aListIter.Value();
292 myRows = aListIter.Value();
294 myCols = aListIter.Value();