src/HEXABLOCKGUI/HEXABLOCKGUI_DocumentModel.cxx

   1 // Copyright (C) 2009-2012  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 #include "HEXABLOCKGUI_VtkDocumentGraphicView.hxx"
  30
  31 #include "HEXABLOCKGUI.hxx"
  32 #include "HEXABLOCKGUI_Trace.hxx"
  33
  34 #include "HexVertex.hxx"
  35 #include "HexShape.hxx"
  36 #include "HexSubShape.hxx"
  37 #include "HexAssoEdge.hxx"
  38
  39
  40 #include <GEOMBase.h>
  41 #include "HEXABLOCKGUI_SalomeTools.hxx"
  42
  43 #include "MyGEOMBase_Helper.hxx"
  44 #include "GEOM_GEOMBase.hxx"
  45 #include "GEOM_GenericObjPtr.h"
  46
  47 #include <GEOM_Displayer.h>
  48 #include <SALOME_ListIO.hxx>
  49 #include <SALOMEconfig.h>
  50 #include <SUIT_ViewWindow.h>
  51 #include CORBA_CLIENT_HEADER(GEOM_Gen)
  52
  53 #include <qglobal.h>
  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 //    parentItem->appendRow(_cloudOfPointsDirItem);
 152
 153     parentItem->appendRow(_groupDirItem);
 154     parentItem->appendRow(_lawDirItem);
 155     parentItem->appendRow(_propagationDirItem);
 156 }
 157
 158 DocumentModel::~DocumentModel()
 159 {
 160     if (_hexaDocument != NULL)
 161         delete _hexaDocument;
 162
 163     if (_hexaFile != NULL)
 164         delete _hexaFile;
 165 }
 166
 167 void DocumentModel::setName(const QString& name)
 168 {
 169     _hexaDocument->setName( name.toLocal8Bit().constData() );
 170     emit nameChanged(QString(_hexaDocument->getName()));
 171 }
 172
 173 HEXA_NS::EltBase* DocumentModel::getHexaPtr(const QModelIndex& iElt)
 174 {
 175     HEXA_NS::EltBase *elt = NULL;
 176     switch ( /*data(iElt, HEXA_TREE_ROLE).toInt()*/iElt.data(HEXA_TREE_ROLE).toInt() ){
 177     case VERTEX_TREE : elt = getHexaPtr<HEXA_NS::Vertex*>(iElt); break;
 178     case EDGE_TREE : elt = getHexaPtr<HEXA_NS::Edge*>(iElt); break;
 179     case QUAD_TREE : elt = getHexaPtr<HEXA_NS::Quad*>(iElt); break;
 180     case HEXA_TREE : elt = getHexaPtr<HEXA_NS::Hexa*>(iElt); break;
 181     case VECTOR_TREE : elt = getHexaPtr<HEXA_NS::Vector*>(iElt); break;
 182     case CYLINDER_TREE : elt = getHexaPtr<HEXA_NS::Cylinder*>(iElt); break;
 183     case PIPE_TREE : elt = getHexaPtr<HEXA_NS::Pipe*>(iElt); break;
 184     case ELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::Elements*>(iElt); break;
 185     case CROSSELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::CrossElements*>(iElt); break;
 186     case GEOMSHAPE_TREE: elt = getHexaPtr<HEXA_NS::NewShape*>(iElt); break;
 187     case GEOMPOINT_TREE: elt = getHexaPtr<HEXA_NS::VertexShape*>(iElt); break;
 188     case GEOMEDGE_TREE:  elt = getHexaPtr<HEXA_NS::EdgeShape*>(iElt); break;
 189     case GEOMFACE_TREE:  elt = getHexaPtr<HEXA_NS::FaceShape*>(iElt); break;
 190     }
 191     return elt;
 192 }
 193
 194 //get the number of elements of type 'eltType' in the document
 195 int DocumentModel::getNbrElt(HEXA_NS::EnumElt eltType)
 196 {
 197     if (_hexaDocument == NULL) return 0;
 198
 199    return _hexaDocument->getNbrElt(eltType);
 200 }
 201
 202 //get the number of elements of type 'eltType' used in the document
 203 int DocumentModel::getNbrUsedElt(HEXA_NS::EnumElt eltType)
 204 {
 205     if (_hexaDocument == NULL) return 0;
 206
 207     switch(eltType) {
 208     case HEXA_NS::EL_VERTEX:
 209         return _hexaDocument->countUsedVertex();
 210     case HEXA_NS::EL_EDGE:
 211         return _hexaDocument->countUsedEdge();
 212     case HEXA_NS::EL_QUAD:
 213         return _hexaDocument->countUsedQuad();
 214     case HEXA_NS::EL_HEXA:
 215         return _hexaDocument->countUsedHexa();
 216     default: return 0;
 217     }
 218 }
 219
 220 //associate a shape to the current document
 221 bool DocumentModel::addShape(TopoDS_Shape& aShape, QString& name)
 222 {
 223     if (aShape.IsNull()) return false;
 224     return (_hexaDocument != NULL ? _hexaDocument->addShape(aShape, name.toStdString().c_str()) != NULL : false);
 225 }
 226
 227 //get the number of unused elements of type 'eltType' in the document
 228 int DocumentModel::getNbrUnusedElt(HEXA_NS::EnumElt eltType)
 229 {
 230     if (_hexaDocument == NULL) return 0;
 231
 232     return getNbrElt(eltType) - getNbrUsedElt(eltType);
 233 }
 234
 235 DocumentModel::GeomObj* DocumentModel::convertToGeomObj(GEOM::GeomObjPtr geomObjPtr)
 236 {
 237     TopoDS_Shape aShape;
 238     DocumentModel::GeomObj *res = NULL;
 239
 240     if ( geomObjPtr && GEOMBase::GetShape(geomObjPtr.get(), aShape) && !aShape.IsNull() )
 241     {
 242         res = new DocumentModel::GeomObj;
 243         if (res == NULL) return NULL;
 244         QString mainShapeEntry;
 245         int     subId = -1;
 246         QString brep;
 247
 248         if ( geomObjPtr->IsMainShape() ){
 249             mainShapeEntry = geomObjPtr->GetStudyEntry();
 250             brep =  shape2string( aShape ).c_str();
 251         } else {
 252             TopoDS_Shape shape;
 253             TopoDS_Shape subshape;
 254             GEOM::GEOM_Object_var mainShape = geomObjPtr->GetMainShape();
 255             mainShapeEntry = mainShape->GetStudyEntry();
 256             // CS_TODO : à optimiser
 257             bool okShape = GEOMBase::GetShape( mainShape , shape);
 258             bool oksubShape = GEOMBase::GetShape( geomObjPtr.get(), subshape );
 259             if ( okShape && oksubShape ){
 260                 brep =  shape2string( subshape ).c_str();
 261                 subId = GEOMBase::GetIndex( subshape, shape );
 262                 MESSAGE("subid = " << QString::number(subId).toStdString());
 263             }
 264         }
 265         res->shapeName = getGeomObjName(mainShapeEntry);
 266         res->name    = GEOMBase::GetName( geomObjPtr.get() );
 267         res->subid   = QString::number(subId);
 268         res->brep    = brep;
 269         res->start   = 0.;
 270         res->end     = 1.;
 271     }
 272
 273     return res;
 274 }
 275
 276
 277 //Load the current Document
 278 void DocumentModel::load()
 279 {
 280     if (_hexaDocument == NULL) return;
 281     load(_hexaDocument->getName());
 282 }
 283
 284
 285 void DocumentModel::load( const QString& xmlFileName ) // Fill Data
 286 {
 287     _hexaDocument->loadXml(xmlFileName.toLocal8Bit().constData() );
 288     clearAll();
 289
 290     fillData();
 291     fillBuilder();
 292     fillGeometry();
 293     fillAssociation();
 294     fillGroups();
 295     fillMesh();
 296
 297     emit patternDataChanged();
 298
 299     // BUILDER, ASSOCIATION, GROUPS, ... CS_TODO _fillBuilderFrom( _hexaDocument );
 300 }
 301
 302 bool DocumentModel::isEmpty() const
 303 {
 304     if (_hexaDocument == NULL) return true;
 305     return _hexaDocument->isEmpty();
 306 }
 307
 308 void DocumentModel::save( const QString& xmlFileName )
 309 {
 310     _hexaDocument->save( xmlFileName.toLocal8Bit().constData() );
 311 }
 312
 313 QString DocumentModel::getName()
 314 {
 315     return _hexaDocument->getName();
 316 }
 317
 318 void DocumentModel::updateData()
 319 {
 320     clearData();
 321     fillData();
 322     clearMesh();
 323     fillMesh();
 324     emit patternDataChanged();
 325 }
 326
 327 void DocumentModel::refresh()
 328 {
 329     clearAll();
 330
 331     fillData();
 332     fillBuilder();
 333     fillGeometry();
 334     fillAssociation();
 335     fillGroups();
 336     fillMesh();
 337
 338     emit patternDataChanged();
 339
 340 }
 341
 342 void DocumentModel::clearAll()
 343 {
 344     clearData();
 345     clearBuilder();
 346     clearGeometry();
 347     clearAssociation();
 348     clearGroups();
 349     clearMesh();
 350
 351     //dataChanged( const QModelIndex & topLeft, const QModelIndex & bottomRight )
 352     //CS_TODO : todo : association, groups, mesh
 353 }
 354
 355 void DocumentModel::clearData()
 356 {
 357     _vertexDirItem->removeRows( 0, _vertexDirItem->rowCount() );
 358     _edgeDirItem->removeRows(0, _edgeDirItem->rowCount() );
 359     _quadDirItem->removeRows(0, _quadDirItem->rowCount() );
 360     _hexaDirItem->removeRows(0, _hexaDirItem->rowCount() );
 361 }
 362
 363
 364 void DocumentModel::clearBuilder()
 365 {
 366     _vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
 367     _cylinderDirItem->removeRows(0, _cylinderDirItem->rowCount() );
 368     _pipeDirItem->removeRows(0, _pipeDirItem->rowCount() );
 369     _elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
 370     _crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
 371 }
 372
 373 void DocumentModel::clearGeometry()
 374 {
 375     _explicitShapesDirItem->removeRows(0, _explicitShapesDirItem->rowCount() );
 376     _implicitShapesDirItem->removeRows(0, _implicitShapesDirItem->rowCount() );
 377     _cloudOfPointsDirItem->removeRows(0, _cloudOfPointsDirItem->rowCount() );
 378 }
 379
 380 void DocumentModel::clearAssociation()
 381 {
 382     //CS_TODO
 383 }
 384
 385 void DocumentModel::clearGroups()
 386 {
 387     _groupDirItem->removeRows(0, _groupDirItem->rowCount() );
 388 }
 389
 390 void DocumentModel::clearMesh()
 391 {
 392     _lawDirItem->removeRows(0, _lawDirItem->rowCount() );
 393     _propagationDirItem->removeRows(0, _propagationDirItem->rowCount() );
 394 }
 395
 396
 397 void DocumentModel::fillData()
 398 {
 399     // DATA
 400     HEXA_NS::Vertex *v     = NULL;
 401     VertexItem      *vItem = NULL;
 402     for ( int i=0; i<_hexaDocument->countVertex(); ++i ){
 403         v = _hexaDocument->getVertex(i);
 404         vItem = new VertexItem(v, _entry);
 405         _vertexDirItem->appendRow(vItem);
 406     }
 407
 408     HEXA_NS::Edge *e     = NULL;
 409     EdgeItem      *eItem = NULL;
 410     for ( int i=0; i<_hexaDocument->countEdge(); ++i ){
 411         e = _hexaDocument->getEdge(i);
 412         eItem = new EdgeItem(e, _entry);
 413         _edgeDirItem->appendRow(eItem);
 414     }
 415
 416     HEXA_NS::Quad *q     = NULL;
 417     QuadItem      *qItem = NULL;
 418     for ( int i=0; i<_hexaDocument->countQuad(); ++i ){
 419         q = _hexaDocument->getQuad(i);
 420         qItem = new QuadItem(q, _entry);
 421         _quadDirItem->appendRow(qItem);
 422     }
 423
 424     HEXA_NS::Hexa *h     = NULL;
 425     HexaItem      *hItem = NULL;
 426     for ( int i=0; i<_hexaDocument->countHexa(); ++i ){
 427         h = _hexaDocument->getHexa(i);
 428         hItem = new HexaItem(h, _entry);
 429         _hexaDirItem->appendRow(hItem);
 430     }
 431 }
 432
 433
 434 void DocumentModel::fillBuilder()
 435 {
 436     HEXA_NS::Vector *v     = NULL;
 437     VectorItem      *vItem = NULL;
 438     for ( int i=0; i<_hexaDocument->countVector(); ++i ){
 439         v = _hexaDocument->getVector(i);
 440         vItem = new VectorItem(v);
 441         _vectorDirItem->appendRow(vItem);
 442     }
 443
 444     //   _cylinderDirItem
 445     HEXA_NS::Cylinder *c     = NULL;
 446     CylinderItem      *cItem = NULL;
 447     for ( int i=0; i<_hexaDocument->countCylinder(); ++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     for ( int i=0; i<_hexaDocument->countPipe(); ++i ){
 457         p = _hexaDocument->getPipe(i);
 458         pItem = new PipeItem(p);
 459         _pipeDirItem->appendRow(pItem);
 460     }
 461 }
 462
 463 void DocumentModel::fillGeometry()
 464 {
 465
 466     if (_hexaDocument == NULL) return;
 467
 468     HEXA_NS::NewShape* shape;
 469     HEXA_NS::VertexShape* node;
 470     HEXA_NS::EdgeShape* line;
 471     HEXA_NS::FaceShape* face;
 472
 473     //explicit shape
 474
 475     //fill the shape tree
 476     shapeById.clear();
 477     for (int i=0; i < _hexaDocument->countShape(); ++i)
 478     {
 479         shape = _hexaDocument->getShape(i);
 480         QString shapeName = shape->getName();
 481
 482         //publish the shape in the study if not done yet
 483         if (!docShapesEntry.contains(shapeName))
 484         {
 485             //save the brep of the shape in a temporary file
 486             QString fileName = shapeName + ".brep";
 487             shape->saveBrep();
 488
 489             //importing the brep in the study
 490             QString objStudyEntry = HEXABLOCKGUI::addInStudy(fileName);
 491
 492             docShapesName[objStudyEntry] = shapeName;
 493             docShapesEntry[shapeName] = objStudyEntry;
 494         }
 495
 496         GeomShapeItem* shItem = new GeomShapeItem(shape);
 497         if (shape->getOrigin() == HEXA_NS::SH_IMPORT)
 498             _explicitShapesDirItem->appendRow(shItem);
 499         else
 500             _implicitShapesDirItem->appendRow(shItem);
 501
 502         //add vertices to the tree
 503         QStandardItem* geomPointDirItem = new QStandardItem(tr("TREE_ITEM_VERTEX"));
 504         geomPointDirItem->setData( GEOMPOINT_DIR_TREE, HEXA_TREE_ROLE );
 505         shItem->appendRow(geomPointDirItem);
 506         for (int j=0; j < shape->countVertex(); ++j)
 507         {
 508             node = shape->getVertexShape(j);
 509             GeomPointItem* gPointItem = new GeomPointItem(node);
 510             geomPointDirItem->appendRow(gPointItem);
 511             shapeById[shapeName+","+QString::number(node->getIdent())] = node;
 512         }
 513
 514         //add edges to the tree
 515         QStandardItem* geomEdgeDirItem = new QStandardItem(tr("TREE_ITEM_EDGE"));
 516         geomEdgeDirItem->setData( GEOMEDGE_DIR_TREE, HEXA_TREE_ROLE );
 517         shItem->appendRow(geomEdgeDirItem);
 518         for (int j = 0; j < shape->countEdge(); ++j)
 519         {
 520             line = shape->getEdgeShape(j);
 521             GeomEdgeItem* gEdgeItem = new GeomEdgeItem(line);
 522             geomEdgeDirItem->appendRow(gEdgeItem);
 523             shapeById[shapeName+","+QString::number(line->getIdent())] = line;
 524         }
 525
 526         //add faces to the tree
 527         QStandardItem* geomFaceDirItem = new QStandardItem(tr("TREE_ITEM_QUAD"));
 528         geomFaceDirItem->setData( GEOMFACE_DIR_TREE, HEXA_TREE_ROLE );
 529         shItem->appendRow(geomFaceDirItem);
 530         for (int j = 0; j < shape->countFace(); ++j)
 531         {
 532             face = shape->getFaceShape(j);
 533             GeomFaceItem* gFaceItem = new GeomFaceItem(face);
 534             geomFaceDirItem->appendRow(gFaceItem);
 535             shapeById[shapeName+","+QString::number(face->getIdent())] = face;
 536         }
 537     }
 538
 539     //implicit shapes
 540     //...here
 541
 542
 543     //cloud of points
 544     //...here
 545
 546 }
 547
 548 void DocumentModel::fillAssociation()
 549 {
 550 }
 551
 552 //------------------------------------------- NEW ITEMS
 553 //void DocumentModel::fillGroups()
 554 //{
 555 //  HEXA_NS::Group *g     = NULL;
 556 //  GroupItem      *gItem = NULL;
 557 //  for ( int i=0; i<_hexaDocument->countGroup(); ++i ){
 558 //    g = _hexaDocument->getGroup(i);
 559 //    gItem = new GroupItem(g, _entry);
 560 //    _groupDirItem->appendRow(gItem);
 561 //  }
 562 //}
 563 //
 564 //void DocumentModel::fillMesh()
 565 //{
 566 //  HEXA_NS::Law *l     = NULL;
 567 //  LawItem      *lItem = NULL;
 568 //  for ( int i=0; i<_hexaDocument->countLaw(); ++i ){
 569 //    l = _hexaDocument->getLaw(i);
 570 //    lItem = new LawItem(l);
 571 //    _lawDirItem->appendRow(lItem);
 572 //  }
 573 //
 574 //  HEXA_NS::Propagation *p     = NULL;
 575 //  PropagationItem      *pItem = NULL;
 576 //  for ( int i=0; i<_hexaDocument->countPropagation(); ++i ){
 577 //    p = _hexaDocument->getPropagation(i);
 578 //    pItem = new PropagationItem(p, _entry);
 579 //    pItem->setText(QString("Propagation%1").arg(i) );
 580 //    _propagationDirItem->appendRow(pItem);
 581 //  }
 582 //}
 583 //----------------------------------------------- END NEW ITEMS
 584
 585 void DocumentModel::fillGroups()
 586 {
 587     HEXA_NS::Group *g     = NULL;
 588     GroupItem      *gItem = NULL;
 589     for ( int i=0; i<_hexaDocument->countGroup(); ++i ){
 590         g = _hexaDocument->getGroup(i);
 591         //std::cout<<"getGroup => "<< i << std::endl;
 592         gItem = new GroupItem(g);
 593         gItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
 594         _groupDirItem->appendRow(gItem);
 595     }
 596 }
 597
 598 void DocumentModel::fillMesh()
 599 {
 600     //   _lawDirItem
 601     HEXA_NS::Law *l     = NULL;
 602     LawItem      *lItem = NULL;
 603     for ( int i=0; i<_hexaDocument->countLaw(); ++i ){
 604         l = _hexaDocument->getLaw(i);
 605         lItem = new LawItem(l);
 606         _lawDirItem->appendRow(lItem);
 607     }
 608
 609     //   _propagationDirItem
 610     HEXA_NS::Propagation *p     = NULL;
 611     PropagationItem      *pItem = NULL;
 612     for ( int i=0; i<_hexaDocument->countPropagation(); ++i ){
 613         p = _hexaDocument->getPropagation(i);
 614         pItem = new PropagationItem(p);
 615         pItem->setText(QString("Propagation%1").arg(i) );
 616         pItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
 617         _propagationDirItem->appendRow(pItem);
 618     }
 619 }
 620
 621 HEXA_NS::Hexa* DocumentModel::getQuadHexa(HEXA_NS::Quad* quad)
 622 {
 623     HEXA_NS::Hexa* hexa;
 624     for ( int i=0; i<_hexaDocument->countHexa(); ++i ){
 625         hexa = _hexaDocument->getHexa(i);
 626         if (hexa->findQuad(quad) > -1) return hexa;
 627     }
 628     return NULL;
 629 }
 630
 631
 632 Qt::ItemFlags DocumentModel::flags(const QModelIndex &index) const
 633 {
 634     Qt::ItemFlags flags;
 635
 636     if (!index.isValid()) return Qt::ItemIsEnabled;
 637
 638     if ( _disallowEdition ){
 639         return QAbstractItemModel::flags(index) | Qt::ItemFlags( ~Qt::ItemIsEditable );
 640     } else {
 641         return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
 642     }
 643 }
 644
 645 void DocumentModel::allowEdition()
 646 {
 647     _disallowEdition = false;
 648 }
 649
 650 void DocumentModel::disallowEdition()
 651 {
 652     _disallowEdition = true;
 653 }
 654
 655 void DocumentModel::allowDataSelectionOnly()
 656 {
 657     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 658     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 659     _quadItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 660     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 661
 662     _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 663     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 664     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 665     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 666     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 667
 668     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 669     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 670     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 671 }
 672
 673 void DocumentModel::allowVertexSelectionOnly()
 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::ItemIsEditable );
 681     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 682     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEditable );
 683     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 684     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 685
 686     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 687     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 688     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 689
 690     //     emit layoutChanged();
 691 }
 692
 693 void DocumentModel::allowEdgeSelectionOnly()
 694 {
 695     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 696     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 697     _quadItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 698     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 699
 700     _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 701     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 702     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 703     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 704     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 705
 706     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 707     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 708     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 709 }
 710
 711 void DocumentModel::allowQuadSelectionOnly()
 712 {
 713     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 714     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 715     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 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::allowHexaSelectionOnly()
 730 {
 731     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 732     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 733     _quadItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 734     _hexaItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 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::allowVectorSelectionOnly()
 748 {
 749     _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 750     _edgeItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 751     _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 752     _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 753
 754     _vectorItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 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::allowCylinderSelectionOnly()
 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::ItemIsEnabled );
 773     _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 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::allowPipeSelectionOnly()
 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::ItemIsEnabled );
 792     _pipeItemFlags     = Qt::ItemFlags( ~Qt::ItemIsEditable );
 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::allowElementsSelectionOnly()
 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::ItemIsEnabled );
 811     _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 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::allowCrossElementsSelectionOnly()
 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::ItemIsEnabled );
 830     _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
 831
 832     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 833     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 834     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 835 }
 836
 837 void DocumentModel::allowLawSelectionOnly()
 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::ItemIsEnabled );
 849
 850     _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 851     _lawItemFlags   = Qt::ItemFlags( ~Qt::ItemIsEditable );
 852     _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
 853 }
 854
 855
 856 void DocumentModel::setName( const QModelIndex& iElt, const QString& name )
 857 {
 858     HEXA_NS::EltBase *elt = NULL;
 859
 860     switch ( data(iElt, HEXA_TREE_ROLE).toInt() ){
 861     case GROUP_TREE :
 862     {
 863         HEXA_NS::Group* grp = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Group* >();
 864         grp->setName( name.toLatin1().data() );
 865         break;
 866     }
 867     case LAW_TREE :
 868     {
 869         HEXA_NS::Law* l = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Law* >();
 870         l->setName( name.toLatin1().data() );
 871         break;
 872     }
 873     //   case PROPAGATION_TREE : elt = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Propagation* >(); break;
 874     default: elt = getHexaPtr(iElt);
 875     }
 876
 877     if ( elt != NULL ) elt->setName( name.toStdString() );
 878     setData( iElt, name );
 879
 880 }
 881
 882 bool DocumentModel::clearEltAssociations( const QModelIndex& iElt )
 883 {
 884     bool isOk = false;
 885     HEXA_NS::EltBase *elt = getHexaPtr(iElt);
 886
 887     if ( elt != NULL ){
 888         elt->clearAssociation();
 889         setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 890         isOk = true;
 891     }
 892
 893     return isOk;
 894 }
 895
 896 void DocumentModel::clearAssociation(HEXA_NS::EnumElt& eltType)
 897 {
 898     if (_hexaDocument != NULL)
 899         _hexaDocument->clearAssociation(eltType);
 900
 901     QModelIndex iElt;
 902     HEXA_NS::Vertex* vertex;
 903     HEXA_NS::Edge* edge;
 904     HEXA_NS::Quad* quad;
 905     int nbElts;
 906
 907     if (HEXABLOCKGUI::currentDocGView == NULL) return;
 908     PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
 909     PatternDataModel* pdm = HEXABLOCKGUI::currentDocGView->getPatternDataModel();
 910     if (pdsm == NULL || pdm == NULL) return;
 911
 912     //update associations in the model
 913     if (eltType == HEXA_NS::EL_VERTEX)
 914     {
 915         nbElts = _hexaDocument->countVertex();
 916         for (int i = 0; i < nbElts; ++i)
 917         {
 918             vertex = _hexaDocument->getVertex(i);
 919             iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(vertex)));
 920             if (iElt.isValid())
 921                 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 922         }
 923     }
 924     else if (eltType == HEXA_NS::EL_EDGE)
 925     {
 926         nbElts = _hexaDocument->countEdge();
 927         for (int i = 0; i < nbElts; ++i)
 928         {
 929             edge = _hexaDocument->getEdge(i);
 930             iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(edge)));
 931             if (iElt.isValid())
 932                 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 933         }
 934     }
 935     else if (eltType == HEXA_NS::EL_QUAD)
 936     {
 937         nbElts = _hexaDocument->countQuad();
 938         for (int i = 0; i < nbElts; ++i)
 939         {
 940             quad = _hexaDocument->getQuad(i);
 941             iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(quad)));
 942             if (iElt.isValid())
 943                 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
 944         }
 945     }
 946 }
 947
 948
 949 QModelIndex DocumentModel::addVertex( double x, double y, double z )
 950 {
 951     QModelIndex vertexIndex;
 952
 953     HEXA_NS::Vertex* hv = _hexaDocument->addVertex(x, y, z);
 954     if (BadElement(hv)) return vertexIndex;
 955
 956     VertexItem* v = new VertexItem(hv, _entry);
 957     _vertexDirItem->appendRow(v);
 958     vertexIndex = v->index();
 959     emit patternDataChanged();
 960
 961     return vertexIndex;
 962 }
 963
 964 QModelIndex DocumentModel::addEdgeVertices (const QModelIndex &i_v0, const QModelIndex &i_v1 )
 965 {
 966     QModelIndex edgeIndex;
 967
 968     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
 969     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
 970
 971     HEXA_NS::Edge* he = _hexaDocument->addEdge( hv0, hv1 );
 972     if ( BadElement(he) ) return edgeIndex;
 973
 974     EdgeItem* e = new EdgeItem(he, _entry);
 975     _edgeDirItem->appendRow(e);
 976     edgeIndex = e->index();
 977     emit patternDataChanged();
 978
 979     return edgeIndex;
 980 }
 981
 982 QModelIndex DocumentModel::addEdgeVector( const QModelIndex &i_v, const QModelIndex &i_vec )
 983 {
 984     QModelIndex edgeIndex;
 985
 986     HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(i_v);
 987     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(i_vec);
 988
 989     if (!hv || !hvec) return edgeIndex;
 990
 991     HEXA_NS::Edge* he = _hexaDocument->addEdge( hv, hvec );
 992     if ( BadElement(he) ) return edgeIndex;
 993
 994     HEXA_NS::Vertex* hv2 = he->getAval(); //the new vertex resulting from the creation of the edge
 995     if (hv2 == NULL) return edgeIndex;
 996
 997     //ADD the elements in the treeview
 998     //The Edge
 999     EdgeItem* e = new EdgeItem(he, _entry);
1000     _edgeDirItem->appendRow(e);
1001
1002     //The resulting Vertex
1003     VertexItem* v = new VertexItem(hv2, _entry);
1004     _vertexDirItem->appendRow(v);
1005     edgeIndex = e->index();
1006     emit patternDataChanged();
1007
1008     return edgeIndex;
1009 }
1010
1011 QModelIndex DocumentModel::addQuadVertices( const QModelIndex &i_v0, const QModelIndex &i_v1,
1012         const QModelIndex &i_v2, const QModelIndex &i_v3 )
1013 { //CS_TODO : gestion erreur
1014     QModelIndex quadIndex;
1015
1016     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
1017     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
1018     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(i_v2);
1019     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(i_v3);
1020
1021     if ( hv0 and hv1 and hv2 and hv3 ){
1022         HEXA_NS::Quad* hq = _hexaDocument->addQuadVertices( hv0, hv1, hv2, hv3 );
1023         if ( BadElement(hq) ) return quadIndex;
1024
1025         QuadItem* q = new QuadItem(hq, _entry);
1026         _quadDirItem->appendRow(q);
1027         quadIndex = q->index();
1028         emit patternDataChanged();
1029     }
1030
1031     return quadIndex;
1032 }
1033
1034 QModelIndex DocumentModel::addQuadEdges( const QModelIndex &e0, const QModelIndex &e1,
1035         const QModelIndex &e2, const QModelIndex &e3 )
1036 { //CS_TODO
1037     QModelIndex quadIndex;
1038
1039     HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(e0);
1040     HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(e1);
1041     HEXA_NS::Edge* he2 = getHexaPtr<HEXA_NS::Edge*>(e2);
1042     HEXA_NS::Edge* he3 = getHexaPtr<HEXA_NS::Edge*>(e3);
1043
1044     if ( he0 and he1 and he2 and he3 ){
1045
1046         HEXA_NS::Quad* hq = _hexaDocument->addQuad( he0, he1, he2, he3 );
1047         if ( BadElement(hq) ) return quadIndex;
1048
1049         QuadItem* q = new QuadItem(hq, _entry);
1050         _quadDirItem->appendRow(q);
1051         quadIndex = q->index();
1052         emit patternDataChanged();
1053     }
1054
1055     return quadIndex;
1056 }
1057
1058 QModelIndex DocumentModel::addHexaVertices(
1059         const QModelIndex &iv0, const QModelIndex &iv1,
1060         const QModelIndex &iv2, const QModelIndex &iv3,
1061         const QModelIndex &iv4, const QModelIndex &iv5,
1062         const QModelIndex &iv6, const QModelIndex &iv7 )
1063 {
1064     QModelIndex iHexa;
1065
1066     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1067     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1068     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1069     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1070     HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
1071     HEXA_NS::Vertex* hv5 = getHexaPtr<HEXA_NS::Vertex*>(iv5);
1072     HEXA_NS::Vertex* hv6 = getHexaPtr<HEXA_NS::Vertex*>(iv6);
1073     HEXA_NS::Vertex* hv7 = getHexaPtr<HEXA_NS::Vertex*>(iv7);
1074
1075     HEXA_NS::Hexa* hh = _hexaDocument->addHexaVertices( hv0, hv1, hv2, hv3,
1076             hv4, hv5, hv6, hv7 );
1077
1078     if ( BadElement(hh) ) return iHexa;
1079
1080     HexaItem* h = new HexaItem(hh, _entry);
1081     _hexaDirItem->appendRow(h);
1082     iHexa = h->index();
1083     emit patternDataChanged();
1084
1085     return iHexa;
1086 }
1087
1088 QModelIndex DocumentModel::addHexaQuad( const QModelIndex &i_q0, const QModelIndex &i_q1,
1089         const QModelIndex &i_q2,const QModelIndex &i_q3, const QModelIndex &i_q4, const QModelIndex &i_q5 )
1090 { //CS_TODO : gestion erreur
1091     QModelIndex hexaIndex;
1092
1093     HEXA_NS::Quad* hq0 = getHexaPtr<HEXA_NS::Quad*>(i_q0);
1094     HEXA_NS::Quad* hq1 = getHexaPtr<HEXA_NS::Quad*>(i_q1);
1095     HEXA_NS::Quad* hq2 = getHexaPtr<HEXA_NS::Quad*>(i_q2);
1096     HEXA_NS::Quad* hq3 = getHexaPtr<HEXA_NS::Quad*>(i_q3);
1097     HEXA_NS::Quad* hq4 = getHexaPtr<HEXA_NS::Quad*>(i_q4);
1098     HEXA_NS::Quad* hq5 = getHexaPtr<HEXA_NS::Quad*>(i_q5);
1099
1100     HEXA_NS::Hexa* hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
1101     if ( BadElement(hh) ) return hexaIndex;
1102
1103     HexaItem* h = new HexaItem(hh, _entry);
1104     _hexaDirItem->appendRow(h);
1105     hexaIndex = h->index();
1106     emit patternDataChanged();
1107
1108     return hexaIndex;
1109 }
1110
1111 QModelIndex DocumentModel::addHexaQuads( const QModelIndexList &iquads)
1112 {
1113     QModelIndex hexaIndex;
1114
1115     HEXA_NS::Hexa* hh = NULL;
1116     HEXA_NS::Quad* hq0, *hq1, *hq2, *hq3, *hq4, *hq5 = NULL;
1117
1118     hq0 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(0));
1119     hq1 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(1));
1120     hq2 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(2));
1121     hq3 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(3));
1122     hq4 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(4));
1123     hq5 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(5));
1124
1125     if ( hq0 && hq1 && hq2 && hq3 && hq4 && hq5 )
1126         hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
1127     else if ( hq0 && hq1 && hq2 && hq3 && hq4 )
1128         hh = _hexaDocument->addHexa5Quads( hq0, hq1, hq2, hq3, hq4 );
1129     else if ( hq0 && hq1 && hq2 && hq3 )
1130         hh = _hexaDocument->addHexa4Quads( hq0, hq1, hq2, hq3 );
1131     else if ( hq0 && hq1 && hq2)
1132         hh = _hexaDocument->addHexa3Quads( hq0, hq1, hq2 );
1133     else if ( hq0 && hq1 )
1134         hh = _hexaDocument->addHexa2Quads( hq0, hq1);
1135
1136     if ( BadElement(hh) ) return hexaIndex;
1137
1138     updateData();
1139     unsigned int nbRows = _hexaDirItem->rowCount();
1140     if (nbRows > 0)
1141         hexaIndex = _hexaDirItem->child(nbRows-1)->index();
1142
1143     return hexaIndex;
1144 }
1145
1146 // Vector addVector( in double dx, in double dy, in double dz )
1147 //         raises (SALOME::SALOME_Exception);
1148 QModelIndex DocumentModel::addVector( double dx, double dy, double dz )
1149 {
1150     QModelIndex vectorIndex;
1151
1152     HEXA_NS::Vector* hv = _hexaDocument->addVector(dx, dy, dz);
1153     if ( BadElement(hv) ) return vectorIndex; //Invalid index
1154
1155     VectorItem* v = new VectorItem(hv);
1156     _vectorDirItem->appendRow(v);
1157     vectorIndex = v->index();
1158
1159     return vectorIndex;
1160 }
1161
1162 QModelIndex DocumentModel::addVectorVertices( const QModelIndex &iv0, const QModelIndex &iv1 )
1163 {
1164     QModelIndex iVec;
1165
1166     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1167     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1168
1169     HEXA_NS::Vector* hvec = _hexaDocument->addVectorVertices( hv0, hv1 );
1170     if ( BadElement(hvec) ) return iVec;
1171
1172     VectorItem* vec = new VectorItem(hvec);
1173     _vectorDirItem->appendRow(vec);
1174     iVec = vec->index();
1175
1176     return iVec;
1177 }
1178
1179 QModelIndex DocumentModel::addCylinder( const QModelIndex &iv, const QModelIndex &ivec, double r,  double h )
1180 {
1181     QModelIndex iCyl;
1182
1183     HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(iv);
1184     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1185
1186     HEXA_NS::Cylinder* hcyl = _hexaDocument->addCylinder( hv, hvec, r, h );
1187     if ( BadElement(hcyl) ) return iCyl;
1188
1189     CylinderItem* cyl = new CylinderItem(hcyl);
1190     _cylinderDirItem->appendRow(cyl);
1191     iCyl = cyl->index();
1192
1193     return iCyl;
1194 }
1195
1196 QModelIndex DocumentModel::addPipe( const QModelIndex &iv, const QModelIndex &ivec, double ri, double re, double h )
1197 {
1198     QModelIndex iPipe;
1199
1200     HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(iv);
1201     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1202
1203     HEXA_NS::Pipe* hPipe = _hexaDocument->addPipe( hv, hvec, ri, re, h );
1204     if ( BadElement(hPipe) ) return iPipe;
1205
1206     PipeItem* pipe = new PipeItem(hPipe);
1207     _pipeDirItem->appendRow(pipe);
1208     iPipe = pipe->index();
1209
1210     return iPipe;
1211 }
1212
1213 QModelIndex DocumentModel::makeCartesian( const QModelIndex& i_pt,
1214         const QModelIndex& i_vec_x, const QModelIndex& i_vec_y, const QModelIndex& i_vec_z,
1215         long nx, long ny, long nz)
1216 {
1217     QModelIndex eltsIndex;
1218     //std::cout<<"makeCartesian begin"<<std::endl;
1219
1220     HEXA_NS::Vertex* hpt    = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
1221     HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
1222     HEXA_NS::Vector* hvec_y = getHexaPtr<HEXA_NS::Vector*>(i_vec_y);
1223     HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
1224
1225     HEXA_NS::Elements* new_helts = _hexaDocument->makeCartesian( hpt,
1226             hvec_x, hvec_y, hvec_z,
1227             nx, ny, nz );
1228     if ( BadElement(new_helts) ) return eltsIndex;
1229
1230     updateData(); //CS_TODO more or less?
1231     ElementsItem* eltsItem = new ElementsItem(new_helts);
1232     _elementsDirItem->appendRow(eltsItem);
1233     eltsIndex = eltsItem->index();
1234
1235     return eltsIndex;
1236 }
1237
1238 QModelIndex DocumentModel::makeCartesian( const QModelIndex& ivex,
1239         const QModelIndex& ivec,
1240         int nx, int ny, int nz )
1241 {
1242     QModelIndex iElts;
1243
1244     HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1245     HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1246
1247     HEXA_NS::Elements* hElts = _hexaDocument->makeCartesian( hVex,
1248             hVec,
1249             nx, ny, nz );
1250     if ( BadElement(hElts) ) return iElts;
1251
1252     updateData(); //CS_TODO more or less?
1253     ElementsItem* elts = new ElementsItem(hElts);
1254     _elementsDirItem->appendRow(elts);
1255     iElts = elts->index();
1256
1257     return iElts;
1258 }
1259
1260 // Elements makeCylindrical( in Vertex pt,
1261 //           in Vector vex, in Vector vez,
1262 //           in double dr, in double da, in double dl,
1263 //           in long nr, in long na, in long nl,
1264 //           in boolean fill )
1265 //         raises (SALOME::SALOME_Exception);
1266 QModelIndex DocumentModel::makeCylindrical( const QModelIndex& i_pt,
1267         const QModelIndex& i_vec_x, const QModelIndex& i_vec_z,
1268         double dr, double da, double dl,
1269         long nr, long na, long nl,
1270         bool fill )
1271 {
1272
1273     QModelIndex eltsIndex;
1274
1275     HEXA_NS::Vertex* hpt    = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
1276     HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
1277     HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
1278
1279     HEXA_NS::Elements* new_helts = _hexaDocument->makeCylindrical( hpt, hvec_x, hvec_z, dr, da, dl, nr, na, nl, fill );
1280     if ( BadElement(new_helts) ) return eltsIndex;
1281
1282     updateData(); //CS_TODO  more or less?
1283     ElementsItem* eltsItem = new ElementsItem(new_helts);
1284     _elementsDirItem->appendRow(eltsItem);
1285     eltsIndex = eltsItem->index();
1286
1287     return eltsIndex;
1288 }
1289
1290 QModelIndex DocumentModel::makeCylindricals(
1291         const QModelIndex& icenter, const QModelIndex& ibase, const QModelIndex& iheight,
1292         QList< double> radius, QList<double> angles, QList<double> heights,
1293         bool fill ) //HEXA3
1294 {
1295     QModelIndex eltsIndex;
1296
1297     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1298     HEXA_NS::Vector* hbase   =getHexaPtr<HEXA_NS::Vector*>(ibase);
1299     HEXA_NS::Vector* hheight = getHexaPtr<HEXA_NS::Vector*>(iheight);
1300
1301     //   HEXA_NS::Elements* helts;
1302     std::vector<double> r = radius.toVector().toStdVector();
1303     std::vector<double> a = angles.toVector().toStdVector();
1304     std::vector<double> h = heights.toVector().toStdVector();
1305
1306     HEXA_NS::Elements* helts = _hexaDocument->makeCylindricals(
1307             hcenter, hbase, hheight,
1308             r, a, h,
1309             fill );
1310     if ( BadElement(helts) ) return eltsIndex;
1311
1312     updateData(); //CS_TODO  more or less?
1313     ElementsItem* eltsItem = new ElementsItem(helts);
1314     _elementsDirItem->appendRow(eltsItem);
1315     eltsIndex = eltsItem->index();
1316
1317     return eltsIndex;
1318 }
1319
1320 QModelIndex DocumentModel::makeSpherical( const QModelIndex& iv, const QModelIndex& ivec, int nb, double k)
1321 {
1322     QModelIndex iElts;
1323
1324     HEXA_NS::Vertex* hv   = getHexaPtr<HEXA_NS::Vertex*>(iv);
1325     HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1326
1327     HEXA_NS::Elements* hElts = _hexaDocument->makeSpherical( hv, hvec, nb, k );
1328     if ( BadElement(hElts) ) return iElts;
1329
1330     updateData(); //CS_TODO more or less?
1331     ElementsItem* elts = new ElementsItem(hElts);
1332     _elementsDirItem->appendRow(elts);
1333     iElts = elts->index();
1334
1335     return iElts;
1336 }
1337
1338 QModelIndex DocumentModel::makeSpherical( const QModelIndex& icenter, double radius, int nb, double k )
1339 {
1340     QModelIndex iElts;
1341
1342     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1343
1344     HEXA_NS::Elements* helts = _hexaDocument->makeSpherical( hcenter, radius, nb, k );
1345     if ( BadElement(helts) ) return iElts;
1346
1347     updateData(); //CS_TODO more or less?
1348     ElementsItem* eltsItem = new ElementsItem(helts);
1349     _elementsDirItem->appendRow(eltsItem);
1350     iElts = eltsItem->index();
1351
1352     return iElts;
1353 }
1354
1355 QModelIndex DocumentModel::makeCylinder( const QModelIndex& icyl, const QModelIndex& ivec,
1356         int nr, int na, int nl )
1357 {
1358     QModelIndex iElts;
1359
1360     HEXA_NS::Cylinder* hcyl = getHexaPtr<HEXA_NS::Cylinder*>(icyl);
1361     HEXA_NS::Vector* hvec   = getHexaPtr<HEXA_NS::Vector*>(ivec);
1362
1363     HEXA_NS::Elements* hElts = _hexaDocument->makeCylinder( hcyl, hvec, nr, na, nl );
1364     if ( BadElement(hElts) ) return iElts;
1365
1366     updateData(); //CS_TODO more or less?
1367     ElementsItem* elts = new ElementsItem(hElts);
1368     _elementsDirItem->appendRow(elts);
1369     iElts = elts->index();
1370
1371     return iElts;
1372 }
1373
1374 QModelIndex DocumentModel::makePipe( const QModelIndex& ipipe, const QModelIndex& ivecx,
1375         int nr, int na, int nl )
1376 {
1377     QModelIndex iElts;
1378
1379     HEXA_NS::Pipe*   hPipe  = getHexaPtr<HEXA_NS::Pipe*>(ipipe);
1380     HEXA_NS::Vector* hVecx  = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1381
1382     HEXA_NS::Elements* hElts = _hexaDocument->makePipe( hPipe, hVecx, nr, na, nl );
1383     if ( BadElement(hElts) ) return iElts;
1384
1385     updateData(); //CS_TODO more or less?
1386     ElementsItem* elts = new ElementsItem(hElts);
1387     _elementsDirItem->appendRow(elts);
1388     iElts = elts->index();
1389
1390     return iElts;
1391 }
1392
1393 QModelIndex DocumentModel::makeCylinders(const QModelIndex& icyl1, const QModelIndex& icyl2)
1394 { //CS_TODO
1395     QModelIndex iCrossElts;
1396
1397     HEXA_NS::Cylinder* hCyl1  = getHexaPtr<HEXA_NS::Cylinder*>(icyl1);
1398     HEXA_NS::Cylinder* hCyl2  = getHexaPtr<HEXA_NS::Cylinder*>(icyl2);
1399
1400     HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makeCylinders( hCyl1, hCyl2 );
1401     if ( BadElement(hCrossElts) ) return iCrossElts;
1402
1403     updateData(); //CS_TODO more or less?
1404     ElementsItem* crossElts = new ElementsItem(hCrossElts);
1405     _crossElementsDirItem->appendRow(crossElts);
1406     iCrossElts = crossElts->index();
1407
1408     return iCrossElts;
1409 }
1410
1411 //
1412 QModelIndex DocumentModel::makePipes( const QModelIndex& ipipe1, const QModelIndex& ipipe2 )
1413 {
1414     QModelIndex iCrossElts;
1415
1416     HEXA_NS::Pipe* hPipe1  = getHexaPtr<HEXA_NS::Pipe*>(ipipe1);
1417     HEXA_NS::Pipe* hPipe2  = getHexaPtr<HEXA_NS::Pipe*>(ipipe2);
1418
1419     HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makePipes( hPipe1, hPipe2 );
1420     if ( BadElement(hCrossElts) ) return iCrossElts;
1421
1422     updateData(); //CS_TODO more or less?
1423     ElementsItem* crossElts = new ElementsItem(hCrossElts);
1424     _crossElementsDirItem->appendRow(crossElts);
1425     iCrossElts = crossElts->index();
1426
1427     return iCrossElts;
1428 }
1429
1430 QModelIndex DocumentModel::makeRind( const QModelIndex& icenter,
1431         const QModelIndex& ivecx, const QModelIndex& ivecz,
1432         double  radext, double radint, double radhole,
1433         const QModelIndex& iplorig,
1434         int nrad, int nang, int nhaut )
1435 {
1436     QModelIndex iElts;
1437
1438     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1439     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1440     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1441     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1442
1443     HEXA_NS::Elements* hElts = _hexaDocument->makeRind( hcenter,
1444             hvecx, hvecz,
1445             radext, radint, radhole,
1446             hplorig,
1447             nrad, nang, nhaut );
1448     if ( BadElement(hElts) ) return iElts;
1449
1450     updateData(); //CS_TODO more or less?
1451     ElementsItem* eltsItem = new ElementsItem(hElts);
1452     _elementsDirItem->appendRow(eltsItem);
1453     iElts = eltsItem->index();
1454
1455     return iElts;
1456 }
1457
1458 QModelIndex DocumentModel::makePartRind( const QModelIndex& icenter,
1459         const QModelIndex& ivecx, const QModelIndex& ivecz,
1460         double  radext, double radint, double radhole,
1461         const QModelIndex& iplorig, double angle,
1462         int nrad, int nang, int nhaut )
1463 {
1464     QModelIndex iElts;
1465
1466     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1467     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1468     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1469     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1470
1471     HEXA_NS::Elements* hElts = _hexaDocument->makePartRind( hcenter,
1472             hvecx, hvecz,
1473             radext, radint, radhole,
1474             hplorig, angle,
1475             nrad, nang, nhaut );
1476     if ( BadElement(hElts) ) return iElts;
1477
1478     updateData();
1479     ElementsItem* eltsItem = new ElementsItem(hElts);
1480     _elementsDirItem->appendRow(eltsItem);
1481     iElts = eltsItem->index();
1482
1483     return iElts;
1484 }
1485
1486 QModelIndex DocumentModel::makeSphere( const QModelIndex& icenter,
1487         const QModelIndex& ivecx, const QModelIndex& ivecz,
1488         double radius, double radhole,
1489         const QModelIndex& iplorig,
1490         int nrad, int nang, int nhaut )
1491 {
1492     QModelIndex iElts;
1493
1494     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1495     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1496     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1497     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1498
1499     HEXA_NS::Elements* hElts = _hexaDocument->makeSphere( hcenter,
1500             hvecx, hvecz,
1501             radius, radhole,
1502             hplorig,
1503             nrad, nang, nhaut);
1504     if ( BadElement(hElts) ) return iElts;
1505
1506     updateData();
1507     ElementsItem* eltsItem = new ElementsItem(hElts);
1508     _elementsDirItem->appendRow(eltsItem);
1509     iElts = eltsItem->index();
1510
1511     return iElts;
1512 }
1513
1514 QModelIndex DocumentModel::makePartSphere( const QModelIndex& icenter,
1515         const QModelIndex& ivecx, const QModelIndex& ivecz,
1516         double  radius, double radhole,
1517         const QModelIndex& iplorig, double angle,
1518         int nrad, int nang, int nhaut )
1519 {
1520     QModelIndex iElts;
1521
1522     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1523     HEXA_NS::Vector* hvecx   = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1524     HEXA_NS::Vector* hvecz   = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1525     HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1526
1527     HEXA_NS::Elements* hElts = _hexaDocument->makePartSphere( hcenter,
1528             hvecx, hvecz,
1529             radius, radhole,
1530             hplorig, angle,
1531             nrad, nang, nhaut);
1532     if ( BadElement(hElts) ) return iElts;
1533
1534     updateData();
1535     ElementsItem* eltsItem = new ElementsItem(hElts);
1536     _elementsDirItem->appendRow(eltsItem);
1537     iElts = eltsItem->index();
1538
1539     return iElts;
1540 }
1541
1542 // ************  EDIT HEXABLOCK MODEL ************
1543
1544 bool DocumentModel::updateVertex( const QModelIndex& ivertex, double x, double y, double z )
1545 {
1546     bool ret = false;
1547
1548     //HEXA_NS::Vertex* hVertex = ivertex.data(HEXA_DATA_ROLE).value<HEXA_NS::Vertex *>(); //CS_TODO?  pareil pour toutes les autres méthodes du modèle?
1549     HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
1550
1551     if ( hVertex ){
1552         //     hVertex->setName( name.toStdString() );
1553         hVertex->setX ( x );
1554         hVertex->setY ( y );
1555         hVertex->setZ ( z );
1556         emit patternDataChanged();
1557         ret = true;
1558     }
1559
1560     return ret;
1561 }
1562
1563 bool DocumentModel::removeHexa( const QModelIndex& ihexa )
1564 {
1565     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1566
1567     int r = _hexaDocument->removeHexa( hHexa );
1568     if ( r == HOK ){
1569         updateData();
1570         return true;
1571     }
1572
1573     return false;
1574 }
1575
1576 bool DocumentModel::removeConnectedHexa( const QModelIndex& ihexa )
1577 {
1578     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1579
1580     int r = _hexaDocument->removeConnectedHexa( hHexa );
1581     if ( r == HOK ){
1582         updateData();
1583         return true;
1584     }
1585
1586     return false;
1587 }
1588
1589 QModelIndex DocumentModel::prismQuad( const QModelIndex& iquad, const QModelIndex& ivec, int nb)
1590 {
1591     QModelIndex iElts;
1592
1593     HEXA_NS::Quad*   hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1594     HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
1595
1596     HEXA_NS::Elements* hElts = _hexaDocument->prismQuad( hQuad, hVect, nb );
1597     if ( BadElement(hElts) ) return iElts;
1598
1599     updateData(); //CS_TODO more or less?
1600     ElementsItem* elts = new ElementsItem(hElts);
1601     _elementsDirItem->appendRow(elts);
1602     iElts = elts->index();
1603
1604     return iElts;
1605 }
1606
1607 QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, int nb)
1608 {
1609     QModelIndex iElts;
1610
1611     HEXA_NS::Quads   hQuads;
1612     HEXA_NS::Quad*   hQuad = NULL;
1613     foreach( const QModelIndex& iquad, iquads ){
1614         hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1615         hQuads.push_back( hQuad );
1616     }
1617     HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
1618
1619     HEXA_NS::Elements* hElts = _hexaDocument->prismQuads( hQuads, hVect, nb );
1620     if ( BadElement(hElts) ) return iElts;
1621
1622     updateData(); //CS_TODO more or less?
1623     ElementsItem* elts = new ElementsItem(hElts);
1624     _elementsDirItem->appendRow(elts);
1625     iElts = elts->index();
1626
1627     return iElts;
1628 }
1629
1630 QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, std::vector<double> layersSize, int nb)
1631 {
1632     QModelIndex iElts;
1633
1634     HEXA_NS::Quads   hQuads;
1635     HEXA_NS::Quad*   hQuad = NULL;
1636     foreach( const QModelIndex& iquad, iquads ){
1637         hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1638         hQuads.push_back( hQuad );
1639     }
1640     HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
1641
1642     HEXA_NS::Elements* hElts = _hexaDocument->prismQuadsVec( hQuads, hVect, layersSize, nb );
1643     if ( BadElement(hElts) ) return iElts;
1644
1645     updateData(); //CS_TODO more or less?
1646     ElementsItem* elts = new ElementsItem(hElts);
1647     _elementsDirItem->appendRow(elts);
1648     iElts = elts->index();
1649
1650     return iElts;
1651 }
1652
1653 //
1654 QModelIndex DocumentModel::joinQuad(
1655         const QModelIndex& iquadstart, const QModelIndex& iquaddest,
1656         const QModelIndex& iv0, const QModelIndex& iv1,
1657         const QModelIndex& iv2, const QModelIndex& iv3,
1658         int nb )
1659 {
1660     QModelIndex iElts;
1661
1662     HEXA_NS::Quad*   hQuadStart  = getHexaPtr<HEXA_NS::Quad*>(iquadstart);
1663     HEXA_NS::Quad*   hQuadDest   = getHexaPtr<HEXA_NS::Quad*>(iquaddest);
1664
1665     HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1666     HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1667     HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1668     HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1669
1670     HEXA_NS::Elements* hElts = _hexaDocument->joinQuad( hQuadStart, hQuadDest,
1671             hVertex0,  hVertex1,  hVertex2,  hVertex3, nb );
1672     if ( BadElement(hElts) ) return iElts;
1673
1674     updateData(); //CS_TODO more or less?
1675     ElementsItem* elts = new ElementsItem(hElts);
1676     _elementsDirItem->appendRow(elts);
1677     iElts = elts->index();
1678
1679     return iElts;
1680 }
1681
1682 QModelIndex DocumentModel::joinQuads(
1683         const QModelIndexList& iquadsstart, const QModelIndex& iquaddest,
1684         const QModelIndex& iv0, const QModelIndex& iv1,
1685         const QModelIndex& iv2, const QModelIndex& iv3,
1686         int nb )
1687 {
1688     QModelIndex iElts;
1689
1690     HEXA_NS::Quad*   hQuadStart;
1691     HEXA_NS::Quads  hQuadsStart;
1692
1693     foreach( const QModelIndex& iquad, iquadsstart ){
1694         hQuadStart = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
1695         hQuadsStart.push_back( hQuadStart );
1696     }
1697     HEXA_NS::Quad*   hQuadDest = data( iquaddest, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
1698
1699     HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1700     HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1701     HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1702     HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1703
1704     HEXA_NS::Elements* hElts = _hexaDocument->joinQuads(
1705             hQuadsStart, hQuadDest,
1706             hVertex0,  hVertex1,  hVertex2,  hVertex3,
1707             nb );
1708     if ( BadElement(hElts) ) return iElts;
1709
1710     updateData(); //CS_TODO more or less?
1711     ElementsItem* elts = new ElementsItem(hElts);
1712     _elementsDirItem->appendRow(elts);
1713     iElts = elts->index();
1714
1715     return iElts;
1716 }
1717
1718 bool DocumentModel::mergeVertices( const QModelIndex &iv0, const QModelIndex &iv1 ) //CS_TODO : impact sur le model?
1719 {
1720     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1721     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1722
1723     int r = _hexaDocument->mergeVertices( hv0, hv1 );
1724     if ( r == HOK ){
1725         updateData(); //CS_TODO more or less?
1726         return true;
1727     }
1728
1729     return false;
1730 }
1731
1732 bool DocumentModel::mergeEdges( const QModelIndex &ie0, const QModelIndex &ie1,
1733         const QModelIndex &iv0, const QModelIndex &iv1 )
1734 //CS_TODO : impact sur le model?
1735 {
1736     HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(ie0);
1737     HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(ie1);
1738
1739     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1740     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1741
1742     //Merge
1743     int r = _hexaDocument->mergeEdges( he0, he1, hv0, hv1 );
1744     if ( r == HOK ){
1745         updateData();
1746         return true;
1747     }
1748
1749     return false;
1750 }
1751
1752 bool DocumentModel::mergeQuads( const QModelIndex& iquad0, const QModelIndex& iquad1,
1753         const QModelIndex& iv0, const QModelIndex& iv1,
1754         const QModelIndex& iv2, const QModelIndex& iv3 )
1755 {
1756     HEXA_NS::Quad* hquad0 = data(iquad0, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
1757     HEXA_NS::Quad* hquad1 = data(iquad1, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
1758
1759     HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1760     HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1761     HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1762     HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1763
1764     int r = _hexaDocument->mergeQuads( hquad0, hquad1, hv0, hv1, hv2, hv3 );
1765     if ( r == HOK ){
1766         updateData();
1767         return true;
1768     }
1769
1770     return false;
1771 }
1772
1773 //
1774 QModelIndex DocumentModel::disconnectVertex( const QModelIndex& ihexa, const QModelIndex& ivertex )
1775 {
1776     QModelIndex iElts;
1777
1778     HEXA_NS::Hexa*   hHexa   = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1779     HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
1780
1781     HEXA_NS::Elements* hElts = _hexaDocument->disconnectVertex( hHexa, hVertex );
1782     if ( BadElement(hElts) ) return iElts;
1783
1784     updateData(); //CS_TO_CHECK
1785     ElementsItem* elts = new ElementsItem(hElts);
1786     _elementsDirItem->appendRow(elts);
1787     iElts = elts->index();
1788
1789     return iElts;
1790 }
1791
1792 QModelIndex DocumentModel::disconnectEdge( const QModelIndex& ihexa, const QModelIndex& iedge )
1793 {
1794     QModelIndex iElts;
1795
1796     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1797     HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1798
1799     HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdge( hHexa, hEdge );
1800     if ( BadElement(hElts) ) return iElts;
1801
1802     updateData(); //CS_TO_CHECK
1803     ElementsItem* elts = new ElementsItem(hElts);
1804     _elementsDirItem->appendRow(elts);
1805     iElts = elts->index();
1806
1807     return iElts;
1808 }
1809
1810
1811 QModelIndex DocumentModel::disconnectEdges( const QModelIndexList& ihexas, const QModelIndexList& iedges )
1812 {
1813     QModelIndex iElts;
1814
1815     HEXA_NS::Hexas hHexas;
1816     HEXA_NS::Edges hEdges;
1817
1818     //edges list
1819     HEXA_NS::Edge* hedge = NULL;
1820     foreach( const QModelIndex& iedge, iedges ){
1821         hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1822         hEdges.push_back( hedge );
1823     }
1824
1825     //hexas list
1826     HEXA_NS::Hexa* hhexa = NULL;
1827     foreach( const QModelIndex& ihexa, ihexas ){
1828         hhexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1829         hHexas.push_back( hhexa );
1830     }
1831
1832
1833     HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdges( hHexas, hEdges );
1834     if ( BadElement(hElts) ) return iElts;
1835
1836     updateData(); //CS_TO_CHECK
1837     ElementsItem* elts = new ElementsItem(hElts);
1838     _elementsDirItem->appendRow(elts);
1839     iElts = elts->index();
1840
1841     return iElts;
1842 }
1843
1844
1845 QModelIndex DocumentModel::disconnectQuad( const QModelIndex& ihexa, const QModelIndex& iquad )
1846 {
1847     QModelIndex iElts;
1848
1849     HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1850     HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1851
1852     HEXA_NS::Elements* hElts = _hexaDocument->disconnectQuad( hHexa, hQuad );
1853     if ( BadElement(hElts) ) return iElts;
1854
1855     updateData(); //CS_TO_CHECK
1856     ElementsItem* elts = new ElementsItem(hElts);
1857     _elementsDirItem->appendRow(elts);
1858     iElts = elts->index();
1859
1860     return iElts;
1861 }
1862
1863
1864 QModelIndex DocumentModel::cutEdge( const QModelIndex &i_e0, int nbcuts )
1865 //CS_TODO : impact sur le model?
1866 {
1867     QModelIndex iElts;
1868
1869     HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(i_e0);
1870     HEXA_NS::Elements* helts = _hexaDocument->cut( he0, nbcuts );
1871
1872     if ( BadElement(helts) ) return iElts;
1873
1874     updateData(); //CS_TODO more?
1875     ElementsItem* elts = new ElementsItem(helts);
1876     _elementsDirItem->appendRow(elts);
1877     iElts = elts->index();
1878
1879     return iElts;
1880 }
1881
1882
1883 // Elements makeTranslation( in Elements l, in Vector vec )
1884 //         raises (SALOME::SALOME_Exception);
1885 QModelIndex DocumentModel::makeTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
1886 {
1887     QModelIndex iElts;
1888
1889     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1890     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1891
1892     HEXA_NS::Elements* hNewElts = _hexaDocument->makeTranslation( hElts, hVec );
1893     if ( BadElement(hNewElts) ) return iElts;
1894
1895     updateData(); //CS_TODO  more or less?
1896     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1897     _elementsDirItem->appendRow(eltsItem);
1898     iElts = eltsItem->index();
1899
1900     return iElts;
1901 }
1902
1903
1904
1905 QModelIndex DocumentModel::makeScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
1906 {
1907     QModelIndex iElts;
1908
1909     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1910     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1911
1912     HEXA_NS::Elements* hNewElts = _hexaDocument->makeScale( hElts, hVex, k );
1913     if ( BadElement(hNewElts) ) return iElts;
1914
1915     updateData(); //CS_TODO  more or less?
1916     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1917     _elementsDirItem->appendRow(eltsItem);
1918     iElts = eltsItem->index();
1919
1920     return iElts;
1921 }
1922
1923
1924
1925 QModelIndex DocumentModel::makeRotation( const QModelIndex& ielts,
1926         const QModelIndex& iv,
1927         const QModelIndex& ivec, double angle )
1928 {
1929     QModelIndex iElts;
1930
1931     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1932     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1933     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1934
1935     HEXA_NS::Elements* hNewElts = _hexaDocument->makeRotation( hElts, hVex, hVec, angle );
1936     if ( BadElement(hNewElts) ) return iElts;
1937
1938     updateData(); //CS_TODO  more or less?
1939     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1940     _elementsDirItem->appendRow(eltsItem);
1941     iElts = eltsItem->index();
1942
1943     return iElts;
1944 }
1945
1946
1947 QModelIndex DocumentModel::makeSymmetryPoint( const QModelIndex& ielts, const QModelIndex& iv )
1948 {
1949     QModelIndex iElts;
1950
1951     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1952     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1953
1954     HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPoint (hElts, hVex);
1955     if ( BadElement(hNewElts) ) return iElts;
1956
1957     updateData(); //CS_TODO  more or less?
1958     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1959     _elementsDirItem->appendRow(eltsItem);
1960     iElts = eltsItem->index();
1961
1962     return iElts;
1963 }
1964
1965
1966 QModelIndex DocumentModel::makeSymmetryLine( const QModelIndex& ielts,
1967         const QModelIndex& iv,
1968         const QModelIndex& ivec )
1969 {
1970     QModelIndex iElts;
1971
1972     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1973     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1974     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1975
1976
1977     HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryLine( hElts, hVex, hVec );
1978     if ( BadElement(hNewElts) ) return iElts;
1979
1980     updateData(); //CS_TODO  more or less?
1981     ElementsItem* eltsItem = new ElementsItem(hNewElts);
1982     _elementsDirItem->appendRow(eltsItem);
1983     iElts = eltsItem->index();
1984
1985     return iElts;
1986 }
1987
1988
1989 QModelIndex DocumentModel::makeSymmetryPlane( const QModelIndex& ielts, const QModelIndex& iv, const QModelIndex& ivec )
1990 {
1991     QModelIndex iElts;
1992
1993     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1994     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(iv);
1995     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
1996
1997     HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPlane( hElts, hVex, hVec );
1998     if ( BadElement(hNewElts) ) return iElts;
1999
2000     updateData(); //CS_TODO  more or less?
2001     ElementsItem* eltsItem = new ElementsItem(hNewElts);
2002     _elementsDirItem->appendRow(eltsItem);
2003     iElts = eltsItem->index();
2004
2005     return iElts;
2006 }
2007
2008
2009 bool DocumentModel::performTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
2010 {
2011     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2012     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
2013
2014     int r = _hexaDocument->performTranslation (hElts, hVec);
2015     if ( r == HOK ){ //Job well done?
2016         updateData();
2017         return true;
2018     }
2019
2020     return false;
2021 }
2022
2023
2024 //
2025 bool DocumentModel::performScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
2026 {
2027     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2028     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2029
2030     int r = _hexaDocument->performScale (hElts, hVex, k);
2031     if ( r == HOK ){
2032         updateData();
2033         return true;
2034     }
2035
2036     return false;
2037 }
2038
2039 //
2040 bool DocumentModel::performRotation( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec, double angle )
2041 {
2042     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2043     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2044     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
2045
2046     int r = _hexaDocument-> performRotation( hElts, hVex, hVec, angle );
2047     if ( r == HOK ){
2048         updateData();
2049         return true;
2050     }
2051
2052     return false;
2053 }
2054
2055
2056 //
2057 bool DocumentModel::performSymmetryPoint( const QModelIndex& ielts, const QModelIndex& ivex )
2058 {
2059     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2060     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2061
2062     int r = _hexaDocument->performSymmetryPoint( hElts, hVex );
2063     if ( r == HOK ){
2064         updateData();
2065         return true;
2066     }
2067
2068     return false;
2069 }
2070
2071
2072 bool DocumentModel::performSymmetryLine( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec )
2073 {
2074     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2075     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2076     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
2077
2078     int r = _hexaDocument->performSymmetryLine( hElts, hVex, hVec );
2079     if ( r == HOK ){
2080         updateData();
2081         return true;
2082     }
2083
2084     return false;
2085 }
2086
2087
2088 bool DocumentModel::performSymmetryPlane( const QModelIndex& ielts,
2089         const QModelIndex& ivex,
2090         const QModelIndex& ivec )
2091 {
2092     HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2093     HEXA_NS::Vertex*   hVex  = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2094     HEXA_NS::Vector*   hVec  = getHexaPtr<HEXA_NS::Vector*>(ivec);
2095
2096     int r = _hexaDocument->performSymmetryPlane( hElts, hVex, hVec );
2097     if ( r == HOK ){
2098         updateData();
2099         return true;
2100     }
2101
2102     return false;
2103 }
2104
2105 QModelIndex DocumentModel::revolutionQuads( const QModelIndexList& istartquads,
2106         const QModelIndex& icenter,
2107         const QModelIndex& ivecaxis,
2108         const QList<double>& angles )
2109 {
2110     QModelIndex ielts;
2111
2112     HEXA_NS::Quads   hstartquads;
2113     HEXA_NS::Quad*   hquad = NULL;
2114     foreach( const QModelIndex& iquad, istartquads){
2115         hquad = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad*>();
2116         hstartquads.push_back( hquad );
2117     }
2118     HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2119     HEXA_NS::Vector* haxis   = getHexaPtr<HEXA_NS::Vector*>(ivecaxis);
2120     std::vector<double> hangles = angles.toVector().toStdVector();
2121
2122     HEXA_NS::Elements* helts = _hexaDocument->revolutionQuads( hstartquads, hcenter, haxis, hangles );
2123     if ( BadElement(helts) ) return ielts;
2124
2125     updateData();
2126     ElementsItem* eltsItem = new ElementsItem(helts);
2127     _elementsDirItem->appendRow(eltsItem);
2128     ielts = eltsItem->index();
2129
2130     return ielts;
2131 }
2132
2133 QModelIndex DocumentModel::replace( const QModelIndexList& iquadsPattern,
2134         const QModelIndex& ip1, const QModelIndex& ic1,
2135         const QModelIndex& ip2, const QModelIndex& ic2,
2136         const QModelIndex& ip3, const QModelIndex& ic3 )
2137 {
2138     QModelIndex ielts;
2139
2140     HEXA_NS::Vertex* hp1 = getHexaPtr<HEXA_NS::Vertex*>(ip1);
2141     HEXA_NS::Vertex* hc1 = getHexaPtr<HEXA_NS::Vertex*>(ic1);
2142     HEXA_NS::Vertex* hp2 = getHexaPtr<HEXA_NS::Vertex*>(ip2);
2143     HEXA_NS::Vertex* hc2 = getHexaPtr<HEXA_NS::Vertex*>(ic2);
2144     HEXA_NS::Vertex* hp3 = getHexaPtr<HEXA_NS::Vertex*>(ip3);
2145     HEXA_NS::Vertex* hc3 = getHexaPtr<HEXA_NS::Vertex*>(ic3);
2146
2147     HEXA_NS::Quads   hquads;
2148     HEXA_NS::Quad*   hquad = NULL;
2149     foreach( const QModelIndex& iquad, iquadsPattern ){
2150         hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
2151         hquads.push_back( hquad );
2152     }
2153
2154     HEXA_NS::Elements* helts = _hexaDocument->replace( hquads,
2155             hp1, hc1, hp2, hc2, hp3, hc3 );
2156     if ( BadElement(helts) ) return ielts;
2157
2158     updateData();
2159     ElementsItem* eltsItem = new ElementsItem(helts);
2160     _elementsDirItem->appendRow(eltsItem);
2161     ielts = eltsItem->index();
2162
2163     return ielts;
2164 }
2165
2166 // ************  ADD ASSOCIATION ************
2167 //
2168
2169 //--------------- METHOD OBSOLETE
2170 //void DocumentModel::addAssociation( const QModelIndex& iElt, const DocumentModel::GeomObj& assocIn )
2171 //{
2172 //    //   assocIn.name;
2173 //    HEXA_NS::Shape* assoc = new HEXA_NS::Shape( assocIn.brep.toStdString() );//CS_TODO : delete assoc
2174 //    assoc->setStart (assocIn.start);
2175 //    assoc->setEnd   (assocIn.end);
2176 //    assoc->setIdent ( (assocIn.shapeName + "," + assocIn.subid).toStdString() );
2177 //
2178 //    QString currentAssoc, newAssoc;
2179 //
2180 //    if ( data(iElt, HEXA_TREE_ROLE) == VERTEX_TREE ){
2181 //        HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iElt);
2182 //        hVex->setAssociation( assoc );
2183 //    } else if ( data(iElt, HEXA_TREE_ROLE) == EDGE_TREE ){
2184 //        HEXA_NS::Edge*   hEdge = getHexaPtr<HEXA_NS::Edge*>(iElt);
2185 //        hEdge->addAssociation( assoc );
2186 //    } else if ( data(iElt, HEXA_TREE_ROLE) == QUAD_TREE ){
2187 //        HEXA_NS::Quad*   hQuad  = getHexaPtr<HEXA_NS::Quad*>(iElt);
2188 //        hQuad->addAssociation( assoc );
2189 //    }
2190 //
2191 //    currentAssoc = data( iElt, HEXA_ASSOC_ENTRY_ROLE ).toString();
2192 //    if ( !currentAssoc.isEmpty() ){
2193 //        newAssoc = currentAssoc + assocIn.shapeName + "," + assocIn.subid + ";";
2194 //    } else {
2195 //        newAssoc = assocIn.shapeName + "," + assocIn.subid + ";";
2196 //    }
2197 //    setData( iElt, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2198 //}
2199 //--------------------------------
2200
2201
2202 QMultiMap< QString, int >     DocumentModel::getAssocShapesIds(const QModelIndex& dataIndex)
2203 {
2204    QMultiMap< QString, int > result;
2205    HEXA_NS::NewShape* mainShape;
2206    HEXA_NS::VertexShape* node;
2207    HEXA_NS::EdgeShape* line;
2208    HEXA_NS::FaceShape* face;
2209    QString shapeName;
2210    int subid;
2211
2212    PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
2213    QModelIndexList assocsInd = pdsm->getGeomAssociations(/*index*/dataIndex);
2214    foreach( const QModelIndex& anAssoc, assocsInd )
2215    {
2216       node = getHexaPtr<HEXA_NS::VertexShape*>(anAssoc);
2217       line = getHexaPtr<HEXA_NS::EdgeShape*>(anAssoc);
2218       face = getHexaPtr<HEXA_NS::FaceShape*>(anAssoc);
2219
2220       if (node != NULL)
2221          {
2222             mainShape = node->getParentShape();
2223             if (mainShape != NULL)
2224                {
2225                   shapeName = mainShape->getName();
2226                   subid = node->getIdent();
2227                }
2228          }
2229       else if (line != NULL)
2230          {
2231             mainShape = line->getParentShape();
2232             if (mainShape != NULL)
2233                {
2234                   shapeName = mainShape->getName();
2235                   subid = line->getIdent();
2236                }
2237          }
2238       else if (face != NULL)
2239          {
2240             mainShape = face->getParentShape();
2241             if (mainShape != NULL)
2242                {
2243                   shapeName = mainShape->getName();
2244                   subid = face->getIdent();
2245                }
2246          }
2247
2248       if (!shapeName.isEmpty())
2249          result.insert( shapeName, subid );
2250
2251       shapeName = QString();
2252    }
2253    return result;
2254 }
2255
2256 bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, double x, double y, double z)
2257 {
2258     HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
2259
2260     if (vertex == NULL || _hexaDocument == NULL || vertex->setAssociation(x, y, z) != HOK)
2261         return false;
2262
2263     setData( iVertex, QVariant::fromValue(QString::number(x)+","+QString::number(y)+","+QString::number(z)), HEXA_ASSOC_ENTRY_ROLE );
2264     return true;
2265 }
2266
2267 bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, const QModelIndex& iGeomVertex)
2268 {
2269     //parameters control
2270     QString newAssoc;
2271     HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
2272     HEXA_NS::VertexShape* geomVertex = getHexaPtr<HEXA_NS::VertexShape*>(iGeomVertex);
2273     if (_hexaDocument == NULL || vertex == NULL || geomVertex == NULL) return false;
2274     HEXA_NS::NewShape* mainShape = geomVertex->getParentShape();
2275     if (mainShape == NULL) return false;
2276
2277     //add association
2278     if (vertex->setAssociation(geomVertex) != HOK)
2279         return false;
2280
2281     //update association state in the model
2282     newAssoc =  QString(mainShape->getName()) + "," + QString::number(geomVertex->getIdent()) + ";";
2283     setData( iVertex, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2284
2285     return true;
2286 }
2287
2288 bool DocumentModel::addEdgeAssociation( const QModelIndex& iEdge, const QModelIndex& iGeomEdge, double start, double end)
2289 {
2290     //parameters control
2291     QString currentAssoc, newAssoc;
2292     HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
2293     HEXA_NS::EdgeShape* geomEdge = getHexaPtr<HEXA_NS::EdgeShape*>(iGeomEdge);
2294     if (_hexaDocument == NULL || edge == NULL ||
2295             geomEdge == NULL || start > end) return false;
2296     HEXA_NS::NewShape* mainShape = geomEdge->getParentShape();
2297     if (mainShape == NULL) return false;
2298
2299     //add association in the engine side
2300     if (edge->addAssociation(geomEdge, start, end) != HOK)
2301         return false;
2302
2303     //add/update association in the model side (UI)
2304     currentAssoc = data(iEdge, HEXA_ASSOC_ENTRY_ROLE).toString();
2305     newAssoc = QString(mainShape->getName()) + "," + QString::number(geomEdge->getIdent()) + ";";
2306     if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
2307
2308     setData( iEdge, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2309
2310     return true;
2311 }
2312
2313 bool DocumentModel::addQuadAssociation (const QModelIndex& iQuad, const QModelIndex& iGeomFace)
2314 {
2315     //parameters control
2316     QString currentAssoc, newAssoc;
2317     HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
2318     HEXA_NS::FaceShape* geomFace = getHexaPtr<HEXA_NS::FaceShape*>(iGeomFace);
2319     if (_hexaDocument == NULL || quad == NULL || geomFace == NULL)
2320         return false;
2321     HEXA_NS::NewShape* mainShape = geomFace->getParentShape();
2322     if (mainShape == NULL) return false;
2323
2324     //add association
2325     if (quad->addAssociation(geomFace) != HOK)
2326         return false;
2327
2328     //update association
2329     currentAssoc = data( iQuad, HEXA_ASSOC_ENTRY_ROLE).toString();
2330     newAssoc = QString(mainShape->getName()) + "," + QString::number(geomFace->getIdent()) + ";";
2331     if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
2332     setData( iQuad, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2333
2334     return true;
2335 }
2336
2337
2338 QModelIndex DocumentModel::getVertexAssociation(const QModelIndex& iVertex)
2339 {
2340     HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex*>(iVertex);
2341     if (vertex == NULL) return QModelIndex();
2342
2343     //get the associated geom vertex
2344     HEXA_NS::VertexShape* geomVertex = vertex->getAssoVertex();
2345     if (geomVertex == NULL) return QModelIndex();
2346
2347     //convert geom vertex to qmodelindex
2348     if (HEXABLOCKGUI::currentDocGView == NULL) return QModelIndex();
2349     PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
2350     PatternGeomModel* pgm = HEXABLOCKGUI::currentDocGView->getPatternGeomModel();
2351     if (pgsm == NULL || pgm == NULL) return QModelIndex();
2352
2353     return pgm->mapToSource(pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomVertex) ));
2354 }
2355
2356
2357 QList<DocumentModel::GeomObj> DocumentModel::getEdgeAssociations(const QModelIndex& iEdge)
2358 {
2359     QList<DocumentModel::GeomObj> result;
2360     HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
2361     if (edge == NULL) return result;
2362
2363     DocumentModel::GeomObj        assoc;
2364     HEXA_NS::EdgeShape* geomEdge;
2365     HEXA_NS::AssoEdge* anEdgeAssoc;
2366     HEXA_NS::NewShape* mainShape;
2367     QString name;
2368
2369     int nbAssocs = edge->countAssociation();
2370     for (int i = 0; i < nbAssocs; ++i)
2371     {
2372         anEdgeAssoc = edge->getAssociation(i);
2373         if (anEdgeAssoc == NULL) continue;
2374         geomEdge = anEdgeAssoc->getEdgeShape();
2375         if (geomEdge == NULL) continue;
2376         mainShape = geomEdge->getParentShape();
2377         if (mainShape == NULL) continue;    // => les generatrices ne sont pas gerees pour le moment
2378         assoc.shapeName = mainShape->getName();
2379         assoc.subid = QString::number(geomEdge->getIdent());
2380         assoc.start = anEdgeAssoc->getStart();
2381         assoc.end = anEdgeAssoc->getEnd();
2382         result << assoc;
2383     }
2384
2385     return result;
2386 }
2387
2388
2389 QModelIndexList DocumentModel::getQuadAssociations(const QModelIndex& iQuad)
2390 {
2391     QModelIndexList result;
2392     QModelIndex geomQuadIndex;
2393     HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
2394     if (quad == NULL) return result;
2395
2396     if (HEXABLOCKGUI::currentDocGView == NULL) return result;
2397     PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
2398     PatternGeomModel* pgm = HEXABLOCKGUI::currentDocGView->getPatternGeomModel();
2399     if (pgsm == NULL || pgm == NULL) return result;
2400
2401     HEXA_NS::FaceShape* geomFace;
2402
2403     int nbAssocs = quad->countAssociation();
2404     for (int i = 0; i < nbAssocs; ++i)
2405     {
2406         geomFace = quad->getAssociation(i);
2407         if (geomFace == NULL) continue;
2408
2409         geomQuadIndex = pgm->mapToSource(pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomFace) ));
2410         result << geomQuadIndex;
2411     }
2412
2413     return result;
2414 }
2415
2416 //--------------- METHOD OBSOLETE
2417 //QList<DocumentModel::GeomObj> DocumentModel::getAssociations( const QModelIndex& iElt )
2418 //{
2419 //    QList<DocumentModel::GeomObj> res;
2420 //    DocumentModel::GeomObj        assoc;
2421 //
2422 //    //std::cout << "getAssociations() start"  << std::endl;
2423 //    if ( data(iElt, HEXA_TREE_ROLE) == VERTEX_TREE ){
2424 //        //    HEXA_NS::Vertex* hVex = data(iElt, HEXA_DATA_ROLE).value<HEXA_NS::Vertex *>();
2425 //        HEXA_NS::Vertex *hVex = getHexaPtr<HEXA_NS::Vertex *>(iElt);
2426 //        HEXA_NS::Shape* hShape = hVex->getAssociation();
2427 //        QStringList shapeID;
2428 //        if ( hShape != NULL ){
2429 //            assoc.shapeName = QString();
2430 //            assoc.subid = QString::number(-1);
2431 //            assoc.brep  = hShape->getBrep().c_str();
2432 //            assoc.start = hShape->getStart();
2433 //            assoc.end   = hShape->getEnd();
2434 //
2435 //            shapeID = QString( hShape->getIdent().c_str() ).split(",");
2436 //            if ( shapeID.count() == 2 ){
2437 //                assoc.shapeName = shapeID[0];
2438 //                assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
2439 //            }
2440 //            res << assoc;
2441 //        }
2442 //    } else if ( data(iElt, HEXA_TREE_ROLE) == EDGE_TREE ){
2443 //        HEXA_NS::Edge*   hEdge = getHexaPtr<HEXA_NS::Edge *>(iElt);
2444 //        HEXA_NS::Shapes  hShapes = hEdge->getAssociations();
2445 //        QStringList shapeID;
2446 //        for ( HEXA_NS::Shapes::iterator it = hShapes.begin(); it != hShapes.end(); ++it){
2447 //            assoc.shapeName = QString();
2448 //            assoc.subid = QString::number(-1);
2449 //            assoc.brep  = (*it)->getBrep().c_str();
2450 //            assoc.start = (*it)->getStart();
2451 //            assoc.end   = (*it)->getEnd();
2452 //
2453 //            shapeID = QString( (*it)->getIdent().c_str() ).split(",");
2454 //            if ( shapeID.count() == 2 ){
2455 //                assoc.shapeName = shapeID[0];
2456 //                assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
2457 //            }
2458 //            res << assoc;
2459 //        }
2460 //    } else if ( data(iElt, HEXA_TREE_ROLE) == QUAD_TREE ){
2461 //        HEXA_NS::Quad*   hQuad  = getHexaPtr<HEXA_NS::Quad*>(iElt);
2462 //        HEXA_NS::Shapes  hShapes = hQuad->getAssociations();
2463 //        QStringList shapeID;
2464 //        for ( HEXA_NS::Shapes::iterator it = hShapes.begin(); it != hShapes.end(); ++it){
2465 //            assoc.shapeName = QString();
2466 //            assoc.subid = QString::number(-1);
2467 //            assoc.brep  = (*it)->getBrep().c_str();
2468 //            assoc.start = (*it)->getStart();
2469 //            assoc.end   = (*it)->getEnd();
2470 //            shapeID = QString( (*it)->getIdent().c_str() ).split(",");
2471 //            if ( shapeID.count() == 2 ){
2472 //                assoc.shapeName = shapeID[0];
2473 //                assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
2474 //            }
2475 //
2476 //            res << assoc;
2477 //        }
2478 //    }
2479 //
2480 //    return res;
2481 //}
2482 //----------------------------------
2483
2484 bool DocumentModel::associateOpenedLine( const QModelIndexList& iedges,
2485         HEXA_NS::NewShapes shapes,
2486         HEXA_NS::IntVector subIds,
2487         double pstart,
2488         double pend )
2489 {
2490
2491     HEXA_NS::Edges  mline;
2492
2493     HEXA_NS::Edge* hedge = NULL;
2494     foreach( const QModelIndex& iedge, iedges ){
2495         hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
2496         if (hedge != NULL)
2497             mline.push_back( hedge );
2498     }
2499
2500     int err = _hexaDocument->associateOpenedLine( mline, shapes, subIds, pstart, pend );
2501     if ( err == HOK ){
2502         updateData();
2503         return true;
2504     }
2505     return false;
2506 }
2507
2508
2509 bool DocumentModel::associateClosedLine( const  QModelIndex& ivertex,
2510         const  QModelIndexList& iedges,
2511         HEXA_NS::NewShapes shapes,
2512         HEXA_NS::IntVector subIds,
2513         double pstart,
2514         bool   inv )
2515 {
2516     HEXA_NS::Vertex* mfirst = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
2517     HEXA_NS::Edges   mline;
2518
2519     HEXA_NS::Edge* hedge = NULL;
2520     foreach( const QModelIndex& iedge, iedges ){
2521         hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
2522         if (hedge != NULL)
2523             mline.push_back( hedge );
2524     }
2525
2526     int err = _hexaDocument->associateClosedLine( mfirst, mline, shapes, subIds, pstart, inv);
2527     if ( err == HOK ){
2528         updateData();
2529         return true;
2530     }
2531     return false;
2532 }
2533
2534 // ************  GROUPS  ************
2535 //
2536 QModelIndex DocumentModel::addGroup( const QString& name, Group kind )
2537 {
2538     QModelIndex iGroup;
2539
2540     HEXA_NS::Group* hGroup = _hexaDocument->addGroup( name.toLocal8Bit().constData(), kind );
2541     if ( hGroup == NULL ) return iGroup;
2542
2543     GroupItem* groupItem = new GroupItem(hGroup);
2544     groupItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
2545     _groupDirItem->appendRow(groupItem);
2546     iGroup = groupItem->index();
2547
2548     return iGroup;
2549 }
2550
2551
2552 //
2553 bool DocumentModel::removeGroup( const QModelIndex& igrp )
2554 {
2555     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2556     int r = _hexaDocument->removeGroup ( hGroup );
2557
2558     if ( r == HOK ){
2559         removeRow( igrp.row(), igrp.parent());
2560         return true;
2561     }
2562
2563     return false;
2564 }
2565 /*
2566 QModelIndex* DocumentModel::found(eltBase)
2567 {
2568         TODO_JMD
2569 }
2570  */
2571
2572 QModelIndexList DocumentModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
2573 {
2574     QModelIndexList iElements;
2575
2576     HEXA_NS::Group* g = iGroup.data(HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2577     if ( g == NULL ) return iElements;
2578
2579     QModelIndexList iFound;
2580     QVariant q;
2581     HEXA_NS::EltBase* eltBase = NULL;
2582     for ( int nr = 0; nr < g->countElement(); ++nr ){
2583         eltBase = g->getElement( nr );
2584         kind = g->getKind();
2585         switch ( kind ){
2586         case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: q = QVariant::fromValue( (HEXA_NS::Hexa *)eltBase ); break;
2587         case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: q = QVariant::fromValue( (HEXA_NS::Quad *)eltBase ); break;
2588         case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: q = QVariant::fromValue( (HEXA_NS::Edge *)eltBase ); break;
2589         case HEXA_NS::VertexNode: q = QVariant::fromValue( (HEXA_NS::Vertex *)eltBase ); break;
2590         }
2591         iFound = match( index(0, 0),
2592                 HEXA_DATA_ROLE,
2593                 q,
2594                 1,
2595                 Qt::MatchRecursive );
2596         if ( !iFound.isEmpty() )
2597             iElements << iFound[0];
2598     }
2599     return iElements;
2600 }
2601
2602 // 7.4 Boite: éditer un groupe
2603 void DocumentModel::setGroupName( const QModelIndex& igrp, const QString& name )
2604 {
2605     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2606
2607     if ( hGroup ){
2608         hGroup->setName( name.toLocal8Bit().constData() );
2609         setData(igrp, QVariant::fromValue( name ) );
2610     }
2611
2612 }
2613
2614 bool DocumentModel::addGroupElement( const QModelIndex& igrp, const QModelIndex& ielt )
2615 { //CS_TODO : check input? add child?
2616     // int       addElement    (EltBase* elt);
2617
2618     HEXA_NS::Group*   hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2619     if (hGroup == NULL) return false;
2620
2621     HEXA_NS::EltBase* hElt   = NULL;
2622     switch ( hGroup->getKind() ){
2623     case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: hElt = getHexaPtr<HEXA_NS::Hexa*>(ielt); break;
2624     case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: hElt = getHexaPtr<HEXA_NS::Quad*>(ielt); break;
2625     case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: hElt = getHexaPtr<HEXA_NS::Edge*>(ielt); break;
2626     case HEXA_NS::VertexNode: hElt = getHexaPtr<HEXA_NS::Vertex*>(ielt); break;
2627     }
2628
2629     int res = HERR;
2630     if ( hElt != NULL )
2631         res = hGroup->addElement( hElt );
2632
2633     if ( res == HOK ) return true;
2634
2635     return false;
2636 }
2637
2638 bool DocumentModel::removeGroupElement( const QModelIndex& igrp, int nro )
2639 { //CS_TODO : remove child?
2640     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2641     if (hGroup == NULL) return false;
2642
2643     if (hGroup->removeElement( nro ) == HOK) return true;
2644
2645     return false;
2646 }
2647
2648 bool DocumentModel::clearGroupElement( const QModelIndex& igrp )
2649 {
2650     HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2651
2652     if ( hGroup != NULL)
2653     {
2654         hGroup->clearElement();
2655         return true;
2656     }
2657     return false;
2658 }
2659
2660 // ************  LAWS  ************
2661
2662 //
2663 QModelIndex DocumentModel::addLaw( const QString& name, int nbnodes )
2664 {
2665     QModelIndex iLaw;
2666
2667     HEXA_NS::Law* hLaw = _hexaDocument->addLaw( name.toLocal8Bit().constData(), nbnodes );
2668     if ( BadElement(hLaw) ) return iLaw;
2669
2670     LawItem* lawItem = new LawItem(hLaw);
2671     _lawDirItem->appendRow(lawItem);
2672     iLaw = lawItem->index();
2673
2674     return iLaw;
2675 }
2676
2677 bool DocumentModel::setLaw( const QModelIndex& ilaw, int nbnodes, double coeff, KindLaw type )
2678 {
2679     bool ret = false;
2680
2681     HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2682
2683     if ( hLaw ){
2684         int ok;
2685         ok = hLaw->setNodes( nbnodes );
2686         ( ok == HOK) ? ret = true : ret = false;
2687         ok = hLaw->setCoefficient( coeff );
2688         hLaw->setKind(type);
2689     }
2690
2691     return ret;
2692 }
2693
2694 //
2695 bool  DocumentModel::removeLaw( const QModelIndex& ilaw )
2696 {
2697     HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2698     int r = _hexaDocument->removeLaw( hLaw );
2699
2700     if ( r == HOK ){
2701         removeRow( ilaw.row(),  ilaw.parent());
2702         return true;
2703     }
2704
2705     return false;
2706 }
2707
2708 bool DocumentModel::setPropagation( const QModelIndex& iPropagation, const QModelIndex& iLaw, bool way )
2709 {
2710     HEXA_NS::Propagation* hPropagation = data(iPropagation, HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
2711     HEXA_NS::Law* hLaw = data(iLaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2712
2713     int r = hPropagation->setLaw( hLaw );
2714     hPropagation->setWay( way );
2715
2716     if ( r == HOK ) return true;
2717
2718     return false;
2719 }
2720
2721 QModelIndexList DocumentModel::getPropagation( const QModelIndex& iPropagation ) const
2722 {
2723     QModelIndexList iEdges;
2724
2725     QModelIndexList iFound;
2726     HEXA_NS::Propagation* propa = iPropagation.data(HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
2727     if ( propa == NULL ) return iEdges;
2728
2729     const HEXA_NS::Edges& edges = propa->getEdges();
2730     for ( HEXA_NS::Edges::const_iterator anEdge = edges.begin();
2731             anEdge != edges.end();
2732             ++anEdge ){
2733         iFound = match( index(0, 0),
2734                 HEXA_DATA_ROLE,
2735                 QVariant::fromValue( *anEdge ),
2736                 1,
2737                 Qt::MatchRecursive);
2738         if ( !iFound.isEmpty() )
2739             iEdges << iFound[0];
2740     }
2741
2742     return iEdges;
2743 }
2744
2745 HEXA_NS::Document* DocumentModel::documentImpl()
2746 {
2747     return _hexaDocument;
2748 }
2749
2750 QString DocumentModel::documentEntry()
2751 {
2752     return _entry;
2753 }
2754
2755 // 8.3 Boite: éditer une loi  CS_TODO
2756 // (idem création)
2757
2758 /*****************************************************************
2759                       PatternDataModel
2760  *****************************************************************/
2761
2762 PatternDataModel::PatternDataModel( QObject * parent ) :
2763                               QSortFilterProxyModel( parent )
2764 {
2765     QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8)").
2766             arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).
2767             arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).arg(HEXA_DIR_TREE);
2768
2769     setFilterRole(HEXA_TREE_ROLE);
2770     setFilterRegExp ( QRegExp(dataRegExp) );
2771 }
2772
2773 PatternDataModel::~PatternDataModel()
2774 {
2775 }
2776
2777 HEXA_NS::Document* PatternDataModel::documentImpl()
2778 {
2779     HEXA_NS::Document* doc = NULL;
2780     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2781     if (m) doc = m->documentImpl();
2782     return doc;
2783 }
2784
2785 QString PatternDataModel::documentEntry()
2786 {
2787     QString entry;
2788     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2789     if (m) entry = m->documentEntry();
2790     return entry;
2791 }
2792
2793 Qt::ItemFlags PatternDataModel::flags(const QModelIndex &index) const
2794 {
2795     Qt::ItemFlags flags;
2796
2797     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2798     if ( m != NULL ){
2799         flags = m->flags( mapToSource(index) );
2800     }
2801     return flags;
2802 }
2803
2804
2805 QVariant PatternDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2806 {
2807     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2808         return QVariant( "Data" );
2809     } else {
2810         return QSortFilterProxyModel::headerData ( section, orientation, role );
2811     }
2812 }
2813
2814
2815 QStandardItem* PatternDataModel::itemFromIndex ( const QModelIndex & index ) const
2816 {
2817     QStandardItem *item = NULL;
2818     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2819     if ( m != NULL ){
2820         item = m->itemFromIndex( mapToSource(index) );
2821     }
2822     return item;
2823 }
2824
2825 PatternBuilderModel::PatternBuilderModel( QObject * parent ) :
2826                               QSortFilterProxyModel( parent )
2827 {
2828     QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10)").
2829             arg(VECTOR_TREE).arg(CYLINDER_TREE).arg(PIPE_TREE).arg(ELEMENTS_TREE).
2830             arg(CROSSELEMENTS_TREE).arg(VECTOR_DIR_TREE).arg(CYLINDER_DIR_TREE).
2831             arg(PIPE_DIR_TREE).arg(ELEMENTS_DIR_TREE).arg(CROSSELEMENTS_DIR_TREE);
2832
2833     setFilterRole( HEXA_TREE_ROLE );
2834     setFilterRegExp ( QRegExp(builderRegExp ) );
2835 }
2836
2837 PatternBuilderModel::~PatternBuilderModel()
2838 {
2839 }
2840
2841 Qt::ItemFlags PatternBuilderModel::flags(const QModelIndex &index) const
2842 {
2843     //   std::cout<<"PatternBuilderModel::flags()"<<std::endl;
2844     Qt::ItemFlags flags;
2845
2846     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2847     if ( m != NULL ){
2848         flags = m->flags( mapToSource(index) );
2849     }
2850     return flags;
2851 }
2852
2853 QVariant PatternBuilderModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2854 {
2855     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2856         return QVariant( "Builder" );
2857     } else {
2858         return QSortFilterProxyModel::headerData ( section, orientation, role );
2859     }
2860 }
2861
2862 QStandardItem* PatternBuilderModel::itemFromIndex ( const QModelIndex & index ) const
2863 {
2864     QStandardItem *item = NULL;
2865     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2866     if ( m != NULL ){
2867         item = m->itemFromIndex( mapToSource(index) );
2868     }
2869     return item;
2870 }
2871
2872 //====================================================================
2873 //              PatternGeomModel
2874 //====================================================================
2875 PatternGeomModel::PatternGeomModel( QObject * parent ) :
2876                               QSortFilterProxyModel( parent )
2877 {
2878     QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12|%13|%14)").
2879             arg(EXPLICIT_SHAPES_TREE).arg(IMPLICIT_SHAPES_TREE).arg(CLOUD_OF_POINTS_TREE).
2880             arg(GEOMSHAPE_TREE).arg(GEOMPOINT_TREE).arg(GEOMEDGE_TREE).arg(GEOMFACE_TREE).
2881             arg(EXPLICIT_SHAPES_DIR_TREE).arg(IMPLICIT_SHAPES_DIR_TREE).arg(CLOUD_OF_POINTS_DIR_TREE).
2882             arg(GEOMSHAPE_DIR_TREE).arg(GEOMPOINT_DIR_TREE).arg(GEOMEDGE_DIR_TREE).arg(GEOMFACE_DIR_TREE);
2883
2884     setFilterRole( HEXA_TREE_ROLE );
2885     setFilterRegExp ( QRegExp(builderRegExp ) );
2886 }
2887
2888 PatternGeomModel::~PatternGeomModel()
2889 {
2890 }
2891
2892 Qt::ItemFlags PatternGeomModel::flags(const QModelIndex &index) const
2893 {
2894     Qt::ItemFlags flags;
2895
2896     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2897     if ( m != NULL ){
2898         flags = m->flags( mapToSource(index) );
2899     }
2900     return flags;
2901 }
2902
2903 QVariant PatternGeomModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2904 {
2905     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2906         return QVariant( "Geometry" );
2907     } else {
2908         return QSortFilterProxyModel::headerData ( section, orientation, role );
2909     }
2910 }
2911
2912 QStandardItem* PatternGeomModel::itemFromIndex ( const QModelIndex & index ) const
2913 {
2914     QStandardItem *item = NULL;
2915     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2916     if ( m != NULL ){
2917         item = m->itemFromIndex( mapToSource(index) );
2918     }
2919     return item;
2920 }
2921 //==============================================================
2922
2923
2924
2925 AssociationsModel::AssociationsModel( QObject * parent ) :
2926                               QSortFilterProxyModel( parent )
2927 {
2928     QString assocRegExp;// =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE); CS_TODO
2929
2930     setFilterRole( HEXA_TREE_ROLE );
2931     setFilterRegExp ( QRegExp(assocRegExp) );
2932 }
2933
2934 AssociationsModel::~AssociationsModel()
2935 {
2936 }
2937
2938 Qt::ItemFlags AssociationsModel::flags(const QModelIndex &index) const
2939 {
2940     Qt::ItemFlags flags;
2941
2942     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2943     if ( m != NULL ){
2944         flags = m->flags( mapToSource(index) );
2945     }
2946     return flags;
2947 }
2948
2949 QVariant AssociationsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2950 {
2951     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2952         return QVariant( "Associations" );
2953     } else {
2954         return QSortFilterProxyModel::headerData ( section, orientation, role );
2955     }
2956 }
2957
2958 QStandardItem* AssociationsModel::itemFromIndex ( const QModelIndex & index ) const
2959 {
2960     QStandardItem *item = NULL;
2961     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2962     if ( m != NULL ){
2963         item = m->itemFromIndex( mapToSource(index) );
2964     }
2965     return item;
2966 }
2967
2968 GroupsModel::GroupsModel( QObject * parent ) :
2969                               QSortFilterProxyModel( parent )
2970 {
2971     QString groupsRegExp =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE);
2972
2973     setFilterRole( HEXA_TREE_ROLE );
2974     setFilterRegExp ( QRegExp(groupsRegExp ) );
2975 }
2976
2977 GroupsModel::~GroupsModel()
2978 {
2979 }
2980
2981 Qt::ItemFlags GroupsModel::flags(const QModelIndex &index) const
2982 {
2983     Qt::ItemFlags flags;
2984
2985     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2986     if ( m != NULL ){
2987         flags = m->flags( mapToSource(index) );
2988     }
2989     return flags;
2990 }
2991
2992 QVariant GroupsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2993 {
2994     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2995         return QVariant( "Groups" );
2996     } else {
2997         return QSortFilterProxyModel::headerData ( section, orientation, role );
2998     }
2999 }
3000
3001 QStandardItem* GroupsModel::itemFromIndex ( const QModelIndex & index ) const
3002 {
3003     QStandardItem *item = NULL;
3004     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3005     if ( m != NULL ){
3006         item = m->itemFromIndex( mapToSource(index) );
3007     }
3008     return item;
3009 }
3010
3011 QModelIndexList GroupsModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
3012 {
3013     QModelIndexList elements;
3014     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3015     if ( m != NULL ){
3016         elements = m->getGroupElements( mapToSource(iGroup), kind );
3017     }
3018     return elements;
3019 }
3020
3021 MeshModel::MeshModel( QObject * parent ) :
3022                               QSortFilterProxyModel( parent )
3023 {
3024     QString meshRegExp =QString("(%1|%2|%3|%4)").arg(LAW_TREE).arg(LAW_DIR_TREE)                            .arg(PROPAGATION_TREE).arg(PROPAGATION_DIR_TREE);
3025
3026     setFilterRole( HEXA_TREE_ROLE );
3027     setFilterRegExp ( QRegExp(meshRegExp) );
3028 }
3029
3030 MeshModel::~MeshModel()
3031 {
3032 }
3033
3034 Qt::ItemFlags MeshModel::flags(const QModelIndex &index) const
3035 {
3036     Qt::ItemFlags flags;
3037
3038     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3039     if ( m != NULL ){
3040         flags = m->flags( mapToSource(index) );
3041     }
3042     return flags;
3043 }
3044
3045 QVariant MeshModel::headerData ( int section, Qt::Orientation orientation, int role ) const
3046 {
3047     if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
3048         return QVariant( "Mesh" );
3049     } else {
3050         return QSortFilterProxyModel::headerData ( section, orientation, role );
3051     }
3052 }
3053
3054 QStandardItem* MeshModel::itemFromIndex ( const QModelIndex & index ) const
3055 {
3056     QStandardItem *item = NULL;
3057     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3058     if ( m != NULL ){
3059         item = m->itemFromIndex( mapToSource(index) );
3060     }
3061     return item;
3062 }
3063
3064 QModelIndexList MeshModel::getPropagation( const QModelIndex& iPropagation ) const
3065 {
3066     QModelIndexList edges;
3067     DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3068     if ( m != NULL ){
3069         edges = m->getPropagation( mapToSource(iPropagation) );
3070     }
3071     return edges;
3072 }