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