1 // Copyright (C) 2009-2013 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 //CS_TODO: relever les fonctions qui nécessitent updateData().
21 // addGroupElement à tester
25 #include "utilities.h"
27 #include "HEXABLOCKGUI_DocumentModel.hxx"
28 #include "HEXABLOCKGUI_DocumentItem.hxx"
29 #include "HEXABLOCKGUI_VtkDocumentGraphicView.hxx"
31 #include "HEXABLOCKGUI.hxx"
32 #include "HEXABLOCKGUI_Trace.hxx"
34 #include "HexVertex.hxx"
35 #include "HexShape.hxx"
36 #include "HexSubShape.hxx"
37 #include "HexAssoEdge.hxx"
41 #include "HEXABLOCKGUI_SalomeTools.hxx"
43 #include "MyGEOMBase_Helper.hxx"
44 #include "GEOM_GEOMBase.hxx"
45 #include "GEOM_GenericObjPtr.h"
47 #include <GEOM_Displayer.h>
48 #include <SALOME_ListIO.hxx>
49 #include <SALOMEconfig.h>
50 #include <SUIT_ViewWindow.h>
51 #include CORBA_CLIENT_HEADER(GEOM_Gen)
60 //using namespace HEXA_NS;
61 using namespace HEXABLOCK::GUI;
63 /*****************************************************************
65 *****************************************************************/
66 // DocumentModel::DocumentModel(QObject * parent):
67 DocumentModel::DocumentModel(HEXA_NS::Document* docIn, const QString& entryIn, QObject * parent):
68 QStandardItemModel(parent),
69 _hexaFile( new QTemporaryFile() ),
70 _hexaDocument( docIn ),
72 // _hexaDocument( new HEXA_NS::Document("/tmp/doc.hex") ), //CS_TODO
74 _vertexDirItem( new QStandardItem(tr("TREE_ITEM_VERTEX")) ),
75 _edgeDirItem( new QStandardItem(tr("TREE_ITEM_EDGE")) ),
76 _quadDirItem( new QStandardItem(tr("TREE_ITEM_QUAD")) ),
77 _hexaDirItem( new QStandardItem(tr("TREE_ITEM_HEXA")) ),
79 _vectorDirItem( new QStandardItem(tr("TREE_ITEM_VECTOR")) ),
80 _cylinderDirItem( new QStandardItem(tr("TREE_ITEM_CYLINDER")) ),
81 _pipeDirItem( new QStandardItem(tr("TREE_ITEM_PIPE")) ),
82 _elementsDirItem( new QStandardItem(tr("TREE_ITEM_ELEMENT")) ),
83 _crossElementsDirItem( new QStandardItem(tr("TREE_ITEM_CROSSELEMENT")) ),
85 _explicitShapesDirItem( new QStandardItem(tr("TREE_ITEM_EXPSHAPE")) ),
86 _implicitShapesDirItem( new QStandardItem(tr("TREE_ITEM_IMPSHAPE")) ),
87 _cloudOfPointsDirItem( new QStandardItem(tr("TREE_ITEM_CLOUD_OF_POINT")) ),
89 _groupDirItem( new QStandardItem(tr("TREE_ITEM_GROUP")) ),
91 _lawDirItem( new QStandardItem(tr("TREE_ITEM_LAW")) ),
92 _propagationDirItem( new QStandardItem(tr("TREE_ITEM_PROPAGATION")) ),
94 _vertexItemFlags( Qt::NoItemFlags ),
95 _edgeItemFlags( Qt::NoItemFlags ),
96 _quadItemFlags( Qt::NoItemFlags ),
97 _hexaItemFlags( Qt::NoItemFlags ),
98 _vectorItemFlags( Qt::NoItemFlags ),
99 _cylinderItemFlags( Qt::NoItemFlags ),
100 _pipeItemFlags( Qt::NoItemFlags ),
101 _elementsItemFlags( Qt::NoItemFlags ),
102 _crossElementsItemFlags( Qt::NoItemFlags ),
104 _disallowEdition( false )
106 // setColumnCount( 4 ); //CS_TEST
107 if ( !_hexaDocument && _hexaFile->open() ){
108 _hexaDocument = new HEXA_NS::Document( _hexaFile->fileName().toLatin1() );
109 _hexaDocument->reorderFaces();
112 QStandardItem *parentItem = invisibleRootItem();
113 // parentItem->setData( QString::number( reinterpret_cast<intptr_t>(_hexaDocument) ), HEXA_ENTRY_ROLE );
114 parentItem->setData( _entry, HEXA_ENTRY_ROLE );
116 _vertexDirItem->setData( VERTEX_DIR_TREE, HEXA_TREE_ROLE );
117 _edgeDirItem->setData( EDGE_DIR_TREE, HEXA_TREE_ROLE );
118 _quadDirItem->setData( QUAD_DIR_TREE, HEXA_TREE_ROLE );
119 _hexaDirItem->setData( HEXA_DIR_TREE, HEXA_TREE_ROLE );
121 _vectorDirItem->setData( VECTOR_DIR_TREE, HEXA_TREE_ROLE );
122 _cylinderDirItem->setData( CYLINDER_DIR_TREE, HEXA_TREE_ROLE );
123 _pipeDirItem->setData( PIPE_DIR_TREE, HEXA_TREE_ROLE );
124 _elementsDirItem->setData( ELEMENTS_DIR_TREE, HEXA_TREE_ROLE );
125 _crossElementsDirItem->setData( CROSSELEMENTS_DIR_TREE, HEXA_TREE_ROLE );
127 _explicitShapesDirItem->setData( EXPLICIT_SHAPES_DIR_TREE, HEXA_TREE_ROLE );
128 _implicitShapesDirItem->setData( IMPLICIT_SHAPES_DIR_TREE, HEXA_TREE_ROLE );
129 _cloudOfPointsDirItem->setData( CLOUD_OF_POINTS_DIR_TREE, HEXA_TREE_ROLE );
131 _groupDirItem->setData( GROUP_DIR_TREE, HEXA_TREE_ROLE );
133 //CS_TODO associations
135 _lawDirItem->setData( LAW_DIR_TREE, HEXA_TREE_ROLE );
136 _propagationDirItem->setData( PROPAGATION_DIR_TREE, HEXA_TREE_ROLE );
138 parentItem->appendRow(_vertexDirItem);
139 parentItem->appendRow(_edgeDirItem);
140 parentItem->appendRow(_quadDirItem);
141 parentItem->appendRow(_hexaDirItem);
143 parentItem->appendRow(_vectorDirItem);
144 parentItem->appendRow(_cylinderDirItem);
145 parentItem->appendRow(_pipeDirItem);
146 parentItem->appendRow(_elementsDirItem);
147 parentItem->appendRow(_crossElementsDirItem);
149 parentItem->appendRow(_explicitShapesDirItem);
150 parentItem->appendRow(_implicitShapesDirItem);
151 // parentItem->appendRow(_cloudOfPointsDirItem);
153 parentItem->appendRow(_groupDirItem);
154 parentItem->appendRow(_lawDirItem);
155 parentItem->appendRow(_propagationDirItem);
158 DocumentModel::~DocumentModel()
160 if (_hexaDocument != NULL)
161 delete _hexaDocument;
163 if (_hexaFile != NULL)
167 void DocumentModel::setName(const QString& name)
169 _hexaDocument->setName( name.toLocal8Bit().constData() );
170 emit nameChanged(QString(_hexaDocument->getName()));
173 HEXA_NS::EltBase* DocumentModel::getHexaPtr(const QModelIndex& iElt)
175 HEXA_NS::EltBase *elt = NULL;
176 switch ( /*data(iElt, HEXA_TREE_ROLE).toInt()*/iElt.data(HEXA_TREE_ROLE).toInt() ){
177 case VERTEX_TREE : elt = getHexaPtr<HEXA_NS::Vertex*>(iElt); break;
178 case EDGE_TREE : elt = getHexaPtr<HEXA_NS::Edge*>(iElt); break;
179 case QUAD_TREE : elt = getHexaPtr<HEXA_NS::Quad*>(iElt); break;
180 case HEXA_TREE : elt = getHexaPtr<HEXA_NS::Hexa*>(iElt); break;
181 case VECTOR_TREE : elt = getHexaPtr<HEXA_NS::Vector*>(iElt); break;
182 case CYLINDER_TREE : elt = getHexaPtr<HEXA_NS::Cylinder*>(iElt); break;
183 case PIPE_TREE : elt = getHexaPtr<HEXA_NS::Pipe*>(iElt); break;
184 case ELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::Elements*>(iElt); break;
185 case CROSSELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::CrossElements*>(iElt); break;
186 case GEOMSHAPE_TREE: elt = getHexaPtr<HEXA_NS::NewShape*>(iElt); break;
187 case GEOMPOINT_TREE: elt = getHexaPtr<HEXA_NS::VertexShape*>(iElt); break;
188 case GEOMEDGE_TREE: elt = getHexaPtr<HEXA_NS::EdgeShape*>(iElt); break;
189 case GEOMFACE_TREE: elt = getHexaPtr<HEXA_NS::FaceShape*>(iElt); break;
194 //get the number of elements of type 'eltType' in the document
195 int DocumentModel::getNbrElt(HEXA_NS::EnumElt eltType)
197 if (_hexaDocument == NULL) return 0;
199 return _hexaDocument->getNbrElt(eltType);
202 //get the number of elements of type 'eltType' used in the document
203 int DocumentModel::getNbrUsedElt(HEXA_NS::EnumElt eltType)
205 if (_hexaDocument == NULL) return 0;
208 case HEXA_NS::EL_VERTEX:
209 return _hexaDocument->countUsedVertex();
210 case HEXA_NS::EL_EDGE:
211 return _hexaDocument->countUsedEdge();
212 case HEXA_NS::EL_QUAD:
213 return _hexaDocument->countUsedQuad();
214 case HEXA_NS::EL_HEXA:
215 return _hexaDocument->countUsedHexa();
220 //associate a shape to the current document
221 bool DocumentModel::addShape(TopoDS_Shape& aShape, QString& name)
223 if (aShape.IsNull()) return false;
224 return (_hexaDocument != NULL ? _hexaDocument->addShape(aShape, name.toStdString().c_str()) != NULL : false);
227 //get the number of unused elements of type 'eltType' in the document
228 int DocumentModel::getNbrUnusedElt(HEXA_NS::EnumElt eltType)
230 if (_hexaDocument == NULL) return 0;
232 return getNbrElt(eltType) - getNbrUsedElt(eltType);
235 DocumentModel::GeomObj* DocumentModel::convertToGeomObj(GEOM::GeomObjPtr geomObjPtr)
238 DocumentModel::GeomObj *res = NULL;
240 if ( geomObjPtr && GEOMBase::GetShape(geomObjPtr.get(), aShape) && !aShape.IsNull() )
242 res = new DocumentModel::GeomObj;
243 if (res == NULL) return NULL;
244 QString mainShapeEntry;
248 if ( geomObjPtr->IsMainShape() ){
249 mainShapeEntry = geomObjPtr->GetStudyEntry();
250 brep = shape2string( aShape ).c_str();
253 TopoDS_Shape subshape;
254 GEOM::GEOM_Object_var mainShape = geomObjPtr->GetMainShape();
255 mainShapeEntry = mainShape->GetStudyEntry();
256 // CS_TODO : à optimiser
257 bool okShape = GEOMBase::GetShape( mainShape , shape);
258 bool oksubShape = GEOMBase::GetShape( geomObjPtr.get(), subshape );
259 if ( okShape && oksubShape ){
260 brep = shape2string( subshape ).c_str();
261 subId = GEOMBase::GetIndex( subshape, shape );
262 MESSAGE("subid = " << QString::number(subId).toStdString());
265 res->shapeName = getGeomObjName(mainShapeEntry);
266 res->name = GEOMBase::GetName( geomObjPtr.get() );
267 res->subid = QString::number(subId);
277 //Load the current Document
278 void DocumentModel::load()
280 if (_hexaDocument == NULL) return;
281 load(_hexaDocument->getName());
285 void DocumentModel::load( const QString& xmlFileName ) // Fill Data
287 _hexaDocument->loadXml(xmlFileName.toLocal8Bit().constData() );
297 emit patternDataChanged();
299 // BUILDER, ASSOCIATION, GROUPS, ... CS_TODO _fillBuilderFrom( _hexaDocument );
302 bool DocumentModel::isEmpty() const
304 if (_hexaDocument == NULL) return true;
305 return _hexaDocument->isEmpty();
308 void DocumentModel::save( const QString& xmlFileName )
310 _hexaDocument->save( xmlFileName.toLocal8Bit().constData() );
313 QString DocumentModel::getName()
315 return _hexaDocument->getName();
318 void DocumentModel::updateData()
324 emit patternDataChanged();
327 void DocumentModel::refresh()
338 emit patternDataChanged();
342 void DocumentModel::clearAll()
351 //dataChanged( const QModelIndex & topLeft, const QModelIndex & bottomRight )
352 //CS_TODO : todo : association, groups, mesh
355 void DocumentModel::clearData()
357 _vertexDirItem->removeRows( 0, _vertexDirItem->rowCount() );
358 _edgeDirItem->removeRows(0, _edgeDirItem->rowCount() );
359 _quadDirItem->removeRows(0, _quadDirItem->rowCount() );
360 _hexaDirItem->removeRows(0, _hexaDirItem->rowCount() );
364 void DocumentModel::clearBuilder()
366 _vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
367 _cylinderDirItem->removeRows(0, _cylinderDirItem->rowCount() );
368 _pipeDirItem->removeRows(0, _pipeDirItem->rowCount() );
369 _elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
370 _crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
373 void DocumentModel::clearGeometry()
375 _explicitShapesDirItem->removeRows(0, _explicitShapesDirItem->rowCount() );
376 _implicitShapesDirItem->removeRows(0, _implicitShapesDirItem->rowCount() );
377 _cloudOfPointsDirItem->removeRows(0, _cloudOfPointsDirItem->rowCount() );
380 void DocumentModel::clearAssociation()
385 void DocumentModel::clearGroups()
387 _groupDirItem->removeRows(0, _groupDirItem->rowCount() );
390 void DocumentModel::clearMesh()
392 _lawDirItem->removeRows(0, _lawDirItem->rowCount() );
393 _propagationDirItem->removeRows(0, _propagationDirItem->rowCount() );
397 void DocumentModel::fillData()
400 HEXA_NS::Vertex *v = NULL;
401 VertexItem *vItem = NULL;
402 for ( int i=0; i<_hexaDocument->countVertex(); ++i ){
403 v = _hexaDocument->getVertex(i);
404 vItem = new VertexItem(v, _entry);
405 _vertexDirItem->appendRow(vItem);
408 HEXA_NS::Edge *e = NULL;
409 EdgeItem *eItem = NULL;
410 for ( int i=0; i<_hexaDocument->countEdge(); ++i ){
411 e = _hexaDocument->getEdge(i);
412 eItem = new EdgeItem(e, _entry);
413 _edgeDirItem->appendRow(eItem);
416 HEXA_NS::Quad *q = NULL;
417 QuadItem *qItem = NULL;
418 for ( int i=0; i<_hexaDocument->countQuad(); ++i ){
419 q = _hexaDocument->getQuad(i);
420 qItem = new QuadItem(q, _entry);
421 _quadDirItem->appendRow(qItem);
424 HEXA_NS::Hexa *h = NULL;
425 HexaItem *hItem = NULL;
426 for ( int i=0; i<_hexaDocument->countHexa(); ++i ){
427 h = _hexaDocument->getHexa(i);
428 hItem = new HexaItem(h, _entry);
429 _hexaDirItem->appendRow(hItem);
434 void DocumentModel::fillBuilder()
436 HEXA_NS::Vector *v = NULL;
437 VectorItem *vItem = NULL;
438 for ( int i=0; i<_hexaDocument->countVector(); ++i ){
439 v = _hexaDocument->getVector(i);
440 vItem = new VectorItem(v);
441 _vectorDirItem->appendRow(vItem);
445 HEXA_NS::Cylinder *c = NULL;
446 CylinderItem *cItem = NULL;
447 for ( int i=0; i<_hexaDocument->countCylinder(); ++i ){
448 c = _hexaDocument->getCylinder(i);
449 cItem = new CylinderItem(c, _entry);
450 _cylinderDirItem->appendRow(cItem);
454 HEXA_NS::Pipe *p = NULL;
455 PipeItem *pItem = NULL;
456 for ( int i=0; i<_hexaDocument->countPipe(); ++i ){
457 p = _hexaDocument->getPipe(i);
458 pItem = new PipeItem(p);
459 _pipeDirItem->appendRow(pItem);
463 void DocumentModel::fillGeometry()
466 if (_hexaDocument == NULL) return;
468 HEXA_NS::NewShape* shape;
469 HEXA_NS::VertexShape* node;
470 HEXA_NS::EdgeShape* line;
471 HEXA_NS::FaceShape* face;
475 //fill the shape tree
477 for (int i=0; i < _hexaDocument->countShape(); ++i)
479 shape = _hexaDocument->getShape(i);
480 QString shapeName = shape->getName();
482 //publish the shape in the study if not done yet
483 if (!docShapesEntry.contains(shapeName))
485 //save the brep of the shape in a temporary file
486 QString fileName = shapeName + ".brep";
489 //importing the brep in the study
490 QString objStudyEntry = HEXABLOCKGUI::addInStudy(fileName);
492 docShapesName[objStudyEntry] = shapeName;
493 docShapesEntry[shapeName] = objStudyEntry;
496 GeomShapeItem* shItem = new GeomShapeItem(shape);
497 if (shape->getOrigin() == HEXA_NS::SH_IMPORT)
498 _explicitShapesDirItem->appendRow(shItem);
500 _implicitShapesDirItem->appendRow(shItem);
502 //add vertices to the tree
503 QStandardItem* geomPointDirItem = new QStandardItem(tr("TREE_ITEM_VERTEX"));
504 geomPointDirItem->setData( GEOMPOINT_DIR_TREE, HEXA_TREE_ROLE );
505 shItem->appendRow(geomPointDirItem);
506 for (int j=0; j < shape->countVertex(); ++j)
508 node = shape->getVertexShape(j);
509 GeomPointItem* gPointItem = new GeomPointItem(node);
510 geomPointDirItem->appendRow(gPointItem);
511 shapeById[shapeName+","+QString::number(node->getIdent())] = node;
514 //add edges to the tree
515 QStandardItem* geomEdgeDirItem = new QStandardItem(tr("TREE_ITEM_EDGE"));
516 geomEdgeDirItem->setData( GEOMEDGE_DIR_TREE, HEXA_TREE_ROLE );
517 shItem->appendRow(geomEdgeDirItem);
518 for (int j = 0; j < shape->countEdge(); ++j)
520 line = shape->getEdgeShape(j);
521 GeomEdgeItem* gEdgeItem = new GeomEdgeItem(line);
522 geomEdgeDirItem->appendRow(gEdgeItem);
523 shapeById[shapeName+","+QString::number(line->getIdent())] = line;
526 //add faces to the tree
527 QStandardItem* geomFaceDirItem = new QStandardItem(tr("TREE_ITEM_QUAD"));
528 geomFaceDirItem->setData( GEOMFACE_DIR_TREE, HEXA_TREE_ROLE );
529 shItem->appendRow(geomFaceDirItem);
530 for (int j = 0; j < shape->countFace(); ++j)
532 face = shape->getFaceShape(j);
533 GeomFaceItem* gFaceItem = new GeomFaceItem(face);
534 geomFaceDirItem->appendRow(gFaceItem);
535 shapeById[shapeName+","+QString::number(face->getIdent())] = face;
548 void DocumentModel::fillAssociation()
552 //------------------------------------------- NEW ITEMS
553 //void DocumentModel::fillGroups()
555 // HEXA_NS::Group *g = NULL;
556 // GroupItem *gItem = NULL;
557 // for ( int i=0; i<_hexaDocument->countGroup(); ++i ){
558 // g = _hexaDocument->getGroup(i);
559 // gItem = new GroupItem(g, _entry);
560 // _groupDirItem->appendRow(gItem);
564 //void DocumentModel::fillMesh()
566 // HEXA_NS::Law *l = NULL;
567 // LawItem *lItem = NULL;
568 // for ( int i=0; i<_hexaDocument->countLaw(); ++i ){
569 // l = _hexaDocument->getLaw(i);
570 // lItem = new LawItem(l);
571 // _lawDirItem->appendRow(lItem);
574 // HEXA_NS::Propagation *p = NULL;
575 // PropagationItem *pItem = NULL;
576 // for ( int i=0; i<_hexaDocument->countPropagation(); ++i ){
577 // p = _hexaDocument->getPropagation(i);
578 // pItem = new PropagationItem(p, _entry);
579 // pItem->setText(QString("Propagation%1").arg(i) );
580 // _propagationDirItem->appendRow(pItem);
583 //----------------------------------------------- END NEW ITEMS
585 void DocumentModel::fillGroups()
587 HEXA_NS::Group *g = NULL;
588 GroupItem *gItem = NULL;
589 for ( int i=0; i<_hexaDocument->countGroup(); ++i ){
590 g = _hexaDocument->getGroup(i);
591 //std::cout<<"getGroup => "<< i << std::endl;
592 gItem = new GroupItem(g);
593 gItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
594 _groupDirItem->appendRow(gItem);
598 void DocumentModel::fillMesh()
601 HEXA_NS::Law *l = NULL;
602 LawItem *lItem = NULL;
603 for ( int i=0; i<_hexaDocument->countLaw(); ++i ){
604 l = _hexaDocument->getLaw(i);
605 lItem = new LawItem(l);
606 _lawDirItem->appendRow(lItem);
609 // _propagationDirItem
610 HEXA_NS::Propagation *p = NULL;
611 PropagationItem *pItem = NULL;
612 for ( int i=0; i<_hexaDocument->countPropagation(); ++i ){
613 p = _hexaDocument->getPropagation(i);
614 pItem = new PropagationItem(p);
615 pItem->setText(QString("Propagation%1").arg(i) );
616 pItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
617 _propagationDirItem->appendRow(pItem);
621 HEXA_NS::Hexa* DocumentModel::getQuadHexa(HEXA_NS::Quad* quad)
624 for ( int i=0; i<_hexaDocument->countHexa(); ++i ){
625 hexa = _hexaDocument->getHexa(i);
626 if (hexa->findQuad(quad) > -1) return hexa;
632 Qt::ItemFlags DocumentModel::flags(const QModelIndex &index) const
636 if (!index.isValid()) return Qt::ItemIsEnabled;
638 if ( _disallowEdition ){
639 return QAbstractItemModel::flags(index) | Qt::ItemFlags( ~Qt::ItemIsEditable );
641 return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
645 void DocumentModel::allowEdition()
647 _disallowEdition = false;
650 void DocumentModel::disallowEdition()
652 _disallowEdition = true;
655 void DocumentModel::allowDataSelectionOnly()
657 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
658 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
659 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
660 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
662 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
663 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
664 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
665 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
666 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
668 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
669 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
670 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
673 void DocumentModel::allowVertexSelectionOnly()
675 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable);
676 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
677 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
678 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
680 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
681 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
682 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
683 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
684 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
686 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
687 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
688 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
690 // emit layoutChanged();
693 void DocumentModel::allowEdgeSelectionOnly()
695 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
696 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
697 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
698 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
700 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
701 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
702 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
703 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
704 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
706 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
707 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
708 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
711 void DocumentModel::allowQuadSelectionOnly()
713 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
714 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
715 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
716 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
718 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
719 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
720 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
721 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
722 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
724 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
725 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
726 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
729 void DocumentModel::allowHexaSelectionOnly()
731 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
732 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
733 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
734 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
736 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
737 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
738 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
739 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
740 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
742 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
743 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
744 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
747 void DocumentModel::allowVectorSelectionOnly()
749 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
750 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
751 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
752 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
754 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
755 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
756 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
757 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
758 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
760 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
761 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
762 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
765 void DocumentModel::allowCylinderSelectionOnly()
767 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
768 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
769 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
770 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
772 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
773 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
774 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
775 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
776 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
778 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
779 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
780 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
783 void DocumentModel::allowPipeSelectionOnly()
785 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
786 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
787 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
788 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
790 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
791 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
792 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
793 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
794 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
796 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
797 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
798 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
801 void DocumentModel::allowElementsSelectionOnly()
803 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
804 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
805 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
806 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
808 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
809 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
810 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
811 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
812 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
814 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
815 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
816 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
819 void DocumentModel::allowCrossElementsSelectionOnly()
821 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
822 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
823 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
824 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
826 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
827 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
828 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
829 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
830 _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
832 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
833 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
834 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
837 void DocumentModel::allowLawSelectionOnly()
839 _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
840 _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
841 _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
842 _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
844 _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
845 _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
846 _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
847 _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
848 _crossElementsItemFlags = Qt::ItemFlags( Qt::ItemIsEnabled );
850 _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
851 _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
852 _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
856 void DocumentModel::setName( const QModelIndex& iElt, const QString& name )
858 HEXA_NS::EltBase *elt = NULL;
860 switch ( data(iElt, HEXA_TREE_ROLE).toInt() ){
863 HEXA_NS::Group* grp = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Group* >();
864 grp->setName( name.toLatin1().data() );
869 HEXA_NS::Law* l = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Law* >();
870 l->setName( name.toLatin1().data() );
873 // case PROPAGATION_TREE : elt = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Propagation* >(); break;
874 default: elt = getHexaPtr(iElt);
877 if ( elt != NULL ) elt->setName( name.toStdString() );
878 setData( iElt, name );
882 bool DocumentModel::clearEltAssociations( const QModelIndex& iElt )
885 HEXA_NS::EltBase *elt = getHexaPtr(iElt);
888 elt->clearAssociation();
889 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
896 void DocumentModel::clearAssociation(HEXA_NS::EnumElt& eltType)
898 if (_hexaDocument != NULL)
899 _hexaDocument->clearAssociation(eltType);
902 HEXA_NS::Vertex* vertex;
907 if (HEXABLOCKGUI::currentDocGView == NULL) return;
908 PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
909 PatternDataModel* pdm = HEXABLOCKGUI::currentDocGView->getPatternDataModel();
910 if (pdsm == NULL || pdm == NULL) return;
912 //update associations in the model
913 if (eltType == HEXA_NS::EL_VERTEX)
915 nbElts = _hexaDocument->countVertex();
916 for (int i = 0; i < nbElts; ++i)
918 vertex = _hexaDocument->getVertex(i);
919 iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(vertex)));
921 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
924 else if (eltType == HEXA_NS::EL_EDGE)
926 nbElts = _hexaDocument->countEdge();
927 for (int i = 0; i < nbElts; ++i)
929 edge = _hexaDocument->getEdge(i);
930 iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(edge)));
932 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
935 else if (eltType == HEXA_NS::EL_QUAD)
937 nbElts = _hexaDocument->countQuad();
938 for (int i = 0; i < nbElts; ++i)
940 quad = _hexaDocument->getQuad(i);
941 iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(quad)));
943 setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
949 QModelIndex DocumentModel::addVertex( double x, double y, double z )
951 QModelIndex vertexIndex;
953 HEXA_NS::Vertex* hv = _hexaDocument->addVertex(x, y, z);
954 if (BadElement(hv)) return vertexIndex;
956 VertexItem* v = new VertexItem(hv, _entry);
957 _vertexDirItem->appendRow(v);
958 vertexIndex = v->index();
959 emit patternDataChanged();
964 QModelIndex DocumentModel::addEdgeVertices (const QModelIndex &i_v0, const QModelIndex &i_v1 )
966 QModelIndex edgeIndex;
968 HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
969 HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
971 HEXA_NS::Edge* he = _hexaDocument->addEdge( hv0, hv1 );
972 if ( BadElement(he) ) return edgeIndex;
974 EdgeItem* e = new EdgeItem(he, _entry);
975 _edgeDirItem->appendRow(e);
976 edgeIndex = e->index();
977 emit patternDataChanged();
982 QModelIndex DocumentModel::addEdgeVector( const QModelIndex &i_v, const QModelIndex &i_vec )
984 QModelIndex edgeIndex;
986 HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(i_v);
987 HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(i_vec);
989 if (!hv || !hvec) return edgeIndex;
991 HEXA_NS::Edge* he = _hexaDocument->addEdge( hv, hvec );
992 if ( BadElement(he) ) return edgeIndex;
994 HEXA_NS::Vertex* hv2 = he->getAval(); //the new vertex resulting from the creation of the edge
995 if (hv2 == NULL) return edgeIndex;
997 //ADD the elements in the treeview
999 EdgeItem* e = new EdgeItem(he, _entry);
1000 _edgeDirItem->appendRow(e);
1002 //The resulting Vertex
1003 VertexItem* v = new VertexItem(hv2, _entry);
1004 _vertexDirItem->appendRow(v);
1005 edgeIndex = e->index();
1006 emit patternDataChanged();
1011 QModelIndex DocumentModel::addQuadVertices( const QModelIndex &i_v0, const QModelIndex &i_v1,
1012 const QModelIndex &i_v2, const QModelIndex &i_v3 )
1013 { //CS_TODO : gestion erreur
1014 QModelIndex quadIndex;
1016 HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
1017 HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
1018 HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(i_v2);
1019 HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(i_v3);
1021 if ( hv0 and hv1 and hv2 and hv3 ){
1022 HEXA_NS::Quad* hq = _hexaDocument->addQuadVertices( hv0, hv1, hv2, hv3 );
1023 if ( BadElement(hq) ) return quadIndex;
1025 QuadItem* q = new QuadItem(hq, _entry);
1026 _quadDirItem->appendRow(q);
1027 quadIndex = q->index();
1028 emit patternDataChanged();
1034 QModelIndex DocumentModel::addQuadEdges( const QModelIndex &e0, const QModelIndex &e1,
1035 const QModelIndex &e2, const QModelIndex &e3 )
1037 QModelIndex quadIndex;
1039 HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(e0);
1040 HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(e1);
1041 HEXA_NS::Edge* he2 = getHexaPtr<HEXA_NS::Edge*>(e2);
1042 HEXA_NS::Edge* he3 = getHexaPtr<HEXA_NS::Edge*>(e3);
1044 if ( he0 and he1 and he2 and he3 ){
1046 HEXA_NS::Quad* hq = _hexaDocument->addQuad( he0, he1, he2, he3 );
1047 if ( BadElement(hq) ) return quadIndex;
1049 QuadItem* q = new QuadItem(hq, _entry);
1050 _quadDirItem->appendRow(q);
1051 quadIndex = q->index();
1052 emit patternDataChanged();
1058 QModelIndex DocumentModel::addHexaVertices(
1059 const QModelIndex &iv0, const QModelIndex &iv1,
1060 const QModelIndex &iv2, const QModelIndex &iv3,
1061 const QModelIndex &iv4, const QModelIndex &iv5,
1062 const QModelIndex &iv6, const QModelIndex &iv7 )
1066 HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1067 HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1068 HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1069 HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1070 HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
1071 HEXA_NS::Vertex* hv5 = getHexaPtr<HEXA_NS::Vertex*>(iv5);
1072 HEXA_NS::Vertex* hv6 = getHexaPtr<HEXA_NS::Vertex*>(iv6);
1073 HEXA_NS::Vertex* hv7 = getHexaPtr<HEXA_NS::Vertex*>(iv7);
1075 HEXA_NS::Hexa* hh = _hexaDocument->addHexaVertices( hv0, hv1, hv2, hv3,
1076 hv4, hv5, hv6, hv7 );
1078 if ( BadElement(hh) ) return iHexa;
1080 HexaItem* h = new HexaItem(hh, _entry);
1081 _hexaDirItem->appendRow(h);
1083 emit patternDataChanged();
1088 QModelIndex DocumentModel::addHexaQuad( const QModelIndex &i_q0, const QModelIndex &i_q1,
1089 const QModelIndex &i_q2,const QModelIndex &i_q3, const QModelIndex &i_q4, const QModelIndex &i_q5 )
1090 { //CS_TODO : gestion erreur
1091 QModelIndex hexaIndex;
1093 HEXA_NS::Quad* hq0 = getHexaPtr<HEXA_NS::Quad*>(i_q0);
1094 HEXA_NS::Quad* hq1 = getHexaPtr<HEXA_NS::Quad*>(i_q1);
1095 HEXA_NS::Quad* hq2 = getHexaPtr<HEXA_NS::Quad*>(i_q2);
1096 HEXA_NS::Quad* hq3 = getHexaPtr<HEXA_NS::Quad*>(i_q3);
1097 HEXA_NS::Quad* hq4 = getHexaPtr<HEXA_NS::Quad*>(i_q4);
1098 HEXA_NS::Quad* hq5 = getHexaPtr<HEXA_NS::Quad*>(i_q5);
1100 HEXA_NS::Hexa* hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
1101 if ( BadElement(hh) ) return hexaIndex;
1103 HexaItem* h = new HexaItem(hh, _entry);
1104 _hexaDirItem->appendRow(h);
1105 hexaIndex = h->index();
1106 emit patternDataChanged();
1111 QModelIndex DocumentModel::addHexaQuads( const QModelIndexList &iquads)
1113 QModelIndex hexaIndex;
1115 HEXA_NS::Hexa* hh = NULL;
1116 HEXA_NS::Quad* hq0, *hq1, *hq2, *hq3, *hq4, *hq5 = NULL;
1118 hq0 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(0));
1119 hq1 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(1));
1120 hq2 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(2));
1121 hq3 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(3));
1122 hq4 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(4));
1123 hq5 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(5));
1125 if ( hq0 && hq1 && hq2 && hq3 && hq4 && hq5 )
1126 hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
1127 else if ( hq0 && hq1 && hq2 && hq3 && hq4 )
1128 hh = _hexaDocument->addHexa5Quads( hq0, hq1, hq2, hq3, hq4 );
1129 else if ( hq0 && hq1 && hq2 && hq3 )
1130 hh = _hexaDocument->addHexa4Quads( hq0, hq1, hq2, hq3 );
1131 else if ( hq0 && hq1 && hq2)
1132 hh = _hexaDocument->addHexa3Quads( hq0, hq1, hq2 );
1133 else if ( hq0 && hq1 )
1134 hh = _hexaDocument->addHexa2Quads( hq0, hq1);
1136 if ( BadElement(hh) ) return hexaIndex;
1139 unsigned int nbRows = _hexaDirItem->rowCount();
1141 hexaIndex = _hexaDirItem->child(nbRows-1)->index();
1146 // Vector addVector( in double dx, in double dy, in double dz )
1147 // raises (SALOME::SALOME_Exception);
1148 QModelIndex DocumentModel::addVector( double dx, double dy, double dz )
1150 QModelIndex vectorIndex;
1152 HEXA_NS::Vector* hv = _hexaDocument->addVector(dx, dy, dz);
1153 if ( BadElement(hv) ) return vectorIndex; //Invalid index
1155 VectorItem* v = new VectorItem(hv);
1156 _vectorDirItem->appendRow(v);
1157 vectorIndex = v->index();
1162 QModelIndex DocumentModel::addVectorVertices( const QModelIndex &iv0, const QModelIndex &iv1 )
1166 HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1167 HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1169 HEXA_NS::Vector* hvec = _hexaDocument->addVectorVertices( hv0, hv1 );
1170 if ( BadElement(hvec) ) return iVec;
1172 VectorItem* vec = new VectorItem(hvec);
1173 _vectorDirItem->appendRow(vec);
1174 iVec = vec->index();
1179 QModelIndex DocumentModel::addCylinder( const QModelIndex &iv, const QModelIndex &ivec, double r, double h )
1183 HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(iv);
1184 HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1186 HEXA_NS::Cylinder* hcyl = _hexaDocument->addCylinder( hv, hvec, r, h );
1187 if ( BadElement(hcyl) ) return iCyl;
1189 CylinderItem* cyl = new CylinderItem(hcyl);
1190 _cylinderDirItem->appendRow(cyl);
1191 iCyl = cyl->index();
1196 QModelIndex DocumentModel::addPipe( const QModelIndex &iv, const QModelIndex &ivec, double ri, double re, double h )
1200 HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(iv);
1201 HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1203 HEXA_NS::Pipe* hPipe = _hexaDocument->addPipe( hv, hvec, ri, re, h );
1204 if ( BadElement(hPipe) ) return iPipe;
1206 PipeItem* pipe = new PipeItem(hPipe);
1207 _pipeDirItem->appendRow(pipe);
1208 iPipe = pipe->index();
1213 QModelIndex DocumentModel::makeCartesian( const QModelIndex& i_pt,
1214 const QModelIndex& i_vec_x, const QModelIndex& i_vec_y, const QModelIndex& i_vec_z,
1215 long nx, long ny, long nz)
1217 QModelIndex eltsIndex;
1218 //std::cout<<"makeCartesian begin"<<std::endl;
1220 HEXA_NS::Vertex* hpt = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
1221 HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
1222 HEXA_NS::Vector* hvec_y = getHexaPtr<HEXA_NS::Vector*>(i_vec_y);
1223 HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
1225 HEXA_NS::Elements* new_helts = _hexaDocument->makeCartesian( hpt,
1226 hvec_x, hvec_y, hvec_z,
1228 if ( BadElement(new_helts) ) return eltsIndex;
1230 updateData(); //CS_TODO more or less?
1231 ElementsItem* eltsItem = new ElementsItem(new_helts);
1232 _elementsDirItem->appendRow(eltsItem);
1233 eltsIndex = eltsItem->index();
1238 QModelIndex DocumentModel::makeCartesian( const QModelIndex& ivex,
1239 const QModelIndex& ivec,
1240 int nx, int ny, int nz )
1244 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1245 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1247 HEXA_NS::Elements* hElts = _hexaDocument->makeCartesian( hVex,
1250 if ( BadElement(hElts) ) return iElts;
1252 updateData(); //CS_TODO more or less?
1253 ElementsItem* elts = new ElementsItem(hElts);
1254 _elementsDirItem->appendRow(elts);
1255 iElts = elts->index();
1260 // Elements makeCylindrical( in Vertex pt,
1261 // in Vector vex, in Vector vez,
1262 // in double dr, in double da, in double dl,
1263 // in long nr, in long na, in long nl,
1264 // in boolean fill )
1265 // raises (SALOME::SALOME_Exception);
1266 QModelIndex DocumentModel::makeCylindrical( const QModelIndex& i_pt,
1267 const QModelIndex& i_vec_x, const QModelIndex& i_vec_z,
1268 double dr, double da, double dl,
1269 long nr, long na, long nl,
1273 QModelIndex eltsIndex;
1275 HEXA_NS::Vertex* hpt = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
1276 HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
1277 HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
1279 HEXA_NS::Elements* new_helts = _hexaDocument->makeCylindrical( hpt, hvec_x, hvec_z, dr, da, dl, nr, na, nl, fill );
1280 if ( BadElement(new_helts) ) return eltsIndex;
1282 updateData(); //CS_TODO more or less?
1283 ElementsItem* eltsItem = new ElementsItem(new_helts);
1284 _elementsDirItem->appendRow(eltsItem);
1285 eltsIndex = eltsItem->index();
1290 QModelIndex DocumentModel::makeCylindricals(
1291 const QModelIndex& icenter, const QModelIndex& ibase, const QModelIndex& iheight,
1292 QList< double> radius, QList<double> angles, QList<double> heights,
1295 QModelIndex eltsIndex;
1297 HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1298 HEXA_NS::Vector* hbase =getHexaPtr<HEXA_NS::Vector*>(ibase);
1299 HEXA_NS::Vector* hheight = getHexaPtr<HEXA_NS::Vector*>(iheight);
1301 // HEXA_NS::Elements* helts;
1302 std::vector<double> r = radius.toVector().toStdVector();
1303 std::vector<double> a = angles.toVector().toStdVector();
1304 std::vector<double> h = heights.toVector().toStdVector();
1306 HEXA_NS::Elements* helts = _hexaDocument->makeCylindricals(
1307 hcenter, hbase, hheight,
1310 if ( BadElement(helts) ) return eltsIndex;
1312 updateData(); //CS_TODO more or less?
1313 ElementsItem* eltsItem = new ElementsItem(helts);
1314 _elementsDirItem->appendRow(eltsItem);
1315 eltsIndex = eltsItem->index();
1320 QModelIndex DocumentModel::makeSpherical( const QModelIndex& iv, const QModelIndex& ivec, int nb, double k)
1324 HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(iv);
1325 HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1327 HEXA_NS::Elements* hElts = _hexaDocument->makeSpherical( hv, hvec, nb, k );
1328 if ( BadElement(hElts) ) return iElts;
1330 updateData(); //CS_TODO more or less?
1331 ElementsItem* elts = new ElementsItem(hElts);
1332 _elementsDirItem->appendRow(elts);
1333 iElts = elts->index();
1338 QModelIndex DocumentModel::makeSpherical( const QModelIndex& icenter, double radius, int nb, double k )
1342 HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1344 HEXA_NS::Elements* helts = _hexaDocument->makeSpherical( hcenter, radius, nb, k );
1345 if ( BadElement(helts) ) return iElts;
1347 updateData(); //CS_TODO more or less?
1348 ElementsItem* eltsItem = new ElementsItem(helts);
1349 _elementsDirItem->appendRow(eltsItem);
1350 iElts = eltsItem->index();
1355 QModelIndex DocumentModel::makeCylinder( const QModelIndex& icyl, const QModelIndex& ivec,
1356 int nr, int na, int nl )
1360 HEXA_NS::Cylinder* hcyl = getHexaPtr<HEXA_NS::Cylinder*>(icyl);
1361 HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1363 HEXA_NS::Elements* hElts = _hexaDocument->makeCylinder( hcyl, hvec, nr, na, nl );
1364 if ( BadElement(hElts) ) return iElts;
1366 updateData(); //CS_TODO more or less?
1367 ElementsItem* elts = new ElementsItem(hElts);
1368 _elementsDirItem->appendRow(elts);
1369 iElts = elts->index();
1374 QModelIndex DocumentModel::makePipe( const QModelIndex& ipipe, const QModelIndex& ivecx,
1375 int nr, int na, int nl )
1379 HEXA_NS::Pipe* hPipe = getHexaPtr<HEXA_NS::Pipe*>(ipipe);
1380 HEXA_NS::Vector* hVecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1382 HEXA_NS::Elements* hElts = _hexaDocument->makePipe( hPipe, hVecx, nr, na, nl );
1383 if ( BadElement(hElts) ) return iElts;
1385 updateData(); //CS_TODO more or less?
1386 ElementsItem* elts = new ElementsItem(hElts);
1387 _elementsDirItem->appendRow(elts);
1388 iElts = elts->index();
1393 QModelIndex DocumentModel::makeCylinders(const QModelIndex& icyl1, const QModelIndex& icyl2)
1395 QModelIndex iCrossElts;
1397 HEXA_NS::Cylinder* hCyl1 = getHexaPtr<HEXA_NS::Cylinder*>(icyl1);
1398 HEXA_NS::Cylinder* hCyl2 = getHexaPtr<HEXA_NS::Cylinder*>(icyl2);
1400 HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makeCylinders( hCyl1, hCyl2 );
1401 if ( BadElement(hCrossElts) ) return iCrossElts;
1403 updateData(); //CS_TODO more or less?
1404 ElementsItem* crossElts = new ElementsItem(hCrossElts);
1405 _crossElementsDirItem->appendRow(crossElts);
1406 iCrossElts = crossElts->index();
1412 QModelIndex DocumentModel::makePipes( const QModelIndex& ipipe1, const QModelIndex& ipipe2 )
1414 QModelIndex iCrossElts;
1416 HEXA_NS::Pipe* hPipe1 = getHexaPtr<HEXA_NS::Pipe*>(ipipe1);
1417 HEXA_NS::Pipe* hPipe2 = getHexaPtr<HEXA_NS::Pipe*>(ipipe2);
1419 HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makePipes( hPipe1, hPipe2 );
1420 if ( BadElement(hCrossElts) ) return iCrossElts;
1422 updateData(); //CS_TODO more or less?
1423 ElementsItem* crossElts = new ElementsItem(hCrossElts);
1424 _crossElementsDirItem->appendRow(crossElts);
1425 iCrossElts = crossElts->index();
1430 QModelIndex DocumentModel::makeRind( const QModelIndex& icenter,
1431 const QModelIndex& ivecx, const QModelIndex& ivecz,
1432 double radext, double radint, double radhole,
1433 const QModelIndex& iplorig,
1434 int nrad, int nang, int nhaut )
1438 HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1439 HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1440 HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1441 HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1443 HEXA_NS::Elements* hElts = _hexaDocument->makeRind( hcenter,
1445 radext, radint, radhole,
1447 nrad, nang, nhaut );
1448 if ( BadElement(hElts) ) return iElts;
1450 updateData(); //CS_TODO more or less?
1451 ElementsItem* eltsItem = new ElementsItem(hElts);
1452 _elementsDirItem->appendRow(eltsItem);
1453 iElts = eltsItem->index();
1458 QModelIndex DocumentModel::makePartRind( const QModelIndex& icenter,
1459 const QModelIndex& ivecx, const QModelIndex& ivecz,
1460 double radext, double radint, double radhole,
1461 const QModelIndex& iplorig, double angle,
1462 int nrad, int nang, int nhaut )
1466 HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1467 HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1468 HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1469 HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1471 HEXA_NS::Elements* hElts = _hexaDocument->makePartRind( hcenter,
1473 radext, radint, radhole,
1475 nrad, nang, nhaut );
1476 if ( BadElement(hElts) ) return iElts;
1479 ElementsItem* eltsItem = new ElementsItem(hElts);
1480 _elementsDirItem->appendRow(eltsItem);
1481 iElts = eltsItem->index();
1486 QModelIndex DocumentModel::makeSphere( const QModelIndex& icenter,
1487 const QModelIndex& ivecx, const QModelIndex& ivecz,
1488 double radius, double radhole,
1489 const QModelIndex& iplorig,
1490 int nrad, int nang, int nhaut )
1494 HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1495 HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1496 HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1497 HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1499 HEXA_NS::Elements* hElts = _hexaDocument->makeSphere( hcenter,
1504 if ( BadElement(hElts) ) return iElts;
1507 ElementsItem* eltsItem = new ElementsItem(hElts);
1508 _elementsDirItem->appendRow(eltsItem);
1509 iElts = eltsItem->index();
1514 QModelIndex DocumentModel::makePartSphere( const QModelIndex& icenter,
1515 const QModelIndex& ivecx, const QModelIndex& ivecz,
1516 double radius, double radhole,
1517 const QModelIndex& iplorig, double angle,
1518 int nrad, int nang, int nhaut )
1522 HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
1523 HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
1524 HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
1525 HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
1527 HEXA_NS::Elements* hElts = _hexaDocument->makePartSphere( hcenter,
1532 if ( BadElement(hElts) ) return iElts;
1535 ElementsItem* eltsItem = new ElementsItem(hElts);
1536 _elementsDirItem->appendRow(eltsItem);
1537 iElts = eltsItem->index();
1542 // ************ EDIT HEXABLOCK MODEL ************
1544 bool DocumentModel::updateVertex( const QModelIndex& ivertex, double x, double y, double z )
1548 //HEXA_NS::Vertex* hVertex = ivertex.data(HEXA_DATA_ROLE).value<HEXA_NS::Vertex *>(); //CS_TODO? pareil pour toutes les autres méthodes du modèle?
1549 HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
1552 // hVertex->setName( name.toStdString() );
1553 hVertex->setX ( x );
1554 hVertex->setY ( y );
1555 hVertex->setZ ( z );
1556 emit patternDataChanged();
1563 bool DocumentModel::removeHexa( const QModelIndex& ihexa )
1565 HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1567 int r = _hexaDocument->removeHexa( hHexa );
1576 bool DocumentModel::removeConnectedHexa( const QModelIndex& ihexa )
1578 HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1580 int r = _hexaDocument->removeConnectedHexa( hHexa );
1589 QModelIndex DocumentModel::prismQuad( const QModelIndex& iquad, const QModelIndex& ivec, int nb)
1593 HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1594 HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
1596 HEXA_NS::Elements* hElts = _hexaDocument->prismQuad( hQuad, hVect, nb );
1597 if ( BadElement(hElts) ) return iElts;
1599 updateData(); //CS_TODO more or less?
1600 ElementsItem* elts = new ElementsItem(hElts);
1601 _elementsDirItem->appendRow(elts);
1602 iElts = elts->index();
1607 QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, int nb)
1611 HEXA_NS::Quads hQuads;
1612 HEXA_NS::Quad* hQuad = NULL;
1613 foreach( const QModelIndex& iquad, iquads ){
1614 hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1615 hQuads.push_back( hQuad );
1617 HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
1619 HEXA_NS::Elements* hElts = _hexaDocument->prismQuads( hQuads, hVect, nb );
1620 if ( BadElement(hElts) ) return iElts;
1622 updateData(); //CS_TODO more or less?
1623 ElementsItem* elts = new ElementsItem(hElts);
1624 _elementsDirItem->appendRow(elts);
1625 iElts = elts->index();
1630 QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, std::vector<double> layersSize, int nb)
1634 HEXA_NS::Quads hQuads;
1635 HEXA_NS::Quad* hQuad = NULL;
1636 foreach( const QModelIndex& iquad, iquads ){
1637 hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1638 hQuads.push_back( hQuad );
1640 HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
1642 HEXA_NS::Elements* hElts = _hexaDocument->prismQuadsVec( hQuads, hVect, layersSize, nb );
1643 if ( BadElement(hElts) ) return iElts;
1645 updateData(); //CS_TODO more or less?
1646 ElementsItem* elts = new ElementsItem(hElts);
1647 _elementsDirItem->appendRow(elts);
1648 iElts = elts->index();
1654 QModelIndex DocumentModel::joinQuad(
1655 const QModelIndex& iquadstart, const QModelIndex& iquaddest,
1656 const QModelIndex& iv0, const QModelIndex& iv1,
1657 const QModelIndex& iv2, const QModelIndex& iv3,
1662 HEXA_NS::Quad* hQuadStart = getHexaPtr<HEXA_NS::Quad*>(iquadstart);
1663 HEXA_NS::Quad* hQuadDest = getHexaPtr<HEXA_NS::Quad*>(iquaddest);
1665 HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1666 HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1667 HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1668 HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1670 HEXA_NS::Elements* hElts = _hexaDocument->joinQuad( hQuadStart, hQuadDest,
1671 hVertex0, hVertex1, hVertex2, hVertex3, nb );
1672 if ( BadElement(hElts) ) return iElts;
1674 updateData(); //CS_TODO more or less?
1675 ElementsItem* elts = new ElementsItem(hElts);
1676 _elementsDirItem->appendRow(elts);
1677 iElts = elts->index();
1682 QModelIndex DocumentModel::joinQuads(
1683 const QModelIndexList& iquadsstart, const QModelIndex& iquaddest,
1684 const QModelIndex& iv0, const QModelIndex& iv1,
1685 const QModelIndex& iv2, const QModelIndex& iv3,
1690 HEXA_NS::Quad* hQuadStart;
1691 HEXA_NS::Quads hQuadsStart;
1693 foreach( const QModelIndex& iquad, iquadsstart ){
1694 hQuadStart = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
1695 hQuadsStart.push_back( hQuadStart );
1697 HEXA_NS::Quad* hQuadDest = data( iquaddest, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
1699 HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1700 HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1701 HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1702 HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1704 HEXA_NS::Elements* hElts = _hexaDocument->joinQuads(
1705 hQuadsStart, hQuadDest,
1706 hVertex0, hVertex1, hVertex2, hVertex3,
1708 if ( BadElement(hElts) ) return iElts;
1710 updateData(); //CS_TODO more or less?
1711 ElementsItem* elts = new ElementsItem(hElts);
1712 _elementsDirItem->appendRow(elts);
1713 iElts = elts->index();
1718 bool DocumentModel::mergeVertices( const QModelIndex &iv0, const QModelIndex &iv1 ) //CS_TODO : impact sur le model?
1720 HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1721 HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1723 int r = _hexaDocument->mergeVertices( hv0, hv1 );
1725 updateData(); //CS_TODO more or less?
1732 bool DocumentModel::mergeEdges( const QModelIndex &ie0, const QModelIndex &ie1,
1733 const QModelIndex &iv0, const QModelIndex &iv1 )
1734 //CS_TODO : impact sur le model?
1736 HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(ie0);
1737 HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(ie1);
1739 HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1740 HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1743 int r = _hexaDocument->mergeEdges( he0, he1, hv0, hv1 );
1752 bool DocumentModel::mergeQuads( const QModelIndex& iquad0, const QModelIndex& iquad1,
1753 const QModelIndex& iv0, const QModelIndex& iv1,
1754 const QModelIndex& iv2, const QModelIndex& iv3 )
1756 HEXA_NS::Quad* hquad0 = data(iquad0, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
1757 HEXA_NS::Quad* hquad1 = data(iquad1, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
1759 HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
1760 HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
1761 HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
1762 HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
1764 int r = _hexaDocument->mergeQuads( hquad0, hquad1, hv0, hv1, hv2, hv3 );
1774 QModelIndex DocumentModel::disconnectVertex( const QModelIndex& ihexa, const QModelIndex& ivertex )
1778 HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1779 HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
1781 HEXA_NS::Elements* hElts = _hexaDocument->disconnectVertex( hHexa, hVertex );
1782 if ( BadElement(hElts) ) return iElts;
1784 updateData(); //CS_TO_CHECK
1785 ElementsItem* elts = new ElementsItem(hElts);
1786 _elementsDirItem->appendRow(elts);
1787 iElts = elts->index();
1792 QModelIndex DocumentModel::disconnectEdge( const QModelIndex& ihexa, const QModelIndex& iedge )
1796 HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1797 HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1799 HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdge( hHexa, hEdge );
1800 if ( BadElement(hElts) ) return iElts;
1802 updateData(); //CS_TO_CHECK
1803 ElementsItem* elts = new ElementsItem(hElts);
1804 _elementsDirItem->appendRow(elts);
1805 iElts = elts->index();
1811 QModelIndex DocumentModel::disconnectEdges( const QModelIndexList& ihexas, const QModelIndexList& iedges )
1815 HEXA_NS::Hexas hHexas;
1816 HEXA_NS::Edges hEdges;
1819 HEXA_NS::Edge* hedge = NULL;
1820 foreach( const QModelIndex& iedge, iedges ){
1821 hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
1822 hEdges.push_back( hedge );
1826 HEXA_NS::Hexa* hhexa = NULL;
1827 foreach( const QModelIndex& ihexa, ihexas ){
1828 hhexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1829 hHexas.push_back( hhexa );
1833 HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdges( hHexas, hEdges );
1834 if ( BadElement(hElts) ) return iElts;
1836 updateData(); //CS_TO_CHECK
1837 ElementsItem* elts = new ElementsItem(hElts);
1838 _elementsDirItem->appendRow(elts);
1839 iElts = elts->index();
1845 QModelIndex DocumentModel::disconnectQuad( const QModelIndex& ihexa, const QModelIndex& iquad )
1849 HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
1850 HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
1852 HEXA_NS::Elements* hElts = _hexaDocument->disconnectQuad( hHexa, hQuad );
1853 if ( BadElement(hElts) ) return iElts;
1855 updateData(); //CS_TO_CHECK
1856 ElementsItem* elts = new ElementsItem(hElts);
1857 _elementsDirItem->appendRow(elts);
1858 iElts = elts->index();
1864 QModelIndex DocumentModel::cutEdge( const QModelIndex &i_e0, int nbcuts )
1865 //CS_TODO : impact sur le model?
1869 HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(i_e0);
1870 HEXA_NS::Elements* helts = _hexaDocument->cut( he0, nbcuts );
1872 if ( BadElement(helts) ) return iElts;
1874 updateData(); //CS_TODO more?
1875 ElementsItem* elts = new ElementsItem(helts);
1876 _elementsDirItem->appendRow(elts);
1877 iElts = elts->index();
1883 // Elements makeTranslation( in Elements l, in Vector vec )
1884 // raises (SALOME::SALOME_Exception);
1885 QModelIndex DocumentModel::makeTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
1889 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1890 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1892 HEXA_NS::Elements* hNewElts = _hexaDocument->makeTranslation( hElts, hVec );
1893 if ( BadElement(hNewElts) ) return iElts;
1895 updateData(); //CS_TODO more or less?
1896 ElementsItem* eltsItem = new ElementsItem(hNewElts);
1897 _elementsDirItem->appendRow(eltsItem);
1898 iElts = eltsItem->index();
1905 QModelIndex DocumentModel::makeScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
1909 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1910 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
1912 HEXA_NS::Elements* hNewElts = _hexaDocument->makeScale( hElts, hVex, k );
1913 if ( BadElement(hNewElts) ) return iElts;
1915 updateData(); //CS_TODO more or less?
1916 ElementsItem* eltsItem = new ElementsItem(hNewElts);
1917 _elementsDirItem->appendRow(eltsItem);
1918 iElts = eltsItem->index();
1925 QModelIndex DocumentModel::makeRotation( const QModelIndex& ielts,
1926 const QModelIndex& iv,
1927 const QModelIndex& ivec, double angle )
1931 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1932 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
1933 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1935 HEXA_NS::Elements* hNewElts = _hexaDocument->makeRotation( hElts, hVex, hVec, angle );
1936 if ( BadElement(hNewElts) ) return iElts;
1938 updateData(); //CS_TODO more or less?
1939 ElementsItem* eltsItem = new ElementsItem(hNewElts);
1940 _elementsDirItem->appendRow(eltsItem);
1941 iElts = eltsItem->index();
1947 QModelIndex DocumentModel::makeSymmetryPoint( const QModelIndex& ielts, const QModelIndex& iv )
1951 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1952 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
1954 HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPoint (hElts, hVex);
1955 if ( BadElement(hNewElts) ) return iElts;
1957 updateData(); //CS_TODO more or less?
1958 ElementsItem* eltsItem = new ElementsItem(hNewElts);
1959 _elementsDirItem->appendRow(eltsItem);
1960 iElts = eltsItem->index();
1966 QModelIndex DocumentModel::makeSymmetryLine( const QModelIndex& ielts,
1967 const QModelIndex& iv,
1968 const QModelIndex& ivec )
1972 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1973 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
1974 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1977 HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryLine( hElts, hVex, hVec );
1978 if ( BadElement(hNewElts) ) return iElts;
1980 updateData(); //CS_TODO more or less?
1981 ElementsItem* eltsItem = new ElementsItem(hNewElts);
1982 _elementsDirItem->appendRow(eltsItem);
1983 iElts = eltsItem->index();
1989 QModelIndex DocumentModel::makeSymmetryPlane( const QModelIndex& ielts, const QModelIndex& iv, const QModelIndex& ivec )
1993 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
1994 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
1995 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
1997 HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPlane( hElts, hVex, hVec );
1998 if ( BadElement(hNewElts) ) return iElts;
2000 updateData(); //CS_TODO more or less?
2001 ElementsItem* eltsItem = new ElementsItem(hNewElts);
2002 _elementsDirItem->appendRow(eltsItem);
2003 iElts = eltsItem->index();
2009 bool DocumentModel::performTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
2011 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2012 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
2014 int r = _hexaDocument->performTranslation (hElts, hVec);
2015 if ( r == HOK ){ //Job well done?
2025 bool DocumentModel::performScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
2027 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2028 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2030 int r = _hexaDocument->performScale (hElts, hVex, k);
2040 bool DocumentModel::performRotation( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec, double angle )
2042 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2043 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2044 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
2046 int r = _hexaDocument-> performRotation( hElts, hVex, hVec, angle );
2057 bool DocumentModel::performSymmetryPoint( const QModelIndex& ielts, const QModelIndex& ivex )
2059 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2060 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2062 int r = _hexaDocument->performSymmetryPoint( hElts, hVex );
2072 bool DocumentModel::performSymmetryLine( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec )
2074 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2075 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2076 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
2078 int r = _hexaDocument->performSymmetryLine( hElts, hVex, hVec );
2088 bool DocumentModel::performSymmetryPlane( const QModelIndex& ielts,
2089 const QModelIndex& ivex,
2090 const QModelIndex& ivec )
2092 HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
2093 HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
2094 HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
2096 int r = _hexaDocument->performSymmetryPlane( hElts, hVex, hVec );
2105 QModelIndex DocumentModel::revolutionQuads( const QModelIndexList& istartquads,
2106 const QModelIndex& icenter,
2107 const QModelIndex& ivecaxis,
2108 const QList<double>& angles )
2112 HEXA_NS::Quads hstartquads;
2113 HEXA_NS::Quad* hquad = NULL;
2114 foreach( const QModelIndex& iquad, istartquads){
2115 hquad = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad*>();
2116 hstartquads.push_back( hquad );
2118 HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
2119 HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(ivecaxis);
2120 std::vector<double> hangles = angles.toVector().toStdVector();
2122 HEXA_NS::Elements* helts = _hexaDocument->revolutionQuads( hstartquads, hcenter, haxis, hangles );
2123 if ( BadElement(helts) ) return ielts;
2126 ElementsItem* eltsItem = new ElementsItem(helts);
2127 _elementsDirItem->appendRow(eltsItem);
2128 ielts = eltsItem->index();
2133 QModelIndex DocumentModel::replace( const QModelIndexList& iquadsPattern,
2134 const QModelIndex& ip1, const QModelIndex& ic1,
2135 const QModelIndex& ip2, const QModelIndex& ic2,
2136 const QModelIndex& ip3, const QModelIndex& ic3 )
2140 HEXA_NS::Vertex* hp1 = getHexaPtr<HEXA_NS::Vertex*>(ip1);
2141 HEXA_NS::Vertex* hc1 = getHexaPtr<HEXA_NS::Vertex*>(ic1);
2142 HEXA_NS::Vertex* hp2 = getHexaPtr<HEXA_NS::Vertex*>(ip2);
2143 HEXA_NS::Vertex* hc2 = getHexaPtr<HEXA_NS::Vertex*>(ic2);
2144 HEXA_NS::Vertex* hp3 = getHexaPtr<HEXA_NS::Vertex*>(ip3);
2145 HEXA_NS::Vertex* hc3 = getHexaPtr<HEXA_NS::Vertex*>(ic3);
2147 HEXA_NS::Quads hquads;
2148 HEXA_NS::Quad* hquad = NULL;
2149 foreach( const QModelIndex& iquad, iquadsPattern ){
2150 hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
2151 hquads.push_back( hquad );
2154 HEXA_NS::Elements* helts = _hexaDocument->replace( hquads,
2155 hp1, hc1, hp2, hc2, hp3, hc3 );
2156 if ( BadElement(helts) ) return ielts;
2159 ElementsItem* eltsItem = new ElementsItem(helts);
2160 _elementsDirItem->appendRow(eltsItem);
2161 ielts = eltsItem->index();
2166 // ************ ADD ASSOCIATION ************
2169 //--------------- METHOD OBSOLETE
2170 //void DocumentModel::addAssociation( const QModelIndex& iElt, const DocumentModel::GeomObj& assocIn )
2173 // HEXA_NS::Shape* assoc = new HEXA_NS::Shape( assocIn.brep.toStdString() );//CS_TODO : delete assoc
2174 // assoc->setStart (assocIn.start);
2175 // assoc->setEnd (assocIn.end);
2176 // assoc->setIdent ( (assocIn.shapeName + "," + assocIn.subid).toStdString() );
2178 // QString currentAssoc, newAssoc;
2180 // if ( data(iElt, HEXA_TREE_ROLE) == VERTEX_TREE ){
2181 // HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iElt);
2182 // hVex->setAssociation( assoc );
2183 // } else if ( data(iElt, HEXA_TREE_ROLE) == EDGE_TREE ){
2184 // HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge*>(iElt);
2185 // hEdge->addAssociation( assoc );
2186 // } else if ( data(iElt, HEXA_TREE_ROLE) == QUAD_TREE ){
2187 // HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iElt);
2188 // hQuad->addAssociation( assoc );
2191 // currentAssoc = data( iElt, HEXA_ASSOC_ENTRY_ROLE ).toString();
2192 // if ( !currentAssoc.isEmpty() ){
2193 // newAssoc = currentAssoc + assocIn.shapeName + "," + assocIn.subid + ";";
2195 // newAssoc = assocIn.shapeName + "," + assocIn.subid + ";";
2197 // setData( iElt, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2199 //--------------------------------
2202 QMultiMap< QString, int > DocumentModel::getAssocShapesIds(const QModelIndex& dataIndex)
2204 QMultiMap< QString, int > result;
2205 HEXA_NS::NewShape* mainShape;
2206 HEXA_NS::VertexShape* node;
2207 HEXA_NS::EdgeShape* line;
2208 HEXA_NS::FaceShape* face;
2212 PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
2213 QModelIndexList assocsInd = pdsm->getGeomAssociations(/*index*/dataIndex);
2214 foreach( const QModelIndex& anAssoc, assocsInd )
2216 node = getHexaPtr<HEXA_NS::VertexShape*>(anAssoc);
2217 line = getHexaPtr<HEXA_NS::EdgeShape*>(anAssoc);
2218 face = getHexaPtr<HEXA_NS::FaceShape*>(anAssoc);
2222 mainShape = node->getParentShape();
2223 if (mainShape != NULL)
2225 shapeName = mainShape->getName();
2226 subid = node->getIdent();
2229 else if (line != NULL)
2231 mainShape = line->getParentShape();
2232 if (mainShape != NULL)
2234 shapeName = mainShape->getName();
2235 subid = line->getIdent();
2238 else if (face != NULL)
2240 mainShape = face->getParentShape();
2241 if (mainShape != NULL)
2243 shapeName = mainShape->getName();
2244 subid = face->getIdent();
2248 if (!shapeName.isEmpty())
2249 result.insert( shapeName, subid );
2251 shapeName = QString();
2256 bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, double x, double y, double z)
2258 HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
2260 if (vertex == NULL || _hexaDocument == NULL || vertex->setAssociation(x, y, z) != HOK)
2263 setData( iVertex, QVariant::fromValue(QString::number(x)+","+QString::number(y)+","+QString::number(z)), HEXA_ASSOC_ENTRY_ROLE );
2267 bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, const QModelIndex& iGeomVertex)
2269 //parameters control
2271 HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
2272 HEXA_NS::VertexShape* geomVertex = getHexaPtr<HEXA_NS::VertexShape*>(iGeomVertex);
2273 if (_hexaDocument == NULL || vertex == NULL || geomVertex == NULL) return false;
2274 HEXA_NS::NewShape* mainShape = geomVertex->getParentShape();
2275 if (mainShape == NULL) return false;
2278 if (vertex->setAssociation(geomVertex) != HOK)
2281 //update association state in the model
2282 newAssoc = QString(mainShape->getName()) + "," + QString::number(geomVertex->getIdent()) + ";";
2283 setData( iVertex, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2288 bool DocumentModel::addEdgeAssociation( const QModelIndex& iEdge, const QModelIndex& iGeomEdge, double start, double end)
2290 //parameters control
2291 QString currentAssoc, newAssoc;
2292 HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
2293 HEXA_NS::EdgeShape* geomEdge = getHexaPtr<HEXA_NS::EdgeShape*>(iGeomEdge);
2294 if (_hexaDocument == NULL || edge == NULL ||
2295 geomEdge == NULL || start > end) return false;
2296 HEXA_NS::NewShape* mainShape = geomEdge->getParentShape();
2297 if (mainShape == NULL) return false;
2299 //add association in the engine side
2300 if (edge->addAssociation(geomEdge, start, end) != HOK)
2303 //add/update association in the model side (UI)
2304 currentAssoc = data(iEdge, HEXA_ASSOC_ENTRY_ROLE).toString();
2305 newAssoc = QString(mainShape->getName()) + "," + QString::number(geomEdge->getIdent()) + ";";
2306 if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
2308 setData( iEdge, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2313 bool DocumentModel::addQuadAssociation (const QModelIndex& iQuad, const QModelIndex& iGeomFace)
2315 //parameters control
2316 QString currentAssoc, newAssoc;
2317 HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
2318 HEXA_NS::FaceShape* geomFace = getHexaPtr<HEXA_NS::FaceShape*>(iGeomFace);
2319 if (_hexaDocument == NULL || quad == NULL || geomFace == NULL)
2321 HEXA_NS::NewShape* mainShape = geomFace->getParentShape();
2322 if (mainShape == NULL) return false;
2325 if (quad->addAssociation(geomFace) != HOK)
2328 //update association
2329 currentAssoc = data( iQuad, HEXA_ASSOC_ENTRY_ROLE).toString();
2330 newAssoc = QString(mainShape->getName()) + "," + QString::number(geomFace->getIdent()) + ";";
2331 if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
2332 setData( iQuad, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
2338 QModelIndex DocumentModel::getVertexAssociation(const QModelIndex& iVertex)
2340 HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex*>(iVertex);
2341 if (vertex == NULL) return QModelIndex();
2343 //get the associated geom vertex
2344 HEXA_NS::VertexShape* geomVertex = vertex->getAssoVertex();
2345 if (geomVertex == NULL) return QModelIndex();
2347 //convert geom vertex to qmodelindex
2348 if (HEXABLOCKGUI::currentDocGView == NULL) return QModelIndex();
2349 PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
2350 PatternGeomModel* pgm = HEXABLOCKGUI::currentDocGView->getPatternGeomModel();
2351 if (pgsm == NULL || pgm == NULL) return QModelIndex();
2353 return pgm->mapToSource(pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomVertex) ));
2357 QList<DocumentModel::GeomObj> DocumentModel::getEdgeAssociations(const QModelIndex& iEdge)
2359 QList<DocumentModel::GeomObj> result;
2360 HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
2361 if (edge == NULL) return result;
2363 DocumentModel::GeomObj assoc;
2364 HEXA_NS::EdgeShape* geomEdge;
2365 HEXA_NS::AssoEdge* anEdgeAssoc;
2366 HEXA_NS::NewShape* mainShape;
2369 int nbAssocs = edge->countAssociation();
2370 for (int i = 0; i < nbAssocs; ++i)
2372 anEdgeAssoc = edge->getAssociation(i);
2373 if (anEdgeAssoc == NULL) continue;
2374 geomEdge = anEdgeAssoc->getEdgeShape();
2375 if (geomEdge == NULL) continue;
2376 mainShape = geomEdge->getParentShape();
2377 if (mainShape == NULL) continue; // => les generatrices ne sont pas gerees pour le moment
2378 assoc.shapeName = mainShape->getName();
2379 assoc.subid = QString::number(geomEdge->getIdent());
2380 assoc.start = anEdgeAssoc->getStart();
2381 assoc.end = anEdgeAssoc->getEnd();
2389 QModelIndexList DocumentModel::getQuadAssociations(const QModelIndex& iQuad)
2391 QModelIndexList result;
2392 QModelIndex geomQuadIndex;
2393 HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
2394 if (quad == NULL) return result;
2396 if (HEXABLOCKGUI::currentDocGView == NULL) return result;
2397 PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
2398 PatternGeomModel* pgm = HEXABLOCKGUI::currentDocGView->getPatternGeomModel();
2399 if (pgsm == NULL || pgm == NULL) return result;
2401 HEXA_NS::FaceShape* geomFace;
2403 int nbAssocs = quad->countAssociation();
2404 for (int i = 0; i < nbAssocs; ++i)
2406 geomFace = quad->getAssociation(i);
2407 if (geomFace == NULL) continue;
2409 geomQuadIndex = pgm->mapToSource(pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomFace) ));
2410 result << geomQuadIndex;
2416 //--------------- METHOD OBSOLETE
2417 //QList<DocumentModel::GeomObj> DocumentModel::getAssociations( const QModelIndex& iElt )
2419 // QList<DocumentModel::GeomObj> res;
2420 // DocumentModel::GeomObj assoc;
2422 // //std::cout << "getAssociations() start" << std::endl;
2423 // if ( data(iElt, HEXA_TREE_ROLE) == VERTEX_TREE ){
2424 // // HEXA_NS::Vertex* hVex = data(iElt, HEXA_DATA_ROLE).value<HEXA_NS::Vertex *>();
2425 // HEXA_NS::Vertex *hVex = getHexaPtr<HEXA_NS::Vertex *>(iElt);
2426 // HEXA_NS::Shape* hShape = hVex->getAssociation();
2427 // QStringList shapeID;
2428 // if ( hShape != NULL ){
2429 // assoc.shapeName = QString();
2430 // assoc.subid = QString::number(-1);
2431 // assoc.brep = hShape->getBrep().c_str();
2432 // assoc.start = hShape->getStart();
2433 // assoc.end = hShape->getEnd();
2435 // shapeID = QString( hShape->getIdent().c_str() ).split(",");
2436 // if ( shapeID.count() == 2 ){
2437 // assoc.shapeName = shapeID[0];
2438 // assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
2442 // } else if ( data(iElt, HEXA_TREE_ROLE) == EDGE_TREE ){
2443 // HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge *>(iElt);
2444 // HEXA_NS::Shapes hShapes = hEdge->getAssociations();
2445 // QStringList shapeID;
2446 // for ( HEXA_NS::Shapes::iterator it = hShapes.begin(); it != hShapes.end(); ++it){
2447 // assoc.shapeName = QString();
2448 // assoc.subid = QString::number(-1);
2449 // assoc.brep = (*it)->getBrep().c_str();
2450 // assoc.start = (*it)->getStart();
2451 // assoc.end = (*it)->getEnd();
2453 // shapeID = QString( (*it)->getIdent().c_str() ).split(",");
2454 // if ( shapeID.count() == 2 ){
2455 // assoc.shapeName = shapeID[0];
2456 // assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
2460 // } else if ( data(iElt, HEXA_TREE_ROLE) == QUAD_TREE ){
2461 // HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iElt);
2462 // HEXA_NS::Shapes hShapes = hQuad->getAssociations();
2463 // QStringList shapeID;
2464 // for ( HEXA_NS::Shapes::iterator it = hShapes.begin(); it != hShapes.end(); ++it){
2465 // assoc.shapeName = QString();
2466 // assoc.subid = QString::number(-1);
2467 // assoc.brep = (*it)->getBrep().c_str();
2468 // assoc.start = (*it)->getStart();
2469 // assoc.end = (*it)->getEnd();
2470 // shapeID = QString( (*it)->getIdent().c_str() ).split(",");
2471 // if ( shapeID.count() == 2 ){
2472 // assoc.shapeName = shapeID[0];
2473 // assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
2482 //----------------------------------
2484 bool DocumentModel::associateOpenedLine( const QModelIndexList& iedges,
2485 HEXA_NS::NewShapes shapes,
2486 HEXA_NS::IntVector subIds,
2491 HEXA_NS::Edges mline;
2493 HEXA_NS::Edge* hedge = NULL;
2494 foreach( const QModelIndex& iedge, iedges ){
2495 hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
2497 mline.push_back( hedge );
2500 int err = _hexaDocument->associateOpenedLine( mline, shapes, subIds, pstart, pend );
2509 bool DocumentModel::associateClosedLine( const QModelIndex& ivertex,
2510 const QModelIndexList& iedges,
2511 HEXA_NS::NewShapes shapes,
2512 HEXA_NS::IntVector subIds,
2516 HEXA_NS::Vertex* mfirst = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
2517 HEXA_NS::Edges mline;
2519 HEXA_NS::Edge* hedge = NULL;
2520 foreach( const QModelIndex& iedge, iedges ){
2521 hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
2523 mline.push_back( hedge );
2526 int err = _hexaDocument->associateClosedLine( mfirst, mline, shapes, subIds, pstart, inv);
2534 // ************ GROUPS ************
2536 QModelIndex DocumentModel::addGroup( const QString& name, Group kind )
2540 HEXA_NS::Group* hGroup = _hexaDocument->addGroup( name.toLocal8Bit().constData(), kind );
2541 if ( hGroup == NULL ) return iGroup;
2543 GroupItem* groupItem = new GroupItem(hGroup);
2544 groupItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
2545 _groupDirItem->appendRow(groupItem);
2546 iGroup = groupItem->index();
2553 bool DocumentModel::removeGroup( const QModelIndex& igrp )
2555 HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2556 int r = _hexaDocument->removeGroup ( hGroup );
2559 removeRow( igrp.row(), igrp.parent());
2566 QModelIndex* DocumentModel::found(eltBase)
2572 QModelIndexList DocumentModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
2574 QModelIndexList iElements;
2576 HEXA_NS::Group* g = iGroup.data(HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2577 if ( g == NULL ) return iElements;
2579 QModelIndexList iFound;
2581 HEXA_NS::EltBase* eltBase = NULL;
2582 for ( int nr = 0; nr < g->countElement(); ++nr ){
2583 eltBase = g->getElement( nr );
2584 kind = g->getKind();
2586 case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: q = QVariant::fromValue( (HEXA_NS::Hexa *)eltBase ); break;
2587 case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: q = QVariant::fromValue( (HEXA_NS::Quad *)eltBase ); break;
2588 case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: q = QVariant::fromValue( (HEXA_NS::Edge *)eltBase ); break;
2589 case HEXA_NS::VertexNode: q = QVariant::fromValue( (HEXA_NS::Vertex *)eltBase ); break;
2591 iFound = match( index(0, 0),
2595 Qt::MatchRecursive );
2596 if ( !iFound.isEmpty() )
2597 iElements << iFound[0];
2602 // 7.4 Boite: éditer un groupe
2603 void DocumentModel::setGroupName( const QModelIndex& igrp, const QString& name )
2605 HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2608 hGroup->setName( name.toLocal8Bit().constData() );
2609 setData(igrp, QVariant::fromValue( name ) );
2614 bool DocumentModel::addGroupElement( const QModelIndex& igrp, const QModelIndex& ielt )
2615 { //CS_TODO : check input? add child?
2616 // int addElement (EltBase* elt);
2618 HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2619 if (hGroup == NULL) return false;
2621 HEXA_NS::EltBase* hElt = NULL;
2622 switch ( hGroup->getKind() ){
2623 case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: hElt = getHexaPtr<HEXA_NS::Hexa*>(ielt); break;
2624 case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: hElt = getHexaPtr<HEXA_NS::Quad*>(ielt); break;
2625 case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: hElt = getHexaPtr<HEXA_NS::Edge*>(ielt); break;
2626 case HEXA_NS::VertexNode: hElt = getHexaPtr<HEXA_NS::Vertex*>(ielt); break;
2631 res = hGroup->addElement( hElt );
2633 if ( res == HOK ) return true;
2638 bool DocumentModel::removeGroupElement( const QModelIndex& igrp, int nro )
2639 { //CS_TODO : remove child?
2640 HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2641 if (hGroup == NULL) return false;
2643 if (hGroup->removeElement( nro ) == HOK) return true;
2648 bool DocumentModel::clearGroupElement( const QModelIndex& igrp )
2650 HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
2652 if ( hGroup != NULL)
2654 hGroup->clearElement();
2660 // ************ LAWS ************
2663 QModelIndex DocumentModel::addLaw( const QString& name, int nbnodes )
2667 HEXA_NS::Law* hLaw = _hexaDocument->addLaw( name.toLocal8Bit().constData(), nbnodes );
2668 if ( BadElement(hLaw) ) return iLaw;
2670 LawItem* lawItem = new LawItem(hLaw);
2671 _lawDirItem->appendRow(lawItem);
2672 iLaw = lawItem->index();
2677 bool DocumentModel::setLaw( const QModelIndex& ilaw, int nbnodes, double coeff, KindLaw type )
2681 HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2685 ok = hLaw->setNodes( nbnodes );
2686 ( ok == HOK) ? ret = true : ret = false;
2687 ok = hLaw->setCoefficient( coeff );
2688 hLaw->setKind(type);
2695 bool DocumentModel::removeLaw( const QModelIndex& ilaw )
2697 HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2698 int r = _hexaDocument->removeLaw( hLaw );
2701 removeRow( ilaw.row(), ilaw.parent());
2708 bool DocumentModel::setPropagation( const QModelIndex& iPropagation, const QModelIndex& iLaw, bool way )
2710 HEXA_NS::Propagation* hPropagation = data(iPropagation, HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
2711 HEXA_NS::Law* hLaw = data(iLaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
2713 int r = hPropagation->setLaw( hLaw );
2714 hPropagation->setWay( way );
2716 if ( r == HOK ) return true;
2721 QModelIndexList DocumentModel::getPropagation( const QModelIndex& iPropagation ) const
2723 QModelIndexList iEdges;
2725 QModelIndexList iFound;
2726 HEXA_NS::Propagation* propa = iPropagation.data(HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
2727 if ( propa == NULL ) return iEdges;
2729 const HEXA_NS::Edges& edges = propa->getEdges();
2730 for ( HEXA_NS::Edges::const_iterator anEdge = edges.begin();
2731 anEdge != edges.end();
2733 iFound = match( index(0, 0),
2735 QVariant::fromValue( *anEdge ),
2737 Qt::MatchRecursive);
2738 if ( !iFound.isEmpty() )
2739 iEdges << iFound[0];
2745 HEXA_NS::Document* DocumentModel::documentImpl()
2747 return _hexaDocument;
2750 QString DocumentModel::documentEntry()
2755 // 8.3 Boite: éditer une loi CS_TODO
2758 /*****************************************************************
2760 *****************************************************************/
2762 PatternDataModel::PatternDataModel( QObject * parent ) :
2763 QSortFilterProxyModel( parent )
2765 QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8)").
2766 arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).
2767 arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).arg(HEXA_DIR_TREE);
2769 setFilterRole(HEXA_TREE_ROLE);
2770 setFilterRegExp ( QRegExp(dataRegExp) );
2773 PatternDataModel::~PatternDataModel()
2777 HEXA_NS::Document* PatternDataModel::documentImpl()
2779 HEXA_NS::Document* doc = NULL;
2780 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2781 if (m) doc = m->documentImpl();
2785 QString PatternDataModel::documentEntry()
2788 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2789 if (m) entry = m->documentEntry();
2793 Qt::ItemFlags PatternDataModel::flags(const QModelIndex &index) const
2795 Qt::ItemFlags flags;
2797 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2799 flags = m->flags( mapToSource(index) );
2805 QVariant PatternDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2807 if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2808 return QVariant( "Data" );
2810 return QSortFilterProxyModel::headerData ( section, orientation, role );
2815 QStandardItem* PatternDataModel::itemFromIndex ( const QModelIndex & index ) const
2817 QStandardItem *item = NULL;
2818 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2820 item = m->itemFromIndex( mapToSource(index) );
2825 PatternBuilderModel::PatternBuilderModel( QObject * parent ) :
2826 QSortFilterProxyModel( parent )
2828 QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10)").
2829 arg(VECTOR_TREE).arg(CYLINDER_TREE).arg(PIPE_TREE).arg(ELEMENTS_TREE).
2830 arg(CROSSELEMENTS_TREE).arg(VECTOR_DIR_TREE).arg(CYLINDER_DIR_TREE).
2831 arg(PIPE_DIR_TREE).arg(ELEMENTS_DIR_TREE).arg(CROSSELEMENTS_DIR_TREE);
2833 setFilterRole( HEXA_TREE_ROLE );
2834 setFilterRegExp ( QRegExp(builderRegExp ) );
2837 PatternBuilderModel::~PatternBuilderModel()
2841 Qt::ItemFlags PatternBuilderModel::flags(const QModelIndex &index) const
2843 // std::cout<<"PatternBuilderModel::flags()"<<std::endl;
2844 Qt::ItemFlags flags;
2846 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2848 flags = m->flags( mapToSource(index) );
2853 QVariant PatternBuilderModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2855 if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2856 return QVariant( "Builder" );
2858 return QSortFilterProxyModel::headerData ( section, orientation, role );
2862 QStandardItem* PatternBuilderModel::itemFromIndex ( const QModelIndex & index ) const
2864 QStandardItem *item = NULL;
2865 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2867 item = m->itemFromIndex( mapToSource(index) );
2872 //====================================================================
2874 //====================================================================
2875 PatternGeomModel::PatternGeomModel( QObject * parent ) :
2876 QSortFilterProxyModel( parent )
2878 QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12|%13|%14)").
2879 arg(EXPLICIT_SHAPES_TREE).arg(IMPLICIT_SHAPES_TREE).arg(CLOUD_OF_POINTS_TREE).
2880 arg(GEOMSHAPE_TREE).arg(GEOMPOINT_TREE).arg(GEOMEDGE_TREE).arg(GEOMFACE_TREE).
2881 arg(EXPLICIT_SHAPES_DIR_TREE).arg(IMPLICIT_SHAPES_DIR_TREE).arg(CLOUD_OF_POINTS_DIR_TREE).
2882 arg(GEOMSHAPE_DIR_TREE).arg(GEOMPOINT_DIR_TREE).arg(GEOMEDGE_DIR_TREE).arg(GEOMFACE_DIR_TREE);
2884 setFilterRole( HEXA_TREE_ROLE );
2885 setFilterRegExp ( QRegExp(builderRegExp ) );
2888 PatternGeomModel::~PatternGeomModel()
2892 Qt::ItemFlags PatternGeomModel::flags(const QModelIndex &index) const
2894 Qt::ItemFlags flags;
2896 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2898 flags = m->flags( mapToSource(index) );
2903 QVariant PatternGeomModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2905 if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2906 return QVariant( "Geometry" );
2908 return QSortFilterProxyModel::headerData ( section, orientation, role );
2912 QStandardItem* PatternGeomModel::itemFromIndex ( const QModelIndex & index ) const
2914 QStandardItem *item = NULL;
2915 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2917 item = m->itemFromIndex( mapToSource(index) );
2921 //==============================================================
2925 AssociationsModel::AssociationsModel( QObject * parent ) :
2926 QSortFilterProxyModel( parent )
2928 QString assocRegExp;// =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE); CS_TODO
2930 setFilterRole( HEXA_TREE_ROLE );
2931 setFilterRegExp ( QRegExp(assocRegExp) );
2934 AssociationsModel::~AssociationsModel()
2938 Qt::ItemFlags AssociationsModel::flags(const QModelIndex &index) const
2940 Qt::ItemFlags flags;
2942 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2944 flags = m->flags( mapToSource(index) );
2949 QVariant AssociationsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2951 if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2952 return QVariant( "Associations" );
2954 return QSortFilterProxyModel::headerData ( section, orientation, role );
2958 QStandardItem* AssociationsModel::itemFromIndex ( const QModelIndex & index ) const
2960 QStandardItem *item = NULL;
2961 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2963 item = m->itemFromIndex( mapToSource(index) );
2968 GroupsModel::GroupsModel( QObject * parent ) :
2969 QSortFilterProxyModel( parent )
2971 QString groupsRegExp =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE);
2973 setFilterRole( HEXA_TREE_ROLE );
2974 setFilterRegExp ( QRegExp(groupsRegExp ) );
2977 GroupsModel::~GroupsModel()
2981 Qt::ItemFlags GroupsModel::flags(const QModelIndex &index) const
2983 Qt::ItemFlags flags;
2985 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
2987 flags = m->flags( mapToSource(index) );
2992 QVariant GroupsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
2994 if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
2995 return QVariant( "Groups" );
2997 return QSortFilterProxyModel::headerData ( section, orientation, role );
3001 QStandardItem* GroupsModel::itemFromIndex ( const QModelIndex & index ) const
3003 QStandardItem *item = NULL;
3004 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3006 item = m->itemFromIndex( mapToSource(index) );
3011 QModelIndexList GroupsModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
3013 QModelIndexList elements;
3014 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3016 elements = m->getGroupElements( mapToSource(iGroup), kind );
3021 MeshModel::MeshModel( QObject * parent ) :
3022 QSortFilterProxyModel( parent )
3024 QString meshRegExp =QString("(%1|%2|%3|%4)").arg(LAW_TREE).arg(LAW_DIR_TREE) .arg(PROPAGATION_TREE).arg(PROPAGATION_DIR_TREE);
3026 setFilterRole( HEXA_TREE_ROLE );
3027 setFilterRegExp ( QRegExp(meshRegExp) );
3030 MeshModel::~MeshModel()
3034 Qt::ItemFlags MeshModel::flags(const QModelIndex &index) const
3036 Qt::ItemFlags flags;
3038 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3040 flags = m->flags( mapToSource(index) );
3045 QVariant MeshModel::headerData ( int section, Qt::Orientation orientation, int role ) const
3047 if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
3048 return QVariant( "Mesh" );
3050 return QSortFilterProxyModel::headerData ( section, orientation, role );
3054 QStandardItem* MeshModel::itemFromIndex ( const QModelIndex & index ) const
3056 QStandardItem *item = NULL;
3057 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3059 item = m->itemFromIndex( mapToSource(index) );
3064 QModelIndexList MeshModel::getPropagation( const QModelIndex& iPropagation ) const
3066 QModelIndexList edges;
3067 DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
3069 edges = m->getPropagation( mapToSource(iPropagation) );