src/HEXABLOCKGUI/HEXABLOCKGUI_DocumentItem.cxx

   1 // Copyright (C) 2009-2013  CEA/DEN, EDF R&D
   2 //
   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.
   7 //
   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.
  12 //
  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
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "HEXABLOCKGUI_SalomeTools.hxx"
  21 #include "HEXABLOCKGUI_DocumentItem.hxx"
  22 #include "HexShape.hxx"
  23
  24 #include "HEXABLOCKGUI_DocumentModel.hxx"
  25 #include "HexAssoEdge.hxx"
  26
  27 #include <inttypes.h>
  28
  29
  30 using namespace std;
  31 using namespace HEXABLOCK::GUI;
  32
  33 // ElementItem --------------------------------------------------
  34 ElementItem::ElementItem( HEXA_NS::EltBase* docElement, QString entry, HexaType ttype, HexaTreeRole treeRole):
  35 QStandardItem()
  36 {
  37         m_DocElt = docElement;
  38         m_type   = ttype;
  39
  40         if (m_DocElt != NULL)
  41         {
  42                 setText(m_DocElt->getName());
  43                 if ( m_DocElt->isAssociated() )
  44                     setData(Qt::darkGreen, Qt::ForegroundRole);
  45         }
  46         setData( treeRole,    HEXA_TREE_ROLE );
  47         setData( entry,       HEXA_DOC_ENTRY_ROLE);
  48         setData( IDptr(),     HEXA_ENTRY_ROLE );
  49
  50         //Init assocs entry
  51         if (m_DocElt!=NULL && m_DocElt->isAssociated())
  52         {
  53                 QString entry;
  54                 if (m_type == VERTEXITEM) //Vertex
  55                 {
  56                     HEXA_NS::Vertex* vertex = (HEXA_NS::Vertex*) m_DocElt;
  57                     HEXA_NS::VertexShape* assoc = vertex->getAssociation();
  58                     if (assoc != NULL)
  59                     {
  60                         HEXA_NS::NewShape* mainSh = assoc->getParentShape();
  61                         if (mainSh != NULL)
  62                         {
  63                             entry = QString(mainSh->getName())+","+QString::number(assoc->getIdent())+";";
  64                             setData( entry, HEXA_ASSOC_ENTRY_ROLE );
  65                         }
  66                     }
  67                 }
  68                 else if (m_type == EDGEITEM)
  69                 {
  70                         QString entries;
  71                         HEXA_NS::Edge* edge = (HEXA_NS::Edge*) m_DocElt;
  72                         HEXA_NS::NewShape* mainShape;
  73                         HEXA_NS::EdgeShape* geomEdge;
  74                         HEXA_NS::AssoEdge* anEdgeAssoc;
  75                         int nbAssocs = edge->countAssociation();
  76                         for (int i = 0; i < nbAssocs; ++i)
  77                         {
  78                             anEdgeAssoc = edge->getAssociation(i);
  79                             if (anEdgeAssoc == NULL) continue;
  80                             geomEdge = anEdgeAssoc->getEdgeShape();
  81                             if (geomEdge == NULL) continue;
  82                             mainShape = geomEdge->getParentShape();
  83                             if (mainShape == NULL) continue;
  84                             entries += QString(mainShape->getName())+","+QString::number(geomEdge->getIdent())+";";
  85                         }
  86                         if ( !entries.isEmpty() )
  87                                 setData( entries, HEXA_ASSOC_ENTRY_ROLE );
  88                 }
  89                 else if (m_type == QUADITEM)
  90                 {
  91                         QString entries;
  92                         HEXA_NS::Quad* quad = (HEXA_NS::Quad*) m_DocElt;
  93                         HEXA_NS::NewShape* mainShape;
  94                         HEXA_NS::FaceShape* geomFace;
  95                         int nbAssocs = quad->countAssociation();
  96                         for (int i = 0; i < nbAssocs; ++i)
  97                         {
  98                             geomFace = quad->getAssociation(i);
  99                             if (geomFace == NULL) continue;
 100                             mainShape = geomFace->getParentShape();
 101                             if (mainShape == NULL) continue;
 102                             entries += QString(mainShape->getName()) + "," + QString::number(geomFace->getIdent()) + ";";
 103                         }
 104                         if ( !entries.isEmpty() )
 105                                 setData( entries, HEXA_ASSOC_ENTRY_ROLE );
 106                 }
 107         }
 108 }
 109
 110 //---------------------------------------------------------------
 111 QVariant ElementItem::data( int role ) const
 112 {
 113     if ( role == HEXA_DATA_ROLE ){
 114         switch(m_type)
 115         {
 116         case VERTEXITEM: return QVariant::fromValue( (HEXA_NS::Vertex*)m_DocElt );
 117         case EDGEITEM: return QVariant::fromValue( (HEXA_NS::Edge*)m_DocElt );
 118         case QUADITEM: return QVariant::fromValue( (HEXA_NS::Quad*)m_DocElt );
 119         case HEXAITEM: return QVariant::fromValue( (HEXA_NS::Hexa*)m_DocElt );
 120         case VECTORITEM: return QVariant::fromValue( (HEXA_NS::Vector*)m_DocElt );
 121         case CYLINDERITEM: return QVariant::fromValue( (HEXA_NS::Cylinder*)m_DocElt );
 122         case PIPEITEM: return QVariant::fromValue( (HEXA_NS::Pipe*)m_DocElt );
 123         case ELEMENTSITEM: return QVariant::fromValue( (HEXA_NS::Elements*)m_DocElt );
 124         case CROSSELEMENTSITEM: return QVariant::fromValue( (HEXA_NS::CrossElements*)m_DocElt );
 125         case GEOMSHAPEITEM: return QVariant::fromValue( (HEXA_NS::NewShape*) m_DocElt );
 126         case GEOMPOINTITEM: return QVariant::fromValue( (HEXA_NS::VertexShape*) m_DocElt );
 127         case GEOMEDGEITEM:  return QVariant::fromValue( (HEXA_NS::EdgeShape*) m_DocElt );
 128         case GEOMFACEITEM:  return QVariant::fromValue( (HEXA_NS::FaceShape*) m_DocElt );
 129         default: return QVariant::fromValue( m_DocElt );
 130         }
 131     }
 132
 133     if (role == Qt::ForegroundRole && m_DocElt != NULL && !m_DocElt->isAssociated())
 134         return QColor(Qt::black);
 135
 136     return QStandardItem::data( role );
 137 }
 138
 139 //---------------------------------------------------------------
 140 void ElementItem::setData ( const QVariant& valcont, int role )
 141 {
 142         if ( role == HEXA_DATA_ROLE ){
 143                 m_DocElt = valcont.value<HEXA_NS::EltBase*>();
 144                 emitDataChanged ();
 145
 146         } else {
 147                 QStandardItem::setData ( valcont, role );
 148         }
 149 }
 150 //---------------------------------------------------------------
 151 int ElementItem::type () const {return m_type;}
 152 //---------------------------------------------------------------
 153 bool ElementItem::isAssoc () const {return m_DocElt->isAssociated();}
 154 //---------------------------------------------------------------
 155 QString ElementItem::IDptr() const {  return QString::number( reinterpret_cast<intptr_t>(m_DocElt) ); }
 156
 157
 158 // ----------------------- VERTEX (DATA)
 159 VertexItem::VertexItem( HEXA_NS::Vertex* hexaVertex, QString entry):
 160                 GraphicElementItem(hexaVertex, entry, VERTEXITEM, VERTEX_TREE)
 161 {
 162 }
 163
 164 // ----------------------- EDGE   (DATA)
 165 EdgeItem::EdgeItem( HEXA_NS::Edge* hexaEdge, QString entry ):
 166                 GraphicElementItem(hexaEdge, entry, EDGEITEM, EDGE_TREE)
 167 {
 168 }
 169
 170 // ----------------------- QUAD   (DATA)
 171 QuadItem::QuadItem( HEXA_NS::Quad* hexaQuad, QString entry):
 172                 GraphicElementItem(hexaQuad, entry, QUADITEM, QUAD_TREE)
 173 {
 174 }
 175
 176 // ----------------------- HEXA   (DATA)
 177 HexaItem::HexaItem( HEXA_NS::Hexa* hexaHexa , QString entry):
 178                 GraphicElementItem(hexaHexa,entry, HEXAITEM, HEXA_TREE)
 179 {
 180 }
 181
 182 // ----------------------- VECTOR   (BUILDER)
 183 VectorItem::VectorItem( HEXA_NS::Vector* hexaVector, QString entry ):
 184                 StandardElementItem(hexaVector, entry, VECTORITEM, VECTOR_TREE)
 185 {
 186 }
 187
 188 // ----------------------- CYLINDER (BUILDER)
 189 CylinderItem::CylinderItem( HEXA_NS::Cylinder* hexaCylinder, QString entry):
 190                 StandardElementItem(hexaCylinder, entry, CYLINDERITEM, CYLINDER_TREE)
 191 {
 192 }
 193
 194 // ----------------------- PIPE     (BUILDER)
 195 PipeItem::PipeItem( HEXA_NS::Pipe* hexaPipe, QString entry ):
 196                 StandardElementItem(hexaPipe, entry, PIPEITEM, PIPE_TREE)
 197 {
 198 }
 199
 200 // ----------------------- ELEMENTS      (NOT USED)
 201 ElementsItem::ElementsItem( HEXA_NS::Elements* hexaElements, QString entry ):
 202                 StandardElementItem(hexaElements, entry, ELEMENTSITEM, ELEMENTS_TREE)
 203 {
 204 }
 205
 206 // ----------------------- CROSSELEMENTS (NOT USED)
 207 CrossElementsItem::CrossElementsItem( HEXA_NS::CrossElements* hexaCrossElts, QString entry ):
 208                 StandardElementItem(hexaCrossElts, entry, CROSSELEMENTSITEM, CROSSELEMENTS_TREE)
 209 {
 210 }
 211
 212 // ----------------------- GEOM     (GEOMETRY)
 213 GeomItem::GeomItem( HEXA_NS::EltBase* geomShape, QString entry, HexaType ttype, HexaTreeRole treeRole, HEXA_NS::EltBase* assoc ):
 214         StandardElementItem(geomShape, entry, ttype, treeRole),
 215         association(assoc)
 216 {
 217 }
 218
 219 // ----------------------- GEOM SHAPE     (GEOMETRY)
 220 GeomShapeItem::GeomShapeItem( HEXA_NS::NewShape* shape, HEXA_NS::EltBase* assoc ):
 221         GeomItem(shape, QString(), GEOMSHAPEITEM, GEOMSHAPE_TREE, assoc)
 222 {
 223 }
 224
 225 // ----------------------- GEOM POINT     (GEOMETRY)
 226 GeomPointItem::GeomPointItem( HEXA_NS::VertexShape* geomPoint, HEXA_NS::Vertex* associatedVertex ):
 227         GeomItem(geomPoint, QString(), GEOMPOINTITEM, GEOMPOINT_TREE, associatedVertex)
 228 {
 229 }
 230
 231 // ----------------------- GEOM EDGE     (GEOMETRY)
 232 GeomEdgeItem::GeomEdgeItem( HEXA_NS::EdgeShape* geomEdge, HEXA_NS::Edge* associatedEdge ):
 233         GeomItem(geomEdge, QString(), GEOMEDGEITEM, GEOMEDGE_TREE, associatedEdge)
 234 {
 235 }
 236
 237 // ----------------------- GEOM FACE     (GEOMETRY)
 238 GeomFaceItem::GeomFaceItem( HEXA_NS::FaceShape* geomFace, HEXA_NS::Quad* associatedQuad ):
 239         GeomItem(geomFace, QString(), GEOMFACEITEM, GEOMFACE_TREE, associatedQuad)
 240 {
 241 }
 242
 243 // ----------------------- GROUP
 244 GroupItem::GroupItem( HEXA_NS::Group* hexaGroup ):
 245   QStandardItem(),
 246   _hexaGroup( hexaGroup )
 247 {
 248 //   char pName[12];
 249   QString name = _hexaGroup->getName();//pName);
 250   setText(name);
 251   setData( GROUP_TREE, HEXA_TREE_ROLE );
 252   setData( QString::number(reinterpret_cast<intptr_t>(_hexaGroup)), HEXA_ENTRY_ROLE );
 253 }
 254
 255 int GroupItem::type() const
 256 {
 257   return GROUPITEM;
 258 }
 259
 260 QVariant GroupItem::data( int role ) const
 261 {
 262     if ( role == HEXA_DATA_ROLE ){
 263       return QVariant::fromValue( _hexaGroup );
 264     } else {
 265       return QStandardItem::data( role );
 266     }
 267 }
 268
 269 void GroupItem::setData ( const QVariant& value, int role )
 270 {
 271     if ( role == HEXA_DATA_ROLE ){
 272       _hexaGroup = value.value<HEXA_NS::Group*>();
 273       emitDataChanged ();
 274     } else {
 275       QStandardItem::setData ( value, role );
 276     }
 277 }
 278
 279
 280
 281 // ----------------------- LAW
 282 LawItem::LawItem( HEXA_NS::Law* hexaLaw ):
 283   QStandardItem(),
 284   _hexaLaw( hexaLaw )
 285 {
 286 //   char pName[12];
 287   QString name = _hexaLaw->getName();//pName);
 288   setText(name);
 289   setData( LAW_TREE, HEXA_TREE_ROLE );
 290   setData( QString::number(reinterpret_cast<intptr_t>(_hexaLaw)), HEXA_ENTRY_ROLE );
 291 }
 292
 293 int LawItem::type() const
 294 {
 295   return LAWITEM;
 296 }
 297
 298 QVariant LawItem::data( int role ) const
 299 {
 300     if ( role == HEXA_DATA_ROLE ){
 301       return QVariant::fromValue( _hexaLaw);
 302     } else {
 303       return QStandardItem::data( role );
 304     }
 305 }
 306
 307 void LawItem::setData ( const QVariant & value, int role )
 308 {
 309     if ( role == HEXA_DATA_ROLE ){
 310       _hexaLaw = value.value<HEXA_NS::Law*>();
 311       emitDataChanged ();
 312     } else {
 313       QStandardItem::setData ( value, role );
 314     }
 315 }
 316
 317
 318
 319 // ----------------------- PROPAGATIONITEM
 320 PropagationItem::PropagationItem( HEXA_NS::Propagation* hexaPropagation ):
 321   QStandardItem(),
 322   _hexaPropagation( hexaPropagation )
 323 {
 324   QString name = "Propagation";
 325   setText(name);
 326   setData( PROPAGATION_TREE, HEXA_TREE_ROLE );
 327   setData( QString::number(reinterpret_cast<intptr_t>(_hexaPropagation)), HEXA_ENTRY_ROLE );
 328 }
 329
 330 int PropagationItem::type() const
 331 {
 332   return PROPAGATIONITEM;
 333 }
 334
 335 QVariant PropagationItem::data( int role ) const
 336 {
 337     if ( role == HEXA_DATA_ROLE ){
 338       return QVariant::fromValue( _hexaPropagation );
 339     } else {
 340       return QStandardItem::data( role );
 341     }
 342 }
 343
 344 void PropagationItem::setData ( const QVariant & value, int role )
 345 {
 346     if ( role == HEXA_DATA_ROLE ){
 347       _hexaPropagation = value.value<HEXA_NS::Propagation*>();
 348       emitDataChanged ();
 349     } else {
 350       QStandardItem::setData ( value, role );
 351     }
 352 }
 353 //-------------------------------------------------
 354
 355