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