src/HEXABLOCKGUI/HEXABLOCKGUI_DocumentModel.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 //CS_TODO: relever les fonctions qui nécessitent updateData().
  21 //        addGroupElement à tester
  22 #include <algorithm>
  23 #include <string>
  24
  25 #include "utilities.h"
  26
  27 #include "HEXABLOCKGUI_DocumentModel.hxx"
  28 #include "HEXABLOCKGUI_DocumentItem.hxx"
  29
  30 #include "HEXABLOCKGUI.hxx"
  31 #include "HEXABLOCKGUI_Trace.hxx"
  32
  33 #include "HexVertex.hxx"
  34 #include "HexShape.hxx"
  35 #include "HexSubShape.hxx"
  36 #include "HexAssoEdge.hxx"
  37 #include "HexBiCylinder.hxx"
  38
  39 #include <TopoDS.hxx>
  40 #include <BRepBuilderAPI_MakeVertex.hxx>
  41
  42 #include <GEOMBase.h>
  43 #include "HEXABLOCKGUI_SalomeTools.hxx"
  44
  45 #include "GEOM_GEOMBase.hxx"
  46
  47 #include <SALOME_ListIO.hxx>
  48 #include <SALOMEconfig.h>
  49 #include <SUIT_ViewWindow.h>
  50
  51 #include <qglobal.h>
  52
  53 #include "HEXABLOCKGUI_VtkDocumentGraphicView.hxx"
  54
  55
  56 //#define _DEVDEBUG_
  57
  58
  59 using namespace std;
  60 //using namespace HEXA_NS;
  61 using namespace HEXABLOCK::GUI;
  62
  63 /*****************************************************************
  64                       DocumentModel
  65  *****************************************************************/
  66 // DocumentModel::DocumentModel(QObject * parent):
  67 DocumentModel::DocumentModel(HEXA_NS::Document* docIn, const QString& entryIn, QObject * parent):
  68                               QStandardItemModel(parent),
  69                               _hexaFile( new QTemporaryFile() ),
  70                               _hexaDocument( docIn ),
  71                               _entry( entryIn ),
  72                               //   _hexaDocument(  new HEXA_NS::Document("/tmp/doc.hex") ), //CS_TODO
  73
  74                               _vertexDirItem( new QStandardItem(tr("TREE_ITEM_VERTEX")) ),
  75                               _edgeDirItem( new QStandardItem(tr("TREE_ITEM_EDGE")) ),
  76                               _quadDirItem( new QStandardItem(tr("TREE_ITEM_QUAD")) ),
  77                               _hexaDirItem( new QStandardItem(tr("TREE_ITEM_HEXA")) ),
  78
  79                               _vectorDirItem( new QStandardItem(tr("TREE_ITEM_VECTOR")) ),
  80                               _cylinderDirItem( new QStandardItem(tr("TREE_ITEM_CYLINDER")) ),
  81                               _pipeDirItem( new QStandardItem(tr("TREE_ITEM_PIPE")) ),
  82                               _elementsDirItem( new QStandardItem(tr("TREE_ITEM_ELEMENT")) ),
  83                               _crossElementsDirItem( new QStandardItem(tr("TREE_ITEM_CROSSELEMENT")) ),
  84
  85                               _explicitShapesDirItem( new QStandardItem(tr("TREE_ITEM_EXPSHAPE")) ),
  86                               _implicitShapesDirItem( new QStandardItem(tr("TREE_ITEM_IMPSHAPE")) ),
  87                               _cloudOfPointsDirItem( new QStandardItem(tr("TREE_ITEM_CLOUD_OF_POINT")) ),
  88
  89                               _groupDirItem( new QStandardItem(tr("TREE_ITEM_GROUP")) ),
  90
  91                               _lawDirItem( new QStandardItem(tr("TREE_ITEM_LAW")) ),
  92                               _propagationDirItem( new QStandardItem(tr("TREE_ITEM_PROPAGATION")) ),
  93
  94                               _vertexItemFlags( Qt::NoItemFlags ),
  95                               _edgeItemFlags( Qt::NoItemFlags ),
  96                               _quadItemFlags( Qt::NoItemFlags ),
  97                               _hexaItemFlags( Qt::NoItemFlags ),
  98                               _vectorItemFlags( Qt::NoItemFlags ),
  99                               _cylinderItemFlags( Qt::NoItemFlags ),
 100                               _pipeItemFlags( Qt::NoItemFlags ),
 101                               _elementsItemFlags( Qt::NoItemFlags ),
 102                               _crossElementsItemFlags( Qt::NoItemFlags ),
 103
 104                               _disallowEdition( false )
 105 {
 106     //   setColumnCount( 4 ); //CS_TEST
 107     if ( !_hexaDocument && _hexaFile->open() ){
 108         _hexaDocument =  new HEXA_NS::Document( _hexaFile->fileName().toLatin1() );
 109         _hexaDocument->reorderFaces();
 110     }
 111
 112     QStandardItem *parentItem = invisibleRootItem();
 113     //   parentItem->setData( QString::number( reinterpret_cast<intptr_t>(_hexaDocument) ), HEXA_ENTRY_ROLE );
 114     parentItem->setData( _entry, HEXA_ENTRY_ROLE );
 115
 116     _vertexDirItem->setData( VERTEX_DIR_TREE,           HEXA_TREE_ROLE );
 117     _edgeDirItem->setData( EDGE_DIR_TREE,               HEXA_TREE_ROLE );
 118     _quadDirItem->setData( QUAD_DIR_TREE,               HEXA_TREE_ROLE );
 119     _hexaDirItem->setData( HEXA_DIR_TREE,               HEXA_TREE_ROLE );
 120
 121     _vectorDirItem->setData( VECTOR_DIR_TREE,           HEXA_TREE_ROLE );
 122     _cylinderDirItem->setData( CYLINDER_DIR_TREE,       HEXA_TREE_ROLE );
 123     _pipeDirItem->setData( PIPE_DIR_TREE,                   HEXA_TREE_ROLE );
 124     _elementsDirItem->setData( ELEMENTS_DIR_TREE,           HEXA_TREE_ROLE );
 125     _crossElementsDirItem->setData( CROSSELEMENTS_DIR_TREE, HEXA_TREE_ROLE );
 126
 127     _explicitShapesDirItem->setData( EXPLICIT_SHAPES_DIR_TREE, HEXA_TREE_ROLE );
 128     _implicitShapesDirItem->setData( IMPLICIT_SHAPES_DIR_TREE, HEXA_TREE_ROLE );
 129     _cloudOfPointsDirItem->setData( CLOUD_OF_POINTS_DIR_TREE, HEXA_TREE_ROLE );
 130
 131     _groupDirItem->setData( GROUP_DIR_TREE, HEXA_TREE_ROLE );
 132
 133     //CS_TODO associations
 134
 135     _lawDirItem->setData( LAW_DIR_TREE, HEXA_TREE_ROLE );
 136     _propagationDirItem->setData( PROPAGATION_DIR_TREE, HEXA_TREE_ROLE );
 137
 138     parentItem->appendRow(_vertexDirItem);
 139     parentItem->appendRow(_edgeDirItem);
 140     parentItem->appendRow(_quadDirItem);
 141     parentItem->appendRow(_hexaDirItem);
 142
 143     parentItem->appendRow(_vectorDirItem);
 144     parentItem->appendRow(_cylinderDirItem);
 145     parentItem->appendRow(_pipeDirItem);
 146     parentItem->appendRow(_elementsDirItem);
 147     parentItem->appendRow(_crossElementsDirItem);
 148
 149     parentItem->appendRow(_explicitShapesDirItem);
 150     parentItem->appendRow(_implicitShapesDirItem);
 151
 152     parentItem->appendRow(_groupDirItem);
 153     parentItem->appendRow(_lawDirItem);
 154     parentItem->appendRow(_propagationDirItem);
 155 }
 156
 157 DocumentModel::~DocumentModel()
 158 {
 159     if (_hexaDocument != NULL)
 160         delete _hexaDocument;
 161
 162     if (_hexaFile != NULL)
 163         delete _hexaFile;
 164 }
 165
 166 void DocumentModel::setName(const QString& name)
 167 {
 168     _hexaDocument->setName( name.toLocal8Bit().constData() );
 169     emit nameChanged(QString(_hexaDocument->getName()));
 170 }
 171
 172 HEXA_NS::EltBase* DocumentModel::getHexaPtr(const QModelIndex& iElt)
 173 {
 174     HEXA_NS::EltBase *elt = NULL;
 175     switch ( /*data(iElt, HEXA_TREE_ROLE).toInt()*/iElt.data(HEXA_TREE_ROLE).toInt() ){
 176     case VERTEX_TREE : elt = getHexaPtr<HEXA_NS::Vertex*>(iElt); break;
 177     case EDGE_TREE : elt = getHexaPtr<HEXA_NS::Edge*>(iElt); break;
 178     case QUAD_TREE : elt = getHexaPtr<HEXA_NS::Quad*>(iElt); break;
 179     case HEXA_TREE : elt = getHexaPtr<HEXA_NS::Hexa*>(iElt); break;
 180     case VECTOR_TREE : elt = getHexaPtr<HEXA_NS::Vector*>(iElt); break;
 181     case CYLINDER_TREE : elt = getHexaPtr<HEXA_NS::Cylinder*>(iElt); break;
 182     case PIPE_TREE : elt = getHexaPtr<HEXA_NS::Pipe*>(iElt); break;
 183     case ELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::Elements*>(iElt); break;
 184     case CROSSELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::CrossElements*>(iElt); break;
 185     case GEOMSHAPE_TREE: elt = getHexaPtr<HEXA_NS::NewShape*>(iElt); break;
 186     case GEOMPOINT_TREE: elt = getHexaPtr<HEXA_NS::VertexShape*>(iElt); break;
 187     case GEOMEDGE_TREE:  elt = getHexaPtr<HEXA_NS::EdgeShape*>(iElt); break;
 188     case GEOMFACE_TREE:  elt = getHexaPtr<HEXA_NS::FaceShape*>(iElt); break;
 189     }
 190     return elt;
 191 }
 192
 193 //get the number of elements of type 'eltType' in the document
 194 int DocumentModel::getNbrElt(HEXA_NS::EnumElt eltType)
 195 {
 196     if (_hexaDocument == NULL) return 0;
 197
 198    return _hexaDocument->getNbrElt(eltType);
 199 }
 200
 201 //get the number of elements of type 'eltType' used in the document
 202 int DocumentModel::getNbrUsedElt(HEXA_NS::EnumElt eltType)
 203 {
 204     if (_hexaDocument == NULL) return 0;
 205
 206     switch(eltType) {
 207     case HEXA_NS::EL_VERTEX:
 208         return _hexaDocument->countUsedVertex();
 209     case HEXA_NS::EL_EDGE:
 210         return _hexaDocument->countUsedEdge();
 211     case HEXA_NS::EL_QUAD:
 212         return _hexaDocument->countUsedQuad();
 213     case HEXA_NS::EL_HEXA:
 214         return _hexaDocument->countUsedHexa();
 215     default: return 0;
 216     }
 217 }
 218
 219 //associate a shape to the current document
 220 bool DocumentModel::addShape(TopoDS_Shape& aShape, QString& name, bool publish)
 221 {
 222     if (aShape.IsNull() || name.isEmpty())
 223         return false;
 224     bool ok = (_hexaDocument != NULL ? _hexaDocument->addShape(aShape, name.toStdString().c_str()) != NULL : false);
 225
 226     // * publish the shape in the study
 227     if (ok && publish)
 228     {
 229         HEXABLOCKGUI* module = HEXABLOCKGUI::getInstance();
 230         if (module != NULL)
 231         {
 232             QMap<QString, TopoDS_Shape> topo_shapes;
 233             topo_shapes[name] = aShape;
 234             module->addInStudy(topo_shapes, docShapesEntry, docShapesName);
 235         }
 236     }
 237
 238     // * update data
 239     if (ok)
 240         updateGeomTree();
 241
 242     return ok;
 243 }
 244
 245 //get the number of unused elements of type 'eltType' in the document
 246 int DocumentModel::getNbrUnusedElt(HEXA_NS::EnumElt eltType)
 247 {
 248     if (_hexaDocument == NULL)
 249         return 0;
 250
 251     return getNbrElt(eltType) - getNbrUsedElt(eltType);
 252 }
 253
 254
 255 //Load the current Document
 256 void DocumentModel::load()
 257 {
 258     if (_hexaDocument == NULL)
 259         return;
 260
 261     load(_hexaDocument->getName());
 262 }
 263
 264
 265 void DocumentModel::load( const QString& xmlFileName ) // Fill Data
 266 {
 267     _hexaDocument->loadXml(xmlFileName.toLocal8Bit().constData() );
 268     clearAll();
 269
 270     fillData();
 271     fillBuilder();
 272     fillGeometry();
 273     fillAssociation();
 274     fillGroups();
 275     fillMesh();
 276
 277     emit patternDataChanged();
 278 }
 279
 280 bool DocumentModel::isEmpty() const
 281 {
 282     if (_hexaDocument == NULL) return true;
 283     return _hexaDocument->isEmpty();
 284 }
 285
 286 void DocumentModel::save( const QString& xmlFileName )
 287 {
 288     _hexaDocument->save( xmlFileName.toLocal8Bit().constData() );
 289 }
 290
 291 QString DocumentModel::getName()
 292 {
 293     return _hexaDocument->getName();
 294 }
 295
 296 void DocumentModel::updateData()
 297 {
 298     clearData();
 299     fillData();
 300     clearMesh();
 301     fillMesh();
 302     emit patternDataChanged();
 303 }
 304
 305 void DocumentModel::updateGeomTree()
 306 {
 307     clearGeometry();
 308     fillGeometry();
 309 }
 310
 311 QModelIndex DocumentModel::addToElementsTree(HEXA_NS::Elements* helts)
 312 {
 313     updateData();
 314     ElementsItem* eltsItem = new ElementsItem(helts);
 315     _elementsDirItem->appendRow(eltsItem);
 316
 317     return eltsItem->index();
 318 }
 319
 320 void DocumentModel::refresh()
 321 {
 322     clearAll();
 323
 324     fillData();
 325     fillBuilder();
 326     fillGeometry();
 327     fillAssociation();
 328     fillGroups();
 329     fillMesh();
 330
 331     emit patternDataChanged();
 332 }
 333
 334 void DocumentModel::clearAll()
 335 {
 336     clearData();
 337     clearBuilder();
 338     clearGeometry();
 339     clearAssociation();
 340     clearGroups();
 341     clearMesh();
 342 }
 343
 344 void DocumentModel::clearData()
 345 {
 346     _vertexDirItem->removeRows( 0, _vertexDirItem->rowCount() );
 347     _edgeDirItem->removeRows(0, _edgeDirItem->rowCount() );
 348     _quadDirItem->removeRows(0, _quadDirItem->rowCount() );
 349     _hexaDirItem->removeRows(0, _hexaDirItem->rowCount() );
 350 }
 351
 352
 353 void DocumentModel::clearBuilder()
 354 {
 355     _vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
 356     _cylinderDirItem->removeRows(0, _cylinderDirItem->rowCount() );
 357     _pipeDirItem->removeRows(0, _pipeDirItem->rowCount() );
 358     _elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
 359     _crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
 360 }
 361
 362 void DocumentModel::clearGeometry()
 363 {
 364     _explicitShapesDirItem->removeRows(0, _explicitShapesDirItem->rowCount() );
 365     _implicitShapesDirItem->removeRows(0, _implicitShapesDirItem->rowCount() );
 366     _cloudOfPointsDirItem->removeRows(0, _cloudOfPointsDirItem->rowCount() );
 367 }
 368
 369 void DocumentModel::clearAssociation()
 370 {
 371     //CS_TODO
 372 }
 373
 374 void DocumentModel::clearGroups()
 375 {
 376     _groupDirItem->removeRows(0, _groupDirItem->rowCount() );
 377 }
 378
 379 void DocumentModel::clearMesh()
 380 {
 381     _lawDirItem->removeRows(0, _lawDirItem->rowCount() );
 382     _propagationDirItem->removeRows(0, _propagationDirItem->rowCount() );
 383 }
 384
 385
 386 void DocumentModel::fillData()
 387 {
 388     PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
 389     if (pdsm == NULL)
 390         return;
 391     pdsm->clearHighlightedItems();
 392
 393     // DATA
 394     HEXA_NS::Vertex *v     = NULL;
 395     VertexItem      *vItem = NULL;
 396     int nbVertex = _hexaDocument->countVertex();
 397     for ( int i=0; i<nbVertex; ++i ){
 398         v = _hexaDocument->getVertex(i);
 399         vItem = new VertexItem(v, _entry);
 400         _vertexDirItem->appendRow(vItem);
 401     }
 402
 403     HEXA_NS::Edge *e     = NULL;
 404     EdgeItem      *eItem = NULL;
 405     int nbEdge = _hexaDocument->countEdge();
 406     for ( int i=0; i<nbEdge; ++i ){
 407         e = _hexaDocument->getEdge(i);
 408         eItem = new EdgeItem(e, _entry);
 409         _edgeDirItem->appendRow(eItem);
 410     }
 411
 412     HEXA_NS::Quad *q     = NULL;
 413     QuadItem      *qItem = NULL;
 414     int nbQuad = _hexaDocument->countQuad();
 415     for ( int i=0; i<nbQuad; ++i ){
 416         q = _hexaDocument->getQuad(i);
 417         qItem = new QuadItem(q, _entry);
 418         _quadDirItem->appendRow(qItem);
 419     }
 420
 421     HEXA_NS::Hexa *h     = NULL;
 422     HexaItem      *hItem = NULL;
 423     int nbHexa = _hexaDocument->countHexa();
 424     for ( int i=0; i<nbHexa; ++i ){
 425         h = _hexaDocument->getHexa(i);
 426         hItem = new HexaItem(h, _entry);
 427         _hexaDirItem->appendRow(hItem);
 428     }
 429 }
 430
 431
 432 void DocumentModel::fillBuilder()
 433 {
 434     HEXA_NS::Vector *v     = NULL;
 435     VectorItem      *vItem = NULL;
 436     int nbVector = _hexaDocument->countVector();
 437     for ( int i=0; i<nbVector; ++i ){
 438         v = _hexaDocument->getVector(i);
 439         vItem = new VectorItem(v);
 440         _vectorDirItem->appendRow(vItem);
 441     }
 442
 443     //   _cylinderDirItem
 444     HEXA_NS::Cylinder *c     = NULL;
 445     CylinderItem      *cItem = NULL;
 446     int nbCylinder = _hexaDocument->countCylinder();
 447     for ( int i=0; i<nbCylinder; ++i ){
 448         c = _hexaDocument->getCylinder(i);
 449         cItem = new CylinderItem(c, _entry);
 450         _cylinderDirItem->appendRow(cItem);
 451     }
 452
 453     //   _pipeDirItem
 454     HEXA_NS::Pipe *p     = NULL;
 455     PipeItem      *pItem = NULL;
 456     int nbPipe = _hexaDocument->countPipe();
 457     for ( int i=0; i<nbPipe; ++i ){
 458         p = _hexaDocument->getPipe(i);
 459         pItem = new PipeItem(p);
 460         _pipeDirItem->appendRow(pItem);
 461     }
 462 }
 463
 464 void DocumentModel::fillGeometry()
 465 {
 466     PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
 467     if (_hexaDocument == NULL || isEmpty() || pgsm == NULL)
 468         return;
 469
 470     HEXA_NS::NewShape* shape;
 471     HEXA_NS::VertexShape* node;
 472     HEXA_NS::EdgeShape* line;
 473     HEXA_NS::FaceShape* face;
 474     TopoDS_Compound vertexCompound;
 475     BRep_Builder compoundBuilder;
 476
 477     // * fill the shape tree
 478
 479     shapeById.clear();
 480     pgsm->clearHighlightedItems();
 481     QMap<QString, TopoDS_Shape> topo_shapes;
 482     int nbShapes = _hexaDocument->countShape();
 483     for (int i=0; i < nbShapes; ++i)
 484     {
 485         shape = _hexaDocument->getShape(i);
 486         QString shapeName = shape->getName();
 487         if (!docShapesEntry.contains(shapeName))
 488         {
 489             if (shape->getOrigin() == HEXA_NS::SH_CLOUD)
 490             {
 491                 compoundBuilder.MakeCompound(vertexCompound);
 492                 topo_shapes[shapeName] = vertexCompound;
 493             }
 494             else
 495                 topo_shapes[shapeName] = shape->getShape();
 496         }
 497
 498         GeomShapeItem* shItem = new GeomShapeItem(shape);
 499         if (shape->getOrigin() == HEXA_NS::SH_IMPORT)
 500             // * explicit shapes
 501             _explicitShapesDirItem->appendRow(shItem);
 502         else
 503             // * implicit shapes
 504             _implicitShapesDirItem->appendRow(shItem);
 505
 506         //add vertices to the tree
 507         QStandardItem* geomPointDirItem = new QStandardItem(tr("TREE_ITEM_VERTEX"));
 508         geomPointDirItem->setData( GEOMPOINT_DIR_TREE, HEXA_TREE_ROLE );
 509         shItem->appendRow(geomPointDirItem);
 510         int nbVertexShape = shape->countVertex();
 511         for (int j=0; j < nbVertexShape; ++j)
 512         {
 513             node = shape->getVertexShape(j);
 514             GeomPointItem* gPointItem = new GeomPointItem(node);
 515             geomPointDirItem->appendRow(gPointItem);
 516             shapeById[shapeName+","+QString::number(node->getIdent())] = node;
 517
 518             // * update the compound of vertices
 519             if (shape->getOrigin() == HEXA_NS::SH_CLOUD && !vertexCompound.IsNull())
 520                 compoundBuilder.Add(topo_shapes[shapeName], node->getShape());
 521         }
 522
 523         //add edges to the tree
 524         QStandardItem* geomEdgeDirItem = new QStandardItem(tr("TREE_ITEM_EDGE"));
 525         geomEdgeDirItem->setData( GEOMEDGE_DIR_TREE, HEXA_TREE_ROLE );
 526         shItem->appendRow(geomEdgeDirItem);
 527         int nbEdgeShape = shape->countEdge();
 528         for (int j = 0; j < nbEdgeShape; ++j)
 529         {
 530             line = shape->getEdgeShape(j);
 531             GeomEdgeItem* gEdgeItem = new GeomEdgeItem(line);
 532             geomEdgeDirItem->appendRow(gEdgeItem);
 533             shapeById[shapeName+","+QString::number(line->getIdent())] = line;
 534         }
 535
 536         //add faces to the tree
 537         QStandardItem* geomFaceDirItem = new QStandardItem(tr("TREE_ITEM_QUAD"));
 538         geomFaceDirItem->setData( GEOMFACE_DIR_TREE, HEXA_TREE_ROLE );
 539         shItem->appendRow(geomFaceDirItem);
 540         int nbFaceShape = shape->countFace();
 541         for (int j = 0; j < nbFaceShape; ++j)
 542         {
 543             face = shape->getFaceShape(j);
 544             GeomFaceItem* gFaceItem = new GeomFaceItem(face);
 545             geomFaceDirItem->appendRow(gFaceItem);
 546             shapeById[shapeName+","+QString::number(face->getIdent())] = face;
 547         }
 548     }
 549
 550     if (topo_shapes.size() == 0)
 551         return;
 552
 553     // * register shapes
 554     HEXABLOCKGUI* module = HEXABLOCKGUI::getInstance();
 555     if (module != NULL)
 556         module->addInStudy(topo_shapes, docShapesEntry, docShapesName);
 557 }
 558
 559 void DocumentModel::fillAssociation()
 560 {
 561 }
 562
 563 //------------------------------------------- NEW ITEMS
 564 //void DocumentModel::fillGroups()
 565 //{
 566 //  HEXA_NS::Group *g     = NULL;
 567 //  GroupItem      *gItem = NULL;
 568 //  int nbGroup = _hexaDocument->countGroup();
 569 //  for ( int i=0; i<nbGroup; ++i ){
 570 //    g = _hexaDocument->getGroup(i);
 571 //    gItem = new GroupItem(g, _entry);
 572 //    _groupDirItem->appendRow(gItem);
 573 //  }
 574 //}
 575 //
 576 //void DocumentModel::fillMesh()
 577 //{
 578 //  HEXA_NS::Law *l     = NULL;
 579 //  LawItem      *lItem = NULL;
 580 //  int nbLaw = _hexaDocument->countLaw();
 581 //  for ( int i=0; i<nbLaw; ++i ){
 582 //    l = _hexaDocument->getLaw(i);
 583 //    lItem = new LawItem(l);
 584 //    _lawDirItem->appendRow(lItem);
 585 //  }
 586 //
 587 //  HEXA_NS::Propagation *p     = NULL;
 588 //  PropagationItem      *pItem = NULL;
 589 //  int nbPropagation = _hexaDocument->countPropagation();
 590 //  for ( int i=0; i<nbPropagation; ++i ){
 591 //    p = _hexaDocument->getPropagation(i);
 592 //    pItem = new PropagationItem(p, _entry);
 593 //    pItem->setText(QString("Propagation%1").arg(i) );
 594 //    _propagationDirItem->appendRow(pItem);
 595 //  }
 596 //}
 597 //----------------------------------------------- END NEW ITEMS
 598
 599 void DocumentModel::fillGroups()
 600 {
 601     HEXA_NS::Group *g     = NULL;
 602     GroupItem      *gItem = NULL;
 603     int nbGroup = _hexaDocument->countGroup();
 604     for ( int i=0; i<nbGroup; ++i ){
 605         g = _hexaDocument->getGroup(i);
 606         //std::cout<<"getGroup => "<< i << std::endl;
 607         gItem = new GroupItem(g);
 608         gItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
 609         _groupDirItem->appendRow(gItem);
 610     }
 611 }
 612
 613 void DocumentModel::fillMesh()
 614 {
 615     //   _lawDirItem
 616     HEXA_NS::Law *l     = NULL;
 617     LawItem      *lItem = NULL;
 618     int nbLaw = _hexaDocument->countLaw();
 619     for ( int i=0; i<nbLaw; ++i ){
 620         l = _hexaDocument->getLaw(i);
 621         lItem = new LawItem(l);
 622         _lawDirItem->appendRow(lItem);
 623     }
 624
 625     //   _propagationDirItem
 626     HEXA_NS::Propagation *p     = NULL;
 627     PropagationItem      *pItem = NULL;
 628     int nbPropagation = _hexaDocument->countPropagation();
 629     for ( int i=0; i<nbPropagation; ++i ){
 630         p = _hexaDocument->getPropagation(i);
 631         pItem = new PropagationItem(p);
 632         pItem->setText(QString("Propagation%1").arg(i) );
 633         pItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
 634         _propagationDirItem->appendRow(pItem);
 635     }
 636 }
 637
 638 HEXA_NS::Hexa* DocumentModel::getQuadHexa(HEXA_NS::Quad* quad)
 639 {
 640     HEXA_NS::Hexa* hexa;
 641     int nbHexa = _hexaDocument->countHexa();
 642     for ( int i=0; i<nbHexa; ++i ){
 643         hexa = _hexaDocument->getHexa(i);
 644         if (hexa->findQuad(quad) > -1) return hexa;
 645     }
 646     return NULL;
 647 }
 648
 649
 650 Qt::ItemFlags DocumentModel::flags(const QModelIndex &index) const
 651 {
 652     Qt::ItemFlags flags;
 653
 654     if (!index.isValid()) return Qt::ItemIsEnabled;
 655
 656     if ( _disallowEdition ){
 657         return QAbstractItemModel::flags(index) | Qt::ItemFlags( ~Qt::ItemIsEditable );
 658     } else {
 659         return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
 660     }
 661 }
 662
 663 void DocumentModel::allowEdition()
 664 {
 665     _disallowEdition = false;
 666 }
 667
 668 void DocumentModel::disallowEdition()
 669 {
 670     _disallowEdition = true;
 671 }
 672
 673 void DocumentModel::allowDataSelectionOnly()
 674 {
 675     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 676     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 677     _quadItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 678     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 679
 680     _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 681     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 682     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 683     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 684     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 685
 686     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 687     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 688     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 689 }
 690
 691 void DocumentModel::allowVertexSelectionOnly()
 692 {
 693     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable);
 694     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 695     _quadItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 696     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 697
 698     _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 699     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 700     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEditable );
 701     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 702     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 703
 704     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 705     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 706     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 707
 708     //     emit layoutChanged();
 709 }
 710
 711 void DocumentModel::allowEdgeSelectionOnly()
 712 {
 713     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 714     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 715     _quadItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 716     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 717
 718     _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 719     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 720     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 721     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 722     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 723
 724     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 725     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 726     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 727 }
 728
 729 void DocumentModel::allowQuadSelectionOnly()
 730 {
 731     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 732     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 733     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 734     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 735
 736     _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 737     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 738     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 739     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 740     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 741
 742     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 743     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 744     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 745 }
 746
 747 void DocumentModel::allowHexaSelectionOnly()
 748 {
 749     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 750     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 751     _quadItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 752     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 753
 754     _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 755     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 756     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 757     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 758     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 759
 760     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 761     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 762     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 763 }
 764
 765 void DocumentModel::allowVectorSelectionOnly()
 766 {
 767     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 768     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 769     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 770     _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 771
 772     _vectorItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 773     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 774     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 775     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 776     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 777
 778     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 779     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 780     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 781 }
 782
 783 void DocumentModel::allowCylinderSelectionOnly()
 784 {
 785     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 786     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 787     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 788     _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 789
 790     _vectorItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 791     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 792     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 793     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 794     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 795
 796     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 797     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 798     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 799 }
 800
 801 void DocumentModel::allowPipeSelectionOnly()
 802 {
 803     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 804     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 805     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 806     _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 807
 808     _vectorItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 809     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 810     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEditable );
 811     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 812     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 813
 814     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 815     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 816     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 817 }
 818
 819 void DocumentModel::allowElementsSelectionOnly()
 820 {
 821     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 822     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 823     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 824     _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 825
 826     _vectorItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 827     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 828     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 829     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 830     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 831
 832     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 833     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 834     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 835 }
 836
 837 void DocumentModel::allowCrossElementsSelectionOnly()
 838 {
 839     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 840     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 841     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 842     _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 843
 844     _vectorItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 845     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 846     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 847     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 848     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 849
 850     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 851     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 852     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 853 }
 854
 855 void DocumentModel::allowLawSelectionOnly()
 856 {
 857     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 858     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 859     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 860     _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 861
 862     _vectorItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 863     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 864     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 865     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 866     _crossElementsItemFlags = Qt::ItemFlags( Qt::ItemIsEnabled );
 867
 868     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 869     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 870     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 871 }
 872
 873
 874 void DocumentModel::setName( const QModelIndex& iElt, const QString& name )
 875 {
 876     HEXA_NS::EltBase *elt = NULL;
 877
 878     switch ( data(iElt, HEXA_TREE_ROLE).toInt() ){
 879     case GROUP_TREE :
 880     {
 881         HEXA_NS::Group* grp = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Group* >();
 882         grp->setName( name.toLatin1().data() );
 883         break;
 884     }
 885     case LAW_TREE :
 886     {
 887         HEXA_NS::Law* l = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Law* >();
 888         l->setName( name.toLatin1().data() );
 889         break;
 890     }
 891     //   case PROPAGATION_TREE : elt = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Propagation* >(); break;
 892     default: elt = getHexaPtr(iElt);
 893     }
 894
 895     if ( elt != NULL ) elt->setName( name.toStdString() );
 896     setData( iElt, name );
 897
 898 }
 899
 900 bool DocumentModel::clearEltAssociations( const QModelIndex& iElt )
 901 {
 902     bool isOk = false;
 903     HEXA_NS::EltBase *elt = getHexaPtr(iElt);
 904
 905     if ( elt != NULL ){
 906         elt->clearAssociation();
 907         setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 908         isOk = true;
 909     }
 910
 911     return isOk;
 912 }
 913
 914 void DocumentModel::clearAssociation(HEXA_NS::EnumElt& eltType)
 915 {
 916     if (_hexaDocument != NULL)
 917         _hexaDocument->clearAssociation(eltType);
 918
 919     QModelIndex iElt;
 920     HEXA_NS::Vertex* vertex;
 921     HEXA_NS::Edge* edge;
 922     HEXA_NS::Quad* quad;
 923     int nbElts;
 924
 925     if (HEXABLOCKGUI::currentDocGView == NULL) return;
 926     PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
 927     PatternDataModel* pdm = HEXABLOCKGUI::currentDocGView->getPatternDataModel();
 928     if (pdsm == NULL || pdm == NULL) return;
 929
 930     //update associations in the model
 931     if (eltType == HEXA_NS::EL_VERTEX)
 932     {
 933         nbElts = _hexaDocument->countVertex();
 934         for (int i = 0; i < nbElts; ++i)
 935         {
 936             vertex = _hexaDocument->getVertex(i);
 937             iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(vertex)));
 938             if (iElt.isValid())
 939                 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 940         }
 941     }
 942     else if (eltType == HEXA_NS::EL_EDGE)
 943     {
 944         nbElts = _hexaDocument->countEdge();
 945         for (int i = 0; i < nbElts; ++i)
 946         {
 947             edge = _hexaDocument->getEdge(i);
 948             iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(edge)));
 949             if (iElt.isValid())
 950                 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 951         }
 952     }
 953     else if (eltType == HEXA_NS::EL_QUAD)
 954     {
 955         nbElts = _hexaDocument->countQuad();
 956         for (int i = 0; i < nbElts; ++i)
 957         {
 958             quad = _hexaDocument->getQuad(i);
 959             iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(quad)));
 960             if (iElt.isValid())
 961                 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 962         }
 963     }
 964 }
 965
 966
 967 QModelIndex DocumentModel::addVertex( double x, double y, double z )
 968 {
 969     QModelIndex vertexIndex;
 970
 971     HEXA_NS::Vertex* hv = _hexaDocument->addVertex(x, y, z);
 972     if (BadElement(hv)) return vertexIndex;
 973
 974     VertexItem* v = new VertexItem(hv, _entry);
 975     _vertexDirItem->appendRow(v);
 976     vertexIndex = v->index();
 977     emit patternDataChanged();
 978
 979     return vertexIndex;
 980 }
 981
 982 QModelIndex DocumentModel::addEdgeVertices (const QModelIndex &i_v0, const QModelIndex &i_v1 )
 983 {
 984     QModelIndex edgeIndex;
 985
 986     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
 987     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
 988
 989     HEXA_NS::Edge* he = _hexaDocument->addEdge( hv0, hv1 );
 990     if ( BadElement(he) ) return edgeIndex;
 991
 992     EdgeItem* e = new EdgeItem(he, _entry);
 993     _edgeDirItem->appendRow(e);
 994     edgeIndex = e->index();
 995     emit patternDataChanged();
 996
 997     return edgeIndex;
 998 }
 999
1000 QModelIndex DocumentModel::addQuadVertices( const QModelIndex &i_v0, const QModelIndex &i_v1,
1001         const QModelIndex &i_v2, const QModelIndex &i_v3 )
1002 { //CS_TODO : gestion erreur
1003     QModelIndex quadIndex;
1004
1005     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
1006     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
1007     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(i_v2);
1008     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(i_v3);
1009
1010     if ( hv0 and hv1 and hv2 and hv3 ){
1011         HEXA_NS::Quad* hq = _hexaDocument->addQuadVertices( hv0, hv1, hv2, hv3 );
1012         if ( BadElement(hq) ) return quadIndex;
1013
1014         QuadItem* q = new QuadItem(hq, _entry);
1015         _quadDirItem->appendRow(q);
1016         quadIndex = q->index();
1017         emit patternDataChanged();
1018     }
1019
1020     return quadIndex;
1021 }
1022
1023 QModelIndex DocumentModel::addQuadEdges( const QModelIndex &e0, const QModelIndex &e1,
1024         const QModelIndex &e2, const QModelIndex &e3 )
1025 { //CS_TODO
1026     QModelIndex quadIndex;
1027
1028     HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(e0);
1029     HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(e1);
1030     HEXA_NS::Edge* he2 = getHexaPtr<HEXA_NS::Edge*>(e2);
1031     HEXA_NS::Edge* he3 = getHexaPtr<HEXA_NS::Edge*>(e3);
1032
1033     if ( he0 and he1 and he2 and he3 ){
1034
1035         HEXA_NS::Quad* hq = _hexaDocument->addQuad( he0, he1, he2, he3 );
1036         if ( BadElement(hq) ) return quadIndex;
1037
1038         QuadItem* q = new QuadItem(hq, _entry);
1039         _quadDirItem->appendRow(q);
1040         quadIndex = q->index();
1041         emit patternDataChanged();
1042     }
1043
1044     return quadIndex;
1045 }
1046
1047 QModelIndex DocumentModel::addHexaVertices(
1048         const QModelIndex &iv0, const QModelIndex &iv1,
1049         const QModelIndex &iv2, const QModelIndex &iv3,
1050         const QModelIndex &iv4, const QModelIndex &iv5,
1051         const QModelIndex &iv6, const QModelIndex &iv7 )
1052 {
1053     QModelIndex iHexa;
1054
1055     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1056     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1057     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1058     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1059     HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
1060     HEXA_NS::Vertex* hv5 = getHexaPtr<HEXA_NS::Vertex*>(iv5);
1061     HEXA_NS::Vertex* hv6 = getHexaPtr<HEXA_NS::Vertex*>(iv6);
1062     HEXA_NS::Vertex* hv7 = getHexaPtr<HEXA_NS::Vertex*>(iv7);
1063
1064     HEXA_NS::Hexa* hh = _hexaDocument->addHexaVertices( hv0, hv1, hv2, hv3,
1065             hv4, hv5, hv6, hv7 );
1066
1067     if ( BadElement(hh) ) return iHexa;
1068
1069     HexaItem* h = new HexaItem(hh, _entry);
1070     _hexaDirItem->appendRow(h);
1071     iHexa = h->index();
1072     emit patternDataChanged();
1073
1074     return iHexa;
1075 }
1076
1077 QModelIndex DocumentModel::addHexaQuad( const QModelIndex &i_q0, const QModelIndex &i_q1,
1078         const QModelIndex &i_q2,const QModelIndex &i_q3, const QModelIndex &i_q4, const QModelIndex &i_q5 )
1079 { //CS_TODO : gestion erreur
1080     QModelIndex hexaIndex;
1081
1082     HEXA_NS::Quad* hq0 = getHexaPtr<HEXA_NS::Quad*>(i_q0);
1083     HEXA_NS::Quad* hq1 = getHexaPtr<HEXA_NS::Quad*>(i_q1);
1084     HEXA_NS::Quad* hq2 = getHexaPtr<HEXA_NS::Quad*>(i_q2);
1085     HEXA_NS::Quad* hq3 = getHexaPtr<HEXA_NS::Quad*>(i_q3);
1086     HEXA_NS::Quad* hq4 = getHexaPtr<HEXA_NS::Quad*>(i_q4);
1087     HEXA_NS::Quad* hq5 = getHexaPtr<HEXA_NS::Quad*>(i_q5);
1088
1089     HEXA_NS::Hexa* hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
1090     if ( BadElement(hh) ) return hexaIndex;
1091
1092     HexaItem* h = new HexaItem(hh, _entry);
1093     _hexaDirItem->appendRow(h);
1094     hexaIndex = h->index();
1095     emit patternDataChanged();
1096
1097     return hexaIndex;
1098 }
1099
1100 QModelIndex DocumentModel::addHexaQuads( const QModelIndexList &iquads)
1101 {
1102     QModelIndex hexaIndex;
1103
1104     HEXA_NS::Hexa* hh = NULL;
1105     HEXA_NS::Quad* hq0, *hq1, *hq2, *hq3, *hq4, *hq5 = NULL;
1106
1107     hq0 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(0));
1108     hq1 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(1));
1109     hq2 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(2));
1110     hq3 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(3));
1111     hq4 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(4));
1112     hq5 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(5));
1113
1114     if ( hq0 && hq1 && hq2 && hq3 && hq4 && hq5 )
1115         hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
1116     else if ( hq0 && hq1 && hq2 && hq3 && hq4 )
1117         hh = _hexaDocument->addHexa5Quads( hq0, hq1, hq2, hq3, hq4 );
1118     else if ( hq0 && hq1 && hq2 && hq3 )
1119         hh = _hexaDocument->addHexa4Quads( hq0, hq1, hq2, hq3 );
1120     else if ( hq0 && hq1 && hq2)
1121         hh = _hexaDocument->addHexa3Quads( hq0, hq1, hq2 );
1122     else if ( hq0 && hq1 )
1123         hh = _hexaDocument->addHexa2Quads( hq0, hq1);
1124
1125     if ( BadElement(hh) ) return hexaIndex;
1126
1127     updateData();
1128     unsigned int nbRows = _hexaDirItem->rowCount();
1129     if (nbRows > 0)
1130         hexaIndex = _hexaDirItem->child(nbRows-1)->index();
1131
1132     return hexaIndex;
1133 }
1134
1135 QModelIndex DocumentModel::addVector( double dx, double dy, double dz )
1136 {
1137     QModelIndex vectorIndex;
1138
1139     HEXA_NS::Vector* hv = _hexaDocument->addVector(dx, dy, dz);
1140     if ( BadElement(hv) ) return vectorIndex; //Invalid index
1141
1142     VectorItem* v = new VectorItem(hv);
1143     _vectorDirItem->appendRow(v);
1144     vectorIndex = v->index();
1145
1146     return vectorIndex;
1147 }
1148
1149 QModelIndex DocumentModel::addVectorVertices( const QModelIndex &iv0, const QModelIndex &iv1 )
1150 {
1151     QModelIndex iVec;
1152
1153     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1154     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1155
1156     HEXA_NS::Vector* hvec = _hexaDocument->addVectorVertices( hv0, hv1 );
1157     if ( BadElement(hvec) ) return iVec;
1158
1159     VectorItem* vec = new VectorItem(hvec);
1160     _vectorDirItem->appendRow(vec);
1161     iVec = vec->index();
1162
1163     return iVec;
1164 }
1165
1166
1167 // ************  EDIT HEXABLOCK MODEL ************
1168
1169 bool DocumentModel::updateVertex( const QModelIndex& ivertex, double x, double y, double z )
1170 {
1171     bool ret = false;
1172
1173     HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
1174
1175     if ( hVertex ){
1176 //        hVertex->setName( name.toStdString() );
1177         hVertex->setX ( x );
1178         hVertex->setY ( y );
1179         hVertex->setZ ( z );
1180         emit patternDataChanged();
1181         ret = true;
1182     }
1183
1184     return ret;
1185 }
1186
1187 bool DocumentModel::removeHexa( const QModelIndex& ihexa )
1188 {
1189     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1190
1191     int r = _hexaDocument->removeHexa( hHexa );
1192     if ( r == HOK ){
1193         updateData();
1194         return true;
1195     }
1196
1197     return false;
1198 }
1199
1200 bool DocumentModel::removeConnectedHexa( const QModelIndex& ihexa )
1201 {
1202     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1203
1204     int r = _hexaDocument->removeConnectedHexa( hHexa );
1205     if ( r == HOK ){
1206         updateData();
1207         return true;
1208     }
1209
1210     return false;
1211 }
1212
1213 bool DocumentModel::mergeVertices( const QModelIndex &iv0, const QModelIndex &iv1 ) //CS_TODO : impact sur le model?
1214 {
1215     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1216     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1217
1218     int r = _hexaDocument->mergeVertices( hv0, hv1 );
1219     if ( r == HOK ){
1220         updateData(); //CS_TODO more or less?
1221         return true;
1222     }
1223
1224     return false;
1225 }
1226
1227 bool DocumentModel::mergeEdges( const QModelIndex &ie0, const QModelIndex &ie1,
1228         const QModelIndex &iv0, const QModelIndex &iv1 )
1229 //CS_TODO : impact sur le model?
1230 {
1231     HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(ie0);
1232     HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(ie1);
1233
1234     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1235     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1236
1237     //Merge
1238     int r = _hexaDocument->mergeEdges( he0, he1, hv0, hv1 );
1239     if ( r == HOK ){
1240         updateData();
1241         return true;
1242     }
1243
1244     return false;
1245 }
1246
1247 bool DocumentModel::mergeQuads( const QModelIndex& iquad0, const QModelIndex& iquad1,
1248         const QModelIndex& iv0, const QModelIndex& iv1,
1249         const QModelIndex& iv2, const QModelIndex& iv3 )
1250 {
1251     HEXA_NS::Quad* hquad0 = data(iquad0, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
1252     HEXA_NS::Quad* hquad1 = data(iquad1, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
1253
1254     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1255     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1256     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1257     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1258
1259     int r = _hexaDocument->mergeQuads( hquad0, hquad1, hv0, hv1, hv2, hv3 );
1260     if ( r == HOK ){
1261         updateData();
1262         return true;
1263     }
1264
1265     return false;
1266 }
1267
1268 //
1269 QModelIndex DocumentModel::disconnectVertex( const QModelIndex& ihexa, const QModelIndex& ivertex )
1270 {
1271     QModelIndex iElts;
1272
1273     HEXA_NS::Hexa*   hHexa   = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1274     HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
1275
1276     HEXA_NS::Elements* hElts = _hexaDocument->disconnectVertex( hHexa, hVertex );
1277     if ( BadElement(hElts) ) return iElts;
1278
1279     updateData(); //CS_TO_CHECK
1280     ElementsItem* elts = new ElementsItem(hElts);
1281     _elementsDirItem->appendRow(elts);
1282     iElts = elts->index();
1283
1284     return iElts;
1285 }
1286
1287 QModelIndex DocumentModel::disconnectEdge( const QModelIndex& ihexa, const QModelIndex& iedge )
1288 {
1289     QModelIndex iElts;
1290
1291     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1292     HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1293
1294     HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdge( hHexa, hEdge );
1295     if ( BadElement(hElts) ) return iElts;
1296
1297     updateData(); //CS_TO_CHECK
1298     ElementsItem* elts = new ElementsItem(hElts);
1299     _elementsDirItem->appendRow(elts);
1300     iElts = elts->index();
1301
1302     return iElts;
1303 }
1304
1305
1306 QModelIndex DocumentModel::disconnectEdges( const QModelIndexList& ihexas, const QModelIndexList& iedges )
1307 {
1308     QModelIndex iElts;
1309
1310     HEXA_NS::Hexas hHexas;
1311     HEXA_NS::Edges hEdges;
1312
1313     //edges list
1314     HEXA_NS::Edge* hedge = NULL;
1315     foreach( const QModelIndex& iedge, iedges ){
1316         hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1317         hEdges.push_back( hedge );
1318     }
1319
1320     //hexas list
1321     HEXA_NS::Hexa* hhexa = NULL;
1322     foreach( const QModelIndex& ihexa, ihexas ){
1323         hhexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1324         hHexas.push_back( hhexa );
1325     }
1326
1327
1328     HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdges( hHexas, hEdges );
1329     if ( BadElement(hElts) ) return iElts;
1330
1331     updateData(); //CS_TO_CHECK
1332     ElementsItem* elts = new ElementsItem(hElts);
1333     _elementsDirItem->appendRow(elts);
1334     iElts = elts->index();
1335
1336     return iElts;
1337 }
1338
1339
1340 QModelIndex DocumentModel::disconnectQuad( const QModelIndex& ihexa, const QModelIndex& iquad )
1341 {
1342     QModelIndex iElts;
1343
1344     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1345     HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1346
1347     HEXA_NS::Elements* hElts = _hexaDocument->disconnectQuad( hHexa, hQuad );
1348     if ( BadElement(hElts) ) return iElts;
1349
1350     updateData(); //CS_TO_CHECK
1351     ElementsItem* elts = new ElementsItem(hElts);
1352     _elementsDirItem->appendRow(elts);
1353     iElts = elts->index();
1354
1355     return iElts;
1356 }
1357
1358
1359 QModelIndex DocumentModel::makeTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
1360 {
1361     QModelIndex iElts;
1362
1363     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1364     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1365
1366     HEXA_NS::Elements* hNewElts = _hexaDocument->makeTranslation( hElts, hVec );
1367     if ( BadElement(hNewElts) ) return iElts;
1368
1369     updateData(); //CS_TODO  more or less?
1370     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1371     _elementsDirItem->appendRow(eltsItem);
1372     iElts = eltsItem->index();
1373
1374     return iElts;
1375 }
1376
1377
1378
1379 QModelIndex DocumentModel::makeScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
1380 {
1381     QModelIndex iElts;
1382
1383     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1384     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1385
1386     HEXA_NS::Elements* hNewElts = _hexaDocument->makeScale( hElts, hVex, k );
1387     if ( BadElement(hNewElts) ) return iElts;
1388
1389     updateData(); //CS_TODO  more or less?
1390     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1391     _elementsDirItem->appendRow(eltsItem);
1392     iElts = eltsItem->index();
1393
1394     return iElts;
1395 }
1396
1397
1398
1399 QModelIndex DocumentModel::makeRotation( const QModelIndex& ielts,
1400         const QModelIndex& iv,
1401         const QModelIndex& ivec, double angle )
1402 {
1403     QModelIndex iElts;
1404
1405     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1406     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1407     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1408
1409     HEXA_NS::Elements* hNewElts = _hexaDocument->makeRotation( hElts, hVex, hVec, angle );
1410     if ( BadElement(hNewElts) ) return iElts;
1411
1412     updateData(); //CS_TODO  more or less?
1413     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1414     _elementsDirItem->appendRow(eltsItem);
1415     iElts = eltsItem->index();
1416
1417     return iElts;
1418 }
1419
1420
1421 QModelIndex DocumentModel::makeSymmetryPoint( const QModelIndex& ielts, const QModelIndex& iv )
1422 {
1423     QModelIndex iElts;
1424
1425     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1426     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1427
1428     HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPoint (hElts, hVex);
1429     if ( BadElement(hNewElts) ) return iElts;
1430
1431     updateData(); //CS_TODO  more or less?
1432     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1433     _elementsDirItem->appendRow(eltsItem);
1434     iElts = eltsItem->index();
1435
1436     return iElts;
1437 }
1438
1439
1440 QModelIndex DocumentModel::makeSymmetryLine( const QModelIndex& ielts,
1441         const QModelIndex& iv,
1442         const QModelIndex& ivec )
1443 {
1444     QModelIndex iElts;
1445
1446     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1447     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1448     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1449
1450
1451     HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryLine( hElts, hVex, hVec );
1452     if ( BadElement(hNewElts) ) return iElts;
1453
1454     updateData(); //CS_TODO  more or less?
1455     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1456     _elementsDirItem->appendRow(eltsItem);
1457     iElts = eltsItem->index();
1458
1459     return iElts;
1460 }
1461
1462
1463 QModelIndex DocumentModel::makeSymmetryPlane( const QModelIndex& ielts, const QModelIndex& iv, const QModelIndex& ivec )
1464 {
1465     QModelIndex iElts;
1466
1467     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1468     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1469     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1470
1471     HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPlane( hElts, hVex, hVec );
1472     if ( BadElement(hNewElts) ) return iElts;
1473
1474     updateData(); //CS_TODO  more or less?
1475     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1476     _elementsDirItem->appendRow(eltsItem);
1477     iElts = eltsItem->index();
1478
1479     return iElts;
1480 }
1481
1482
1483 bool DocumentModel::performTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
1484 {
1485     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1486     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1487
1488     int r = _hexaDocument->performTranslation (hElts, hVec);
1489     if ( r == HOK ){ //Job well done?
1490         updateData();
1491         return true;
1492     }
1493
1494     return false;
1495 }
1496
1497
1498 //
1499 bool DocumentModel::performScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
1500 {
1501     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1502     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1503
1504     int r = _hexaDocument->performScale (hElts, hVex, k);
1505     if ( r == HOK ){
1506         updateData();
1507         return true;
1508     }
1509
1510     return false;
1511 }
1512
1513 //
1514 bool DocumentModel::performRotation( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec, double angle )
1515 {
1516     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1517     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1518     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1519
1520     int r = _hexaDocument-> performRotation( hElts, hVex, hVec, angle );
1521     if ( r == HOK ){
1522         updateData();
1523         return true;
1524     }
1525
1526     return false;
1527 }
1528
1529
1530 //
1531 bool DocumentModel::performSymmetryPoint( const QModelIndex& ielts, const QModelIndex& ivex )
1532 {
1533     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1534     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1535
1536     int r = _hexaDocument->performSymmetryPoint( hElts, hVex );
1537     if ( r == HOK ){
1538         updateData();
1539         return true;
1540     }
1541
1542     return false;
1543 }
1544
1545
1546 bool DocumentModel::performSymmetryLine( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec )
1547 {
1548     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1549     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1550     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1551
1552     int r = _hexaDocument->performSymmetryLine( hElts, hVex, hVec );
1553     if ( r == HOK ){
1554         updateData();
1555         return true;
1556     }
1557
1558     return false;
1559 }
1560
1561
1562 bool DocumentModel::performSymmetryPlane( const QModelIndex& ielts,
1563         const QModelIndex& ivex,
1564         const QModelIndex& ivec )
1565 {
1566     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1567     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1568     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1569
1570     int r = _hexaDocument->performSymmetryPlane( hElts, hVex, hVec );
1571     if ( r == HOK ){
1572         updateData();
1573         return true;
1574     }
1575
1576     return false;
1577 }
1578
1579 QModelIndex DocumentModel::revolutionQuads( const QModelIndexList& istartquads,
1580         const QModelIndex& icenter,
1581         const QModelIndex& ivecaxis,
1582         const QList<double>& angles )
1583 {
1584     QModelIndex ielts;
1585
1586     HEXA_NS::Quads   hstartquads;
1587     HEXA_NS::Quad*   hquad = NULL;
1588     foreach( const QModelIndex& iquad, istartquads){
1589         hquad = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad*>();
1590         hstartquads.push_back( hquad );
1591     }
1592     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1593     HEXA_NS::Vector* haxis   = getHexaPtr<HEXA_NS::Vector*>(ivecaxis);
1594     std::vector<double> hangles = angles.toVector().toStdVector();
1595
1596     HEXA_NS::Elements* helts = _hexaDocument->revolutionQuads( hstartquads, hcenter, haxis, hangles );
1597     if ( BadElement(helts) ) return ielts;
1598
1599     updateData();
1600     ElementsItem* eltsItem = new ElementsItem(helts);
1601     _elementsDirItem->appendRow(eltsItem);
1602     ielts = eltsItem->index();
1603
1604     return ielts;
1605 }
1606
1607 QModelIndex DocumentModel::replace( const QModelIndexList& iquadsPattern,
1608         const QModelIndex& ip1, const QModelIndex& ic1,
1609         const QModelIndex& ip2, const QModelIndex& ic2,
1610         const QModelIndex& ip3, const QModelIndex& ic3 )
1611 {
1612     QModelIndex ielts;
1613
1614     HEXA_NS::Vertex* hp1 = getHexaPtr<HEXA_NS::Vertex*>(ip1);
1615     HEXA_NS::Vertex* hc1 = getHexaPtr<HEXA_NS::Vertex*>(ic1);
1616     HEXA_NS::Vertex* hp2 = getHexaPtr<HEXA_NS::Vertex*>(ip2);
1617     HEXA_NS::Vertex* hc2 = getHexaPtr<HEXA_NS::Vertex*>(ic2);
1618     HEXA_NS::Vertex* hp3 = getHexaPtr<HEXA_NS::Vertex*>(ip3);
1619     HEXA_NS::Vertex* hc3 = getHexaPtr<HEXA_NS::Vertex*>(ic3);
1620
1621     HEXA_NS::Quads   hquads;
1622     HEXA_NS::Quad*   hquad = NULL;
1623     foreach( const QModelIndex& iquad, iquadsPattern ){
1624         hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1625         hquads.push_back( hquad );
1626     }
1627
1628     HEXA_NS::Elements* helts = _hexaDocument->replace( hquads,
1629             hp1, hc1, hp2, hc2, hp3, hc3 );
1630     if ( BadElement(helts) ) return ielts;
1631
1632     updateData();
1633     ElementsItem* eltsItem = new ElementsItem(helts);
1634     _elementsDirItem->appendRow(eltsItem);
1635     ielts = eltsItem->index();
1636
1637     return ielts;
1638 }
1639
1640 QModelIndex DocumentModel::getGeomModelIndex(QString& id) const
1641 {
1642     QModelIndex result;
1643     PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
1644
1645     // ** get the model index of the geom element having this ID
1646     HEXA_NS::SubShape* eltPtr = getGeomPtr(id);
1647     HEXA_NS::VertexShape* geomVertex = dynamic_cast<HEXA_NS::VertexShape*>(eltPtr);
1648     HEXA_NS::EdgeShape* geomEdge = dynamic_cast<HEXA_NS::EdgeShape*>(eltPtr);
1649     HEXA_NS::FaceShape* geomFace = dynamic_cast<HEXA_NS::FaceShape*>(eltPtr);
1650     if (geomVertex != NULL)
1651         result = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomVertex));
1652     if (geomEdge != NULL)
1653         result = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomEdge));
1654     if (geomFace != NULL)
1655         result = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomFace));
1656
1657     return result;
1658 }
1659
1660 QMultiMap< QString, int >     DocumentModel::getAssocShapesIds(const QModelIndex& dataIndex)
1661 {
1662    QMultiMap< QString, int > result;
1663    HEXA_NS::NewShape* mainShape;
1664    HEXA_NS::VertexShape* node;
1665    HEXA_NS::EdgeShape* line;
1666    HEXA_NS::FaceShape* face;
1667    QString shapeName;
1668    int subid;
1669
1670    PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
1671    QModelIndexList assocsInd = pdsm->getGeomAssociations(dataIndex);
1672    foreach( const QModelIndex& anAssoc, assocsInd )
1673    {
1674       node = getHexaPtr<HEXA_NS::VertexShape*>(anAssoc);
1675       line = getHexaPtr<HEXA_NS::EdgeShape*>(anAssoc);
1676       face = getHexaPtr<HEXA_NS::FaceShape*>(anAssoc);
1677
1678       if (node != NULL)
1679          {
1680             mainShape = node->getParentShape();
1681             if (mainShape != NULL)
1682                {
1683                   shapeName = mainShape->getName();
1684                   subid = node->getIdent();
1685                }
1686          }
1687       else if (line != NULL)
1688          {
1689             mainShape = line->getParentShape();
1690             if (mainShape != NULL)
1691                {
1692                   shapeName = mainShape->getName();
1693                   subid = line->getIdent();
1694                }
1695          }
1696       else if (face != NULL)
1697          {
1698             mainShape = face->getParentShape();
1699             if (mainShape != NULL)
1700                {
1701                   shapeName = mainShape->getName();
1702                   subid = face->getIdent();
1703                }
1704          }
1705
1706       if (!shapeName.isEmpty())
1707          result.insert( shapeName, subid );
1708
1709       shapeName = QString();
1710    }
1711    return result;
1712 }
1713
1714 bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, double x, double y, double z)
1715 {
1716     HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
1717
1718     if (vertex == NULL || _hexaDocument == NULL || vertex->setAssociation(x, y, z) != HOK)
1719         return false;
1720
1721     HEXA_NS::VertexShape* assoc = vertex->getAssociation();
1722     if (assoc != NULL)
1723     {
1724         HEXA_NS::NewShape* mainSh = assoc->getParentShape();
1725         setData( iVertex, QVariant::fromValue(QString(mainSh->getName())+","+QString::number(assoc->getIdent())+";"), HEXA_ASSOC_ENTRY_ROLE );
1726     }
1727
1728     return true;
1729 }
1730
1731 bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, const QModelIndex& iGeomVertex)
1732 {
1733     //parameters control
1734     QString newAssoc;
1735     HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
1736     HEXA_NS::VertexShape* geomVertex = getHexaPtr<HEXA_NS::VertexShape*>(iGeomVertex);
1737     if (_hexaDocument == NULL || vertex == NULL || geomVertex == NULL) return false;
1738     HEXA_NS::NewShape* mainShape = geomVertex->getParentShape();
1739     if (mainShape == NULL) return false;
1740
1741     //add association
1742     if (vertex->setAssociation(geomVertex) != HOK)
1743         return false;
1744
1745     //update association state in the model
1746     newAssoc =  QString(mainShape->getName()) + "," + QString::number(geomVertex->getIdent()) + ";";
1747     setData( iVertex, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
1748
1749     return true;
1750 }
1751
1752 bool DocumentModel::addEdgeAssociation( const QModelIndex& iEdge, const QModelIndex& iGeomEdge, double start, double end)
1753 {
1754     //parameters control
1755     QString currentAssoc, newAssoc;
1756     HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
1757     HEXA_NS::EdgeShape* geomEdge = getHexaPtr<HEXA_NS::EdgeShape*>(iGeomEdge);
1758     if (_hexaDocument == NULL || edge == NULL ||
1759             geomEdge == NULL || start > end) return false;
1760     HEXA_NS::NewShape* mainShape = geomEdge->getParentShape();
1761     if (mainShape == NULL) return false;
1762
1763     //add association in the engine side
1764     if (edge->addAssociation(geomEdge, start, end) != HOK)
1765         return false;
1766
1767     //add/update association in the model side (UI)
1768     currentAssoc = data(iEdge, HEXA_ASSOC_ENTRY_ROLE).toString();
1769     newAssoc = QString(mainShape->getName()) + "," + QString::number(geomEdge->getIdent()) + ";";
1770     if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
1771
1772     setData( iEdge, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
1773
1774     return true;
1775 }
1776
1777
1778 bool DocumentModel::addQuadAssociation (const QModelIndex& iQuad, const QModelIndex& iGeomFace)
1779 {
1780     //parameters control
1781     QString currentAssoc, newAssoc;
1782     HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
1783     HEXA_NS::FaceShape* geomFace = getHexaPtr<HEXA_NS::FaceShape*>(iGeomFace);
1784     if (_hexaDocument == NULL || quad == NULL || geomFace == NULL)
1785         return false;
1786     HEXA_NS::NewShape* mainShape = geomFace->getParentShape();
1787     if (mainShape == NULL) return false;
1788
1789     //add association
1790     if (quad->addAssociation(geomFace) != HOK)
1791         return false;
1792
1793     //update association
1794     currentAssoc = data( iQuad, HEXA_ASSOC_ENTRY_ROLE).toString();
1795     newAssoc = QString(mainShape->getName()) + "," + QString::number(geomFace->getIdent()) + ";";
1796     if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
1797     setData( iQuad, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
1798
1799     return true;
1800 }
1801
1802
1803 QModelIndex DocumentModel::getVertexAssociation(const QModelIndex& iVertex)
1804 {
1805     HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex*>(iVertex);
1806     if (vertex == NULL)
1807         return QModelIndex();
1808
1809     //get the associated geom vertex
1810     HEXA_NS::VertexShape* geomVertex = vertex->getAssociation();
1811     if (geomVertex == NULL)
1812         return QModelIndex();
1813
1814     //convert geom vertex to qmodelindex
1815     PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
1816     if (pgsm == NULL)
1817         return QModelIndex();
1818
1819     return pgsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(geomVertex));
1820 }
1821
1822
1823 QModelIndexList DocumentModel::getEdgeAssociations(const QModelIndex& iEdge)
1824 {
1825     QModelIndexList result;
1826     HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
1827     if (edge == NULL) return result;
1828
1829     HEXA_NS::EdgeShape* geomEdge;
1830     HEXA_NS::AssoEdge* anEdgeAssoc;
1831
1832     PatternGeomSelectionModel* pGSModel = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
1833     int nbAssocs = edge->countAssociation();
1834     for (int i = 0; i < nbAssocs; ++i)
1835     {
1836         anEdgeAssoc = edge->getAssociation(i);
1837         if (anEdgeAssoc == NULL) continue;
1838         geomEdge = anEdgeAssoc->getEdgeShape();
1839         if (geomEdge == NULL) continue;
1840         result << pGSModel->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomEdge));
1841     }
1842
1843     return result;
1844 }
1845
1846
1847 QModelIndexList DocumentModel::getQuadAssociations(const QModelIndex& iQuad)
1848 {
1849     QModelIndexList result;
1850     QModelIndex geomQuadIndex;
1851     HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
1852     if (quad == NULL) return result;
1853
1854     if (HEXABLOCKGUI::currentDocGView == NULL) return result;
1855     PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
1856     PatternGeomModel* pgm = HEXABLOCKGUI::currentDocGView->getPatternGeomModel();
1857     if (pgsm == NULL || pgm == NULL) return result;
1858
1859     HEXA_NS::FaceShape* geomFace;
1860
1861     int nbAssocs = quad->countAssociation();
1862     for (int i = 0; i < nbAssocs; ++i)
1863     {
1864         geomFace = quad->getAssociation(i);
1865         if (geomFace == NULL) continue;
1866
1867         geomQuadIndex = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomFace) );
1868         result << geomQuadIndex;
1869     }
1870
1871     return result;
1872 }
1873
1874
1875 bool DocumentModel::associateOpenedLine( const QModelIndexList& iedges,
1876         HEXA_NS::NewShapes shapes,
1877         HEXA_NS::IntVector subIds,
1878         double pstart,
1879         double pend )
1880 {
1881
1882     HEXA_NS::Edges  mline;
1883
1884     HEXA_NS::Edge* hedge = NULL;
1885     foreach( const QModelIndex& iedge, iedges ){
1886         hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1887         if (hedge != NULL)
1888             mline.push_back( hedge );
1889     }
1890
1891     int err = _hexaDocument->associateOpenedLine( mline, shapes, subIds, pstart, pend );
1892     if ( err == HOK ){
1893         updateData();
1894         return true;
1895     }
1896     return false;
1897 }
1898
1899 bool DocumentModel::associateClosedLine( const  QModelIndex& ivertex,
1900         const  QModelIndexList& iedges,
1901         HEXA_NS::NewShapes shapes,
1902         HEXA_NS::IntVector subIds,
1903         double pstart,
1904         bool   inv )
1905 {
1906     HEXA_NS::Vertex* mfirst = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
1907     HEXA_NS::Edges   mline;
1908
1909     HEXA_NS::Edge* hedge = NULL;
1910     foreach( const QModelIndex& iedge, iedges ){
1911         hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1912         if (hedge != NULL)
1913             mline.push_back( hedge );
1914     }
1915
1916     int err = _hexaDocument->associateClosedLine( mfirst, mline, shapes, subIds, pstart, inv);
1917     if ( err == HOK ){
1918         updateData();
1919         return true;
1920     }
1921     return false;
1922 }
1923
1924 // ************  GROUPS  ************
1925 //
1926 QModelIndex DocumentModel::addGroup( const QString& name, Group kind )
1927 {
1928     QModelIndex iGroup;
1929
1930     HEXA_NS::Group* hGroup = _hexaDocument->addGroup( name.toLocal8Bit().constData(), kind );
1931     if ( hGroup == NULL ) return iGroup;
1932
1933     GroupItem* groupItem = new GroupItem(hGroup);
1934     groupItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
1935     _groupDirItem->appendRow(groupItem);
1936     iGroup = groupItem->index();
1937
1938     return iGroup;
1939 }
1940
1941
1942 bool DocumentModel::removeGroup( const QModelIndex& igrp )
1943 {
1944     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
1945     int r = _hexaDocument->removeGroup ( hGroup );
1946
1947     if ( r == HOK ){
1948         removeRow( igrp.row(), igrp.parent());
1949         return true;
1950     }
1951
1952     return false;
1953 }
1954
1955
1956 QModelIndexList DocumentModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
1957 {
1958     QModelIndexList iElements;
1959
1960     HEXA_NS::Group* g = iGroup.data(HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
1961     if ( g == NULL ) return iElements;
1962
1963     QModelIndexList iFound;
1964     QVariant q;
1965     HEXA_NS::EltBase* eltBase = NULL;
1966     int nbElement = g->countElement();
1967     for ( int nr = 0; nr < nbElement; ++nr ){
1968         eltBase = g->getElement( nr );
1969         kind = g->getKind();
1970         switch ( kind ){
1971         case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: q = QVariant::fromValue( (HEXA_NS::Hexa *)eltBase ); break;
1972         case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: q = QVariant::fromValue( (HEXA_NS::Quad *)eltBase ); break;
1973         case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: q = QVariant::fromValue( (HEXA_NS::Edge *)eltBase ); break;
1974         case HEXA_NS::VertexNode: q = QVariant::fromValue( (HEXA_NS::Vertex *)eltBase ); break;
1975         }
1976         iFound = match( index(0, 0),
1977                 HEXA_DATA_ROLE,
1978                 q,
1979                 1,
1980                 Qt::MatchRecursive );
1981         if ( !iFound.isEmpty() )
1982             iElements << iFound[0];
1983     }
1984     return iElements;
1985 }
1986
1987 // 7.4 Boite: éditer un groupe
1988 void DocumentModel::setGroupName( const QModelIndex& igrp, const QString& name )
1989 {
1990     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
1991
1992     if ( hGroup ){
1993         hGroup->setName( name.toLocal8Bit().constData() );
1994         setData(igrp, QVariant::fromValue( name ) );
1995     }
1996 }
1997
1998 bool DocumentModel::addGroupElement( const QModelIndex& igrp, const QModelIndex& ielt )
1999 {
2000     HEXA_NS::Group*   hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2001     if (hGroup == NULL) return false;
2002
2003     HEXA_NS::EltBase* hElt   = NULL;
2004     switch ( hGroup->getKind() ){
2005     case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: hElt = getHexaPtr<HEXA_NS::Hexa*>(ielt); break;
2006     case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: hElt = getHexaPtr<HEXA_NS::Quad*>(ielt); break;
2007     case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: hElt = getHexaPtr<HEXA_NS::Edge*>(ielt); break;
2008     case HEXA_NS::VertexNode: hElt = getHexaPtr<HEXA_NS::Vertex*>(ielt); break;
2009     }
2010
2011     int res = HERR;
2012     if ( hElt != NULL )
2013         res = hGroup->addElement( hElt );
2014
2015     if ( res == HOK ) return true;
2016
2017     return false;
2018 }
2019
2020 bool DocumentModel::removeGroupElement( const QModelIndex& igrp, int nro )
2021 { //CS_TODO : remove child?
2022     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2023     if (hGroup == NULL) return false;
2024
2025     if (hGroup->removeElement( nro ) == HOK) return true;
2026
2027     return false;
2028 }
2029
2030 bool DocumentModel::clearGroupElement( const QModelIndex& igrp )
2031 {
2032     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2033
2034     if ( hGroup != NULL)
2035     {
2036         hGroup->clearElement();
2037         return true;
2038     }
2039     return false;
2040 }
2041
2042 // ************  LAWS  ************
2043
2044 //
2045 QModelIndex DocumentModel::addLaw( const QString& name, int nbnodes )
2046 {
2047     QModelIndex iLaw;
2048
2049     HEXA_NS::Law* hLaw = _hexaDocument->addLaw( name.toLocal8Bit().constData(), nbnodes );
2050     if ( BadElement(hLaw) ) return iLaw;
2051
2052     LawItem* lawItem = new LawItem(hLaw);
2053     _lawDirItem->appendRow(lawItem);
2054     iLaw = lawItem->index();
2055
2056     return iLaw;
2057 }
2058
2059 bool DocumentModel::setLaw( const QModelIndex& ilaw, int nbnodes, double coeff, KindLaw type )
2060 {
2061     bool ret = false;
2062
2063     HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2064
2065     if ( hLaw ){
2066         int ok;
2067         ok = hLaw->setNodes( nbnodes );
2068         ( ok == HOK) ? ret = true : ret = false;
2069         ok = hLaw->setCoefficient( coeff );
2070         hLaw->setKind(type);
2071     }
2072
2073     return ret;
2074 }
2075
2076 //
2077 bool  DocumentModel::removeLaw( const QModelIndex& ilaw )
2078 {
2079     HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2080     int r = _hexaDocument->removeLaw( hLaw );
2081
2082     if ( r == HOK ){
2083         removeRow( ilaw.row(),  ilaw.parent());
2084         return true;
2085     }
2086
2087     return false;
2088 }
2089
2090 bool DocumentModel::setPropagation( const QModelIndex& iPropagation, const QModelIndex& iLaw, bool way )
2091 {
2092     HEXA_NS::Propagation* hPropagation = data(iPropagation, HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
2093     HEXA_NS::Law* hLaw = data(iLaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2094
2095     int r = hPropagation->setLaw( hLaw );
2096     hPropagation->setWay( way );
2097
2098     if ( r == HOK ) return true;
2099
2100     return false;
2101 }
2102
2103
2104 QModelIndexList DocumentModel::getPropagation( const QModelIndex& iPropagation ) const
2105 {
2106     QModelIndexList iEdges;
2107
2108     QModelIndexList iFound;
2109     HEXA_NS::Propagation* propa = iPropagation.data(HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
2110     if ( propa == NULL ) return iEdges;
2111
2112     const HEXA_NS::Edges& edges = propa->getEdges();
2113     for ( HEXA_NS::Edges::const_iterator anEdge = edges.begin(), endIt = edges.end();
2114             anEdge != endIt;
2115             ++anEdge ){
2116         iFound = match( index(0, 0),
2117                 HEXA_DATA_ROLE,
2118                 QVariant::fromValue( *anEdge ),
2119                 1,
2120                 Qt::MatchRecursive);
2121         if ( !iFound.isEmpty() )
2122             iEdges << iFound[0];
2123     }
2124
2125     return iEdges;
2126 }
2127
2128 HEXA_NS::Document* DocumentModel::documentImpl()
2129 {
2130     return _hexaDocument;
2131 }
2132
2133 QString DocumentModel::documentEntry()
2134 {
2135     return _entry;
2136 }
2137
2138 // 8.3 Boite: éditer une loi  CS_TODO
2139 // (idem création)
2140
2141 /*****************************************************************
2142                       PatternDataModel
2143  *****************************************************************/
2144
2145 PatternDataModel::PatternDataModel( QObject * parent ) :
2146                               QSortFilterProxyModel( parent )
2147 {
2148     QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8)").
2149             arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).
2150             arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).arg(HEXA_DIR_TREE);
2151
2152     setFilterRole(HEXA_TREE_ROLE);
2153     setFilterRegExp ( QRegExp(dataRegExp) );
2154 }
2155
2156 // *** Pour suppression des panneaux "Builder" et "Geometry" ****/
2157
2158 //PatternDataModel::PatternDataModel( QObject * parent ) :
2159 //                              QSortFilterProxyModel( parent )
2160 //{
2161 //    QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12|%13|%14|%15|%16|%17|%18|%19|%20|%21|%22|%23|%24|%25|%26)").
2162 //            arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).
2163 //            arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).
2164 //            arg(HEXA_DIR_TREE).arg(VECTOR_TREE).arg(ELEMENTS_TREE).
2165 //            arg(VECTOR_DIR_TREE).arg(ELEMENTS_DIR_TREE).
2166 //            arg(IMPLICIT_SHAPES_TREE).arg(EXPLICIT_SHAPES_TREE).arg(CLOUD_OF_POINTS_TREE).
2167 //            arg(GEOMSHAPE_TREE).arg(GEOMPOINT_TREE).arg(GEOMEDGE_TREE).arg(GEOMFACE_TREE).
2168 //            arg(IMPLICIT_SHAPES_DIR_TREE).arg(EXPLICIT_SHAPES_DIR_TREE).arg(CLOUD_OF_POINTS_DIR_TREE).
2169 //            arg(GEOMSHAPE_DIR_TREE).arg(GEOMPOINT_DIR_TREE).arg(GEOMEDGE_DIR_TREE).arg(GEOMFACE_DIR_TREE);
2170 //
2171 //    setFilterRole(HEXA_TREE_ROLE);
2172 //    setFilterRegExp ( QRegExp(dataRegExp) );
2173 //}
2174
2175 // ****************
2176
2177 PatternDataModel::~PatternDataModel()
2178 {
2179 }
2180
2181 HEXA_NS::Document* PatternDataModel::documentImpl()
2182 {
2183     HEXA_NS::Document* doc = NULL;
2184     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2185     if (m) doc = m->documentImpl();
2186     return doc;
2187 }
2188
2189 QString PatternDataModel::documentEntry()
2190 {
2191     QString entry;
2192     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2193     if (m) entry = m->documentEntry();
2194     return entry;
2195 }
2196
2197 Qt::ItemFlags PatternDataModel::flags(const QModelIndex &index) const
2198 {
2199     Qt::ItemFlags flags;
2200
2201     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2202     if ( m != NULL ){
2203         flags = m->flags( mapToSource(index) );
2204     }
2205     return flags;
2206 }
2207
2208
2209 QVariant PatternDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2210 {
2211     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2212         return QVariant( "Data" );
2213     } else {
2214         return QSortFilterProxyModel::headerData ( section, orientation, role );
2215     }
2216 }
2217
2218
2219 QStandardItem* PatternDataModel::itemFromIndex ( const QModelIndex & index ) const
2220 {
2221     QStandardItem *item = NULL;
2222     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2223     if ( m != NULL ){
2224         item = m->itemFromIndex( mapToSource(index) );
2225     }
2226     return item;
2227 }
2228
2229 PatternBuilderModel::PatternBuilderModel( QObject * parent ) :
2230                               QSortFilterProxyModel( parent )
2231 {
2232     QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10)").
2233             arg(VECTOR_TREE).arg(CYLINDER_TREE).arg(PIPE_TREE).arg(ELEMENTS_TREE).
2234             arg(CROSSELEMENTS_TREE).arg(VECTOR_DIR_TREE).arg(CYLINDER_DIR_TREE).
2235             arg(PIPE_DIR_TREE).arg(ELEMENTS_DIR_TREE).arg(CROSSELEMENTS_DIR_TREE);
2236
2237     setFilterRole( HEXA_TREE_ROLE );
2238     setFilterRegExp ( QRegExp( builderRegExp ) );
2239 }
2240
2241 PatternBuilderModel::~PatternBuilderModel()
2242 {
2243 }
2244
2245 Qt::ItemFlags PatternBuilderModel::flags(const QModelIndex &index) const
2246 {
2247     Qt::ItemFlags flags;
2248
2249     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2250     if ( m != NULL ){
2251         flags = m->flags( mapToSource(index) );
2252     }
2253     return flags;
2254 }
2255
2256 QVariant PatternBuilderModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2257 {
2258     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2259         return QVariant( "Builder" );
2260     } else {
2261         return QSortFilterProxyModel::headerData ( section, orientation, role );
2262     }
2263 }
2264
2265 QStandardItem* PatternBuilderModel::itemFromIndex ( const QModelIndex & index ) const
2266 {
2267     QStandardItem *item = NULL;
2268     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2269     if ( m != NULL ){
2270         item = m->itemFromIndex( mapToSource(index) );
2271     }
2272     return item;
2273 }
2274
2275 //====================================================================
2276 //              PatternGeomModel
2277 //====================================================================
2278 PatternGeomModel::PatternGeomModel( QObject * parent ) :
2279                               QSortFilterProxyModel( parent )
2280 {
2281     QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12|%13|%14)").
2282             arg(EXPLICIT_SHAPES_TREE).arg(IMPLICIT_SHAPES_TREE).arg(CLOUD_OF_POINTS_TREE).
2283             arg(GEOMSHAPE_TREE).arg(GEOMPOINT_TREE).arg(GEOMEDGE_TREE).arg(GEOMFACE_TREE).
2284             arg(EXPLICIT_SHAPES_DIR_TREE).arg(IMPLICIT_SHAPES_DIR_TREE).arg(CLOUD_OF_POINTS_DIR_TREE).
2285             arg(GEOMSHAPE_DIR_TREE).arg(GEOMPOINT_DIR_TREE).arg(GEOMEDGE_DIR_TREE).arg(GEOMFACE_DIR_TREE);
2286
2287     setFilterRole( HEXA_TREE_ROLE );
2288     setFilterRegExp ( QRegExp(builderRegExp ) );
2289 }
2290
2291 PatternGeomModel::~PatternGeomModel()
2292 {
2293 }
2294
2295 Qt::ItemFlags PatternGeomModel::flags(const QModelIndex &index) const
2296 {
2297     Qt::ItemFlags flags;
2298
2299     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2300     if ( m != NULL ){
2301         flags = m->flags( mapToSource(index) );
2302     }
2303     return flags;
2304 }
2305
2306 QVariant PatternGeomModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2307 {
2308     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2309         return QVariant( "Geometry" );
2310     } else {
2311         return QSortFilterProxyModel::headerData ( section, orientation, role );
2312     }
2313 }
2314
2315 QStandardItem* PatternGeomModel::itemFromIndex ( const QModelIndex & index ) const
2316 {
2317     QStandardItem *item = NULL;
2318     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2319     if ( m != NULL ){
2320         item = m->itemFromIndex( mapToSource(index) );
2321     }
2322     return item;
2323 }
2324 //==============================================================
2325
2326
2327 AssociationsModel::AssociationsModel( QObject * parent ) :
2328                               QSortFilterProxyModel( parent )
2329 {
2330     QString assocRegExp;
2331
2332     setFilterRole( HEXA_TREE_ROLE );
2333     setFilterRegExp ( QRegExp(assocRegExp) );
2334 }
2335
2336 AssociationsModel::~AssociationsModel()
2337 {
2338 }
2339
2340 Qt::ItemFlags AssociationsModel::flags(const QModelIndex &index) const
2341 {
2342     Qt::ItemFlags flags;
2343
2344     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2345     if ( m != NULL ){
2346         flags = m->flags( mapToSource(index) );
2347     }
2348     return flags;
2349 }
2350
2351 QVariant AssociationsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2352 {
2353     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2354         return QVariant( "Associations" );
2355     } else {
2356         return QSortFilterProxyModel::headerData ( section, orientation, role );
2357     }
2358 }
2359
2360 QStandardItem* AssociationsModel::itemFromIndex ( const QModelIndex & index ) const
2361 {
2362     QStandardItem *item = NULL;
2363     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2364     if ( m != NULL ){
2365         item = m->itemFromIndex( mapToSource(index) );
2366     }
2367     return item;
2368 }
2369
2370 GroupsModel::GroupsModel( QObject * parent ) :
2371                               QSortFilterProxyModel( parent )
2372 {
2373     QString groupsRegExp =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE);
2374
2375     setFilterRole( HEXA_TREE_ROLE );
2376     setFilterRegExp ( QRegExp(groupsRegExp ) );
2377 }
2378
2379 GroupsModel::~GroupsModel()
2380 {
2381 }
2382
2383 Qt::ItemFlags GroupsModel::flags(const QModelIndex &index) const
2384 {
2385     Qt::ItemFlags flags;
2386
2387     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2388     if ( m != NULL ){
2389         flags = m->flags( mapToSource(index) );
2390     }
2391     return flags;
2392 }
2393
2394 QVariant GroupsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2395 {
2396     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2397         return QVariant( "Groups" );
2398     } else {
2399         return QSortFilterProxyModel::headerData ( section, orientation, role );
2400     }
2401 }
2402
2403 QStandardItem* GroupsModel::itemFromIndex ( const QModelIndex & index ) const
2404 {
2405     QStandardItem *item = NULL;
2406     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2407     if ( m != NULL ){
2408         item = m->itemFromIndex( mapToSource(index) );
2409     }
2410     return item;
2411 }
2412
2413 QModelIndexList GroupsModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
2414 {
2415     QModelIndexList elements;
2416     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2417     if ( m != NULL ){
2418         elements = m->getGroupElements( mapToSource(iGroup), kind );
2419     }
2420     return elements;
2421 }
2422
2423 MeshModel::MeshModel( QObject * parent ) :
2424                               QSortFilterProxyModel( parent )
2425 {
2426     QString meshRegExp =QString("(%1|%2|%3|%4)").arg(LAW_TREE).arg(LAW_DIR_TREE)                            .arg(PROPAGATION_TREE).arg(PROPAGATION_DIR_TREE);
2427
2428     setFilterRole( HEXA_TREE_ROLE );
2429     setFilterRegExp ( QRegExp(meshRegExp) );
2430 }
2431
2432 MeshModel::~MeshModel()
2433 {
2434 }
2435
2436 Qt::ItemFlags MeshModel::flags(const QModelIndex &index) const
2437 {
2438     Qt::ItemFlags flags;
2439
2440     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2441     if ( m != NULL ){
2442         flags = m->flags( mapToSource(index) );
2443     }
2444     return flags;
2445 }
2446
2447 QVariant MeshModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2448 {
2449     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2450         return QVariant( "Mesh" );
2451     } else {
2452         return QSortFilterProxyModel::headerData ( section, orientation, role );
2453     }
2454 }
2455
2456 QStandardItem* MeshModel::itemFromIndex ( const QModelIndex & index ) const
2457 {
2458     QStandardItem *item = NULL;
2459     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2460     if ( m != NULL ){
2461         item = m->itemFromIndex( mapToSource(index) );
2462     }
2463     return item;
2464 }
2465
2466 QModelIndexList MeshModel::getPropagation( const QModelIndex& iPropagation ) const
2467 {
2468     QModelIndexList edges;
2469     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2470     if ( m != NULL ){
2471         edges = m->getPropagation( mapToSource(iPropagation) );
2472     }
2473     return edges;
2474 }
2475
2476
2477 // ================================== NEW ======================================
2478
2479 // ===== CARTESIAN GRID
2480
2481 QModelIndex DocumentModel::makeCartesianTop(int nx, int ny, int nz)
2482 {
2483     QModelIndex result;
2484
2485     HEXA_NS::Elements* helts = _hexaDocument->makeCartesianTop( nx, ny, nz );
2486     if ( BadElement(helts) )
2487         return result;
2488
2489     result = addToElementsTree(helts);
2490
2491     return result;
2492 }
2493
2494 QModelIndex DocumentModel::makeCartesianUni(const QModelIndex& icenter,
2495                             const QModelIndex& ibase, const QModelIndex& ivec, const QModelIndex& iaxis,
2496                             double lx, double ly, double lz, int nx, int ny, int nz)
2497 {
2498     QModelIndex result;
2499
2500     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2501     HEXA_NS::Vector* hbase   = getHexaPtr<HEXA_NS::Vector*>(ibase);
2502     HEXA_NS::Vector* hvec    = getHexaPtr<HEXA_NS::Vector*>(ivec);
2503     HEXA_NS::Vector* haxis   = getHexaPtr<HEXA_NS::Vector*>(iaxis);
2504
2505     HEXA_NS::Elements* helts = _hexaDocument->makeCartesianUni( hcenter, hbase, hvec, haxis,
2506                                                                 lx, ly, lz, nx, ny, nz);
2507     if ( BadElement(helts) )
2508         return result;
2509
2510     result = addToElementsTree(helts);
2511
2512     return result;
2513 }
2514
2515 QModelIndex DocumentModel::makeCartesian(const QModelIndex& icenter,
2516                                          const QModelIndex& ibase, const QModelIndex& ivec, const QModelIndex& iaxis,
2517                                          vector<double>& radius, vector<double>& angles, vector<double>& heights)
2518 {
2519     QModelIndex result;
2520
2521     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2522     HEXA_NS::Vector* hbase   = getHexaPtr<HEXA_NS::Vector*>(ibase);
2523     HEXA_NS::Vector* hvec    = getHexaPtr<HEXA_NS::Vector*>(ivec);
2524     HEXA_NS::Vector* haxis   = getHexaPtr<HEXA_NS::Vector*>(iaxis);
2525
2526     HEXA_NS::Elements* helts = _hexaDocument->makeCartesian( hcenter, hbase, hvec, haxis,
2527                                                              radius, angles, heights);
2528     if ( BadElement(helts) )
2529         return result;
2530
2531     result = addToElementsTree(helts);
2532
2533     return result;
2534 }
2535
2536
2537 // ===== SPHERE
2538
2539 QModelIndex DocumentModel::makeSphereTop (int nr, int na, int nh)
2540 {
2541     QModelIndex result;
2542
2543     HEXA_NS::Elements* helts = _hexaDocument->makeSphereTop( nr, na, nh );
2544     if ( BadElement(helts) )
2545         return result;
2546
2547     result = addToElementsTree(helts);
2548
2549     return result;
2550 }
2551
2552 QModelIndex DocumentModel::makeSphereUni (QModelIndex& icenter,
2553                                           QModelIndex& ivec_x, QModelIndex& ivec_z,
2554                                           double rtrou, double rext, double ang,
2555                                           QModelIndex& ivplan,
2556                                           int nr, int na, int nh)
2557 {
2558     QModelIndex result;
2559
2560     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2561     HEXA_NS::Vector* hvec_x  = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
2562     HEXA_NS::Vector* hvec_z  = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
2563     HEXA_NS::Vertex* hvplan  = getHexaPtr<HEXA_NS::Vertex*>(ivplan);
2564
2565     HEXA_NS::Elements* helts = _hexaDocument->makeSphereUni( hcenter, hvec_x, hvec_z,
2566                                                              rtrou, rext, ang, hvplan,
2567                                                              nr, na, nh);
2568     result = addToElementsTree(helts);
2569
2570     return result;
2571 }
2572
2573 QModelIndex DocumentModel::makeSphere    (QModelIndex& icenter,
2574                                           QModelIndex& ivec_x, QModelIndex& ivec_z,
2575                                           vector<double>& tray, vector<double>& tang, vector<double>& thaut)
2576 {
2577     QModelIndex result;
2578
2579     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2580     HEXA_NS::Vector* hvec_x  = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
2581     HEXA_NS::Vector* hvec_z  = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
2582
2583     HEXA_NS::Elements* helts = _hexaDocument->makeSphere( hcenter, hvec_x, hvec_z,
2584                                                           tray, tang, thaut);
2585
2586     result = addToElementsTree(helts);
2587
2588     return result;
2589 }
2590
2591 // ====== SPHERICAL
2592
2593 QModelIndex DocumentModel::makeSphericalTop (int nbre, int crit)
2594 {
2595     QModelIndex result;
2596
2597     HEXA_NS::Elements* helts = _hexaDocument->makeSphericalTop(nbre, crit);
2598     if (BadElement(helts))
2599         return result;
2600
2601     result = addToElementsTree(helts);
2602
2603     return result;
2604 }
2605
2606 QModelIndex DocumentModel::makeSphericalUni (QModelIndex& icenter,
2607                                              QModelIndex& ivec_x, QModelIndex& ivec_z,
2608                                              double rayon,
2609                                              int nbre, int crit)
2610 {
2611     QModelIndex result;
2612
2613     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2614     HEXA_NS::Vector* hvec_x  = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
2615     HEXA_NS::Vector* hvec_z  = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
2616
2617     HEXA_NS::Elements* helts = _hexaDocument->makeSphericalUni(hcenter, hvec_x, hvec_z, rayon, nbre, crit);
2618     if (BadElement(helts))
2619         return result;
2620
2621     result = addToElementsTree(helts);
2622
2623     return result;
2624 }
2625
2626 QModelIndex DocumentModel::makeSpherical    (QModelIndex& icenter,
2627                                              QModelIndex& ivec_x, QModelIndex& ivec_z,
2628                                              vector<double>& rayon,
2629                                              int crit)
2630 {
2631     QModelIndex result;
2632
2633     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2634     HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
2635     HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
2636
2637     HEXA_NS::Elements* helts = _hexaDocument->makeSpherical(hcenter, hvec_x, hvec_z, rayon, crit);
2638     if (BadElement(helts))
2639         return result;
2640
2641     result = addToElementsTree(helts);
2642
2643     return result;
2644 }
2645
2646 // ===== RIND
2647 QModelIndex DocumentModel::makeRindTop (int nr, int na, int nh)
2648 {
2649     QModelIndex result;
2650
2651     HEXA_NS::Elements* helts = _hexaDocument->makeRindTop(nr, na, nh);
2652     if (BadElement(helts))
2653         return result;
2654
2655     result = addToElementsTree(helts);
2656
2657     return result;
2658 }
2659
2660 QModelIndex DocumentModel::makeRindUni (QModelIndex& icenter,
2661                                         QModelIndex& ivec_x, QModelIndex& ivec_z,
2662                                         double raytrou, double rint, double rext, double ang,
2663                                         QModelIndex& ivplan,
2664                                         int nr, int na, int nh)
2665 {
2666     QModelIndex result;
2667
2668     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2669     HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
2670     HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
2671     HEXA_NS::Vertex* hvplan = getHexaPtr<HEXA_NS::Vertex*>(ivplan);
2672
2673     HEXA_NS::Elements* helts = _hexaDocument->makeRindUni(hcenter, hvec_x, hvec_z, raytrou, rint, rext, ang,
2674                                                           hvplan, nr, na, nh);
2675     if (BadElement(helts))
2676         return result;
2677
2678     result = addToElementsTree(helts);
2679
2680     return result;
2681 }
2682
2683 QModelIndex DocumentModel::makeRind    (QModelIndex& icenter,
2684                                         QModelIndex& ivec_x, QModelIndex& ivec_z,
2685                                         vector<double>& tray, vector<double>& tang, vector<double>& thaut)
2686 {
2687     QModelIndex result;
2688
2689     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2690     HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
2691     HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
2692
2693     HEXA_NS::Elements* helts = _hexaDocument->makeRind(hcenter, hvec_x, hvec_z, tray, tang, thaut);
2694     if (BadElement(helts))
2695         return result;
2696
2697     result = addToElementsTree(helts);
2698
2699     return result;
2700 }
2701
2702 // ======== Cylinder
2703 QModelIndex DocumentModel::makeCylinderTop(int nr, int na, int nh)
2704 {
2705     QModelIndex result;
2706
2707     HEXA_NS::Elements* helts = _hexaDocument->makeCylinderTop(nr, na, nh);
2708     if (BadElement(helts))
2709         return result;
2710
2711     result = addToElementsTree(helts);
2712
2713     return result;
2714 }
2715
2716 QModelIndex DocumentModel::makeCylinderUni(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
2717                                            double rint, double rext, double angle, double haut,
2718                                            int nr, int na, int nh)
2719 {
2720     QModelIndex result;
2721
2722     HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
2723     HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
2724     HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
2725
2726     HEXA_NS::Elements* helts = _hexaDocument->makeCylinderUni(horig, hvecx, hvecz,
2727                                                               rint, rext, angle, haut,
2728                                                               nr, na, nh);
2729     if (BadElement(helts))
2730         return result;
2731
2732     result = addToElementsTree(helts);
2733
2734     return result;
2735 }
2736
2737 QModelIndex DocumentModel::makeCylinder(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
2738                                         vector<double>& tray, vector<double>& tang, vector<double>& thaut)
2739 {
2740     QModelIndex result;
2741
2742     HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
2743     HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
2744     HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
2745
2746     HEXA_NS::Elements* helts = _hexaDocument->makeCylinder(horig, hvecx, hvecz, tray, tang, thaut);
2747     if (BadElement(helts))
2748         return result;
2749
2750     result = addToElementsTree(helts);
2751
2752     return result;
2753 }
2754
2755
2756 // ======== Cylinders
2757 QModelIndex DocumentModel::makeCylinders(QModelIndex& iorig1, QModelIndex& ivecz1,  double r1, double h1,
2758                                          QModelIndex& iorig2, QModelIndex& ivecz2, double r2, double h2)
2759 {
2760     QModelIndex result;
2761
2762     HEXA_NS::Vertex* horig1 = getHexaPtr<HEXA_NS::Vertex*>(iorig1);
2763     HEXA_NS::Vertex* horig2 = getHexaPtr<HEXA_NS::Vertex*>(iorig2);
2764     HEXA_NS::Vector* hvecz1 = getHexaPtr<HEXA_NS::Vector*>(ivecz1);
2765     HEXA_NS::Vector* hvecz2 = getHexaPtr<HEXA_NS::Vector*>(ivecz2);
2766
2767     HEXA_NS::BiCylinder* helts = _hexaDocument->makeCylinders(horig1, hvecz1, r1, h1,
2768                                                               horig2, hvecz2, r2, h2);
2769     if (BadElement(helts))
2770         return result;
2771
2772     result = addToElementsTree(helts);
2773
2774     return result;
2775 }
2776
2777 // =========== PIPE
2778 QModelIndex DocumentModel::makePipeTop(int nr, int na, int nh)
2779 {
2780     QModelIndex result;
2781
2782     HEXA_NS::Elements* helts = _hexaDocument->makePipeTop(nr, na, nh);
2783     if (BadElement(helts))
2784         return result;
2785
2786     result = addToElementsTree(helts);
2787
2788     return result;
2789 }
2790
2791 QModelIndex DocumentModel::makePipeUni(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
2792                                        double rint, double rext, double angle, double haut,
2793                                        int nr, int na, int nh)
2794 {
2795     QModelIndex result;
2796
2797     HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
2798     HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
2799     HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
2800
2801     HEXA_NS::Elements* helts = _hexaDocument->makePipeUni(horig, hvecx, hvecz, rint, rext, angle,
2802                                                           haut, nr, na, nh);
2803     if (BadElement(helts))
2804         return result;
2805
2806     result = addToElementsTree(helts);
2807
2808     return result;
2809 }
2810
2811 QModelIndex DocumentModel::makePipe(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
2812                                     vector<double>& tray, vector<double>& tang, vector<double>& thaut)
2813 {
2814     QModelIndex result;
2815
2816     HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
2817     HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
2818     HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
2819
2820     HEXA_NS::Elements* helts = _hexaDocument->makePipe(horig, hvecx, hvecz, tray, tang, thaut);
2821     if (BadElement(helts))
2822         return result;
2823
2824     result = addToElementsTree(helts);
2825
2826     return result;
2827 }
2828
2829 // ======== Pipes
2830 QModelIndex DocumentModel::makePipes(QModelIndex& iorig1, QModelIndex& ivecz1, double rint1, double rex1, double h1,
2831                                      QModelIndex& iorig2, QModelIndex& ivecz2, double rint2, double rex2, double h2)
2832 {
2833     QModelIndex result;
2834
2835     HEXA_NS::Vertex* horig1 = getHexaPtr<HEXA_NS::Vertex*>(iorig1);
2836     HEXA_NS::Vertex* horig2 = getHexaPtr<HEXA_NS::Vertex*>(iorig2);
2837     HEXA_NS::Vector* hvecz1 = getHexaPtr<HEXA_NS::Vector*>(ivecz1);
2838     HEXA_NS::Vector* hvecz2 = getHexaPtr<HEXA_NS::Vector*>(ivecz2);
2839
2840     HEXA_NS::BiCylinder* helts = _hexaDocument->makePipes(horig1, hvecz1, rint1, rex1, h1,
2841                                                         horig2, hvecz2, rint2, rex2, h2);
2842     if (BadElement(helts))
2843         return result;
2844
2845     result = addToElementsTree(helts);
2846
2847     return result;
2848 }
2849
2850 // ======== Join Quads
2851 QModelIndex DocumentModel::joinQuadUni(QModelIndex&  istart, QModelIndex& idest, QModelIndex& iv1, QModelIndex& iv2,
2852                                        QModelIndex& iv3, QModelIndex& iv4, int nb)
2853 {
2854     QModelIndex result;
2855
2856     HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
2857     HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
2858     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
2859     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
2860     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
2861     HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
2862
2863     HEXA_NS::Elements* helts = _hexaDocument->joinQuadUni(hstart, hdest, hv1, hv2, hv3, hv4, nb);
2864     if (BadElement(helts))
2865         return result;
2866
2867     result = addToElementsTree(helts);
2868
2869     return result;
2870 }
2871
2872 QModelIndex DocumentModel::joinQuad(QModelIndex&  istart, QModelIndex& idest, QModelIndex& iva1, QModelIndex& ivb1,
2873                      QModelIndex& iva2, QModelIndex& ivb2, vector<double>& tlen)
2874 {
2875     QModelIndex result;
2876
2877     HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
2878     HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
2879     HEXA_NS::Vertex* hva1 = getHexaPtr<HEXA_NS::Vertex*>(iva1);
2880     HEXA_NS::Vertex* hvb1 = getHexaPtr<HEXA_NS::Vertex*>(ivb1);
2881     HEXA_NS::Vertex* hva2 = getHexaPtr<HEXA_NS::Vertex*>(iva2);
2882     HEXA_NS::Vertex* hvb2 = getHexaPtr<HEXA_NS::Vertex*>(ivb2);
2883
2884     HEXA_NS::Elements* helts = _hexaDocument->joinQuad(hstart, hdest, hva1, hvb1, hva2, hvb2, tlen);
2885     if (BadElement(helts))
2886         return result;
2887
2888     result = addToElementsTree(helts);
2889
2890     return result;
2891 }
2892
2893 QModelIndex DocumentModel::joinQuadsUni(QModelIndexList& istarts, QModelIndex& idest, QModelIndex& iv1, QModelIndex& iv2,
2894                                         QModelIndex& iv3, QModelIndex& iv4, int nb)
2895 {
2896     QModelIndex result;
2897
2898     HEXA_NS::Quads hstarts;
2899     int nbQuads = istarts.size();
2900     for (int i = 0; i < nbQuads; ++i)
2901         hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
2902
2903     HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
2904     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
2905     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
2906     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
2907     HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
2908
2909     HEXA_NS::Elements* helts = _hexaDocument->joinQuadsUni(hstarts, hdest, hv1, hv2, hv3, hv4, nb);
2910     if (BadElement(helts))
2911         return result;
2912
2913     result = addToElementsTree(helts);
2914
2915     return result;
2916 }
2917
2918 QModelIndex DocumentModel::joinQuads(QModelIndexList& istarts, QModelIndex& idest, QModelIndex& iva1, QModelIndex& ivb1,
2919                                      QModelIndex& iva2, QModelIndex& ivb2, vector<double>& tlen)
2920 {
2921     QModelIndex result;
2922
2923     HEXA_NS::Quads hstarts;
2924     int nbQuads = istarts.size();
2925     for (int i = 0; i < nbQuads; ++i)
2926         hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
2927
2928     HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
2929     HEXA_NS::Vertex* hva1 = getHexaPtr<HEXA_NS::Vertex*>(iva1);
2930     HEXA_NS::Vertex* hvb1 = getHexaPtr<HEXA_NS::Vertex*>(ivb1);
2931     HEXA_NS::Vertex* hva2 = getHexaPtr<HEXA_NS::Vertex*>(iva2);
2932     HEXA_NS::Vertex* hvb2 = getHexaPtr<HEXA_NS::Vertex*>(ivb2);
2933
2934     HEXA_NS::Elements* helts = _hexaDocument->joinQuads(hstarts, hdest, hva1, hvb1, hva2, hvb2, tlen);
2935     if (BadElement(helts))
2936         return result;
2937
2938     result = addToElementsTree(helts);
2939
2940     return result;
2941 }
2942
2943 // ======== Quad Revolution
2944 QModelIndex DocumentModel::revolutionQuadUni(QModelIndex& istart, QModelIndex& icenter, QModelIndex& iaxis,
2945                                              double angle, int nbre)
2946 {
2947     QModelIndex result;
2948
2949     HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
2950     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2951     HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
2952
2953     HEXA_NS::Elements* helts = _hexaDocument->revolutionQuadUni(hstart, hcenter, haxis, angle, nbre);
2954     if (BadElement(helts))
2955         return result;
2956
2957     result = addToElementsTree(helts);
2958
2959     return result;
2960 }
2961
2962 QModelIndex DocumentModel::revolutionQuad(QModelIndex& istart, QModelIndex& icenter, QModelIndex& iaxis,
2963                                           vector<double>& angles)
2964 {
2965     QModelIndex result;
2966
2967     HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
2968     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2969     HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
2970
2971     HEXA_NS::Elements* helts = _hexaDocument->revolutionQuad(hstart, hcenter, haxis, angles);
2972     if (BadElement(helts))
2973         return result;
2974
2975     result = addToElementsTree(helts);
2976
2977     return result;
2978 }
2979
2980 QModelIndex DocumentModel::revolutionQuadsUni(QModelIndexList& istarts, QModelIndex& icenter, QModelIndex& iaxis,
2981                                               double angle, int nbre)
2982 {
2983     QModelIndex result;
2984
2985     HEXA_NS::Quads hstarts;
2986     int nbQuads = istarts.count();
2987     for (int i = 0; i < nbQuads; ++i)
2988         hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
2989
2990     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2991     HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
2992
2993     HEXA_NS::Elements* helts = _hexaDocument->revolutionQuadsUni(hstarts, hcenter, haxis, angle, nbre);
2994     if (BadElement(helts))
2995         return result;
2996
2997     result = addToElementsTree(helts);
2998
2999     return result;
3000 }
3001
3002 QModelIndex DocumentModel::revolutionQuads(QModelIndexList& istarts, QModelIndex& icenter, QModelIndex& iaxis,
3003                                            vector<double>& angles)
3004 {
3005     QModelIndex result;
3006
3007     HEXA_NS::Quads hstarts;
3008     int nbQuads = istarts.count();
3009     for (int i = 0; i < nbQuads; ++i)
3010         hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
3011
3012     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
3013     HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
3014
3015     HEXA_NS::Elements* helts = _hexaDocument->revolutionQuads(hstarts, hcenter, haxis, angles);
3016     if (BadElement(helts))
3017         return result;
3018
3019     result = addToElementsTree(helts);
3020
3021     return result;
3022
3023 }
3024
3025 // ==== PrismQuad or ExtrudeQuad
3026 QModelIndex DocumentModel::extrudeQuadTop(QModelIndex& istart, int nbre)
3027 {
3028     QModelIndex result;
3029
3030     HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
3031     HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadTop(hstart, nbre);
3032     if (BadElement(helts))
3033         return result;
3034
3035     result = addToElementsTree(helts);
3036
3037     return result;
3038 }
3039
3040 QModelIndex DocumentModel::extrudeQuadUni(QModelIndex& istart, QModelIndex& dv, double len, int nbre)
3041 {
3042     QModelIndex result;
3043
3044     HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
3045     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(dv);
3046
3047     HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadUni(hstart, hvec, len, nbre);
3048     if (BadElement(helts))
3049         return result;
3050
3051     result = addToElementsTree(helts);
3052
3053     return result;
3054 }
3055
3056 QModelIndex DocumentModel::extrudeQuad(QModelIndex& istart, QModelIndex& dv, vector<double>& tlen)
3057 {
3058     QModelIndex result;
3059
3060     HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
3061     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(dv);
3062
3063     HEXA_NS::Elements* helts = _hexaDocument->extrudeQuad(hstart, hvec, tlen);
3064     if (BadElement(helts))
3065         return result;
3066     result = addToElementsTree(helts);
3067
3068     return result;
3069 }
3070
3071 QModelIndex DocumentModel::extrudeQuadsTop (QModelIndexList& istarts, int nbre)
3072 {
3073     QModelIndex result;
3074
3075     HEXA_NS::Quads hquads;
3076     int nbQuads = istarts.count();
3077     for (int i = 0; i < nbQuads; ++i)
3078         hquads.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
3079
3080     HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadsTop(hquads, nbre);
3081     if (BadElement(helts))
3082         return result;
3083     result = addToElementsTree(helts);
3084
3085     return result;
3086 }
3087
3088 QModelIndex DocumentModel::extrudeQuadsUni (QModelIndexList& istarts, QModelIndex& axis, double len, int nbre)
3089 {
3090     QModelIndex result;
3091
3092     HEXA_NS::Quads hquads;
3093     int nbQuads = istarts.count();
3094     for (int i = 0; i < nbQuads; ++i)
3095         hquads.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
3096
3097     HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(axis);
3098
3099     HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadsUni(hquads, haxis, len, nbre);
3100     if (BadElement(helts))
3101         return result;
3102     result = addToElementsTree(helts);
3103
3104     return result;
3105 }
3106
3107 QModelIndex DocumentModel::extrudeQuads(QModelIndexList& istarts, QModelIndex& iaxis, vector<double>& tlen)
3108 {
3109     QModelIndex result;
3110
3111     HEXA_NS::Quads hquads;
3112     int nbQuads = istarts.count();
3113     for (int i=0; i < nbQuads; ++i)
3114         hquads.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
3115
3116     HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
3117
3118     HEXA_NS::Elements* helts = _hexaDocument->extrudeQuads(hquads, haxis, tlen);
3119     if (BadElement(helts))
3120         return result;
3121     result = addToElementsTree(helts);
3122
3123     return result;
3124 }
3125
3126 // ==== Cut Edge
3127 QModelIndex DocumentModel::cutUni(QModelIndex& iEdge, int nbre)
3128 {
3129     QModelIndex result;
3130
3131     HEXA_NS::Edge* hedge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
3132
3133     HEXA_NS::Elements* helts = _hexaDocument->cutUni(hedge, nbre);
3134     if (BadElement(helts))
3135         return result;
3136     result = addToElementsTree(helts);
3137
3138     return result;
3139 }
3140
3141 QModelIndex DocumentModel::cut(QModelIndex& iEdge, vector<double>& tlen)
3142 {
3143     QModelIndex result;
3144
3145     HEXA_NS::Edge* hedge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
3146
3147     HEXA_NS::Elements* helts = _hexaDocument->cut(hedge, tlen);
3148     if (BadElement(helts))
3149         return result;
3150     result = addToElementsTree(helts);
3151
3152     return result;
3153 }
3154
3155 // ================================== END NEW ==================================
3156
3157
3158 // ================================== OBSOLETE =============================================
3159
3160 QModelIndex DocumentModel::makeCartesian( const QModelIndex& i_pt,
3161         const QModelIndex& i_vec_x, const QModelIndex& i_vec_y, const QModelIndex& i_vec_z,
3162         long nx, long ny, long nz)
3163 {
3164     QModelIndex eltsIndex;
3165
3166     HEXA_NS::Vertex* hpt    = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
3167     HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
3168     HEXA_NS::Vector* hvec_y = getHexaPtr<HEXA_NS::Vector*>(i_vec_y);
3169     HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
3170
3171     HEXA_NS::Elements* new_helts = _hexaDocument->makeCartesian( hpt,
3172             hvec_x, hvec_y, hvec_z,
3173             nx, ny, nz );
3174     if ( BadElement(new_helts) )
3175         return eltsIndex;
3176
3177     updateData(); //CS_TODO more or less?
3178     ElementsItem* eltsItem = new ElementsItem(new_helts);
3179     _elementsDirItem->appendRow(eltsItem);
3180     eltsIndex = eltsItem->index();
3181
3182     return eltsIndex;
3183 }
3184
3185 QModelIndex DocumentModel::makeCartesian( const QModelIndex& ivex,
3186         const QModelIndex& ivec,
3187         int nx, int ny, int nz )
3188 {
3189     QModelIndex iElts;
3190
3191     HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
3192     HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
3193
3194     HEXA_NS::Elements* hElts = _hexaDocument->makeCartesian( hVex,
3195             hVec,
3196             nx, ny, nz );
3197     if ( BadElement(hElts) ) return iElts;
3198
3199     updateData(); //CS_TODO more or less?
3200     ElementsItem* elts = new ElementsItem(hElts);
3201     _elementsDirItem->appendRow(elts);
3202     iElts = elts->index();
3203
3204     return iElts;
3205 }
3206
3207 QModelIndex DocumentModel::makeCylindrical( const QModelIndex& i_pt,
3208         const QModelIndex& i_vec_x, const QModelIndex& i_vec_z,
3209         double dr, double da, double dl,
3210         long nr, long na, long nl,
3211         bool fill )
3212 {
3213
3214     QModelIndex eltsIndex;
3215
3216     HEXA_NS::Vertex* hpt    = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
3217     HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
3218     HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
3219
3220     HEXA_NS::Elements* new_helts = _hexaDocument->makeCylindrical( hpt, hvec_x, hvec_z, dr, da, dl, nr, na, nl, fill );
3221     if ( BadElement(new_helts) ) return eltsIndex;
3222
3223     updateData(); //CS_TODO  more or less?
3224     ElementsItem* eltsItem = new ElementsItem(new_helts);
3225     _elementsDirItem->appendRow(eltsItem);
3226     eltsIndex = eltsItem->index();
3227
3228     return eltsIndex;
3229 }
3230
3231 QModelIndex DocumentModel::makeCylindricals(
3232         const QModelIndex& icenter, const QModelIndex& ibase, const QModelIndex& iheight,
3233         QList< double> radius, QList<double> angles, QList<double> heights,
3234         bool fill ) //HEXA3
3235 {
3236     QModelIndex eltsIndex;
3237
3238     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
3239     HEXA_NS::Vector* hbase   =getHexaPtr<HEXA_NS::Vector*>(ibase);
3240     HEXA_NS::Vector* hheight = getHexaPtr<HEXA_NS::Vector*>(iheight);
3241
3242     std::vector<double> r = radius.toVector().toStdVector();
3243     std::vector<double> a = angles.toVector().toStdVector();
3244     std::vector<double> h = heights.toVector().toStdVector();
3245
3246     HEXA_NS::Elements* helts = _hexaDocument->makeCylindricals(
3247             hcenter, hbase, hheight,
3248             r, a, h,
3249             fill );
3250     if ( BadElement(helts) ) return eltsIndex;
3251
3252     updateData(); //CS_TODO  more or less?
3253     ElementsItem* eltsItem = new ElementsItem(helts);
3254     _elementsDirItem->appendRow(eltsItem);
3255     eltsIndex = eltsItem->index();
3256
3257     return eltsIndex;
3258 }
3259
3260 QModelIndex DocumentModel::makeSpherical( const QModelIndex& iv, const QModelIndex& ivec, int nb, double k)
3261 {
3262     QModelIndex iElts;
3263
3264 //    HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(iv);
3265 //    HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
3266 //
3267 //    HEXA_NS::Elements* hElts = _hexaDocument->makeSpherical( hv, hvec, nb, k ); // OBSOLETE
3268 //    HEXA_NS::Elements* hElts = NULL;
3269 //    if ( BadElement(hElts) ) return iElts;
3270 //
3271 //    updateData(); //CS_TODO more or less?
3272 //    ElementsItem* elts = new ElementsItem(hElts);
3273 //    _elementsDirItem->appendRow(elts);
3274 //    iElts = elts->index();
3275
3276     return iElts;
3277 }
3278
3279 QModelIndex DocumentModel::makeSpherical( const QModelIndex& icenter, double radius, int nb, double k )
3280 {
3281     QModelIndex iElts;
3282
3283     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
3284
3285     HEXA_NS::Elements* helts = _hexaDocument->makeSpherical( hcenter, radius, nb, k );
3286     if ( BadElement(helts) ) return iElts;
3287
3288     updateData(); //CS_TODO more or less?
3289     ElementsItem* eltsItem = new ElementsItem(helts);
3290     _elementsDirItem->appendRow(eltsItem);
3291     iElts = eltsItem->index();
3292
3293     return iElts;
3294 }
3295
3296 QModelIndex DocumentModel::makeCylinder( const QModelIndex& icyl, const QModelIndex& ivec,
3297         int nr, int na, int nl )
3298 {
3299     QModelIndex iElts;
3300
3301     HEXA_NS::Cylinder* hcyl = getHexaPtr<HEXA_NS::Cylinder*>(icyl);
3302     HEXA_NS::Vector* hvec   = getHexaPtr<HEXA_NS::Vector*>(ivec);
3303
3304     HEXA_NS::Elements* hElts = _hexaDocument->makeCylinder( hcyl, hvec, nr, na, nl );
3305     if ( BadElement(hElts) ) return iElts;
3306
3307     updateData(); //CS_TODO more or less?
3308     ElementsItem* elts = new ElementsItem(hElts);
3309     _elementsDirItem->appendRow(elts);
3310     iElts = elts->index();
3311
3312     return iElts;
3313 }
3314
3315 QModelIndex DocumentModel::makeCylinders(const QModelIndex& icyl1, const QModelIndex& icyl2)
3316 { //CS_TODO
3317     QModelIndex iCrossElts;
3318
3319     HEXA_NS::Cylinder* hCyl1  = getHexaPtr<HEXA_NS::Cylinder*>(icyl1);
3320     HEXA_NS::Cylinder* hCyl2  = getHexaPtr<HEXA_NS::Cylinder*>(icyl2);
3321
3322     HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makeCylinders( hCyl1, hCyl2 );
3323     if ( BadElement(hCrossElts) ) return iCrossElts;
3324
3325     updateData(); //CS_TODO more or less?
3326     ElementsItem* crossElts = new ElementsItem(hCrossElts);
3327     _crossElementsDirItem->appendRow(crossElts);
3328     iCrossElts = crossElts->index();
3329
3330     return iCrossElts;
3331 }
3332
3333 QModelIndex DocumentModel::addEdgeVector( const QModelIndex &i_v, const QModelIndex &i_vec )
3334 {
3335     QModelIndex edgeIndex;
3336
3337     HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(i_v);
3338     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(i_vec);
3339
3340     if (!hv || !hvec) return edgeIndex;
3341
3342 //    HEXA_NS::Edge* he = _hexaDocument->addEdge( hv, hvec ); //OBSOLETE
3343     HEXA_NS::Edge* he = NULL;
3344     if ( BadElement(he) ) return edgeIndex;
3345
3346     HEXA_NS::Vertex* hv2 = he->getAval(); //the new vertex resulting from the creation of the edge
3347     if (hv2 == NULL) return edgeIndex;
3348
3349     //ADD the elements in the treeview
3350     //The Edge
3351     EdgeItem* e = new EdgeItem(he, _entry);
3352     _edgeDirItem->appendRow(e);
3353
3354     //The resulting Vertex
3355     VertexItem* v = new VertexItem(hv2, _entry);
3356     _vertexDirItem->appendRow(v);
3357     edgeIndex = e->index();
3358     emit patternDataChanged();
3359
3360     return edgeIndex;
3361 }
3362
3363 QModelIndex DocumentModel::addCylinder( const QModelIndex &iv, const QModelIndex &ivec, double r,  double h )
3364 {
3365     QModelIndex iCyl;
3366
3367     HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(iv);
3368     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
3369
3370     HEXA_NS::Cylinder* hcyl = _hexaDocument->addCylinder( hv, hvec, r, h );
3371     if ( BadElement(hcyl) ) return iCyl;
3372
3373     CylinderItem* cyl = new CylinderItem(hcyl);
3374     _cylinderDirItem->appendRow(cyl);
3375     iCyl = cyl->index();
3376
3377     return iCyl;
3378 }
3379
3380
3381 QModelIndex DocumentModel::addPipe( const QModelIndex &iv, const QModelIndex &ivec, double ri, double re, double h )
3382 {
3383     QModelIndex iPipe;
3384
3385     HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(iv);
3386     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
3387
3388     HEXA_NS::Pipe* hPipe = _hexaDocument->addPipe( hv, hvec, ri, re, h );
3389     if ( BadElement(hPipe) ) return iPipe;
3390
3391     PipeItem* pipe = new PipeItem(hPipe);
3392     _pipeDirItem->appendRow(pipe);
3393     iPipe = pipe->index();
3394
3395     return iPipe;
3396 }
3397
3398 QModelIndex DocumentModel::makePipe( const QModelIndex& ipipe, const QModelIndex& ivecx,
3399         int nr, int na, int nl )
3400 {
3401     QModelIndex iElts;
3402
3403     HEXA_NS::Pipe*   hPipe  = getHexaPtr<HEXA_NS::Pipe*>(ipipe);
3404     HEXA_NS::Vector* hVecx  = getHexaPtr<HEXA_NS::Vector*>(ivecx);
3405
3406     HEXA_NS::Elements* hElts = _hexaDocument->makePipe( hPipe, hVecx, nr, na, nl );
3407     if ( BadElement(hElts) ) return iElts;
3408
3409     updateData(); //CS_TODO more or less?
3410     ElementsItem* elts = new ElementsItem(hElts);
3411     _elementsDirItem->appendRow(elts);
3412     iElts = elts->index();
3413
3414     return iElts;
3415 }
3416
3417 //
3418 QModelIndex DocumentModel::makePipes( const QModelIndex& ipipe1, const QModelIndex& ipipe2 )
3419 {
3420     QModelIndex iCrossElts;
3421
3422     HEXA_NS::Pipe* hPipe1  = getHexaPtr<HEXA_NS::Pipe*>(ipipe1);
3423     HEXA_NS::Pipe* hPipe2  = getHexaPtr<HEXA_NS::Pipe*>(ipipe2);
3424
3425     HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makePipes( hPipe1, hPipe2 );
3426     if ( BadElement(hCrossElts) ) return iCrossElts;
3427
3428     updateData(); //CS_TODO more or less?
3429     ElementsItem* crossElts = new ElementsItem(hCrossElts);
3430     _crossElementsDirItem->appendRow(crossElts);
3431     iCrossElts = crossElts->index();
3432
3433     return iCrossElts;
3434 }
3435
3436 QModelIndex DocumentModel::makeRind( const QModelIndex& icenter,
3437         const QModelIndex& ivecx, const QModelIndex& ivecz,
3438         double  radext, double radint, double radhole,
3439         const QModelIndex& iplorig,
3440         int nrad, int nang, int nhaut )
3441 {
3442     QModelIndex iElts;
3443
3444     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
3445     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
3446     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
3447     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
3448
3449     HEXA_NS::Elements* hElts = _hexaDocument->makeRind( hcenter,
3450             hvecx, hvecz,
3451             radext, radint, radhole,
3452             hplorig,
3453             nrad, nang, nhaut );
3454     if ( BadElement(hElts) ) return iElts;
3455
3456     updateData(); //CS_TODO more or less?
3457     ElementsItem* eltsItem = new ElementsItem(hElts);
3458     _elementsDirItem->appendRow(eltsItem);
3459     iElts = eltsItem->index();
3460
3461     return iElts;
3462 }
3463
3464 QModelIndex DocumentModel::makePartRind( const QModelIndex& icenter,
3465         const QModelIndex& ivecx, const QModelIndex& ivecz,
3466         double  radext, double radint, double radhole,
3467         const QModelIndex& iplorig, double angle,
3468         int nrad, int nang, int nhaut )
3469 {
3470     QModelIndex iElts;
3471
3472     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
3473     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
3474     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
3475     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
3476
3477     HEXA_NS::Elements* hElts = _hexaDocument->makePartRind( hcenter,
3478             hvecx, hvecz,
3479             radext, radint, radhole,
3480             hplorig, angle,
3481             nrad, nang, nhaut );
3482     if ( BadElement(hElts) ) return iElts;
3483
3484     updateData();
3485     ElementsItem* eltsItem = new ElementsItem(hElts);
3486     _elementsDirItem->appendRow(eltsItem);
3487     iElts = eltsItem->index();
3488
3489     return iElts;
3490 }
3491
3492 QModelIndex DocumentModel::makeSphere( const QModelIndex& icenter,
3493         const QModelIndex& ivecx, const QModelIndex& ivecz,
3494         double radius, double radhole,
3495         const QModelIndex& iplorig,
3496         int nrad, int nang, int nhaut )
3497 {
3498     QModelIndex iElts;
3499
3500     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
3501     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
3502     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
3503     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
3504
3505     HEXA_NS::Elements* hElts = _hexaDocument->makeSphere( hcenter,
3506             hvecx, hvecz,
3507             radius, radhole,
3508             hplorig,
3509             nrad, nang, nhaut);
3510     if ( BadElement(hElts) ) return iElts;
3511
3512     updateData();
3513     ElementsItem* eltsItem = new ElementsItem(hElts);
3514     _elementsDirItem->appendRow(eltsItem);
3515     iElts = eltsItem->index();
3516
3517     return iElts;
3518 }
3519
3520 QModelIndex DocumentModel::makePartSphere( const QModelIndex& icenter,
3521         const QModelIndex& ivecx, const QModelIndex& ivecz,
3522         double  radius, double radhole,
3523         const QModelIndex& iplorig, double angle,
3524         int nrad, int nang, int nhaut )
3525 {
3526     QModelIndex iElts;
3527
3528     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
3529     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
3530     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
3531     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
3532
3533     HEXA_NS::Elements* hElts = _hexaDocument->makePartSphere( hcenter,
3534             hvecx, hvecz,
3535             radius, radhole,
3536             hplorig, angle,
3537             nrad, nang, nhaut);
3538     if ( BadElement(hElts) ) return iElts;
3539
3540     updateData();
3541     ElementsItem* eltsItem = new ElementsItem(hElts);
3542     _elementsDirItem->appendRow(eltsItem);
3543     iElts = eltsItem->index();
3544
3545     return iElts;
3546 }
3547
3548 QModelIndex DocumentModel::prismQuad( const QModelIndex& iquad, const QModelIndex& ivec, int nb)
3549 {
3550     QModelIndex iElts;
3551
3552     HEXA_NS::Quad*   hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
3553     HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
3554
3555     HEXA_NS::Elements* hElts = _hexaDocument->prismQuad( hQuad, hVect, nb );
3556     if ( BadElement(hElts) ) return iElts;
3557
3558     updateData(); //CS_TODO more or less?
3559     ElementsItem* elts = new ElementsItem(hElts);
3560     _elementsDirItem->appendRow(elts);
3561     iElts = elts->index();
3562
3563     return iElts;
3564 }
3565
3566 QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, int nb)
3567 {
3568     QModelIndex iElts;
3569
3570     HEXA_NS::Quads   hQuads;
3571     HEXA_NS::Quad*   hQuad = NULL;
3572     foreach( const QModelIndex& iquad, iquads ){
3573         hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
3574         hQuads.push_back( hQuad );
3575     }
3576     HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
3577
3578     HEXA_NS::Elements* hElts = _hexaDocument->prismQuads( hQuads, hVect, nb );
3579     if ( BadElement(hElts) ) return iElts;
3580
3581     updateData(); //CS_TODO more or less?
3582     ElementsItem* elts = new ElementsItem(hElts);
3583     _elementsDirItem->appendRow(elts);
3584     iElts = elts->index();
3585
3586     return iElts;
3587 }
3588
3589 QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, std::vector<double> layersSize, int nb)
3590 {
3591     QModelIndex iElts;
3592
3593     HEXA_NS::Quads   hQuads;
3594     HEXA_NS::Quad*   hQuad = NULL;
3595     foreach( const QModelIndex& iquad, iquads ){
3596         hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
3597         hQuads.push_back( hQuad );
3598     }
3599     HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
3600
3601     HEXA_NS::Elements* hElts = _hexaDocument->prismQuadsVec( hQuads, hVect, layersSize, nb );
3602     if ( BadElement(hElts) ) return iElts;
3603
3604     updateData(); //CS_TODO more or less?
3605     ElementsItem* elts = new ElementsItem(hElts);
3606     _elementsDirItem->appendRow(elts);
3607     iElts = elts->index();
3608
3609     return iElts;
3610 }
3611
3612 //
3613 QModelIndex DocumentModel::joinQuad(
3614         const QModelIndex& iquadstart, const QModelIndex& iquaddest,
3615         const QModelIndex& iv0, const QModelIndex& iv1,
3616         const QModelIndex& iv2, const QModelIndex& iv3,
3617         int nb )
3618 {
3619     QModelIndex iElts;
3620
3621     HEXA_NS::Quad*   hQuadStart  = getHexaPtr<HEXA_NS::Quad*>(iquadstart);
3622     HEXA_NS::Quad*   hQuadDest   = getHexaPtr<HEXA_NS::Quad*>(iquaddest);
3623
3624     HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
3625     HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
3626     HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
3627     HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
3628
3629     HEXA_NS::Elements* hElts = _hexaDocument->joinQuad( hQuadStart, hQuadDest,
3630             hVertex0,  hVertex1,  hVertex2,  hVertex3, nb );
3631     if ( BadElement(hElts) ) return iElts;
3632
3633     updateData(); //CS_TODO more or less?
3634     ElementsItem* elts = new ElementsItem(hElts);
3635     _elementsDirItem->appendRow(elts);
3636     iElts = elts->index();
3637
3638     return iElts;
3639 }
3640
3641 QModelIndex DocumentModel::joinQuads(
3642         const QModelIndexList& iquadsstart, const QModelIndex& iquaddest,
3643         const QModelIndex& iv0, const QModelIndex& iv1,
3644         const QModelIndex& iv2, const QModelIndex& iv3,
3645         int nb )
3646 {
3647     QModelIndex iElts;
3648
3649     HEXA_NS::Quad*   hQuadStart;
3650     HEXA_NS::Quads  hQuadsStart;
3651
3652     foreach( const QModelIndex& iquad, iquadsstart ){
3653         hQuadStart = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
3654         hQuadsStart.push_back( hQuadStart );
3655     }
3656     HEXA_NS::Quad*   hQuadDest = data( iquaddest, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
3657
3658     HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
3659     HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
3660     HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
3661     HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
3662
3663     HEXA_NS::Elements* hElts = _hexaDocument->joinQuads(
3664             hQuadsStart, hQuadDest,
3665             hVertex0,  hVertex1,  hVertex2,  hVertex3,
3666             nb );
3667     if ( BadElement(hElts) ) return iElts;
3668
3669     updateData(); //CS_TODO more or less?
3670     ElementsItem* elts = new ElementsItem(hElts);
3671     _elementsDirItem->appendRow(elts);
3672     iElts = elts->index();
3673
3674     return iElts;
3675 }
3676
3677 QModelIndex DocumentModel::cutEdge( const QModelIndex &i_e0, int nbcuts )
3678 //CS_TODO : impact sur le model?
3679 {
3680     QModelIndex iElts;
3681
3682     HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(i_e0);
3683     HEXA_NS::Elements* helts = _hexaDocument->cut( he0, nbcuts );
3684
3685     if ( BadElement(helts) ) return iElts;
3686
3687     updateData(); //CS_TODO more?
3688     ElementsItem* elts = new ElementsItem(helts);
3689     _elementsDirItem->appendRow(elts);
3690     iElts = elts->index();
3691
3692     return iElts;
3693 }
3694
3695 // ===================================== END OBSOLETE ==========================================
3696