-// Copyright (C) 2009-2012 CEA/DEN, EDF R&D
+// Copyright (C) 2009-2019 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "HexVertex.hxx"
#include "HexShape.hxx"
+#include "HexSubShape.hxx"
+#include "HexAssoEdge.hxx"
+#include "HexBiCylinder.hxx"
+
+#include <TopoDS.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
-#include <GEOMBase.h>
#include "HEXABLOCKGUI_SalomeTools.hxx"
+#include <SALOME_ListIO.hxx>
+#include <SALOMEconfig.h>
+#include <SUIT_ViewWindow.h>
+
#include <qglobal.h>
+
+#include "HEXABLOCKGUI_VtkDocumentGraphicView.hxx"
+
+#include <Geom_Circle.hxx>
+#include <gp_Circ.hxx>
+#include <BRep_Tool.hxx>
+#include <TopoDS_Edge.hxx>
//#define _DEVDEBUG_
/*****************************************************************
DocumentModel
-*****************************************************************/
+ *****************************************************************/
// DocumentModel::DocumentModel(QObject * parent):
DocumentModel::DocumentModel(HEXA_NS::Document* docIn, const QString& entryIn, QObject * parent):
- QStandardItemModel(parent),
- _hexaFile( new QTemporaryFile() ),
- _hexaDocument( docIn ),
- _entry( entryIn ),
-// _hexaDocument( new HEXA_NS::Document("/tmp/doc.hex") ), //CS_TODO
-
- _vertexDirItem( new QStandardItem(tr("TREE_ITEM_VERTEX")) ),
- _edgeDirItem( new QStandardItem(tr("TREE_ITEM_EDGE")) ),
- _quadDirItem( new QStandardItem(tr("TREE_ITEM_QUAD")) ),
- _hexaDirItem( new QStandardItem(tr("TREE_ITEM_HEXA")) ),
-
- _vectorDirItem( new QStandardItem(tr("TREE_ITEM_VECTOR")) ),
- _cylinderDirItem( new QStandardItem(tr("TREE_ITEM_CYLINDER")) ),
- _pipeDirItem( new QStandardItem(tr("TREE_ITEM_PIPE")) ),
- _elementsDirItem( new QStandardItem(tr("TREE_ITEM_ELEMENT")) ),
- _crossElementsDirItem( new QStandardItem(tr("TREE_ITEM_CROSSELEMENT")) ),
-
- _groupDirItem( new QStandardItem(tr("TREE_ITEM_GROUP")) ),
-
- _lawDirItem( new QStandardItem(tr("TREE_ITEM_LAW")) ),
- _propagationDirItem( new QStandardItem(tr("TREE_ITEM_PROPAGATION")) ),
-
- _vertexItemFlags( Qt::NoItemFlags ),
- _edgeItemFlags( Qt::NoItemFlags ),
- _quadItemFlags( Qt::NoItemFlags ),
- _hexaItemFlags( Qt::NoItemFlags ),
- _vectorItemFlags( Qt::NoItemFlags ),
- _cylinderItemFlags( Qt::NoItemFlags ),
- _pipeItemFlags( Qt::NoItemFlags ),
- _elementsItemFlags( Qt::NoItemFlags ),
- _crossElementsItemFlags( Qt::NoItemFlags ),
- _disallowEdition( false )
-{
-// setColumnCount( 4 ); //CS_TEST
- if ( !_hexaDocument && _hexaFile->open() ){
- _hexaDocument = new HEXA_NS::Document( _hexaFile->fileName().toLatin1() );
- _hexaDocument->reorderFaces();
- }
-
- QStandardItem *parentItem = invisibleRootItem();
-// parentItem->setData( QString::number( reinterpret_cast<intptr_t>(_hexaDocument) ), HEXA_ENTRY_ROLE );
- parentItem->setData( _entry, HEXA_ENTRY_ROLE );
-
- _vertexDirItem->setData( VERTEX_DIR_TREE, HEXA_TREE_ROLE );
- _edgeDirItem->setData( EDGE_DIR_TREE, HEXA_TREE_ROLE );
- _quadDirItem->setData( QUAD_DIR_TREE, HEXA_TREE_ROLE );
- _hexaDirItem->setData( HEXA_DIR_TREE, HEXA_TREE_ROLE );
-
- _vectorDirItem->setData( VECTOR_DIR_TREE, HEXA_TREE_ROLE );
- _cylinderDirItem->setData( CYLINDER_DIR_TREE, HEXA_TREE_ROLE );
- _pipeDirItem->setData( PIPE_DIR_TREE, HEXA_TREE_ROLE );
- _elementsDirItem->setData( ELEMENTS_DIR_TREE, HEXA_TREE_ROLE );
- _crossElementsDirItem->setData( CROSSELEMENTS_DIR_TREE, HEXA_TREE_ROLE );
-
- _groupDirItem->setData( GROUP_DIR_TREE, HEXA_TREE_ROLE );
-
- //CS_TODO associations
-
- _lawDirItem->setData( LAW_DIR_TREE, HEXA_TREE_ROLE );
- _propagationDirItem->setData( PROPAGATION_DIR_TREE, HEXA_TREE_ROLE );
-
-
- parentItem->appendRow(_vertexDirItem);
- parentItem->appendRow(_edgeDirItem);
- parentItem->appendRow(_quadDirItem);
- parentItem->appendRow(_hexaDirItem);
- parentItem->appendRow(_vectorDirItem);
- parentItem->appendRow(_cylinderDirItem);
- parentItem->appendRow(_pipeDirItem);
- parentItem->appendRow(_elementsDirItem);
- parentItem->appendRow(_crossElementsDirItem);
- parentItem->appendRow(_groupDirItem);
- parentItem->appendRow(_lawDirItem);
- parentItem->appendRow(_propagationDirItem);
+ QStandardItemModel(parent),
+ _hexaFile( new QTemporaryFile() ),
+ _hexaDocument( docIn ),
+ _entry( entryIn ),
+ // _hexaDocument( new HEXA_NS::Document("/tmp/doc.hex") ), //CS_TODO
+
+ _vertexDirItem( new QStandardItem(tr("TREE_ITEM_VERTEX")) ),
+ _edgeDirItem( new QStandardItem(tr("TREE_ITEM_EDGE")) ),
+ _quadDirItem( new QStandardItem(tr("TREE_ITEM_QUAD")) ),
+ _hexaDirItem( new QStandardItem(tr("TREE_ITEM_HEXA")) ),
+
+ _vectorDirItem( new QStandardItem(tr("TREE_ITEM_VECTOR")) ),
+ _elementsDirItem( new QStandardItem(tr("TREE_ITEM_ELEMENT")) ),
+ _crossElementsDirItem( new QStandardItem(tr("TREE_ITEM_CROSSELEMENT")) ),
+
+ _explicitShapesDirItem( new QStandardItem(tr("TREE_ITEM_EXPSHAPE")) ),
+ _implicitShapesDirItem( new QStandardItem(tr("TREE_ITEM_IMPSHAPE")) ),
+ _cloudOfPointsDirItem( new QStandardItem(tr("TREE_ITEM_CLOUD_OF_POINT")) ),
+
+ _groupDirItem( new QStandardItem(tr("TREE_ITEM_GROUP")) ),
+
+ _lawDirItem( new QStandardItem(tr("TREE_ITEM_LAW")) ),
+ _propagationDirItem( new QStandardItem(tr("TREE_ITEM_PROPAGATION")) ),
+
+ _vertexItemFlags( Qt::NoItemFlags ),
+ _edgeItemFlags( Qt::NoItemFlags ),
+ _quadItemFlags( Qt::NoItemFlags ),
+ _hexaItemFlags( Qt::NoItemFlags ),
+ _vectorItemFlags( Qt::NoItemFlags ),
+ _elementsItemFlags( Qt::NoItemFlags ),
+ _crossElementsItemFlags( Qt::NoItemFlags ),
+
+ _disallowEdition( false )
+{
+ // setColumnCount( 4 ); //CS_TEST
+ if ( !_hexaDocument && _hexaFile->open() ){
+ _hexaDocument = new HEXA_NS::Document( _hexaFile->fileName().toLatin1() );
+ _hexaDocument->reorderFaces();
+ }
+
+ QStandardItem *parentItem = invisibleRootItem();
+ // parentItem->setData( QString::number( reinterpret_cast<intptr_t>(_hexaDocument) ), HEXA_ENTRY_ROLE );
+ parentItem->setData( _entry, HEXA_ENTRY_ROLE );
+
+ _vertexDirItem->setData( VERTEX_DIR_TREE, HEXA_TREE_ROLE );
+ _edgeDirItem->setData( EDGE_DIR_TREE, HEXA_TREE_ROLE );
+ _quadDirItem->setData( QUAD_DIR_TREE, HEXA_TREE_ROLE );
+ _hexaDirItem->setData( HEXA_DIR_TREE, HEXA_TREE_ROLE );
+
+ _vectorDirItem->setData( VECTOR_DIR_TREE, HEXA_TREE_ROLE );
+ _elementsDirItem->setData( ELEMENTS_DIR_TREE, HEXA_TREE_ROLE );
+ _crossElementsDirItem->setData( CROSSELEMENTS_DIR_TREE, HEXA_TREE_ROLE );
+
+ _explicitShapesDirItem->setData( EXPLICIT_SHAPES_DIR_TREE, HEXA_TREE_ROLE );
+ _implicitShapesDirItem->setData( IMPLICIT_SHAPES_DIR_TREE, HEXA_TREE_ROLE );
+ _cloudOfPointsDirItem->setData( CLOUD_OF_POINTS_DIR_TREE, HEXA_TREE_ROLE );
+
+ _groupDirItem->setData( GROUP_DIR_TREE, HEXA_TREE_ROLE );
+
+ //CS_TODO associations
+
+ _lawDirItem->setData( LAW_DIR_TREE, HEXA_TREE_ROLE );
+ _propagationDirItem->setData( PROPAGATION_DIR_TREE, HEXA_TREE_ROLE );
+
+ parentItem->appendRow(_vertexDirItem);
+ parentItem->appendRow(_edgeDirItem);
+ parentItem->appendRow(_quadDirItem);
+ parentItem->appendRow(_hexaDirItem);
+
+ parentItem->appendRow(_vectorDirItem);
+ parentItem->appendRow(_elementsDirItem);
+ parentItem->appendRow(_crossElementsDirItem);
+
+ parentItem->appendRow(_explicitShapesDirItem);
+ parentItem->appendRow(_implicitShapesDirItem);
+
+ parentItem->appendRow(_groupDirItem);
+ parentItem->appendRow(_lawDirItem);
+ parentItem->appendRow(_propagationDirItem);
}
DocumentModel::~DocumentModel()
{
- delete _hexaDocument;
- delete _hexaFile;
+ if (_hexaDocument != NULL)
+ delete _hexaDocument;
+
+ if (_hexaFile != NULL)
+ delete _hexaFile;
}
void DocumentModel::setName(const QString& name)
{
- _hexaDocument->setName( name.toLocal8Bit().constData() );
- emit nameChanged(name);
+ _hexaDocument->setName( name.toLocal8Bit().constData() );
+ emit nameChanged(QString(_hexaDocument->getName()));
}
-QString DocumentModel::getName()
+HEXA_NS::EltBase* DocumentModel::getHexaPtr(const QModelIndex& iElt)
{
- return _hexaDocument->getName();
+ HEXA_NS::EltBase *elt = NULL;
+ switch ( /*data(iElt, HEXA_TREE_ROLE).toInt()*/iElt.data(HEXA_TREE_ROLE).toInt() ){
+ case VERTEX_TREE : elt = getHexaPtr<HEXA_NS::Vertex*>(iElt); break;
+ case EDGE_TREE : elt = getHexaPtr<HEXA_NS::Edge*>(iElt); break;
+ case QUAD_TREE : elt = getHexaPtr<HEXA_NS::Quad*>(iElt); break;
+ case HEXA_TREE : elt = getHexaPtr<HEXA_NS::Hexa*>(iElt); break;
+ case VECTOR_TREE : elt = getHexaPtr<HEXA_NS::Vector*>(iElt); break;
+ case ELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::Elements*>(iElt); break;
+// case CROSSELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::CrossElements*>(iElt); break;
+ case GEOMSHAPE_TREE: elt = getHexaPtr<HEXA_NS::NewShape*>(iElt); break;
+ case GEOMPOINT_TREE: elt = getHexaPtr<HEXA_NS::VertexShape*>(iElt); break;
+ case GEOMEDGE_TREE: elt = getHexaPtr<HEXA_NS::EdgeShape*>(iElt); break;
+ case GEOMFACE_TREE: elt = getHexaPtr<HEXA_NS::FaceShape*>(iElt); break;
+ }
+ return elt;
}
-HEXA_NS::EltBase* DocumentModel::getHexaPtr(const QModelIndex& iElt)
+//get the number of elements of type 'eltType' in the document
+int DocumentModel::getNbrElt(HEXA_NS::EnumElt eltType)
+{
+ if (_hexaDocument == NULL) return 0;
+
+ return _hexaDocument->getNbrElt(eltType);
+}
+
+//get the number of elements of type 'eltType' used in the document
+int DocumentModel::getNbrUsedElt(HEXA_NS::EnumElt eltType)
+{
+ if (_hexaDocument == NULL) return 0;
+
+ switch(eltType) {
+ case HEXA_NS::EL_VERTEX:
+ return _hexaDocument->countUsedVertex();
+ case HEXA_NS::EL_EDGE:
+ return _hexaDocument->countUsedEdge();
+ case HEXA_NS::EL_QUAD:
+ return _hexaDocument->countUsedQuad();
+ case HEXA_NS::EL_HEXA:
+ return _hexaDocument->countUsedHexa();
+ default: return 0;
+ }
+}
+
+//associate a shape to the current document
+bool DocumentModel::addShape(TopoDS_Shape& aShape, QString& name, bool publish)
+{
+ if (aShape.IsNull() || name.isEmpty())
+ return false;
+ bool ok = (_hexaDocument != NULL ? _hexaDocument->addShape(aShape, name.toStdString().c_str()) != NULL : false);
+
+ // * publish the shape in the study
+ if (ok && publish)
+ {
+ HEXABLOCKGUI* module = HEXABLOCKGUI::getInstance();
+ if (module != NULL)
+ {
+ QMap<QString, TopoDS_Shape> topo_shapes;
+ topo_shapes[name] = aShape;
+ module->addInStudy(topo_shapes, docShapesEntry, docShapesName);
+ }
+ }
+
+ // * update data
+ if (ok)
+ updateGeomTree();
+
+ return ok;
+}
+
+//get the number of unused elements of type 'eltType' in the document
+int DocumentModel::getNbrUnusedElt(HEXA_NS::EnumElt eltType)
+{
+ if (_hexaDocument == NULL)
+ return 0;
+
+ return getNbrElt(eltType) - getNbrUsedElt(eltType);
+}
+
+// compute the length of the given edge
+double DocumentModel::getLength(const QModelIndex& iEdge)
+{
+ // * Get the pointer to the edge
+ HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
+ HEXA_NS::EdgeShape* geomEdge = getHexaPtr<HEXA_NS::EdgeShape*>(iEdge);
+
+ // * The edge can be from VTK or OCC View
+ if (edge != NULL)
+ return edge->getLength();
+ else if (geomEdge != NULL)
+ return geomEdge->getLength();
+ else
+ return 0.;
+}
+
+// Compute the radius of the given edge
+double DocumentModel::getRadius(const QModelIndex& iEdge)
+{
+ // * Get the pointer to the edge
+ // * In our case only an OCC edge can have a radius
+ HEXA_NS::EdgeShape* edge = getHexaPtr<HEXA_NS::EdgeShape*>(iEdge);
+ if (edge == NULL)
+ return 0.;
+
+ return edge->getRadius();
+}
+
+// Compute the angle of the given edge (internal angle)
+double DocumentModel::getAngle(const QModelIndex& iEdge)
+{
+ // * Get the pointer to the edge
+ HEXA_NS::EdgeShape* edge = getHexaPtr<HEXA_NS::EdgeShape*>(iEdge);
+ if (edge == NULL)
+ return 0.;
+
+ return edge->getAngle();
+}
+
+//Load the current Document
+void DocumentModel::load()
{
- HEXA_NS::EltBase *elt = NULL;
- switch ( /*data(iElt, HEXA_TREE_ROLE).toInt()*/iElt.data(HEXA_TREE_ROLE).toInt() ){
- case VERTEX_TREE : elt = getHexaPtr<HEXA_NS::Vertex*>(iElt); break;
- case EDGE_TREE : elt = getHexaPtr<HEXA_NS::Edge*>(iElt); break;
- case QUAD_TREE : elt = getHexaPtr<HEXA_NS::Quad*>(iElt); break;
- case HEXA_TREE : elt = getHexaPtr<HEXA_NS::Hexa*>(iElt); break;
- case VECTOR_TREE : elt = getHexaPtr<HEXA_NS::Vector*>(iElt); break;
- case CYLINDER_TREE : elt = getHexaPtr<HEXA_NS::Cylinder*>(iElt); break;
- case PIPE_TREE : elt = getHexaPtr<HEXA_NS::Pipe*>(iElt); break;
- case ELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::Elements*>(iElt); break;
- case CROSSELEMENTS_TREE : elt = getHexaPtr<HEXA_NS::CrossElements*>(iElt); break;
- }
- return elt;
-}
-
-DocumentModel::GeomObj* DocumentModel::convertToGeomObj(GEOM::GeomObjPtr geomObjPtr)
-{
- TopoDS_Shape aShape;
- DocumentModel::GeomObj *res = NULL;
-
- if ( geomObjPtr && GEOMBase::GetShape(geomObjPtr.get(), aShape) && !aShape.IsNull() )
- {
- res = new DocumentModel::GeomObj;
- if (res == NULL) return NULL;
- QString mainShapeEntry;
- int subId = -1;
- QString brep;
-
- if ( geomObjPtr->IsMainShape() ){
- mainShapeEntry = geomObjPtr->GetStudyEntry();
- brep = shape2string( aShape ).c_str();
- } else {
- TopoDS_Shape shape;
- TopoDS_Shape subshape;
- GEOM::GEOM_Object_var mainShape = geomObjPtr->GetMainShape();
- mainShapeEntry = mainShape->GetStudyEntry();
- // CS_TODO : à optimiser
- bool okShape = GEOMBase::GetShape( mainShape , shape);//,const TopAbs_ShapeEnum type = TopAbs_SHAPE );
- bool oksubShape = GEOMBase::GetShape( geomObjPtr.get(), subshape );//,const TopAbs_ShapeEnum type = TopAbs_SHAPE );
- if ( okShape && oksubShape ){
- brep = shape2string( subshape ).c_str();
- subId = GEOMBase::GetIndex( subshape, shape );
- }
- }
- res->name = GEOMBase::GetName( geomObjPtr.get() );
- res->entry = mainShapeEntry;
- res->subid = QString::number(subId);
- res->brep = brep;
- res->start = 0.;
- res->end = 1.;
- }
-
- return res;
+ if (_hexaDocument == NULL)
+ return;
+
+ load(_hexaDocument->getName());
}
void DocumentModel::load( const QString& xmlFileName ) // Fill Data
{
- MESSAGE("HEXABLOCKGUI::load() => "<<xmlFileName.toStdString());
- _hexaDocument->loadXml(xmlFileName.toLocal8Bit().constData() );
- clearAll();
+ _hexaDocument->loadXml(xmlFileName.toLocal8Bit().constData() );
+ clearAll();
- fillData();
- fillBuilder();
- fillAssociation();
- fillGroups();
- fillMesh();
+ fillData();
+// fillBuilder();
+ fillGeometry();
+ fillAssociation();
+ fillGroups();
+ fillMesh();
- emit patternDataChanged();
+ emit patternDataChanged();
+}
- // BUILDER, ASSOCIATION, GROUPS, ... CS_TODO _fillBuilderFrom( _hexaDocument );
+bool DocumentModel::isEmpty() const
+{
+ if (_hexaDocument == NULL) return true;
+ return _hexaDocument->isEmpty();
}
void DocumentModel::save( const QString& xmlFileName )
{
- MESSAGE("HEXABLOCKGUI::save() => "<<xmlFileName.toStdString());
- _hexaDocument->save( xmlFileName.toLocal8Bit().constData() );
+ _hexaDocument->save( xmlFileName.toLocal8Bit().constData() );
+}
+
+QString DocumentModel::getName()
+{
+ return _hexaDocument->getName();
}
void DocumentModel::updateData()
{
- clearData();
- fillData();
- clearMesh();
- fillMesh();
- emit patternDataChanged();
+ clearData();
+ fillData();
+ clearMesh();
+ fillMesh();
+ emit patternDataChanged();
+}
+
+void DocumentModel::updateGeomTree()
+{
+ clearGeometry();
+ fillGeometry();
+}
+
+QModelIndex DocumentModel::addElementsToTree(HEXA_NS::Elements* helts, QStandardItem* tree)
+{
+ QModelIndex eltIndex;
+ if (helts == NULL || tree == NULL)
+ return eltIndex;
+
+ updateData();
+ ElementsItem* eltsItem = new ElementsItem(helts);
+ tree->appendRow(eltsItem);
+
+ return eltsItem->index();
+}
+
+void DocumentModel::refresh()
+{
+ clearAll();
+
+ fillData();
+// fillBuilder();
+ fillGeometry();
+ fillAssociation();
+ fillGroups();
+ fillMesh();
+
+ emit patternDataChanged();
}
-void DocumentModel::clearAll()
+void DocumentModel::clearAll()
{
- clearData();
- clearBuilder();
- clearAssociation();
- clearGroups();
- clearMesh();
- //dataChanged( const QModelIndex & topLeft, const QModelIndex & bottomRight )
- //CS_TODO : todo : association, groups, mesh
+ clearData();
+// clearBuilder();
+ clearGeometry();
+ clearAssociation();
+ clearGroups();
+ clearMesh();
}
void DocumentModel::clearData()
{
- _vertexDirItem->removeRows( 0, _vertexDirItem->rowCount() );
- _edgeDirItem->removeRows(0, _edgeDirItem->rowCount() );
- _quadDirItem->removeRows(0, _quadDirItem->rowCount() );
- _hexaDirItem->removeRows(0, _hexaDirItem->rowCount() );
+ _vertexDirItem->removeRows( 0, _vertexDirItem->rowCount() );
+ _edgeDirItem->removeRows(0, _edgeDirItem->rowCount() );
+ _quadDirItem->removeRows(0, _quadDirItem->rowCount() );
+ _hexaDirItem->removeRows(0, _hexaDirItem->rowCount() );
+
+ _vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
+ _elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
+ _crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
}
-void DocumentModel::clearBuilder()
+//void DocumentModel::clearBuilder()
+//{
+// _vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
+// _elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
+// _crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
+//}
+
+void DocumentModel::clearGeometry()
{
- _vectorDirItem->removeRows(0, _vectorDirItem->rowCount() );
- _cylinderDirItem->removeRows(0, _cylinderDirItem->rowCount() );
- _pipeDirItem->removeRows(0, _pipeDirItem->rowCount() );
- _elementsDirItem->removeRows(0, _elementsDirItem->rowCount() );
- _crossElementsDirItem->removeRows(0, _crossElementsDirItem->rowCount() );
+ _explicitShapesDirItem->removeRows(0, _explicitShapesDirItem->rowCount() );
+ _implicitShapesDirItem->removeRows(0, _implicitShapesDirItem->rowCount() );
+ _cloudOfPointsDirItem->removeRows(0, _cloudOfPointsDirItem->rowCount() );
}
-void DocumentModel::clearAssociation()
+void DocumentModel::clearAssociation()
{
- //CS_TODO
+ //CS_TODO
}
void DocumentModel::clearGroups()
{
- _groupDirItem->removeRows(0, _groupDirItem->rowCount() );
+ _groupDirItem->removeRows(0, _groupDirItem->rowCount() );
}
void DocumentModel::clearMesh()
{
- _lawDirItem->removeRows(0, _lawDirItem->rowCount() );
- _propagationDirItem->removeRows(0, _propagationDirItem->rowCount() );
+ _lawDirItem->removeRows(0, _lawDirItem->rowCount() );
+ _propagationDirItem->removeRows(0, _propagationDirItem->rowCount() );
}
void DocumentModel::fillData()
{
- // DATA
- HEXA_NS::Vertex *v = NULL;
- VertexItem *vItem = NULL;
- for ( int i=0; i<_hexaDocument->countVertex(); ++i ){
- v = _hexaDocument->getVertex(i);
-
- vItem = new VertexItem(v, _entry);
- _vertexDirItem->appendRow(vItem);
- }
-
- HEXA_NS::Edge *e = NULL;
- EdgeItem *eItem = NULL;
- for ( int i=0; i<_hexaDocument->countEdge(); ++i ){
- e = _hexaDocument->getEdge(i);
- eItem = new EdgeItem(e, _entry);
- _edgeDirItem->appendRow(eItem);
- }
-
- HEXA_NS::Quad *q = NULL;
- QuadItem *qItem = NULL;
- for ( int i=0; i<_hexaDocument->countQuad(); ++i ){
- q = _hexaDocument->getQuad(i);
- qItem = new QuadItem(q, _entry);
- _quadDirItem->appendRow(qItem);
- }
-
- HEXA_NS::Hexa *h = NULL;
- HexaItem *hItem = NULL;
- for ( int i=0; i<_hexaDocument->countHexa(); ++i ){
- h = _hexaDocument->getHexa(i);
- hItem = new HexaItem(h, _entry);
- _hexaDirItem->appendRow(hItem);
- }
-}
-
-
-void DocumentModel::fillBuilder()
-{
- HEXA_NS::Vector *v = NULL;
- VectorItem *vItem = NULL;
- for ( int i=0; i<_hexaDocument->countVector(); ++i ){
- v = _hexaDocument->getVector(i);
- vItem = new VectorItem(v);
- _vectorDirItem->appendRow(vItem);
- }
-
- // _cylinderDirItem
- HEXA_NS::Cylinder *c = NULL;
- CylinderItem *cItem = NULL;
- for ( int i=0; i<_hexaDocument->countCylinder(); ++i ){
- c = _hexaDocument->getCylinder(i);
- cItem = new CylinderItem(c, _entry);
- _cylinderDirItem->appendRow(cItem);
- }
-
-// _pipeDirItem
- HEXA_NS::Pipe *p = NULL;
- PipeItem *pItem = NULL;
- for ( int i=0; i<_hexaDocument->countPipe(); ++i ){
- p = _hexaDocument->getPipe(i);
- pItem = new PipeItem(p);
- _pipeDirItem->appendRow(pItem);
- }
+ PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
+ if (pdsm == NULL)
+ return;
+ pdsm->clearHighlightedItems();
+
+ // DATA
+ HEXA_NS::Vertex *v = NULL;
+ VertexItem *vItem = NULL;
+ int nbVertex = _hexaDocument->countVertex();
+ for ( int i=0; i<nbVertex; ++i ){
+ v = _hexaDocument->getVertex(i);
+ vItem = new VertexItem(v, _entry);
+ _vertexDirItem->appendRow(vItem);
+ }
+
+ HEXA_NS::Edge *e = NULL;
+ EdgeItem *eItem = NULL;
+ int nbEdge = _hexaDocument->countEdge();
+ for ( int i=0; i<nbEdge; ++i ){
+ e = _hexaDocument->getEdge(i);
+ eItem = new EdgeItem(e, _entry);
+ _edgeDirItem->appendRow(eItem);
+ }
+
+ HEXA_NS::Quad *q = NULL;
+ QuadItem *qItem = NULL;
+ int nbQuad = _hexaDocument->countQuad();
+ for ( int i=0; i<nbQuad; ++i ){
+ q = _hexaDocument->getQuad(i);
+ qItem = new QuadItem(q, _entry);
+ _quadDirItem->appendRow(qItem);
+ }
+
+ HEXA_NS::Hexa *h = NULL;
+ HexaItem *hItem = NULL;
+ int nbHexa = _hexaDocument->countHexa();
+ for ( int i=0; i<nbHexa; ++i ){
+ h = _hexaDocument->getHexa(i);
+ hItem = new HexaItem(h, _entry);
+ _hexaDirItem->appendRow(hItem);
+ }
+
+ // +++++ Builder ++++++++++++++++++++++++++++++
+
+ HEXA_NS::Vector *vec = NULL;
+ VectorItem *vecItem = NULL;
+ int nbVector = _hexaDocument->countVector();
+ for ( int i=0; i<nbVector; ++i ){
+ vec = _hexaDocument->getVector(i);
+ vecItem = new VectorItem(vec);
+ _vectorDirItem->appendRow(vecItem);
+ }
+
+ //******* A VOIR AVEC ALAIN POUR LE REMPLISSAGE DE L'ARBRE ELEMENTS ET CROSSELEMENTS (ByCylinder) *******/
+ //******* OU SONT STOCKES LES ELEMENTS ET LES CROSSELEMENTS DANS LE DOCUMENT? ******/
+
+ // _cylinderDirItem
+ // HEXA_NS::Cylinder *c = NULL;
+ // HEXA_NS::Elements* c = NULL;
+ // CylinderItem *cItem = NULL;
+ // ElementsItem* cItem = NULL;
+ // int nbCylinder = _hexaDocument->countCylinder();
+ // for ( int i=0; i<nbCylinder; ++i ){
+ // c = _hexaDocument->getCylinder(i);
+ // cItem = new CylinderItem(c, _entry);
+ // cItem = new ElementsItem(c, _entry);
+ // _cylinderDirItem->appendRow(cItem);
+ // _elementsDirItem->appendRow(cItem);
+ // }
+
+ // _pipeDirItem
+ // HEXA_NS::Pipe *p = NULL;
+ // HEXA_NS::Elements* p = NULL;
+ // PipeItem *pItem = NULL;
+ // ElementsItem* pItem = NULL;
+ // int nbPipe = _hexaDocument->countPipe();
+ // for ( int i=0; i<nbPipe; ++i ){
+ // p = _hexaDocument->getPipe(i);
+ // pItem = new PipeItem(p);
+ // pItem = new ElementsItem(p, _entry);
+ // _pipeDirItem->appendRow(pItem);
+ // _elementsDirItem->appendRow(pItem);
+ // }
+ //********************************************************************************************************
+}
+
+
+//void DocumentModel::fillBuilder()
+//{
+// HEXA_NS::Vector *v = NULL;
+// VectorItem *vItem = NULL;
+// int nbVector = _hexaDocument->countVector();
+// for ( int i=0; i<nbVector; ++i ){
+// v = _hexaDocument->getVector(i);
+// vItem = new VectorItem(v);
+// _vectorDirItem->appendRow(vItem);
+// }
+//
+// //******* A VOIR AVEC ALAIN POUR LE REMPLISSAGE DE L'ARBRE ELEMENTS ET CROSSELEMENTS (ByCylinder) *******/
+// //******* OU SONT STOCKES LES ELEMENTS ET LES CROSSELEMENTS DANS LE DOCUMENT? ******/
+//
+// // _cylinderDirItem
+//// HEXA_NS::Cylinder *c = NULL;
+//// HEXA_NS::Elements* c = NULL;
+//// CylinderItem *cItem = NULL;
+//// ElementsItem* cItem = NULL;
+//// int nbCylinder = _hexaDocument->countCylinder();
+//// for ( int i=0; i<nbCylinder; ++i ){
+//// c = _hexaDocument->getCylinder(i);
+//// cItem = new CylinderItem(c, _entry);
+//// cItem = new ElementsItem(c, _entry);
+//// _cylinderDirItem->appendRow(cItem);
+//// _elementsDirItem->appendRow(cItem);
+//// }
+//
+// // _pipeDirItem
+//// HEXA_NS::Pipe *p = NULL;
+//// HEXA_NS::Elements* p = NULL;
+//// PipeItem *pItem = NULL;
+//// ElementsItem* pItem = NULL;
+//// int nbPipe = _hexaDocument->countPipe();
+//// for ( int i=0; i<nbPipe; ++i ){
+//// p = _hexaDocument->getPipe(i);
+//// pItem = new PipeItem(p);
+//// pItem = new ElementsItem(p, _entry);
+//// _pipeDirItem->appendRow(pItem);
+//// _elementsDirItem->appendRow(pItem);
+//// }
+// //********************************************************************************************************
+//}
+
+void DocumentModel::fillGeometry()
+{
+ PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
+ if (_hexaDocument == NULL /*|| isEmpty()*/ || pgsm == NULL)
+ return;
+
+ HEXA_NS::NewShape* shape;
+ HEXA_NS::VertexShape* node;
+ HEXA_NS::EdgeShape* line;
+ HEXA_NS::FaceShape* face;
+ TopoDS_Compound vertexCompound;
+ BRep_Builder compoundBuilder;
+
+ // * fill the shape tree
+
+ shapeById.clear();
+ pgsm->clearHighlightedItems();
+ QMap<QString, TopoDS_Shape> topo_shapes;
+ int nbShapes = _hexaDocument->countShape();
+ for (int i=0; i < nbShapes; ++i)
+ {
+ shape = _hexaDocument->getShape(i);
+ QString shapeName = shape->getName();
+ if (!docShapesEntry.contains(shapeName))
+ {
+ if (shape->getOrigin() == HEXA_NS::SH_CLOUD)
+ {
+ compoundBuilder.MakeCompound(vertexCompound);
+ topo_shapes[shapeName] = vertexCompound;
+ }
+ else
+ topo_shapes[shapeName] = shape->getShape();
+ }
+
+ GeomShapeItem* shItem = new GeomShapeItem(shape);
+ if (shape->getOrigin() == HEXA_NS::SH_IMPORT)
+ // * explicit shapes
+ _explicitShapesDirItem->appendRow(shItem);
+ else
+ // * implicit shapes
+ _implicitShapesDirItem->appendRow(shItem);
+
+ //add vertices to the tree
+ QStandardItem* geomPointDirItem = NULL;
+ if (shape->getOrigin() != HEXA_NS::SH_CLOUD)
+ {
+ geomPointDirItem = new QStandardItem(tr("TREE_ITEM_VERTEX"));
+ geomPointDirItem->setData( GEOMPOINT_DIR_TREE, HEXA_TREE_ROLE );
+ }
+ if (geomPointDirItem != NULL)
+ shItem->appendRow(geomPointDirItem);
+ int nbVertexShape = shape->countVertex();
+ for (int j=0; j < nbVertexShape; ++j)
+ {
+ node = shape->getVertexShape(j);
+ GeomPointItem* gPointItem = new GeomPointItem(node);
+ if (geomPointDirItem != NULL)
+ geomPointDirItem->appendRow(gPointItem);
+ else
+ shItem->appendRow(gPointItem);
+ shapeById[shapeName+","+QString::number(node->getIdent())] = node;
+
+ // * update the compound of vertices
+ if (shape->getOrigin() == HEXA_NS::SH_CLOUD && !vertexCompound.IsNull())
+ compoundBuilder.Add(topo_shapes[shapeName], node->getShape());
+ }
+
+ if (shape->getOrigin() == HEXA_NS::SH_CLOUD)
+ continue; // * it's a cloud of points, there's no edges and no quads to fill
+
+ //add edges to the tree
+ QStandardItem* geomEdgeDirItem = new QStandardItem(tr("TREE_ITEM_EDGE"));
+ geomEdgeDirItem->setData( GEOMEDGE_DIR_TREE, HEXA_TREE_ROLE );
+ shItem->appendRow(geomEdgeDirItem);
+ int nbEdgeShape = shape->countEdge();
+ for (int j = 0; j < nbEdgeShape; ++j)
+ {
+ line = shape->getEdgeShape(j);
+ GeomEdgeItem* gEdgeItem = new GeomEdgeItem(line);
+ geomEdgeDirItem->appendRow(gEdgeItem);
+ shapeById[shapeName+","+QString::number(line->getIdent())] = line;
+ }
+
+ //add faces to the tree
+ QStandardItem* geomFaceDirItem = new QStandardItem(tr("TREE_ITEM_QUAD"));
+ geomFaceDirItem->setData( GEOMFACE_DIR_TREE, HEXA_TREE_ROLE );
+ shItem->appendRow(geomFaceDirItem);
+ int nbFaceShape = shape->countFace();
+ for (int j = 0; j < nbFaceShape; ++j)
+ {
+ face = shape->getFaceShape(j);
+ GeomFaceItem* gFaceItem = new GeomFaceItem(face);
+ geomFaceDirItem->appendRow(gFaceItem);
+ shapeById[shapeName+","+QString::number(face->getIdent())] = face;
+ }
+ }
+
+ if (topo_shapes.size() == 0)
+ return;
+
+ // * register shapes
+ HEXABLOCKGUI* module = HEXABLOCKGUI::getInstance();
+ if (module != NULL)
+ module->addInStudy(topo_shapes, docShapesEntry, docShapesName);
}
+
void DocumentModel::fillAssociation()
{
-
}
//------------------------------------------- NEW ITEMS
//{
// HEXA_NS::Group *g = NULL;
// GroupItem *gItem = NULL;
-// for ( int i=0; i<_hexaDocument->countGroup(); ++i ){
+// int nbGroup = _hexaDocument->countGroup();
+// for ( int i=0; i<nbGroup; ++i ){
// g = _hexaDocument->getGroup(i);
// gItem = new GroupItem(g, _entry);
// _groupDirItem->appendRow(gItem);
//{
// HEXA_NS::Law *l = NULL;
// LawItem *lItem = NULL;
-// for ( int i=0; i<_hexaDocument->countLaw(); ++i ){
+// int nbLaw = _hexaDocument->countLaw();
+// for ( int i=0; i<nbLaw; ++i ){
// l = _hexaDocument->getLaw(i);
// lItem = new LawItem(l);
// _lawDirItem->appendRow(lItem);
//
// HEXA_NS::Propagation *p = NULL;
// PropagationItem *pItem = NULL;
-// for ( int i=0; i<_hexaDocument->countPropagation(); ++i ){
+// int nbPropagation = _hexaDocument->countPropagation();
+// for ( int i=0; i<nbPropagation; ++i ){
// p = _hexaDocument->getPropagation(i);
// pItem = new PropagationItem(p, _entry);
// pItem->setText(QString("Propagation%1").arg(i) );
void DocumentModel::fillGroups()
{
- HEXA_NS::Group *g = NULL;
- GroupItem *gItem = NULL;
- for ( int i=0; i<_hexaDocument->countGroup(); ++i ){
- g = _hexaDocument->getGroup(i);
- //std::cout<<"getGroup => "<< i << std::endl;
- gItem = new GroupItem(g);
- gItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
- _groupDirItem->appendRow(gItem);
- }
+ HEXA_NS::Group *g = NULL;
+ GroupItem *gItem = NULL;
+ int nbGroup = _hexaDocument->countGroup();
+ for ( int i=0; i<nbGroup; ++i ){
+ g = _hexaDocument->getGroup(i);
+ //std::cout<<"getGroup => "<< i << std::endl;
+ gItem = new GroupItem(g);
+ gItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
+ _groupDirItem->appendRow(gItem);
+ }
}
void DocumentModel::fillMesh()
{
- // _lawDirItem
- HEXA_NS::Law *l = NULL;
- LawItem *lItem = NULL;
- for ( int i=0; i<_hexaDocument->countLaw(); ++i ){
- l = _hexaDocument->getLaw(i);
- lItem = new LawItem(l);
- _lawDirItem->appendRow(lItem);
- }
-
- // _propagationDirItem
- HEXA_NS::Propagation *p = NULL;
- PropagationItem *pItem = NULL;
- for ( int i=0; i<_hexaDocument->countPropagation(); ++i ){
- p = _hexaDocument->getPropagation(i);
- pItem = new PropagationItem(p);
- pItem->setText(QString("Propagation%1").arg(i) );
- pItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
- _propagationDirItem->appendRow(pItem);
- }
+ // _lawDirItem
+ HEXA_NS::Law *l = NULL;
+ LawItem *lItem = NULL;
+ int nbLaw = _hexaDocument->countLaw();
+ for ( int i=0; i<nbLaw; ++i ){
+ l = _hexaDocument->getLaw(i);
+ lItem = new LawItem(l);
+ _lawDirItem->appendRow(lItem);
+ }
+
+ // _propagationDirItem
+ HEXA_NS::Propagation *p = NULL;
+ PropagationItem *pItem = NULL;
+ int nbPropagation = _hexaDocument->countPropagation();
+ for ( int i=0; i<nbPropagation; ++i ){
+ p = _hexaDocument->getPropagation(i);
+ pItem = new PropagationItem(p);
+ pItem->setText(QString("Propagation%1").arg(i) );
+ pItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
+ _propagationDirItem->appendRow(pItem);
+ }
}
HEXA_NS::Hexa* DocumentModel::getQuadHexa(HEXA_NS::Quad* quad)
{
- HEXA_NS::Hexa* hexa;
- for ( int i=0; i<_hexaDocument->countHexa(); ++i ){
- hexa = _hexaDocument->getHexa(i);
- if (hexa->findQuad(quad) > -1) return hexa;
- }
- return NULL;
+ HEXA_NS::Hexa* hexa;
+ int nbHexa = _hexaDocument->countHexa();
+ for ( int i=0; i<nbHexa; ++i ){
+ hexa = _hexaDocument->getHexa(i);
+ if (hexa->findQuad(quad) > -1) return hexa;
+ }
+ return NULL;
}
Qt::ItemFlags DocumentModel::flags(const QModelIndex &index) const
{
- Qt::ItemFlags flags;
+ Qt::ItemFlags flags;
- if (!index.isValid()) return Qt::ItemIsEnabled;
+ if (!index.isValid()) return Qt::ItemIsEnabled;
- if ( _disallowEdition ){
- return QAbstractItemModel::flags(index) | Qt::ItemFlags( ~Qt::ItemIsEditable );
- } else {
- return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
- }
+ if ( _disallowEdition ){
+ return QAbstractItemModel::flags(index) | Qt::ItemFlags( ~Qt::ItemIsEditable );
+ } else {
+ return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
+ }
}
void DocumentModel::allowEdition()
{
- MESSAGE("DocumentModel::allowEdition(){");
- _disallowEdition = false;
- MESSAGE("}");
+ _disallowEdition = false;
}
void DocumentModel::disallowEdition()
{
- MESSAGE("DocumentModel::disallowEdition (){");
- _disallowEdition = true;
- MESSAGE("}");
+ _disallowEdition = true;
}
void DocumentModel::allowDataSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::allowVertexSelectionOnly()
_hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
_vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
_elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
_crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
_lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
_propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
-// emit layoutChanged();
+ // emit layoutChanged();
}
void DocumentModel::allowEdgeSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
-
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::allowQuadSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::allowHexaSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::allowVectorSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::allowCylinderSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::allowPipeSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::allowElementsSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
+/**********************************************************
void DocumentModel::allowCrossElementsSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
+ ********************************************************** */
void DocumentModel::allowLawSelectionOnly()
{
- _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _vertexItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _edgeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _quadItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _hexaItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _cylinderItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _pipeItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _crossElementsItemFlags = Qt::ItemFlags( Qt::ItemIsEnabled );
+ _vectorItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _elementsItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _crossElementsItemFlags = Qt::ItemFlags( Qt::ItemIsEnabled );
- _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
- _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
- _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _groupItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
+ _lawItemFlags = Qt::ItemFlags( ~Qt::ItemIsEditable );
+ _propagationItemFlags = Qt::ItemFlags( ~Qt::ItemIsEnabled );
}
void DocumentModel::setName( const QModelIndex& iElt, const QString& name )
{
- HEXA_NS::EltBase *elt = NULL;
+ HEXA_NS::EltBase *elt = NULL;
- switch ( data(iElt, HEXA_TREE_ROLE).toInt() ){
- case GROUP_TREE :
- {
- HEXA_NS::Group* grp = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Group* >();
- grp->setName( name.toLatin1().data() );
- break;
- }
- case LAW_TREE :
- {
- HEXA_NS::Law* l = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Law* >();
- l->setName( name.toLatin1().data() );
- break;
- }
- // case PROPAGATION_TREE : elt = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Propagation* >(); break;
- default: elt = getHexaPtr(iElt);
- }
+ switch ( data(iElt, HEXA_TREE_ROLE).toInt() ){
+ case GROUP_TREE :
+ {
+ HEXA_NS::Group* grp = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Group* >();
+ grp->setName( name.toLatin1().data() );
+ break;
+ }
+ case LAW_TREE :
+ {
+ HEXA_NS::Law* l = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Law* >();
+ l->setName( name.toLatin1().data() );
+ break;
+ }
+ // case PROPAGATION_TREE : elt = iElt.data( HEXA_DATA_ROLE ).value< HEXA_NS::Propagation* >(); break;
+ default: elt = getHexaPtr(iElt);
+ }
- if ( elt != NULL ) elt->setName( name.toStdString() );
- setData( iElt, name );
+ if ( elt != NULL ) elt->setName( name.toStdString() );
+ setData( iElt, name );
}
bool DocumentModel::clearEltAssociations( const QModelIndex& iElt )
{
- bool isOk = false;
- HEXA_NS::EltBase *elt = getHexaPtr(iElt);
+ bool isOk = false;
+ HEXA_NS::EltBase *elt = getHexaPtr(iElt);
+
+ if ( elt != NULL ){
+ elt->clearAssociation();
+ setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
+ isOk = true;
+ }
+
+ return isOk;
+}
+
+void DocumentModel::clearAssociation(HEXA_NS::EnumElt& eltType)
+{
+ if (_hexaDocument != NULL)
+ _hexaDocument->clearAssociation(eltType);
- if ( elt != NULL ){
- elt->clearAssociation();
- setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
- isOk = true;
- }
+ QModelIndex iElt;
+ HEXA_NS::Vertex* vertex;
+ HEXA_NS::Edge* edge;
+ HEXA_NS::Quad* quad;
+ int nbElts;
- return isOk;
+ if (HEXABLOCKGUI::currentDocGView == NULL) return;
+ PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
+ PatternDataModel* pdm = HEXABLOCKGUI::currentDocGView->getPatternDataModel();
+ if (pdsm == NULL || pdm == NULL) return;
+
+ //update associations in the model
+ if (eltType == HEXA_NS::EL_VERTEX)
+ {
+ nbElts = _hexaDocument->countVertex();
+ for (int i = 0; i < nbElts; ++i)
+ {
+ vertex = _hexaDocument->getVertex(i);
+ iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(vertex)));
+ if (iElt.isValid())
+ setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
+ }
+ }
+ else if (eltType == HEXA_NS::EL_EDGE)
+ {
+ nbElts = _hexaDocument->countEdge();
+ for (int i = 0; i < nbElts; ++i)
+ {
+ edge = _hexaDocument->getEdge(i);
+ iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(edge)));
+ if (iElt.isValid())
+ setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
+ }
+ }
+ else if (eltType == HEXA_NS::EL_QUAD)
+ {
+ nbElts = _hexaDocument->countQuad();
+ for (int i = 0; i < nbElts; ++i)
+ {
+ quad = _hexaDocument->getQuad(i);
+ iElt = pdm->mapToSource(pdsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(quad)));
+ if (iElt.isValid())
+ setData( iElt, QVariant(), HEXA_ASSOC_ENTRY_ROLE );
+ }
+ }
}
+
QModelIndex DocumentModel::addVertex( double x, double y, double z )
{
- QModelIndex vertexIndex;
+ QModelIndex vertexIndex;
+
+ HEXA_NS::Vertex* hv = _hexaDocument->addVertex(x, y, z);
+ if (BadElement(hv)) return vertexIndex;
- HEXA_NS::Vertex* hv = _hexaDocument->addVertex(x, y, z);
- if ( hv->isValid() ){
VertexItem* v = new VertexItem(hv, _entry);
_vertexDirItem->appendRow(v);
vertexIndex = v->index();
emit patternDataChanged();
- } else {
- delete hv;
- }
- return vertexIndex;
+ return vertexIndex;
}
QModelIndex DocumentModel::addEdgeVertices (const QModelIndex &i_v0, const QModelIndex &i_v1 )
{
- QModelIndex edgeIndex;
+ QModelIndex edgeIndex;
- HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
- HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
+ HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
- HEXA_NS::Edge* he = _hexaDocument->addEdge( hv0, hv1 );
+ HEXA_NS::Edge* he = _hexaDocument->addEdge( hv0, hv1 );
+ if ( BadElement(he) ) return edgeIndex;
- if ( he->isValid() ){
EdgeItem* e = new EdgeItem(he, _entry);
_edgeDirItem->appendRow(e);
edgeIndex = e->index();
emit patternDataChanged();
- } else {
- delete he;
- }
- return edgeIndex;
+
+ return edgeIndex;
}
QModelIndex DocumentModel::addEdgeVector( const QModelIndex &i_v, const QModelIndex &i_vec )
{
- QModelIndex edgeIndex;
+ QModelIndex edgeIndex;
- HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(i_v);
- HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(i_vec);
+ HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(i_v);
+ HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(i_vec);
- if (!hv || !hvec) return edgeIndex;
+ if (hv == NULL || hvec == NULL) return edgeIndex;
- HEXA_NS::Edge* he = _hexaDocument->addEdge( hv, hvec );
- if (!he) return edgeIndex;
- HEXA_NS::Vertex* hv2 = he->getAval(); //the new vertex resulting from the creation of the edge
- if (!hv2) return edgeIndex;
+ HEXA_NS::Edge* he = _hexaDocument->addEdgeVector( hv, hvec );
+ if ( BadElement(he) ) return edgeIndex;
- //ADD the elements in the treeview
- if ( he->isValid() ){
- //The Edge
+ HEXA_NS::Vertex* hv2 = he->getAval(); //the new vertex resulting from the creation of the edge
+ if (hv2 == NULL) return edgeIndex;
+
+ //ADD the edge in the treeview
EdgeItem* e = new EdgeItem(he, _entry);
_edgeDirItem->appendRow(e);
+ edgeIndex = e->index();
- //The Vertex
+ //The resulting Vertex
VertexItem* v = new VertexItem(hv2, _entry);
_vertexDirItem->appendRow(v);
- edgeIndex = e->index();
emit patternDataChanged();
- } else
- delete he;
- return edgeIndex;
+ return edgeIndex;
}
QModelIndex DocumentModel::addQuadVertices( const QModelIndex &i_v0, const QModelIndex &i_v1,
- const QModelIndex &i_v2, const QModelIndex &i_v3 )
+ const QModelIndex &i_v2, const QModelIndex &i_v3 )
{ //CS_TODO : gestion erreur
- QModelIndex quadIndex;
-
- HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
- HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
- HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(i_v2);
- HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(i_v3);
-
- if ( hv0 and hv1 and hv2 and hv3 ){
- HEXA_NS::Quad* hq = _hexaDocument->addQuadVertices( hv0, hv1, hv2, hv3 );
- if ( hq->isValid() ){
- QuadItem* q = new QuadItem(hq, _entry);
- _quadDirItem->appendRow(q);
- quadIndex = q->index();
- emit patternDataChanged();
- } else {
- delete hq;
+ QModelIndex quadIndex;
+
+ HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(i_v0);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(i_v1);
+ HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(i_v2);
+ HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(i_v3);
+
+ if ( hv0 && hv1 && hv2 && hv3 ){
+ HEXA_NS::Quad* hq = _hexaDocument->addQuadVertices( hv0, hv1, hv2, hv3 );
+ if ( BadElement(hq) ) return quadIndex;
+
+ QuadItem* q = new QuadItem(hq, _entry);
+ _quadDirItem->appendRow(q);
+ quadIndex = q->index();
+ emit patternDataChanged();
}
- }
- return quadIndex;
+
+ return quadIndex;
}
QModelIndex DocumentModel::addQuadEdges( const QModelIndex &e0, const QModelIndex &e1,
- const QModelIndex &e2, const QModelIndex &e3 )
+ const QModelIndex &e2, const QModelIndex &e3 )
{ //CS_TODO
- QModelIndex quadIndex;
-
- HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(e0);
- HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(e1);
- HEXA_NS::Edge* he2 = getHexaPtr<HEXA_NS::Edge*>(e2);
- HEXA_NS::Edge* he3 = getHexaPtr<HEXA_NS::Edge*>(e3);
-
- if ( he0 and he1 and he2 and he3 ){
- HEXA_NS::Quad* hq = _hexaDocument->addQuad( he0, he1, he2, he3 );
- if ( hq->isValid() ){
- QuadItem* q = new QuadItem(hq, _entry);
- _quadDirItem->appendRow(q);
- quadIndex = q->index();
- emit patternDataChanged();
- } else {
- delete hq;
+ QModelIndex quadIndex;
+
+ HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(e0);
+ HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(e1);
+ HEXA_NS::Edge* he2 = getHexaPtr<HEXA_NS::Edge*>(e2);
+ HEXA_NS::Edge* he3 = getHexaPtr<HEXA_NS::Edge*>(e3);
+
+ if ( he0 && he1 && he2 && he3 ){
+
+ HEXA_NS::Quad* hq = _hexaDocument->addQuad( he0, he1, he2, he3 );
+ if ( BadElement(hq) ) return quadIndex;
+
+ QuadItem* q = new QuadItem(hq, _entry);
+ _quadDirItem->appendRow(q);
+ quadIndex = q->index();
+ emit patternDataChanged();
}
- }
- return quadIndex;
+
+ return quadIndex;
}
-QModelIndex DocumentModel::addHexaVertices(
- const QModelIndex &iv0, const QModelIndex &iv1,
- const QModelIndex &iv2, const QModelIndex &iv3,
- const QModelIndex &iv4, const QModelIndex &iv5,
- const QModelIndex &iv6, const QModelIndex &iv7 )
-{
- QModelIndex iHexa;
+QModelIndex DocumentModel::addHexaVertices(
+ const QModelIndex &iv0, const QModelIndex &iv1,
+ const QModelIndex &iv2, const QModelIndex &iv3,
+ const QModelIndex &iv4, const QModelIndex &iv5,
+ const QModelIndex &iv6, const QModelIndex &iv7 )
+{
+ QModelIndex iHexa;
+
+ HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
+ HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
+ HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
+ HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
+ HEXA_NS::Vertex* hv5 = getHexaPtr<HEXA_NS::Vertex*>(iv5);
+ HEXA_NS::Vertex* hv6 = getHexaPtr<HEXA_NS::Vertex*>(iv6);
+ HEXA_NS::Vertex* hv7 = getHexaPtr<HEXA_NS::Vertex*>(iv7);
- HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
- HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
- HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
- HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
- HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
- HEXA_NS::Vertex* hv5 = getHexaPtr<HEXA_NS::Vertex*>(iv5);
- HEXA_NS::Vertex* hv6 = getHexaPtr<HEXA_NS::Vertex*>(iv6);
- HEXA_NS::Vertex* hv7 = getHexaPtr<HEXA_NS::Vertex*>(iv7);
+ HEXA_NS::Hexa* hh = _hexaDocument->addHexaVertices( hv0, hv1, hv2, hv3,
+ hv4, hv5, hv6, hv7 );
- HEXA_NS::Hexa* hh = _hexaDocument->addHexaVertices( hv0, hv1, hv2, hv3,
- hv4, hv5, hv6, hv7 );
+ if ( BadElement(hh) ) return iHexa;
- if ( hh->isValid() ){
HexaItem* h = new HexaItem(hh, _entry);
_hexaDirItem->appendRow(h);
iHexa = h->index();
emit patternDataChanged();
- } else {
- delete hh;
- }
- return iHexa;
+ return iHexa;
}
QModelIndex DocumentModel::addHexaQuad( const QModelIndex &i_q0, const QModelIndex &i_q1,
- const QModelIndex &i_q2,const QModelIndex &i_q3, const QModelIndex &i_q4, const QModelIndex &i_q5 )
+ const QModelIndex &i_q2,const QModelIndex &i_q3, const QModelIndex &i_q4, const QModelIndex &i_q5 )
{ //CS_TODO : gestion erreur
- QModelIndex hexaIndex;
+ QModelIndex hexaIndex;
- HEXA_NS::Quad* hq0 = getHexaPtr<HEXA_NS::Quad*>(i_q0);
- HEXA_NS::Quad* hq1 = getHexaPtr<HEXA_NS::Quad*>(i_q1);
- HEXA_NS::Quad* hq2 = getHexaPtr<HEXA_NS::Quad*>(i_q2);
- HEXA_NS::Quad* hq3 = getHexaPtr<HEXA_NS::Quad*>(i_q3);
- HEXA_NS::Quad* hq4 = getHexaPtr<HEXA_NS::Quad*>(i_q4);
- HEXA_NS::Quad* hq5 = getHexaPtr<HEXA_NS::Quad*>(i_q5);
+ HEXA_NS::Quad* hq0 = getHexaPtr<HEXA_NS::Quad*>(i_q0);
+ HEXA_NS::Quad* hq1 = getHexaPtr<HEXA_NS::Quad*>(i_q1);
+ HEXA_NS::Quad* hq2 = getHexaPtr<HEXA_NS::Quad*>(i_q2);
+ HEXA_NS::Quad* hq3 = getHexaPtr<HEXA_NS::Quad*>(i_q3);
+ HEXA_NS::Quad* hq4 = getHexaPtr<HEXA_NS::Quad*>(i_q4);
+ HEXA_NS::Quad* hq5 = getHexaPtr<HEXA_NS::Quad*>(i_q5);
- HEXA_NS::Hexa* hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
+ HEXA_NS::Hexa* hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
+ if ( BadElement(hh) ) return hexaIndex;
- if ( hh->isValid() ){
HexaItem* h = new HexaItem(hh, _entry);
_hexaDirItem->appendRow(h);
hexaIndex = h->index();
emit patternDataChanged();
- } else
- delete hh;
- return hexaIndex;
+ return hexaIndex;
}
QModelIndex DocumentModel::addHexaQuads( const QModelIndexList &iquads)
-{
- QModelIndex hexaIndex;
-
- HEXA_NS::Hexa* hh = NULL;
- HEXA_NS::Quad* hq0, *hq1, *hq2, *hq3, *hq4, *hq5 = NULL;
-
- hq0 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(0));
- hq1 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(1));
- hq2 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(2));
- hq3 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(3));
- hq4 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(4));
- hq5 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(5));
-
- if ( hq0 && hq1 && hq2 && hq3 && hq4 && hq5 )
- hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
- else if ( hq0 && hq1 && hq2 && hq3 && hq4 )
- hh = _hexaDocument->addHexa5Quads( hq0, hq1, hq2, hq3, hq4 );
- else if ( hq0 && hq1 && hq2 && hq3 )
- hh = _hexaDocument->addHexa4Quads( hq0, hq1, hq2, hq3 );
- else if ( hq0 && hq1 && hq2)
- hh = _hexaDocument->addHexa3Quads( hq0, hq1, hq2 );
- else if ( hq0 && hq1 )
- hh = _hexaDocument->addHexa2Quads( hq0, hq1);
-
- if ( hh && hh->isValid() ){
- updateData();
- unsigned int nbRows = _hexaDirItem->rowCount();
- if (nbRows > 0)
- hexaIndex = _hexaDirItem->child(nbRows-1)->index();
- } else
- delete hh;
-
- return hexaIndex;
-}
-
-// Vector addVector( in double dx, in double dy, in double dz )
-// raises (SALOME::SALOME_Exception);
+{
+ QModelIndex hexaIndex;
+
+ HEXA_NS::Hexa* hh = NULL;
+ HEXA_NS::Quad* hq0, *hq1, *hq2, *hq3, *hq4, *hq5 = NULL;
+
+ hq0 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(0));
+ hq1 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(1));
+ hq2 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(2));
+ hq3 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(3));
+ hq4 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(4));
+ hq5 = getHexaPtr<HEXA_NS::Quad*>(iquads.value(5));
+
+ if ( hq0 && hq1 && hq2 && hq3 && hq4 && hq5 )
+ hh = _hexaDocument->addHexa( hq0, hq1, hq2, hq3, hq4, hq5 );
+ else if ( hq0 && hq1 && hq2 && hq3 && hq4 )
+ hh = _hexaDocument->addHexa5Quads( hq0, hq1, hq2, hq3, hq4 );
+ else if ( hq0 && hq1 && hq2 && hq3 )
+ hh = _hexaDocument->addHexa4Quads( hq0, hq1, hq2, hq3 );
+ else if ( hq0 && hq1 && hq2)
+ hh = _hexaDocument->addHexa3Quads( hq0, hq1, hq2 );
+ else if ( hq0 && hq1 )
+ hh = _hexaDocument->addHexa2Quads( hq0, hq1);
+
+ if ( BadElement(hh) ) return hexaIndex;
+
+ updateData();
+ unsigned int nbRows = _hexaDirItem->rowCount();
+ if (nbRows > 0)
+ hexaIndex = _hexaDirItem->child(nbRows-1)->index();
+
+ return hexaIndex;
+}
+
QModelIndex DocumentModel::addVector( double dx, double dy, double dz )
{
- QModelIndex vectorIndex;
+ QModelIndex vectorIndex;
- HEXA_NS::Vector* hv = _hexaDocument->addVector(dx, dy, dz);
+ HEXA_NS::Vector* hv = _hexaDocument->addVector(dx, dy, dz);
+ if ( BadElement(hv) ) return vectorIndex; //Invalid index
- if ( hv->isValid() ){
VectorItem* v = new VectorItem(hv);
_vectorDirItem->appendRow(v);
vectorIndex = v->index();
- } else
- delete hv;
-
- return vectorIndex;
+ return vectorIndex;
}
QModelIndex DocumentModel::addVectorVertices( const QModelIndex &iv0, const QModelIndex &iv1 )
{
- QModelIndex iVec;
+ QModelIndex iVec;
- HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
- HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
+ HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
- HEXA_NS::Vector* hvec = _hexaDocument->addVectorVertices( hv0, hv1 );
+ HEXA_NS::Vector* hvec = _hexaDocument->addVectorVertices( hv0, hv1 );
+ if ( BadElement(hvec) ) return iVec;
- if ( hvec->isValid() ){
VectorItem* vec = new VectorItem(hvec);
_vectorDirItem->appendRow(vec);
iVec = vec->index();
- } else {
- delete hvec;
- }
- return iVec;
+ return iVec;
}
-QModelIndex DocumentModel::addCylinder( const QModelIndex &iv, const QModelIndex &ivec, double r, double h )
-{
- QModelIndex iCyl;
- HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(iv);
- HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+// ************ EDIT HEXABLOCK MODEL ************
+
+bool DocumentModel::updateVertex( const QModelIndex& ivertex, double x, double y, double z )
+{
+ bool ret = false;
- HEXA_NS::Cylinder* hcyl = _hexaDocument->addCylinder( hv, hvec, r, h );
+ HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
- if ( hcyl->isValid() ){
- CylinderItem* cyl = new CylinderItem(hcyl);
- _cylinderDirItem->appendRow(cyl);
- iCyl = cyl->index();
- } else {
- delete hcyl;
- }
+ if ( hVertex ){
+// hVertex->setName( name.toStdString() );
+ hVertex->setX ( x );
+ hVertex->setY ( y );
+ hVertex->setZ ( z );
+ emit patternDataChanged();
+ ret = true;
+ }
- return iCyl;
+ return ret;
}
-QModelIndex DocumentModel::addPipe( const QModelIndex &iv, const QModelIndex &ivec, double ri, double re, double h )
+bool DocumentModel::removeHexa( const QModelIndex& ihexa )
{
- QModelIndex iPipe;
-
- HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(iv);
- HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
- HEXA_NS::Pipe* hPipe = _hexaDocument->addPipe( hv, hvec, ri, re, h );
-
- if ( hPipe->isValid() ){
- PipeItem* pipe = new PipeItem(hPipe);
- _pipeDirItem->appendRow(pipe);
- iPipe = pipe->index();
- } else {
- delete hPipe;
- }
+ int r = _hexaDocument->removeHexa( hHexa );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
- return iPipe;
+ return false;
}
-QModelIndex DocumentModel::makeCartesian( const QModelIndex& i_pt,
- const QModelIndex& i_vec_x, const QModelIndex& i_vec_y, const QModelIndex& i_vec_z,
- long nx, long ny, long nz)
+bool DocumentModel::removeConnectedHexa( const QModelIndex& ihexa )
{
- QModelIndex eltsIndex;
- //std::cout<<"makeCartesian begin"<<std::endl;
+ HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
+
+ int r = _hexaDocument->removeConnectedHexa( hHexa );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
- HEXA_NS::Vertex* hpt = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
- HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
- HEXA_NS::Vector* hvec_y = getHexaPtr<HEXA_NS::Vector*>(i_vec_y);
- HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
+ return false;
+}
- HEXA_NS::Elements* new_helts = _hexaDocument->makeCartesian( hpt,
- hvec_x, hvec_y, hvec_z,
- nx, ny, nz );
+bool DocumentModel::mergeVertices( const QModelIndex &iv0, const QModelIndex &iv1 ) //CS_TODO : impact sur le model?
+{
+ HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
- if ( new_helts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(new_helts);
- _elementsDirItem->appendRow(eltsItem);
- eltsIndex = eltsItem->index();
- } else
- delete new_helts;
+ int r = _hexaDocument->mergeVertices( hv0, hv1 );
+ if ( r == HOK ){
+ updateData(); //CS_TODO more or less?
+ return true;
+ }
- return eltsIndex;
+ return false;
}
-QModelIndex DocumentModel::makeCartesian( const QModelIndex& ivex,
- const QModelIndex& ivec,
- int nx, int ny, int nz )
+bool DocumentModel::mergeEdges( const QModelIndex &ie0, const QModelIndex &ie1,
+ const QModelIndex &iv0, const QModelIndex &iv1 )
+//CS_TODO : impact sur le model?
{
- QModelIndex iElts;
+ HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(ie0);
+ HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(ie1);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
- HEXA_NS::Elements* hElts = _hexaDocument->makeCartesian( hVex,
- hVec,
- nx, ny, nz );
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
+ //Merge
+ int r = _hexaDocument->mergeEdges( he0, he1, hv0, hv1 );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
- return iElts;
+ return false;
}
-// Elements makeCylindrical( in Vertex pt,
-// in Vector vex, in Vector vez,
-// in double dr, in double da, in double dl,
-// in long nr, in long na, in long nl,
-// in boolean fill )
-// raises (SALOME::SALOME_Exception);
-QModelIndex DocumentModel::makeCylindrical( const QModelIndex& i_pt,
- const QModelIndex& i_vec_x, const QModelIndex& i_vec_z,
- double dr, double da, double dl,
- long nr, long na, long nl,
- bool fill )
+bool DocumentModel::mergeQuads( const QModelIndex& iquad0, const QModelIndex& iquad1,
+ const QModelIndex& iv0, const QModelIndex& iv1,
+ const QModelIndex& iv2, const QModelIndex& iv3 )
{
+ HEXA_NS::Quad* hquad0 = data(iquad0, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
+ HEXA_NS::Quad* hquad1 = data(iquad1, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
- QModelIndex eltsIndex;
-
- HEXA_NS::Vertex* hpt = getHexaPtr<HEXA_NS::Vertex*>(i_pt);
- HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(i_vec_x);
- HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(i_vec_z);
-
- HEXA_NS::Elements* new_helts = _hexaDocument->makeCylindrical( hpt, hvec_x, hvec_z, dr, da, dl, nr, na, nl, fill );
+ HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
+ HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
+ HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
- if ( new_helts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(new_helts);
- _elementsDirItem->appendRow(eltsItem);
- eltsIndex = eltsItem->index();
- } else {
- delete new_helts;
- }
+ int r = _hexaDocument->mergeQuads( hquad0, hquad1, hv0, hv1, hv2, hv3 );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
- return eltsIndex;
+ return false;
}
-QModelIndex DocumentModel::makeCylindricals(
- const QModelIndex& icenter, const QModelIndex& ibase, const QModelIndex& iheight,
- QList< double> radius, QList<double> angles, QList<double> heights,
- bool fill ) //HEXA3
+//
+QModelIndex DocumentModel::disconnectVertex( const QModelIndex& ihexa, const QModelIndex& ivertex )
{
- QModelIndex eltsIndex;
+ QModelIndex iElts;
- HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
- HEXA_NS::Vector* hbase =getHexaPtr<HEXA_NS::Vector*>(ibase);
- HEXA_NS::Vector* hheight = getHexaPtr<HEXA_NS::Vector*>(iheight);
+ HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
+ HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
-// HEXA_NS::Elements* helts;
- std::vector<double> r = radius.toVector().toStdVector();
- std::vector<double> a = angles.toVector().toStdVector();
- std::vector<double> h = heights.toVector().toStdVector();
+ HEXA_NS::Elements* hElts = _hexaDocument->disconnectVertex( hHexa, hVertex );
+ if ( BadElement(hElts) ) return iElts;
- HEXA_NS::Elements* helts = _hexaDocument->makeCylindricals(
- hcenter, hbase, hheight,
- r, a, h,
- fill );
+ updateData(); //CS_TO_CHECK
+ ElementsItem* elts = new ElementsItem(hElts);
+ _elementsDirItem->appendRow(elts);
+ iElts = elts->index();
- if ( helts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(helts);
- _elementsDirItem->appendRow(eltsItem);
- eltsIndex = eltsItem->index();
- } else {
- delete helts;
- }
- return eltsIndex;
+ return iElts;
}
-QModelIndex DocumentModel::makeSpherical( const QModelIndex& iv, const QModelIndex& ivec, int nb, double k)
+QModelIndex DocumentModel::disconnectEdge( const QModelIndex& ihexa, const QModelIndex& iedge )
{
- QModelIndex iElts;
+ QModelIndex iElts;
- HEXA_NS::Vertex* hv = getHexaPtr<HEXA_NS::Vertex*>(iv);
- HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
+ HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge*>(iedge);
- HEXA_NS::Elements* hElts = _hexaDocument->makeSpherical( hv, hvec, nb, k );
+ HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdge( hHexa, hEdge );
+ if ( BadElement(hElts) ) return iElts;
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
+ updateData(); //CS_TO_CHECK
ElementsItem* elts = new ElementsItem(hElts);
_elementsDirItem->appendRow(elts);
iElts = elts->index();
- } else {
- delete hElts;
- }
- return iElts;
+ return iElts;
}
-QModelIndex DocumentModel::makeSpherical( const QModelIndex& icenter, double radius, int nb, double k )
-{
- QModelIndex iElts;
- HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+QModelIndex DocumentModel::disconnectEdges( const QModelIndexList& ihexas, const QModelIndexList& iedges )
+{
+ QModelIndex iElts;
- HEXA_NS::Elements* helts = _hexaDocument->makeSpherical( hcenter, radius, nb, k );
+ HEXA_NS::Hexas hHexas;
+ HEXA_NS::Edges hEdges;
- if ( helts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(helts);
- _elementsDirItem->appendRow(eltsItem);
- iElts = eltsItem->index();
- } else {
- delete helts;
- }
+ //edges list
+ HEXA_NS::Edge* hedge = NULL;
+ foreach( const QModelIndex& iedge, iedges ){
+ hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
+ hEdges.push_back( hedge );
+ }
- return iElts;
-}
+ //hexas list
+ HEXA_NS::Hexa* hhexa = NULL;
+ foreach( const QModelIndex& ihexa, ihexas ){
+ hhexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
+ hHexas.push_back( hhexa );
+ }
-QModelIndex DocumentModel::makeCylinder( const QModelIndex& icyl, const QModelIndex& ivec,
- int nr, int na, int nl )
-{
- QModelIndex iElts;
- HEXA_NS::Cylinder* hcyl = getHexaPtr<HEXA_NS::Cylinder*>(icyl);
- HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdges( hHexas, hEdges );
+ if ( BadElement(hElts) ) return iElts;
- HEXA_NS::Elements* hElts = _hexaDocument->makeCylinder( hcyl, hvec, nr, na, nl );
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
+ updateData(); //CS_TO_CHECK
ElementsItem* elts = new ElementsItem(hElts);
_elementsDirItem->appendRow(elts);
iElts = elts->index();
- } else {
- delete hElts;
- }
- return iElts;
+ return iElts;
}
-QModelIndex DocumentModel::makePipe( const QModelIndex& ipipe, const QModelIndex& ivecx,
- int nr, int na, int nl )
-{
- QModelIndex iElts;
- HEXA_NS::Pipe* hPipe = getHexaPtr<HEXA_NS::Pipe*>(ipipe);
- HEXA_NS::Vector* hVecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
+QModelIndex DocumentModel::disconnectQuad( const QModelIndex& ihexa, const QModelIndex& iquad )
+{
+ QModelIndex iElts;
+
+ HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
+ HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
- HEXA_NS::Elements* hElts = _hexaDocument->makePipe( hPipe, hVecx, nr, na, nl );
+ HEXA_NS::Elements* hElts = _hexaDocument->disconnectQuad( hHexa, hQuad );
+ if ( BadElement(hElts) ) return iElts;
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
+ updateData(); //CS_TO_CHECK
ElementsItem* elts = new ElementsItem(hElts);
_elementsDirItem->appendRow(elts);
iElts = elts->index();
- } else {
- delete hElts;
- }
- return iElts;
+ return iElts;
}
-QModelIndex DocumentModel::makeCylinders(const QModelIndex& icyl1, const QModelIndex& icyl2)
-{ //CS_TODO
- QModelIndex iCrossElts;
-
- HEXA_NS::Cylinder* hCyl1 = getHexaPtr<HEXA_NS::Cylinder*>(icyl1);
- HEXA_NS::Cylinder* hCyl2 = getHexaPtr<HEXA_NS::Cylinder*>(icyl2);
-
- HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makeCylinders( hCyl1, hCyl2 );
-
- if ( hCrossElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* crossElts = new ElementsItem(hCrossElts);
- _crossElementsDirItem->appendRow(crossElts);
- iCrossElts = crossElts->index();
- } else {
- delete hCrossElts;
- }
-
- return iCrossElts;
-}
-//
-QModelIndex DocumentModel::makePipes( const QModelIndex& ipipe1, const QModelIndex& ipipe2 )
-{
- QModelIndex iCrossElts;
-
- HEXA_NS::Pipe* hPipe1 = getHexaPtr<HEXA_NS::Pipe*>(ipipe1);
- HEXA_NS::Pipe* hPipe2 = getHexaPtr<HEXA_NS::Pipe*>(ipipe2);
-
- HEXA_NS::CrossElements* hCrossElts = _hexaDocument->makePipes( hPipe1, hPipe2 );
-
- if ( hCrossElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* crossElts = new ElementsItem(hCrossElts);
- _crossElementsDirItem->appendRow(crossElts);
- iCrossElts = crossElts->index();
- QString tmp = "/tmp/makePipes.vtk";
- _hexaDocument->saveVtk( tmp.toLocal8Bit().constData() );
- } else {
- delete hCrossElts;
- }
-
- return iCrossElts;
-}
-
-QModelIndex DocumentModel::makeRind( const QModelIndex& icenter,
- const QModelIndex& ivecx, const QModelIndex& ivecz,
- double radext, double radint, double radhole,
- const QModelIndex& iplorig,
- int nrad, int nang, int nhaut )
-{
- QModelIndex iElts;
-
- HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
- HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
- HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
-
- HEXA_NS::Elements* hElts = _hexaDocument->makeRind( hcenter,
- hvecx, hvecz,
- radext, radint, radhole,
- hplorig,
- nrad, nang, nhaut );
-
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(hElts);
+QModelIndex DocumentModel::makeTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
+{
+ QModelIndex iElts;
+
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+
+ HEXA_NS::Elements* hNewElts = _hexaDocument->makeTranslation( hElts, hVec );
+ if ( BadElement(hNewElts) ) return iElts;
+
+ updateData(); //CS_TODO more or less?
+ ElementsItem* eltsItem = new ElementsItem(hNewElts);
_elementsDirItem->appendRow(eltsItem);
iElts = eltsItem->index();
- } else {
- delete hElts;
- }
- return iElts;
+ return iElts;
}
-QModelIndex DocumentModel::makePartRind( const QModelIndex& icenter,
- const QModelIndex& ivecx, const QModelIndex& ivecz,
- double radext, double radint, double radhole,
- const QModelIndex& iplorig, double angle,
- int nrad, int nang, int nhaut )
+
+
+QModelIndex DocumentModel::makeScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
{
- QModelIndex iElts;
+ QModelIndex iElts;
- HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
- HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
- HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
- HEXA_NS::Elements* hElts = _hexaDocument->makePartRind( hcenter,
- hvecx, hvecz,
- radext, radint, radhole,
- hplorig, angle,
- nrad, nang, nhaut );
+ HEXA_NS::Elements* hNewElts = _hexaDocument->makeScale( hElts, hVex, k );
+ if ( BadElement(hNewElts) ) return iElts;
- if ( hElts->isValid() ){
- updateData();
- ElementsItem* eltsItem = new ElementsItem(hElts);
+ updateData(); //CS_TODO more or less?
+ ElementsItem* eltsItem = new ElementsItem(hNewElts);
_elementsDirItem->appendRow(eltsItem);
iElts = eltsItem->index();
- } else {
- delete hElts;
- }
- return iElts;
+ return iElts;
}
-QModelIndex DocumentModel::makeSphere( const QModelIndex& icenter,
- const QModelIndex& ivecx, const QModelIndex& ivecz,
- double radius, double radhole,
- const QModelIndex& iplorig,
- int nrad, int nang, int nhaut )
+QModelIndex DocumentModel::makeRotation( const QModelIndex& ielts,
+ const QModelIndex& iv,
+ const QModelIndex& ivec, double angle )
{
- QModelIndex iElts;
+ QModelIndex iElts;
- HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
- HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
- HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
- HEXA_NS::Elements* hElts = _hexaDocument->makeSphere( hcenter,
- hvecx, hvecz,
- radius, radhole,
- hplorig,
- nrad, nang, nhaut);
+ HEXA_NS::Elements* hNewElts = _hexaDocument->makeRotation( hElts, hVex, hVec, angle );
+ if ( BadElement(hNewElts) ) return iElts;
- if ( hElts->isValid() ){
- updateData();
- ElementsItem* eltsItem = new ElementsItem(hElts);
+ updateData(); //CS_TODO more or less?
+ ElementsItem* eltsItem = new ElementsItem(hNewElts);
_elementsDirItem->appendRow(eltsItem);
iElts = eltsItem->index();
- } else {
- delete hElts;
- }
- return iElts;
+ return iElts;
}
-QModelIndex DocumentModel::makePartSphere( const QModelIndex& icenter,
- const QModelIndex& ivecx, const QModelIndex& ivecz,
- double radius, double radhole,
- const QModelIndex& iplorig, double angle,
- int nrad, int nang, int nhaut )
+
+QModelIndex DocumentModel::makeSymmetryPoint( const QModelIndex& ielts, const QModelIndex& iv )
{
- QModelIndex iElts;
+ QModelIndex iElts;
- HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
- HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
- HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- HEXA_NS::Vertex* hplorig = getHexaPtr<HEXA_NS::Vertex*>(iplorig);
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
- HEXA_NS::Elements* hElts = _hexaDocument->makePartSphere( hcenter,
- hvecx, hvecz,
- radius, radhole,
- hplorig, angle,
- nrad, nang, nhaut);
+ HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPoint (hElts, hVex);
+ if ( BadElement(hNewElts) ) return iElts;
- if ( hElts->isValid() ){
- updateData();
- ElementsItem* eltsItem = new ElementsItem(hElts);
+ updateData(); //CS_TODO more or less?
+ ElementsItem* eltsItem = new ElementsItem(hNewElts);
_elementsDirItem->appendRow(eltsItem);
iElts = eltsItem->index();
- } else {
- delete hElts;
- }
- return iElts;
+ return iElts;
}
-// ************ EDIT HEXABLOCK MODEL ************
-bool DocumentModel::updateVertex( const QModelIndex& ivertex, double x, double y, double z )
+QModelIndex DocumentModel::makeSymmetryLine( const QModelIndex& ielts,
+ const QModelIndex& iv,
+ const QModelIndex& ivec )
{
- bool ret = false;
+ QModelIndex iElts;
- //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?
- HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
- if ( hVertex ){
-// hVertex->setName( name.toStdString() );
- hVertex->setX ( x );
- hVertex->setY ( y );
- hVertex->setZ ( z );
- emit patternDataChanged();
- ret = true;
- }
- return ret;
+ HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryLine( hElts, hVex, hVec );
+ if ( BadElement(hNewElts) ) return iElts;
+
+ updateData(); //CS_TODO more or less?
+ ElementsItem* eltsItem = new ElementsItem(hNewElts);
+ _elementsDirItem->appendRow(eltsItem);
+ iElts = eltsItem->index();
+
+ return iElts;
}
-bool DocumentModel::removeHexa( const QModelIndex& ihexa )
+
+QModelIndex DocumentModel::makeSymmetryPlane( const QModelIndex& ielts, const QModelIndex& iv, const QModelIndex& ivec )
{
- bool ret = false;
- HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
+ QModelIndex iElts;
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
- int r = _hexaDocument->removeHexa( hHexa );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
-
- return ret;
+ HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPlane( hElts, hVex, hVec );
+ if ( BadElement(hNewElts) ) return iElts;
+
+ updateData(); //CS_TODO more or less?
+ ElementsItem* eltsItem = new ElementsItem(hNewElts);
+ _elementsDirItem->appendRow(eltsItem);
+ iElts = eltsItem->index();
+
+ return iElts;
}
-bool DocumentModel::removeConnectedHexa( const QModelIndex& ihexa )
+
+bool DocumentModel::performTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
+{
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+
+ int r = _hexaDocument->performTranslation (hElts, hVec);
+ if ( r == HOK ){ //Job well done?
+ updateData();
+ return true;
+ }
+
+ return false;
+}
+
+
+//
+bool DocumentModel::performScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
+{
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+
+ int r = _hexaDocument->performScale (hElts, hVex, k);
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
+
+ return false;
+}
+
+//
+bool DocumentModel::performRotation( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec, double angle )
+{
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+
+ int r = _hexaDocument-> performRotation( hElts, hVex, hVec, angle );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
+
+ return false;
+}
+
+
+//
+bool DocumentModel::performSymmetryPoint( const QModelIndex& ielts, const QModelIndex& ivex )
+{
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+
+ int r = _hexaDocument->performSymmetryPoint( hElts, hVex );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
+
+ return false;
+}
+
+
+bool DocumentModel::performSymmetryLine( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec )
+{
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+
+ int r = _hexaDocument->performSymmetryLine( hElts, hVex, hVec );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
+
+ return false;
+}
+
+
+bool DocumentModel::performSymmetryPlane( const QModelIndex& ielts,
+ const QModelIndex& ivex,
+ const QModelIndex& ivec )
+{
+ HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
+ HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+ HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+
+ int r = _hexaDocument->performSymmetryPlane( hElts, hVex, hVec );
+ if ( r == HOK ){
+ updateData();
+ return true;
+ }
+
+ return false;
+}
+
+QModelIndex DocumentModel::replace( const QModelIndexList& iquads_source,
+ const QModelIndexList& iquads_dest,
+ const QModelIndex& ip1_source, const QModelIndex& ic1_dest,
+ const QModelIndex& ip2_source, const QModelIndex& ic2_dest)
{
- bool ret = false;
- HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
-
- int r = _hexaDocument->removeConnectedHexa( hHexa );
-
- if ( r == HOK ){
+ QModelIndex ielts;
+
+ HEXA_NS::Vertex* hp1 = getHexaPtr<HEXA_NS::Vertex*>(ip1_source);
+ HEXA_NS::Vertex* hp2 = getHexaPtr<HEXA_NS::Vertex*>(ip2_source);
+ HEXA_NS::Vertex* hc1 = getHexaPtr<HEXA_NS::Vertex*>(ic1_dest);
+ HEXA_NS::Vertex* hc2 = getHexaPtr<HEXA_NS::Vertex*>(ic2_dest);
+
+ HEXA_NS::Quads hquads_source, hquads_dest;
+ HEXA_NS::Quad* hquad = NULL;
+ foreach( const QModelIndex& iquad, iquads_source ){
+ hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
+ hquads_source.push_back( hquad );
+ }
+
+ foreach( const QModelIndex& iquad, iquads_dest) {
+ hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
+ hquads_dest.push_back(hquad);
+ }
+
+ HEXA_NS::Elements* helts = _hexaDocument->replace( hquads_source,
+ hquads_dest,
+ hp1, hc1, hp2, hc2);
+ if ( BadElement(helts) )
+ return ielts;
+
updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
-
- return ret;
+ ElementsItem* eltsItem = new ElementsItem(helts);
+ _elementsDirItem->appendRow(eltsItem);
+ ielts = eltsItem->index();
+
+ return ielts;
+}
+
+QModelIndex DocumentModel::getGeomModelIndex(QString& id) const
+{
+ QModelIndex result;
+ PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
+
+ // ** get the model index of the geom element having this ID
+ HEXA_NS::SubShape* eltPtr = getGeomPtr(id);
+ HEXA_NS::VertexShape* geomVertex = dynamic_cast<HEXA_NS::VertexShape*>(eltPtr);
+ HEXA_NS::EdgeShape* geomEdge = dynamic_cast<HEXA_NS::EdgeShape*>(eltPtr);
+ HEXA_NS::FaceShape* geomFace = dynamic_cast<HEXA_NS::FaceShape*>(eltPtr);
+ if (geomVertex != NULL)
+ result = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomVertex));
+ if (geomEdge != NULL)
+ result = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomEdge));
+ if (geomFace != NULL)
+ result = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomFace));
+
+ return result;
+}
+
+QMultiMap< QString, int > DocumentModel::getAssocShapesIds(const QModelIndex& dataIndex)
+{
+ QMultiMap< QString, int > result;
+ HEXA_NS::NewShape* mainShape;
+ HEXA_NS::VertexShape* node;
+ HEXA_NS::EdgeShape* line;
+ HEXA_NS::FaceShape* face;
+ QString shapeName;
+ int subid;
+
+ PatternDataSelectionModel* pdsm = HEXABLOCKGUI::currentDocGView->getPatternDataSelectionModel();
+ QModelIndexList assocsInd = pdsm->getGeomAssociations(dataIndex);
+ foreach( const QModelIndex& anAssoc, assocsInd )
+ {
+ node = getHexaPtr<HEXA_NS::VertexShape*>(anAssoc);
+ line = getHexaPtr<HEXA_NS::EdgeShape*>(anAssoc);
+ face = getHexaPtr<HEXA_NS::FaceShape*>(anAssoc);
+
+ if (node != NULL)
+ {
+ mainShape = node->getParentShape();
+ if (mainShape != NULL)
+ {
+ shapeName = mainShape->getName();
+ subid = node->getIdent();
+ }
+ }
+ else if (line != NULL)
+ {
+ mainShape = line->getParentShape();
+ if (mainShape != NULL)
+ {
+ shapeName = mainShape->getName();
+ subid = line->getIdent();
+ }
+ }
+ else if (face != NULL)
+ {
+ mainShape = face->getParentShape();
+ if (mainShape != NULL)
+ {
+ shapeName = mainShape->getName();
+ subid = face->getIdent();
+ }
+ }
+
+ if (!shapeName.isEmpty())
+ result.insert( shapeName, subid );
+
+ shapeName = QString();
+ }
+ return result;
+}
+
+bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, double x, double y, double z)
+{
+ HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
+
+ if (vertex == NULL || _hexaDocument == NULL || vertex->setAssociation(x, y, z) != HOK)
+ return false;
+
+ HEXA_NS::VertexShape* assoc = vertex->getAssociation();
+ if (assoc != NULL)
+ {
+ HEXA_NS::NewShape* mainSh = assoc->getParentShape();
+ setData( iVertex, QVariant::fromValue(QString(mainSh->getName())+","+QString::number(assoc->getIdent())+";"), HEXA_ASSOC_ENTRY_ROLE );
+ }
+
+ return true;
}
-QModelIndex DocumentModel::prismQuad( const QModelIndex& iquad, const QModelIndex& ivec, int nb)
-{
- QModelIndex iElts;
+bool DocumentModel::setVertexAssociation( const QModelIndex& iVertex, const QModelIndex& iGeomVertex)
+{
+ //parameters control
+ QString newAssoc;
+ HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex *>(iVertex);
+ HEXA_NS::VertexShape* geomVertex = getHexaPtr<HEXA_NS::VertexShape*>(iGeomVertex);
+ if (_hexaDocument == NULL || vertex == NULL || geomVertex == NULL) return false;
+ HEXA_NS::NewShape* mainShape = geomVertex->getParentShape();
+ if (mainShape == NULL) return false;
- HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
- HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ //add association
+ if (vertex->setAssociation(geomVertex) != HOK)
+ return false;
- HEXA_NS::Elements* hElts = _hexaDocument->prismQuad( hQuad, hVect, nb );
+ //update association state in the model
+ newAssoc = QString(mainShape->getName()) + "," + QString::number(geomVertex->getIdent()) + ";";
+ setData( iVertex, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
+ return true;
+}
- return iElts;
+bool DocumentModel::addEdgeAssociation( const QModelIndex& iEdge, const QModelIndex& iGeomEdge, double start, double end)
+{
+ //parameters control
+ QString currentAssoc, newAssoc;
+ HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
+ HEXA_NS::EdgeShape* geomEdge = getHexaPtr<HEXA_NS::EdgeShape*>(iGeomEdge);
+ if (_hexaDocument == NULL || edge == NULL ||
+ geomEdge == NULL || start > end) return false;
+ HEXA_NS::NewShape* mainShape = geomEdge->getParentShape();
+ if (mainShape == NULL) return false;
+
+ //add association in the engine side
+ if (edge->addAssociation(geomEdge, start, end) != HOK)
+ return false;
+
+ //add/update association in the model side (UI)
+ currentAssoc = data(iEdge, HEXA_ASSOC_ENTRY_ROLE).toString();
+ newAssoc = QString(mainShape->getName()) + "," + QString::number(geomEdge->getIdent()) + ";";
+ if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
+
+ setData( iEdge, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
+
+ return true;
}
-QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, int nb)
+
+bool DocumentModel::addQuadAssociation (const QModelIndex& iQuad, const QModelIndex& iGeomFace)
{
- QModelIndex iElts;
+ //parameters control
+ QString currentAssoc, newAssoc;
+ HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
+ HEXA_NS::FaceShape* geomFace = getHexaPtr<HEXA_NS::FaceShape*>(iGeomFace);
+ if (_hexaDocument == NULL || quad == NULL || geomFace == NULL)
+ return false;
+ HEXA_NS::NewShape* mainShape = geomFace->getParentShape();
+ if (mainShape == NULL) return false;
- HEXA_NS::Quads hQuads;
- HEXA_NS::Quad* hQuad = NULL;
- foreach( const QModelIndex& iquad, iquads ){
- hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
- hQuads.push_back( hQuad );
- }
- HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ //add association
+ if (quad->addAssociation(geomFace) != HOK)
+ return false;
- HEXA_NS::Elements* hElts = _hexaDocument->prismQuads( hQuads, hVect, nb );
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
- return iElts;
+ //update association
+ currentAssoc = data( iQuad, HEXA_ASSOC_ENTRY_ROLE).toString();
+ newAssoc = QString(mainShape->getName()) + "," + QString::number(geomFace->getIdent()) + ";";
+ if (!currentAssoc.isEmpty()) newAssoc = currentAssoc + newAssoc;
+ setData( iQuad, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
+
+ return true;
+}
+
+
+QModelIndex DocumentModel::getVertexAssociation(const QModelIndex& iVertex)
+{
+ HEXA_NS::Vertex* vertex = getHexaPtr<HEXA_NS::Vertex*>(iVertex);
+ if (vertex == NULL)
+ return QModelIndex();
+
+ //get the associated geom vertex
+ HEXA_NS::VertexShape* geomVertex = vertex->getAssociation();
+ if (geomVertex == NULL)
+ return QModelIndex();
+
+ //convert geom vertex to qmodelindex
+ PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
+ if (pgsm == NULL)
+ return QModelIndex();
+
+ return pgsm->indexBy(HEXA_DATA_ROLE, QVariant::fromValue(geomVertex));
+}
+
+
+QModelIndexList DocumentModel::getEdgeAssociations(const QModelIndex& iEdge)
+{
+ QModelIndexList result;
+ HEXA_NS::Edge* edge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
+ if (edge == NULL) return result;
+
+ HEXA_NS::EdgeShape* geomEdge;
+ HEXA_NS::AssoEdge* anEdgeAssoc;
+
+ PatternGeomSelectionModel* pGSModel = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
+ int nbAssocs = edge->countAssociation();
+ for (int i = 0; i < nbAssocs; ++i)
+ {
+ anEdgeAssoc = edge->getAssociation(i);
+ if (anEdgeAssoc == NULL) continue;
+ geomEdge = anEdgeAssoc->getEdgeShape();
+ if (geomEdge == NULL) continue;
+ result << pGSModel->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomEdge));
+ }
+
+ return result;
+}
+
+
+QModelIndexList DocumentModel::getQuadAssociations(const QModelIndex& iQuad)
+{
+ QModelIndexList result;
+ QModelIndex geomQuadIndex;
+ HEXA_NS::Quad* quad = getHexaPtr<HEXA_NS::Quad*>(iQuad);
+ if (quad == NULL) return result;
+
+ if (HEXABLOCKGUI::currentDocGView == NULL) return result;
+ PatternGeomSelectionModel* pgsm = HEXABLOCKGUI::currentDocGView->getPatternGeomSelectionModel();
+ PatternGeomModel* pgm = HEXABLOCKGUI::currentDocGView->getPatternGeomModel();
+ if (pgsm == NULL || pgm == NULL) return result;
+
+ HEXA_NS::FaceShape* geomFace;
+
+ int nbAssocs = quad->countAssociation();
+ for (int i = 0; i < nbAssocs; ++i)
+ {
+ geomFace = quad->getAssociation(i);
+ if (geomFace == NULL) continue;
+
+ geomQuadIndex = pgsm->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(geomFace) );
+ result << geomQuadIndex;
+ }
+
+ return result;
+}
+
+
+bool DocumentModel::associateOpenedLine( const QModelIndexList& iedges,
+ HEXA_NS::NewShapes shapes,
+ HEXA_NS::IntVector subIds,
+ double pstart,
+ double pend )
+{
+
+ HEXA_NS::Edges mline;
+
+ HEXA_NS::Edge* hedge = NULL;
+ foreach( const QModelIndex& iedge, iedges ){
+ hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
+ if (hedge != NULL)
+ mline.push_back( hedge );
+ }
+
+ int err = _hexaDocument->associateOpenedLine( mline, shapes, subIds, pstart, pend );
+ if ( err == HOK ){
+ updateData();
+ return true;
+ }
+ return false;
}
-QModelIndex DocumentModel::prismQuads( const QModelIndexList& iquads, const QModelIndex& ivec, std::vector<double> layersSize, int nb)
+bool DocumentModel::associateClosedLine( const QModelIndex& ivertex,
+ const QModelIndexList& iedges,
+ HEXA_NS::NewShapes shapes,
+ HEXA_NS::IntVector subIds,
+ double pstart,
+ bool inv )
{
- QModelIndex iElts;
+ HEXA_NS::Vertex* mfirst = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
+ HEXA_NS::Edges mline;
- HEXA_NS::Quads hQuads;
- HEXA_NS::Quad* hQuad = NULL;
- foreach( const QModelIndex& iquad, iquads ){
- hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
- hQuads.push_back( hQuad );
- }
- HEXA_NS::Vector* hVect = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Edge* hedge = NULL;
+ foreach( const QModelIndex& iedge, iedges ){
+ hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
+ if (hedge != NULL)
+ mline.push_back( hedge );
+ }
- HEXA_NS::Elements* hElts = _hexaDocument->prismQuadsVec( hQuads, hVect, layersSize, nb );
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
- return iElts;
+ int err = _hexaDocument->associateClosedLine( mfirst, mline, shapes, subIds, pstart, inv);
+ if ( err == HOK ){
+ updateData();
+ return true;
+ }
+ return false;
}
+// ************ GROUPS ************
//
-QModelIndex DocumentModel::joinQuad(
- const QModelIndex& iquadstart, const QModelIndex& iquaddest,
- const QModelIndex& iv0, const QModelIndex& iv1,
- const QModelIndex& iv2, const QModelIndex& iv3,
- int nb )
+QModelIndex DocumentModel::addGroup( const QString& name, Group kind )
{
- QModelIndex iElts;
+ QModelIndex iGroup;
- HEXA_NS::Quad* hQuadStart = getHexaPtr<HEXA_NS::Quad*>(iquadstart);
- HEXA_NS::Quad* hQuadDest = getHexaPtr<HEXA_NS::Quad*>(iquaddest);
+ HEXA_NS::Group* hGroup = _hexaDocument->addGroup( name.toLocal8Bit().constData(), kind );
+ if ( hGroup == NULL ) return iGroup;
- HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
- HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
- HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
- HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
+ GroupItem* groupItem = new GroupItem(hGroup);
+ groupItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
+ _groupDirItem->appendRow(groupItem);
+ iGroup = groupItem->index();
- HEXA_NS::Elements* hElts = _hexaDocument->joinQuad( hQuadStart, hQuadDest,
- hVertex0, hVertex1, hVertex2, hVertex3, nb );
+ return iGroup;
+}
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
- return iElts;
+bool DocumentModel::removeGroup( const QModelIndex& igrp )
+{
+ HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
+ int r = _hexaDocument->removeGroup ( hGroup );
+
+ if ( r == HOK ){
+ removeRow( igrp.row(), igrp.parent());
+ return true;
+ }
+
+ return false;
}
-QModelIndex DocumentModel::joinQuads(
- const QModelIndexList& iquadsstart, const QModelIndex& iquaddest,
- const QModelIndex& iv0, const QModelIndex& iv1,
- const QModelIndex& iv2, const QModelIndex& iv3,
- int nb )
+
+QModelIndexList DocumentModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
{
- QModelIndex iElts;
+ QModelIndexList iElements;
+
+ HEXA_NS::Group* g = iGroup.data(HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
+ if ( g == NULL ) return iElements;
+
+ QModelIndexList iFound;
+ QVariant q;
+ HEXA_NS::EltBase* eltBase = NULL;
+ int nbElement = g->countElement();
+ for ( int nr = 0; nr < nbElement; ++nr ){
+ eltBase = g->getElement( nr );
+ kind = g->getKind();
+ switch ( kind ){
+ case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: q = QVariant::fromValue( (HEXA_NS::Hexa *)eltBase ); break;
+ case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: q = QVariant::fromValue( (HEXA_NS::Quad *)eltBase ); break;
+ case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: q = QVariant::fromValue( (HEXA_NS::Edge *)eltBase ); break;
+ case HEXA_NS::VertexNode: q = QVariant::fromValue( (HEXA_NS::Vertex *)eltBase ); break;
+ }
+ iFound = match( index(0, 0),
+ HEXA_DATA_ROLE,
+ q,
+ 1,
+ Qt::MatchRecursive );
+ if ( !iFound.isEmpty() )
+ iElements << iFound[0];
+ }
+ return iElements;
+}
- HEXA_NS::Quad* hQuadStart;
- HEXA_NS::Quads hQuadsStart;
+// 7.4 Boite: éditer un groupe
+void DocumentModel::setGroupName( const QModelIndex& igrp, const QString& name )
+{
+ HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
- foreach( const QModelIndex& iquad, iquadsstart ){
- hQuadStart = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
- hQuadsStart.push_back( hQuadStart );
- }
- HEXA_NS::Quad* hQuadDest = data( iquaddest, HEXA_DATA_ROLE ).value<HEXA_NS::Quad *>();
+ if ( hGroup ){
+ hGroup->setName( name.toLocal8Bit().constData() );
+ setData(igrp, QVariant::fromValue( name ) );
+ }
+}
- HEXA_NS::Vertex* hVertex0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
- HEXA_NS::Vertex* hVertex1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
- HEXA_NS::Vertex* hVertex2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
- HEXA_NS::Vertex* hVertex3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
+bool DocumentModel::addGroupElement( const QModelIndex& igrp, const QModelIndex& ielt )
+{
+ HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
+ if (hGroup == NULL) return false;
- HEXA_NS::Elements* hElts = _hexaDocument->joinQuads(
- hQuadsStart, hQuadDest,
- hVertex0, hVertex1, hVertex2, hVertex3,
- nb );
+ HEXA_NS::EltBase* hElt = NULL;
+ switch ( hGroup->getKind() ){
+ case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: hElt = getHexaPtr<HEXA_NS::Hexa*>(ielt); break;
+ case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: hElt = getHexaPtr<HEXA_NS::Quad*>(ielt); break;
+ case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: hElt = getHexaPtr<HEXA_NS::Edge*>(ielt); break;
+ case HEXA_NS::VertexNode: hElt = getHexaPtr<HEXA_NS::Vertex*>(ielt); break;
+ }
- if ( hElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
+ int res = HERR;
+ if ( hElt != NULL )
+ res = hGroup->addElement( hElt );
+
+ if ( res == HOK ) return true;
- return iElts;
+ return false;
}
-bool DocumentModel::mergeVertices( const QModelIndex &iv0, const QModelIndex &iv1 ) //CS_TODO : impact sur le model?
+bool DocumentModel::removeGroupElement( const QModelIndex& igrp, int nro )
+{ //CS_TODO : remove child?
+ HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
+ if (hGroup == NULL) return false;
+
+ if (hGroup->removeElement( nro ) == HOK) return true;
+
+ return false;
+}
+
+bool DocumentModel::clearGroupElement( const QModelIndex& igrp )
{
- bool ret = false;
+ HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
- HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
- HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
+ if ( hGroup != NULL)
+ {
+ hGroup->clearElement();
+ return true;
+ }
+ return false;
+}
+
+// ************ LAWS ************
+
+//
+QModelIndex DocumentModel::addLaw( const QString& name, int nbnodes )
+{
+ QModelIndex iLaw;
- int r = _hexaDocument->mergeVertices( hv0, hv1 );
- if ( r == HOK ){
- updateData(); //CS_TODO more or less?
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ HEXA_NS::Law* hLaw = _hexaDocument->addLaw( name.toLocal8Bit().constData(), nbnodes );
+ if ( BadElement(hLaw) ) return iLaw;
- return ret;
+ LawItem* lawItem = new LawItem(hLaw);
+ _lawDirItem->appendRow(lawItem);
+ iLaw = lawItem->index();
+
+ return iLaw;
}
-bool DocumentModel::mergeEdges( const QModelIndex &ie0, const QModelIndex &ie1,
- const QModelIndex &iv0, const QModelIndex &iv1 )
-//CS_TODO : impact sur le model?
+bool DocumentModel::setLaw( const QModelIndex& ilaw, int nbnodes, double coeff, KindLaw type )
{
- bool ret = false;
+ bool ret = false;
- HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(ie0);
- HEXA_NS::Edge* he1 = getHexaPtr<HEXA_NS::Edge*>(ie1);
+ HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
- HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
- HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
+ if ( hLaw ){
+ int ok;
+ ok = hLaw->setNodes( nbnodes );
+ ( ok == HOK) ? ret = true : ret = false;
+ ok = hLaw->setCoefficient( coeff );
+ hLaw->setKind(type);
+ }
- int r = _hexaDocument->mergeEdges( he0, he1, hv0, hv1 );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ return ret;
+}
- return ret;
+//
+bool DocumentModel::removeLaw( const QModelIndex& ilaw )
+{
+ HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
+ int r = _hexaDocument->removeLaw( hLaw );
+
+ if ( r == HOK ){
+ removeRow( ilaw.row(), ilaw.parent());
+ return true;
+ }
+
+ return false;
}
-bool DocumentModel::mergeQuads( const QModelIndex& iquad0, const QModelIndex& iquad1,
- const QModelIndex& iv0, const QModelIndex& iv1,
- const QModelIndex& iv2, const QModelIndex& iv3 )
+bool DocumentModel::setPropagation( const QModelIndex& iPropagation, const QModelIndex& iLaw, bool way )
+{
+ HEXA_NS::Propagation* hPropagation = data(iPropagation, HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
+ HEXA_NS::Law* hLaw = data(iLaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
+
+ int r = hPropagation->setLaw( hLaw );
+ hPropagation->setWay( way );
+
+ if ( r == HOK ) return true;
+
+ return false;
+}
+
+
+QModelIndexList DocumentModel::getPropagation( const QModelIndex& iPropagation ) const
+{
+ QModelIndexList iEdges;
+
+ QModelIndexList iFound;
+ HEXA_NS::Propagation* propa = iPropagation.data(HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
+ if ( propa == NULL ) return iEdges;
+
+ const HEXA_NS::Edges& edges = propa->getEdges();
+ for ( HEXA_NS::Edges::const_iterator anEdge = edges.begin(), endIt = edges.end();
+ anEdge != endIt;
+ ++anEdge ){
+ iFound = match( index(0, 0),
+ HEXA_DATA_ROLE,
+ QVariant::fromValue( *anEdge ),
+ 1,
+ Qt::MatchRecursive);
+ if ( !iFound.isEmpty() )
+ iEdges << iFound[0];
+ }
+
+ return iEdges;
+}
+
+HEXA_NS::Document* DocumentModel::documentImpl()
+{
+ return _hexaDocument;
+}
+
+QString DocumentModel::documentEntry()
+{
+ return _entry;
+}
+
+// 8.3 Boite: éditer une loi CS_TODO
+// (idem création)
+
+/*****************************************************************
+ PatternDataModel
+ *****************************************************************/
+
+PatternDataModel::PatternDataModel( QObject * parent ) :
+ QSortFilterProxyModel( parent )
+{
+ QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12)").
+ arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).arg(VECTOR_TREE).arg(ELEMENTS_TREE).
+ arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).arg(HEXA_DIR_TREE).arg(VECTOR_DIR_TREE).
+ arg(ELEMENTS_DIR_TREE);
+
+ setFilterRole(HEXA_TREE_ROLE);
+ setFilterRegExp ( QRegExp(dataRegExp) );
+}
+
+// *** Pour suppression des panneaux "Builder" et "Geometry" ****/
+
+//PatternDataModel::PatternDataModel( QObject * parent ) :
+// QSortFilterProxyModel( parent )
+//{
+// QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12|%13|%14|%15|%16|%17|%18|%19|%20|%21|%22|%23|%24|%25|%26)").
+// arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).
+// arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).
+// arg(HEXA_DIR_TREE).arg(VECTOR_TREE).arg(ELEMENTS_TREE).
+// arg(VECTOR_DIR_TREE).arg(ELEMENTS_DIR_TREE).
+// arg(IMPLICIT_SHAPES_TREE).arg(EXPLICIT_SHAPES_TREE).arg(CLOUD_OF_POINTS_TREE).
+// arg(GEOMSHAPE_TREE).arg(GEOMPOINT_TREE).arg(GEOMEDGE_TREE).arg(GEOMFACE_TREE).
+// arg(IMPLICIT_SHAPES_DIR_TREE).arg(EXPLICIT_SHAPES_DIR_TREE).arg(CLOUD_OF_POINTS_DIR_TREE).
+// arg(GEOMSHAPE_DIR_TREE).arg(GEOMPOINT_DIR_TREE).arg(GEOMEDGE_DIR_TREE).arg(GEOMFACE_DIR_TREE);
+//
+// setFilterRole(HEXA_TREE_ROLE);
+// setFilterRegExp ( QRegExp(dataRegExp) );
+//}
+
+// ****************
+
+PatternDataModel::~PatternDataModel()
+{
+}
+
+HEXA_NS::Document* PatternDataModel::documentImpl()
+{
+ HEXA_NS::Document* doc = NULL;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if (m) doc = m->documentImpl();
+ return doc;
+}
+
+QString PatternDataModel::documentEntry()
+{
+ QString entry;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if (m) entry = m->documentEntry();
+ return entry;
+}
+
+Qt::ItemFlags PatternDataModel::flags(const QModelIndex &index) const
+{
+ Qt::ItemFlags flags;
+
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ flags = m->flags( mapToSource(index) );
+ }
+ return flags;
+}
+
+
+QVariant PatternDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+{
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
+ return QVariant( "Data" );
+ } else {
+ return QSortFilterProxyModel::headerData ( section, orientation, role );
+ }
+}
+
+
+QStandardItem* PatternDataModel::itemFromIndex ( const QModelIndex & index ) const
{
- bool ret = false;
+ QStandardItem *item = NULL;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ item = m->itemFromIndex( mapToSource(index) );
+ }
+ return item;
+}
- HEXA_NS::Quad* hquad0 = data(iquad0, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
- HEXA_NS::Quad* hquad1 = data(iquad1, HEXA_DATA_ROLE).value<HEXA_NS::Quad *>();
+//PatternBuilderModel::PatternBuilderModel( QObject * parent ) :
+// QSortFilterProxyModel( parent )
+//{
+// QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6)").
+// arg(VECTOR_TREE).arg(ELEMENTS_TREE).
+// arg(CROSSELEMENTS_TREE).arg(VECTOR_DIR_TREE).arg(ELEMENTS_DIR_TREE).arg(CROSSELEMENTS_DIR_TREE);
+//
+// setFilterRole( HEXA_TREE_ROLE );
+// setFilterRegExp ( QRegExp( builderRegExp ) );
+//}
+
+//PatternBuilderModel::~PatternBuilderModel()
+//{
+//}
+
+//Qt::ItemFlags PatternBuilderModel::flags(const QModelIndex &index) const
+//{
+// Qt::ItemFlags flags;
+//
+// DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+// if ( m != NULL ){
+// flags = m->flags( mapToSource(index) );
+// }
+// return flags;
+//}
+
+//QVariant PatternBuilderModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+//{
+// if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
+// return QVariant( "Builder" );
+// } else {
+// return QSortFilterProxyModel::headerData ( section, orientation, role );
+// }
+//}
+
+//QStandardItem* PatternBuilderModel::itemFromIndex ( const QModelIndex & index ) const
+//{
+// QStandardItem *item = NULL;
+// DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+// if ( m != NULL ){
+// item = m->itemFromIndex( mapToSource(index) );
+// }
+// return item;
+//}
+
+//====================================================================
+// PatternGeomModel
+//====================================================================
+PatternGeomModel::PatternGeomModel( QObject * parent ) :
+ QSortFilterProxyModel( parent )
+{
+ QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10|%11|%12|%13|%14)").
+ arg(EXPLICIT_SHAPES_TREE).arg(IMPLICIT_SHAPES_TREE).arg(CLOUD_OF_POINTS_TREE).
+ arg(GEOMSHAPE_TREE).arg(GEOMPOINT_TREE).arg(GEOMEDGE_TREE).arg(GEOMFACE_TREE).
+ arg(EXPLICIT_SHAPES_DIR_TREE).arg(IMPLICIT_SHAPES_DIR_TREE).arg(CLOUD_OF_POINTS_DIR_TREE).
+ arg(GEOMSHAPE_DIR_TREE).arg(GEOMPOINT_DIR_TREE).arg(GEOMEDGE_DIR_TREE).arg(GEOMFACE_DIR_TREE);
+
+ setFilterRole( HEXA_TREE_ROLE );
+ setFilterRegExp ( QRegExp(builderRegExp ) );
+}
+
+PatternGeomModel::~PatternGeomModel()
+{
+}
+
+Qt::ItemFlags PatternGeomModel::flags(const QModelIndex &index) const
+{
+ Qt::ItemFlags flags;
+
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ flags = m->flags( mapToSource(index) );
+ }
+ return flags;
+}
+
+QVariant PatternGeomModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+{
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
+ return QVariant( "Geometry" );
+ } else {
+ return QSortFilterProxyModel::headerData ( section, orientation, role );
+ }
+}
+
+QStandardItem* PatternGeomModel::itemFromIndex ( const QModelIndex & index ) const
+{
+ QStandardItem *item = NULL;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ item = m->itemFromIndex( mapToSource(index) );
+ }
+ return item;
+}
+//==============================================================
+
+
+AssociationsModel::AssociationsModel( QObject * parent ) :
+ QSortFilterProxyModel( parent )
+{
+ QString assocRegExp;
+
+ setFilterRole( HEXA_TREE_ROLE );
+ setFilterRegExp ( QRegExp(assocRegExp) );
+}
+
+AssociationsModel::~AssociationsModel()
+{
+}
+
+Qt::ItemFlags AssociationsModel::flags(const QModelIndex &index) const
+{
+ Qt::ItemFlags flags;
+
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ flags = m->flags( mapToSource(index) );
+ }
+ return flags;
+}
+
+QVariant AssociationsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+{
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
+ return QVariant( "Associations" );
+ } else {
+ return QSortFilterProxyModel::headerData ( section, orientation, role );
+ }
+}
+
+QStandardItem* AssociationsModel::itemFromIndex ( const QModelIndex & index ) const
+{
+ QStandardItem *item = NULL;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ item = m->itemFromIndex( mapToSource(index) );
+ }
+ return item;
+}
+
+GroupsModel::GroupsModel( QObject * parent ) :
+ QSortFilterProxyModel( parent )
+{
+ QString groupsRegExp =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE);
+
+ setFilterRole( HEXA_TREE_ROLE );
+ setFilterRegExp ( QRegExp(groupsRegExp ) );
+}
+
+GroupsModel::~GroupsModel()
+{
+}
+
+Qt::ItemFlags GroupsModel::flags(const QModelIndex &index) const
+{
+ Qt::ItemFlags flags;
+
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ flags = m->flags( mapToSource(index) );
+ }
+ return flags;
+}
+
+QVariant GroupsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+{
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
+ return QVariant( "Groups" );
+ } else {
+ return QSortFilterProxyModel::headerData ( section, orientation, role );
+ }
+}
+
+QStandardItem* GroupsModel::itemFromIndex ( const QModelIndex & index ) const
+{
+ QStandardItem *item = NULL;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ item = m->itemFromIndex( mapToSource(index) );
+ }
+ return item;
+}
+
+QModelIndexList GroupsModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
+{
+ QModelIndexList elements;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ elements = m->getGroupElements( mapToSource(iGroup), kind );
+ }
+ return elements;
+}
+
+MeshModel::MeshModel( QObject * parent ) :
+ QSortFilterProxyModel( parent )
+{
+ QString meshRegExp =QString("(%1|%2|%3|%4)").arg(LAW_TREE).arg(LAW_DIR_TREE) .arg(PROPAGATION_TREE).arg(PROPAGATION_DIR_TREE);
+
+ setFilterRole( HEXA_TREE_ROLE );
+ setFilterRegExp ( QRegExp(meshRegExp) );
+}
+
+MeshModel::~MeshModel()
+{
+}
+
+Qt::ItemFlags MeshModel::flags(const QModelIndex &index) const
+{
+ Qt::ItemFlags flags;
+
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ flags = m->flags( mapToSource(index) );
+ }
+ return flags;
+}
+
+QVariant MeshModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+{
+ if ( section == 0 && orientation == Qt::Horizontal && role == Qt::DisplayRole ){
+ return QVariant( "Mesh" );
+ } else {
+ return QSortFilterProxyModel::headerData ( section, orientation, role );
+ }
+}
+
+QStandardItem* MeshModel::itemFromIndex ( const QModelIndex & index ) const
+{
+ QStandardItem *item = NULL;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ item = m->itemFromIndex( mapToSource(index) );
+ }
+ return item;
+}
+
+QModelIndexList MeshModel::getPropagation( const QModelIndex& iPropagation ) const
+{
+ QModelIndexList edges;
+ DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
+ if ( m != NULL ){
+ edges = m->getPropagation( mapToSource(iPropagation) );
+ }
+ return edges;
+}
- HEXA_NS::Vertex* hv0 = getHexaPtr<HEXA_NS::Vertex*>(iv0);
- HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
- HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
- HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
- int r = _hexaDocument->mergeQuads( hquad0, hquad1, hv0, hv1, hv2, hv3 );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+// ================================== NEW ======================================
- return ret;
-}
+// ===== CARTESIAN GRID
-//
-QModelIndex DocumentModel::disconnectVertex( const QModelIndex& ihexa, const QModelIndex& ivertex )
+QModelIndex DocumentModel::makeCartesianTop(int nx, int ny, int nz)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
- HEXA_NS::Vertex* hVertex = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
+ HEXA_NS::Elements* helts = _hexaDocument->makeCartesianTop( nx, ny, nz );
+ if ( BadElement(helts) )
+ return result;
- HEXA_NS::Elements* hElts = _hexaDocument->disconnectVertex( hHexa, hVertex );
-
- if ( hElts && hElts->isValid() ){
- updateData(); //CS_TO_CHECK
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-QModelIndex DocumentModel::disconnectEdge( const QModelIndex& ihexa, const QModelIndex& iedge )
+QModelIndex DocumentModel::makeCartesianUni(const QModelIndex& icenter,
+ const QModelIndex& ibase, const QModelIndex& ivec, const QModelIndex& iaxis,
+ double lx, double ly, double lz, int nx, int ny, int nz)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
- HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge*>(iedge);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hbase = getHexaPtr<HEXA_NS::Vector*>(ibase);
+ HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
- HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdge( hHexa, hEdge );
+ HEXA_NS::Elements* helts = _hexaDocument->makeCartesianUni( hcenter, hbase, hvec, haxis,
+ lx, ly, lz, nx, ny, nz);
+ if ( BadElement(helts) )
+ return result;
- if ( hElts->isValid() ){
- updateData(); //CS_TO_CHECK
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-QModelIndex DocumentModel::disconnectEdges( const QModelIndexList& ihexas, const QModelIndexList& iedges )
+QModelIndex DocumentModel::makeCartesian(const QModelIndex& icenter,
+ const QModelIndex& ibase, const QModelIndex& ivec, const QModelIndex& iaxis,
+ std::vector<double>& radius, std::vector<double>& angles, std::vector<double>& heights)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Hexas hHexas;
- HEXA_NS::Edges hEdges;
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hbase = getHexaPtr<HEXA_NS::Vector*>(ibase);
+ HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
- //Construction de la liste des edges
- HEXA_NS::Edge* hedge = NULL;
- foreach( const QModelIndex& iedge, iedges ){
- hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
- hEdges.push_back( hedge );
- }
+ HEXA_NS::Elements* helts = _hexaDocument->makeCartesian( hcenter, hbase, hvec, haxis,
+ radius, angles, heights);
+ if ( BadElement(helts) )
+ return result;
- //Construction de la liste des hexas
- HEXA_NS::Hexa* hhexa = NULL;
- foreach( const QModelIndex& ihexa, ihexas ){
- hhexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
- hHexas.push_back( hhexa );
- }
+ result = addElementsToTree(helts, _elementsDirItem);
-
- HEXA_NS::Elements* hElts = _hexaDocument->disconnectEdges( hHexas, hEdges );
-
- if ( hElts->isValid() ){
- updateData(); //CS_TO_CHECK
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
-
- return iElts;
+ return result;
}
-QModelIndex DocumentModel::disconnectQuad( const QModelIndex& ihexa, const QModelIndex& iquad )
-{
- QModelIndex iElts;
+// ===== SPHERE
- HEXA_NS::Hexa* hHexa = getHexaPtr<HEXA_NS::Hexa*>(ihexa);
- HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iquad);
+QModelIndex DocumentModel::makeSphereTop (int nr, int na, int nh)
+{
+ QModelIndex result;
- HEXA_NS::Elements* hElts = _hexaDocument->disconnectQuad( hHexa, hQuad );
+ HEXA_NS::Elements* helts = _hexaDocument->makeSphereTop( nr, na, nh );
+ if ( BadElement(helts) )
+ return result;
- if ( hElts->isValid() ){
- updateData(); //CS_TO_CHECK
- ElementsItem* elts = new ElementsItem(hElts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete hElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-QModelIndex DocumentModel::cutEdge( const QModelIndex &i_e0, int nbcuts )
-//CS_TODO : impact sur le model?
+QModelIndex DocumentModel::makeSphereUni (QModelIndex& icenter,
+ QModelIndex& ivec_x, QModelIndex& ivec_z,
+ double rtrou, double rext, double ang,
+ QModelIndex& ivplan,
+ int nr, int na, int nh)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Edge* he0 = getHexaPtr<HEXA_NS::Edge*>(i_e0);
- HEXA_NS::Elements* helts = _hexaDocument->cut( he0, nbcuts );
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
+ HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
+ HEXA_NS::Vertex* hvplan = getHexaPtr<HEXA_NS::Vertex*>(ivplan);
- if ( helts->isValid() ){
- updateData(); //CS_TODO more?
- ElementsItem* elts = new ElementsItem(helts);
- _elementsDirItem->appendRow(elts);
- iElts = elts->index();
- } else {
- delete helts;
- }
+ HEXA_NS::Elements* helts = _hexaDocument->makeSphereUni( hcenter, hvec_x, hvec_z,
+ rtrou, rext, ang, hvplan,
+ nr, na, nh);
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-
-
-// Elements makeTranslation( in Elements l, in Vector vec )
-// raises (SALOME::SALOME_Exception);
-QModelIndex DocumentModel::makeTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
+QModelIndex DocumentModel::makeSphere (QModelIndex& icenter,
+ QModelIndex& ivec_x, QModelIndex& ivec_z,
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
+ HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
- HEXA_NS::Elements* hNewElts = _hexaDocument->makeTranslation( hElts, hVec );
+ HEXA_NS::Elements* helts = _hexaDocument->makeSphere( hcenter, hvec_x, hvec_z,
+ tray, tang, thaut);
- if ( hNewElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(hNewElts);
- _elementsDirItem->appendRow(eltsItem);
- iElts = eltsItem->index();
- } else {
- delete hNewElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
+// ====== SPHERICAL
-
-QModelIndex DocumentModel::makeScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
+QModelIndex DocumentModel::makeSphericalTop (int nbre, int crit)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+ HEXA_NS::Elements* helts = _hexaDocument->makeSphericalTop(nbre, crit);
+ if (BadElement(helts))
+ return result;
- HEXA_NS::Elements* hNewElts = _hexaDocument->makeScale( hElts, hVex, k );
-
- if ( hNewElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(hNewElts);
- _elementsDirItem->appendRow(eltsItem);
- iElts = eltsItem->index();
- } else {
- delete hNewElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-
-QModelIndex DocumentModel::makeRotation( const QModelIndex& ielts,
- const QModelIndex& iv,
- const QModelIndex& ivec, double angle )
+QModelIndex DocumentModel::makeSphericalUni (QModelIndex& icenter,
+ QModelIndex& ivec_x, QModelIndex& ivec_z,
+ double rayon,
+ int nbre, int crit)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
+ HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
- HEXA_NS::Elements* hNewElts = _hexaDocument->makeRotation( hElts, hVex, hVec, angle );
+ HEXA_NS::Elements* helts = _hexaDocument->makeSphericalUni(hcenter, hvec_x, hvec_z, rayon, nbre, crit);
+ if (BadElement(helts))
+ return result;
- if ( hNewElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(hNewElts);
- _elementsDirItem->appendRow(eltsItem);
- iElts = eltsItem->index();
- } else {
- delete hNewElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-QModelIndex DocumentModel::makeSymmetryPoint( const QModelIndex& ielts, const QModelIndex& iv )
+QModelIndex DocumentModel::makeSpherical (QModelIndex& icenter,
+ QModelIndex& ivec_x, QModelIndex& ivec_z,
+ std::vector<double>& rayon,
+ int crit)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
+ HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
- HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPoint (hElts, hVex);
+ HEXA_NS::Elements* helts = _hexaDocument->makeSpherical(hcenter, hvec_x, hvec_z, rayon, crit);
+ if (BadElement(helts))
+ return result;
- if ( hNewElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(hNewElts);
- _elementsDirItem->appendRow(eltsItem);
- iElts = eltsItem->index();
- } else {
- delete hNewElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-QModelIndex DocumentModel::makeSymmetryLine( const QModelIndex& ielts,
- const QModelIndex& iv,
- const QModelIndex& ivec )
+// ===== RIND
+QModelIndex DocumentModel::makeRindTop (int nr, int na, int nh)
{
- QModelIndex iElts;
-
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
-
+ QModelIndex result;
- HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryLine( hElts, hVex, hVec );
+ HEXA_NS::Elements* helts = _hexaDocument->makeRindTop(nr, na, nh);
+ if (BadElement(helts))
+ return result;
- if ( hNewElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(hNewElts);
- _elementsDirItem->appendRow(eltsItem);
- iElts = eltsItem->index();
- } else {
- delete hNewElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-QModelIndex DocumentModel::makeSymmetryPlane( const QModelIndex& ielts, const QModelIndex& iv, const QModelIndex& ivec )
+QModelIndex DocumentModel::makeRindUni (QModelIndex& icenter,
+ QModelIndex& ivec_x, QModelIndex& ivec_z,
+ double raytrou, double rint, double rext, double ang,
+ QModelIndex& ivplan,
+ int nr, int na, int nh)
{
- QModelIndex iElts;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iv);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
+ HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
+ HEXA_NS::Vertex* hvplan = getHexaPtr<HEXA_NS::Vertex*>(ivplan);
- HEXA_NS::Elements* hNewElts = _hexaDocument->makeSymmetryPlane( hElts, hVex, hVec );
+ HEXA_NS::Elements* helts = _hexaDocument->makeRindUni(hcenter, hvec_x, hvec_z, raytrou, rint, rext, ang,
+ hvplan, nr, na, nh);
+ if (BadElement(helts))
+ return result;
- if ( hNewElts->isValid() ){
- updateData(); //CS_TODO more or less?
- ElementsItem* eltsItem = new ElementsItem(hNewElts);
- _elementsDirItem->appendRow(eltsItem);
- iElts = eltsItem->index();
- } else {
- delete hNewElts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iElts;
+ return result;
}
-
-bool DocumentModel::performTranslation( const QModelIndex& ielts, const QModelIndex& ivec )
+QModelIndex DocumentModel::makeRind (QModelIndex& icenter,
+ QModelIndex& ivec_x, QModelIndex& ivec_z,
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
- bool ret = false;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* hvec_x = getHexaPtr<HEXA_NS::Vector*>(ivec_x);
+ HEXA_NS::Vector* hvec_z = getHexaPtr<HEXA_NS::Vector*>(ivec_z);
- int r = _hexaDocument->performTranslation (hElts, hVec);
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ HEXA_NS::Elements* helts = _hexaDocument->makeRind(hcenter, hvec_x, hvec_z, tray, tang, thaut);
+ if (BadElement(helts))
+ return result;
- return ret;
-}
+ result = addElementsToTree(helts, _elementsDirItem);
+ return result;
+}
-//
-bool DocumentModel::performScale( const QModelIndex& ielts, const QModelIndex& ivex, double k )
+// ======== Cylinder
+QModelIndex DocumentModel::makeCylinderTop(int nr, int na, int nh)
{
- bool ret = false;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+ HEXA_NS::Elements* helts = _hexaDocument->makeCylinderTop(nr, na, nh);
+ if (BadElement(helts))
+ return result;
- int r = _hexaDocument->performScale (hElts, hVex, k);
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return ret;
+ return result;
}
-//
-bool DocumentModel::performRotation( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec, double angle )
+QModelIndex DocumentModel::makeCylinderUni(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
+ double rint, double rext, double angle, double haut,
+ int nr, int na, int nh)
{
- bool ret = false;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
+ HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
+ HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- int r = _hexaDocument-> performRotation( hElts, hVex, hVec, angle );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ HEXA_NS::Elements* helts = _hexaDocument->makeCylinderUni(horig, hvecx, hvecz,
+ rint, rext, angle, haut,
+ nr, na, nh);
+ if (BadElement(helts))
+ return result;
- return ret;
-}
+ result = addElementsToTree(helts, _elementsDirItem);
+ return result;
+}
-//
-bool DocumentModel::performSymmetryPoint( const QModelIndex& ielts, const QModelIndex& ivex )
+QModelIndex DocumentModel::makeCylinder(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
- bool ret = false;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
+ HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
+ HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
+ HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- int r = _hexaDocument->performSymmetryPoint( hElts, hVex );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ HEXA_NS::Elements* helts = _hexaDocument->makeCylinder(horig, hvecx, hvecz, tray, tang, thaut);
+ if (BadElement(helts))
+ return result;
- return ret;
+ result = addElementsToTree(helts, _elementsDirItem);
+
+ return result;
}
-bool DocumentModel::performSymmetryLine( const QModelIndex& ielts, const QModelIndex& ivex, const QModelIndex& ivec )
+// ======== Cylinders
+QModelIndex DocumentModel::makeCylinders(QModelIndex& iorig1, QModelIndex& ivecz1, double r1, double h1,
+ QModelIndex& iorig2, QModelIndex& ivecz2, double r2, double h2)
{
- bool ret = false;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Vertex* horig1 = getHexaPtr<HEXA_NS::Vertex*>(iorig1);
+ HEXA_NS::Vertex* horig2 = getHexaPtr<HEXA_NS::Vertex*>(iorig2);
+ HEXA_NS::Vector* hvecz1 = getHexaPtr<HEXA_NS::Vector*>(ivecz1);
+ HEXA_NS::Vector* hvecz2 = getHexaPtr<HEXA_NS::Vector*>(ivecz2);
- int r = _hexaDocument->performSymmetryLine( hElts, hVex, hVec );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ HEXA_NS::BiCylinder* helts = _hexaDocument->makeCylinders(horig1, hvecz1, r1, h1,
+ horig2, hvecz2, r2, h2);
+ if (BadElement(helts))
+ return result;
- return ret;
-}
+ result = addElementsToTree(helts, _crossElementsDirItem);
+ return result;
+}
-bool DocumentModel::performSymmetryPlane( const QModelIndex& ielts,
- const QModelIndex& ivex,
- const QModelIndex& ivec )
+// =========== PIPE
+QModelIndex DocumentModel::makePipeTop(int nr, int na, int nh)
{
- bool ret = false;
+ QModelIndex result;
- HEXA_NS::Elements* hElts = getHexaPtr<HEXA_NS::Elements*>(ielts);
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(ivex);
- HEXA_NS::Vector* hVec = getHexaPtr<HEXA_NS::Vector*>(ivec);
+ HEXA_NS::Elements* helts = _hexaDocument->makePipeTop(nr, na, nh);
+ if (BadElement(helts))
+ return result;
- int r = _hexaDocument->performSymmetryPlane( hElts, hVex, hVec );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return ret;
+ return result;
}
-QModelIndex DocumentModel::revolutionQuads( const QModelIndexList& istartquads,
- const QModelIndex& icenter,
- const QModelIndex& ivecaxis,
- const QList<double>& angles )
+QModelIndex DocumentModel::makePipeUni(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
+ double rint, double rext, double angle, double haut,
+ int nr, int na, int nh)
{
- QModelIndex ielts;
+ QModelIndex result;
- HEXA_NS::Quads hstartquads;
- HEXA_NS::Quad* hquad = NULL;
- foreach( const QModelIndex& iquad, istartquads){
- hquad = data( iquad, HEXA_DATA_ROLE ).value<HEXA_NS::Quad*>();
- hstartquads.push_back( hquad );
- }
- HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
- HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(ivecaxis);
- std::vector<double> hangles = angles.toVector().toStdVector();
+ HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
+ HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
+ HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- HEXA_NS::Elements* helts = _hexaDocument->revolutionQuads( hstartquads, hcenter, haxis, hangles );
+ HEXA_NS::Elements* helts = _hexaDocument->makePipeUni(horig, hvecx, hvecz, rint, rext, angle,
+ haut, nr, na, nh);
+ if (BadElement(helts))
+ return result;
- if ( helts && helts->isValid() ){
- updateData();
- ElementsItem* eltsItem = new ElementsItem(helts);
- _elementsDirItem->appendRow(eltsItem);
- ielts = eltsItem->index();
- } else {
- delete helts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return ielts;
+ return result;
}
-QModelIndex DocumentModel::replace( const QModelIndexList& iquadsPattern,
- const QModelIndex& ip1, const QModelIndex& ic1,
- const QModelIndex& ip2, const QModelIndex& ic2,
- const QModelIndex& ip3, const QModelIndex& ic3 )
+QModelIndex DocumentModel::makePipe(QModelIndex& iorig, QModelIndex& ivecx, QModelIndex& ivecz,
+ std::vector<double>& tray, std::vector<double>& tang, std::vector<double>& thaut)
{
- QModelIndex ielts;
-
- HEXA_NS::Vertex* hp1 = getHexaPtr<HEXA_NS::Vertex*>(ip1);
- HEXA_NS::Vertex* hc1 = getHexaPtr<HEXA_NS::Vertex*>(ic1);
- HEXA_NS::Vertex* hp2 = getHexaPtr<HEXA_NS::Vertex*>(ip2);
- HEXA_NS::Vertex* hc2 = getHexaPtr<HEXA_NS::Vertex*>(ic2);
- HEXA_NS::Vertex* hp3 = getHexaPtr<HEXA_NS::Vertex*>(ip3);
- HEXA_NS::Vertex* hc3 = getHexaPtr<HEXA_NS::Vertex*>(ic3);
+ QModelIndex result;
- HEXA_NS::Quads hquads;
- HEXA_NS::Quad* hquad = NULL;
- foreach( const QModelIndex& iquad, iquadsPattern ){
- hquad = getHexaPtr<HEXA_NS::Quad*>(iquad);
- hquads.push_back( hquad );
- }
+ HEXA_NS::Vertex* horig = getHexaPtr<HEXA_NS::Vertex*>(iorig);
+ HEXA_NS::Vector* hvecx = getHexaPtr<HEXA_NS::Vector*>(ivecx);
+ HEXA_NS::Vector* hvecz = getHexaPtr<HEXA_NS::Vector*>(ivecz);
- HEXA_NS::Elements* helts = _hexaDocument->replace( hquads,
- hp1, hc1, hp2, hc2, hp3, hc3 );
-// HEXA_NS::Elements* helts = NULL;
+ HEXA_NS::Elements* helts = _hexaDocument->makePipe(horig, hvecx, hvecz, tray, tang, thaut);
+ if (BadElement(helts))
+ return result;
- if ( helts && helts->isValid() ){
- updateData();
- ElementsItem* eltsItem = new ElementsItem(helts);
- _elementsDirItem->appendRow(eltsItem);
- ielts = eltsItem->index();
- } else {
- delete helts;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return ielts;
+ return result;
}
-// ************ ADD ASSOCIATION ************
-//
-void DocumentModel::addAssociation( const QModelIndex& iElt, const DocumentModel::GeomObj& assocIn )
-{
-// assocIn.name;
- HEXA_NS::Shape* assoc = new HEXA_NS::Shape( assocIn.brep.toStdString() );//CS_TODO : delete assoc
- assoc->debut = assocIn.start;
- assoc->fin = assocIn.end;
- assoc->ident = ( assocIn.entry + "," + assocIn.subid ).toStdString();
- _assocName[ assocIn.entry ] = assocIn.name; // for getAssociations()
-
- QString currentAssoc, newAssoc;
-
- if ( data(iElt, HEXA_TREE_ROLE) == VERTEX_TREE ){
- HEXA_NS::Vertex* hVex = getHexaPtr<HEXA_NS::Vertex*>(iElt);
- hVex->setAssociation( assoc );
- } else if ( data(iElt, HEXA_TREE_ROLE) == EDGE_TREE ){
- HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge*>(iElt);
- hEdge->addAssociation( assoc );
- } else if ( data(iElt, HEXA_TREE_ROLE) == QUAD_TREE ){
- HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iElt);
- hQuad->addAssociation( assoc );
- }
-
- currentAssoc = data( iElt, HEXA_ASSOC_ENTRY_ROLE ).toString();
- if ( !currentAssoc.isEmpty() ){
- newAssoc = currentAssoc + assocIn.entry + "," + assocIn.subid + ";";
- } else {
- newAssoc = assocIn.entry + "," + assocIn.subid + ";";
- }
-
- setData( iElt, QVariant::fromValue(newAssoc), HEXA_ASSOC_ENTRY_ROLE );
-}
-
-
-QList<DocumentModel::GeomObj> DocumentModel::getAssociations( const QModelIndex& iElt )
-{
- MESSAGE("DocumentModel::getAssociations( "<< iElt.data().toString().toStdString() << " )" );
- QList<DocumentModel::GeomObj> res;
- DocumentModel::GeomObj assoc;
-
- //std::cout << "getAssociations() start" << std::endl;
- if ( data(iElt, HEXA_TREE_ROLE) == VERTEX_TREE ){
- MESSAGE("* of a Vertex");
-// HEXA_NS::Vertex* hVex = data(iElt, HEXA_DATA_ROLE).value<HEXA_NS::Vertex *>();
- HEXA_NS::Vertex *hVex = getHexaPtr<HEXA_NS::Vertex *>(iElt);
- HEXA_NS::Shape* hShape = hVex->getAssociation();
- QStringList shapeID;
- if ( hShape != NULL ){
- assoc.entry = "";
- assoc.subid = QString::number(-1);
- assoc.name = "";
- assoc.brep = hShape->getBrep().c_str();
- assoc.start = hShape->debut;
- assoc.end = hShape->fin;
-
- shapeID = QString( hShape->ident.c_str() ).split(",");
- if ( shapeID.count() == 2 ){
- assoc.entry = shapeID[0];
- assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
- assoc.name = _assocName[assoc.entry];
- }
- MESSAGE("* assoc.entry" << assoc.entry.toStdString() );
- MESSAGE("* assoc.subid" << assoc.subid.toStdString() );
- MESSAGE("* -----------" );
- res << assoc;
- }
- } else if ( data(iElt, HEXA_TREE_ROLE) == EDGE_TREE ){
- MESSAGE("* of an Edge");
- HEXA_NS::Edge* hEdge = getHexaPtr<HEXA_NS::Edge *>(iElt);
- HEXA_NS::Shapes hShapes = hEdge->getAssociations();
- QStringList shapeID;
- for ( HEXA_NS::Shapes::iterator it = hShapes.begin(); it != hShapes.end(); ++it){
- assoc.entry = "";
- assoc.subid = QString::number(-1);
- assoc.name = "";
- assoc.brep = (*it)->getBrep().c_str();
- assoc.start = (*it)->debut;
- assoc.end = (*it)->fin;
-
- MESSAGE("* assoc.ident " << (*it)->ident );
- shapeID = QString( (*it)->ident.c_str() ).split(",");
- if ( shapeID.count() == 2 ){
- assoc.entry = shapeID[0];
- assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
- assoc.name = _assocName[assoc.entry];
- }
- MESSAGE("* assoc.entry" << assoc.entry.toStdString() );
- MESSAGE("* assoc.subid" << assoc.subid.toStdString() );
- MESSAGE("* assoc.brep" << assoc.brep.toStdString() );
- MESSAGE("* assoc.start" << assoc.start );
- MESSAGE("* assoc.end" << assoc.end );
- MESSAGE("* -----------" );
- res << assoc;
- }
- } else if ( data(iElt, HEXA_TREE_ROLE) == QUAD_TREE ){
- MESSAGE("* of a Quad");
- HEXA_NS::Quad* hQuad = getHexaPtr<HEXA_NS::Quad*>(iElt);
- HEXA_NS::Shapes hShapes = hQuad->getAssociations();
- QStringList shapeID;
- for ( HEXA_NS::Shapes::iterator it = hShapes.begin(); it != hShapes.end(); ++it){
- assoc.entry = "";
- assoc.subid = QString::number(-1);
- assoc.name = "";
- assoc.brep = (*it)->getBrep().c_str();
- assoc.start = (*it)->debut;
- assoc.end = (*it)->fin;
- MESSAGE("* assoc.entry" << assoc.entry.toStdString() );
- MESSAGE("* assoc.subid" << assoc.subid.toStdString() );
-// MESSAGE("* assoc.brep" << assoc.brep.toStdString() );
-// MESSAGE("* assoc.start" << assoc.start );
-// MESSAGE("* assoc.end" << assoc.end );
- MESSAGE("* -----------" );
- shapeID = QString( (*it)->ident.c_str() ).split(",");
- if ( shapeID.count() == 2 ){
- assoc.entry = shapeID[0];
- assoc.subid = shapeID[1].isEmpty()? QString::number(-1) : shapeID[1];
- assoc.name = _assocName[assoc.entry];
- }
-
- res << assoc;
- }
- }
-
- MESSAGE("}" );
- return res;
-}
-
-// int associateOpenedLine (Edge* mstart, Edges& mline, Shape* gstart,
-// double pstart, Shapes& gline, double pend);
-// int associateClosedLine (Vertex* mfirst, Edge* mstart, Edges& mline,
-// Shape* gstart, double pstart, Shapes& gline);
-bool DocumentModel::associateOpenedLine( const QModelIndexList& iedges,
- const GeomObjList& assocs,
- double pstart,
- double pend )
+// ======== Pipes
+QModelIndex DocumentModel::makePipes(QModelIndex& iorig1, QModelIndex& ivecz1, double rint1, double rex1, double h1,
+ QModelIndex& iorig2, QModelIndex& ivecz2, double rint2, double rex2, double h2)
{
- MESSAGE("DocumentModel::associateOpenedLine() ");
- bool ret = false;
- HEXA_NS::Edge* mstart = NULL;
- HEXA_NS::Edges mline;
- HEXA_NS::Shape* gstart = NULL;
-// double pstart;
- HEXA_NS::Shapes gline;
-// double pend;
+ QModelIndex result;
- HEXA_NS::Edge* hedge = NULL;
- foreach( const QModelIndex& iedge, iedges ){
- hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
- if ( mstart == NULL ){
- mstart = hedge;
- MESSAGE("* mstart" << iedge.data().toString().toStdString() );
- } else {
- mline.push_back( hedge );
- MESSAGE("* mline :" << iedge.data().toString().toStdString() );
- }
- }
+ HEXA_NS::Vertex* horig1 = getHexaPtr<HEXA_NS::Vertex*>(iorig1);
+ HEXA_NS::Vertex* horig2 = getHexaPtr<HEXA_NS::Vertex*>(iorig2);
+ HEXA_NS::Vector* hvecz1 = getHexaPtr<HEXA_NS::Vector*>(ivecz1);
+ HEXA_NS::Vector* hvecz2 = getHexaPtr<HEXA_NS::Vector*>(ivecz2);
- HEXA_NS::Shape* hshape = NULL;
- foreach( const GeomObj& anAssoc, assocs ){
- hshape = new HEXA_NS::Shape( anAssoc.brep.toStdString() );
- hshape->debut = anAssoc.start; //0.;
- hshape->fin = anAssoc.end; //1.;
- hshape->ident = ( anAssoc.entry + "," + anAssoc.subid ).toStdString(); //anAssoc.entry.toStdString();
-
- if ( gstart == NULL ){
- gstart = hshape; // CS_TODO :gstart.debut = pstart ??
- MESSAGE("* gstart->debut" << gstart->debut);
- MESSAGE("* gstart->fin" << gstart->fin);
- MESSAGE("* gstart->ident" << gstart->ident);
- MESSAGE("* gstart->getBrep()" << gstart->getBrep());
-// pstart = anAssoc.start;
- } else {
- gline.push_back( hshape ); //CS_TODO : hshape.fin = pend ??
- MESSAGE("* gline->debut" << hshape->debut);
- MESSAGE("* gline->fin" << hshape->fin);
- MESSAGE("* gline->ident" << hshape->ident);
- MESSAGE("* gline->getBrep()" << hshape->getBrep());
- }
- }
-// pend = assocs.last().end;
- MESSAGE("* pstart" << pstart );
- MESSAGE("* pend" << pend );
+ HEXA_NS::BiCylinder* helts = _hexaDocument->makePipes(horig1, hvecz1, rint1, rex1, h1,
+ horig2, hvecz2, rint2, rex2, h2);
+ if (BadElement(helts))
+ return result;
- int r = _hexaDocument->associateOpenedLine( mstart, mline,
- gstart, pstart, gline, pend );
- if ( r == HOK ){
- updateData();
- MESSAGE("* DocumentModel:: associateOpenedLine() => OK ");
- ret = true;
- } else if ( r == HERR ){
- MESSAGE("* DocumentModel:: associateOpenedLine() => ERR ");
- ret = false;
- }
- delete gstart; //CS_TODO : delete gline?
- return ret;
+ result = addElementsToTree(helts, _crossElementsDirItem);
+
+ return result;
}
-bool DocumentModel::associateClosedLine( const QModelIndex& ivertex,
- const QModelIndexList& iedges,
- const GeomObjList& assocs,
- double pstart,
- bool inv )
+// ======== Join Quads
+QModelIndex DocumentModel::joinQuadUni(QModelIndex& istart, QModelIndex& idest, QModelIndex& iv1, QModelIndex& iv2,
+ QModelIndex& iv3, QModelIndex& iv4, int nb)
{
- MESSAGE("DocumentModel::associateClosedLine() ");
- bool ret = false;
- HEXA_NS::Vertex* mfirst = getHexaPtr<HEXA_NS::Vertex*>(ivertex);
- HEXA_NS::Edge* mstart = NULL;
- HEXA_NS::Edges mline;
- HEXA_NS::Shape* gstart = NULL;
-// double pstart;
- HEXA_NS::Shapes gline;
+ QModelIndex result;
+ HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
+ HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
+ HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
+ HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
+ HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
- HEXA_NS::Edge* hedge = NULL;
- foreach( const QModelIndex& iedge, iedges ){
- hedge = getHexaPtr<HEXA_NS::Edge*>(iedge);
- if ( mstart == NULL ){
- mstart = hedge;
- MESSAGE("* mstart" << iedge.data().toString().toStdString() );
- } else {
- mline.push_back( hedge );
- MESSAGE("* mline :" << iedge.data().toString().toStdString() );
- }
- }
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuadUni(hstart, hdest, hv1, hv2, hv3, hv4, nb);
+ if (BadElement(helts))
+ return result;
- HEXA_NS::Shape* hshape = NULL;
- foreach( const GeomObj& anAssoc, assocs ){
- hshape = new HEXA_NS::Shape( anAssoc.brep.toStdString() );
- hshape->debut = anAssoc.start; //0.;
- hshape->fin = anAssoc.end; //1.;
- hshape->ident = ( anAssoc.entry + "," + anAssoc.subid ).toStdString();//anAssoc.entry.toStdString();
-
- if ( gstart == NULL ){
- gstart = hshape; // CS_TODO :gstart.debut = pstart ??
-// pstart = anAssoc.start;
- MESSAGE("* gstart->debut" << gstart->debut);
- MESSAGE("* gstart->fin" << gstart->fin);
- MESSAGE("* gstart->ident" << gstart->ident);
- MESSAGE("* gstart->getBrep()" << gstart->getBrep());
- } else {
- gline.push_back( hshape ); //CS_TODO : hshape.fin = pend ??
- MESSAGE("* gline->debut" << hshape->debut);
- MESSAGE("* gline->fin" << hshape->fin);
- MESSAGE("* gline->ident" << hshape->ident);
- MESSAGE("* gline->getBrep()" << hshape->getBrep());
- }
- }
- MESSAGE("* pstart" << pstart );
+ result = addElementsToTree(helts, _elementsDirItem);
- int r = _hexaDocument->associateClosedLine( mfirst, mstart, mline,
- gstart, pstart, inv, gline );
- if ( r == HOK ){
- updateData();
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
- return ret;
+ return result;
}
-// ************ GROUPS ************
-//
-QModelIndex DocumentModel::addGroup( const QString& name, Group kind )
+QModelIndex DocumentModel::joinQuad(QModelIndex& istart, QModelIndex& idest, QModelIndex& iva1, QModelIndex& ivb1,
+ QModelIndex& iva2, QModelIndex& ivb2, std::vector<double>& tlen)
{
- QModelIndex iGroup;
+ QModelIndex result;
- HEXA_NS::Group* hGroup = _hexaDocument->addGroup( name.toLocal8Bit().constData(), kind );
+ HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
+ HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
+ HEXA_NS::Vertex* hva1 = getHexaPtr<HEXA_NS::Vertex*>(iva1);
+ HEXA_NS::Vertex* hvb1 = getHexaPtr<HEXA_NS::Vertex*>(ivb1);
+ HEXA_NS::Vertex* hva2 = getHexaPtr<HEXA_NS::Vertex*>(iva2);
+ HEXA_NS::Vertex* hvb2 = getHexaPtr<HEXA_NS::Vertex*>(ivb2);
- GroupItem* groupItem = new GroupItem(hGroup);
- groupItem->setData( _entry, HEXA_DOC_ENTRY_ROLE );
- _groupDirItem->appendRow(groupItem);
- iGroup = groupItem->index();
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuad(hstart, hdest, hva1, hvb1, hva2, hvb2, tlen);
+ if (BadElement(helts))
+ return result;
- return iGroup;
+ result = addElementsToTree(helts, _elementsDirItem);
+
+ return result;
}
-//
-bool DocumentModel::removeGroup( const QModelIndex& igrp )
+QModelIndex DocumentModel::joinQuadsUni(QModelIndexList& istarts, QModelIndex& idest, QModelIndex& iv1, QModelIndex& iv2,
+ QModelIndex& iv3, QModelIndex& iv4, int nb)
{
- bool ret = false;
-
- HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
- int r = _hexaDocument->removeGroup ( hGroup );
+ QModelIndex result;
- if ( r == HOK ){
- removeRow( igrp.row(), igrp.parent());
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
- return ret;
-}
-/*
-QModelIndex* DocumentModel::found(eltBase)
-{
- TODO_JMD
-}
-*/
+ HEXA_NS::Quads hstarts;
+ int nbQuads = istarts.size();
+ for (int i = 0; i < nbQuads; ++i)
+ hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
-QModelIndexList DocumentModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
-{
- QModelIndexList iElements;
-
- HEXA_NS::Group* g = iGroup.data(HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
- if ( !g ) return iElements;
-
- QModelIndexList iFound;
- QVariant q;
- HEXA_NS::EltBase* eltBase = NULL;
- for ( int nr = 0; nr < g->countElement(); ++nr ){
- eltBase = g->getElement( nr );
- kind = g->getKind();
- switch ( kind ){
- case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: q = QVariant::fromValue( (HEXA_NS::Hexa *)eltBase ); break;
- case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: q = QVariant::fromValue( (HEXA_NS::Quad *)eltBase ); break;
- case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: q = QVariant::fromValue( (HEXA_NS::Edge *)eltBase ); break;
- case HEXA_NS::VertexNode: q = QVariant::fromValue( (HEXA_NS::Vertex *)eltBase ); break;
- }
- iFound = match( index(0, 0),
- HEXA_DATA_ROLE,
- q,
- 1,
- Qt::MatchRecursive );
- if ( !iFound.isEmpty() )
- iElements << iFound[0];
- }
- return iElements;
-}
+ HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
+ HEXA_NS::Vertex* hv1 = getHexaPtr<HEXA_NS::Vertex*>(iv1);
+ HEXA_NS::Vertex* hv2 = getHexaPtr<HEXA_NS::Vertex*>(iv2);
+ HEXA_NS::Vertex* hv3 = getHexaPtr<HEXA_NS::Vertex*>(iv3);
+ HEXA_NS::Vertex* hv4 = getHexaPtr<HEXA_NS::Vertex*>(iv4);
-// 7.4 Boite: éditer un groupe
-void DocumentModel::setGroupName( const QModelIndex& igrp, const QString& name )
-{
- HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuadsUni(hstarts, hdest, hv1, hv2, hv3, hv4, nb);
+ if (BadElement(helts))
+ return result;
- if ( hGroup ){
- hGroup->setName( name.toLocal8Bit().constData() );
- setData(igrp, QVariant::fromValue( name ) );
- }
+ result = addElementsToTree(helts, _elementsDirItem);
+ return result;
}
-bool DocumentModel::addGroupElement( const QModelIndex& igrp, const QModelIndex& ielt )
-{ //CS_TODO : check input? add child?
-// int addElement (EltBase* elt);
-
- bool addOk = false;
- HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
- HEXA_NS::EltBase* hElt = NULL;
- switch ( hGroup->getKind() ){
- case HEXA_NS::HexaCell: case HEXA_NS::HexaNode: hElt = getHexaPtr<HEXA_NS::Hexa*>(ielt); break;
- case HEXA_NS::QuadCell: case HEXA_NS::QuadNode: hElt = getHexaPtr<HEXA_NS::Quad*>(ielt); break;
- case HEXA_NS::EdgeCell: case HEXA_NS::EdgeNode: hElt = getHexaPtr<HEXA_NS::Edge*>(ielt); break;
- case HEXA_NS::VertexNode: hElt = getHexaPtr<HEXA_NS::Vertex*>(ielt); break;
- }
+QModelIndex DocumentModel::joinQuads(QModelIndexList& istarts, QModelIndex& idest, QModelIndex& iva1, QModelIndex& ivb1,
+ QModelIndex& iva2, QModelIndex& ivb2, std::vector<double>& tlen)
+{
+ QModelIndex result;
- int res = HERR;
- if ( hGroup and hElt )
- res = hGroup->addElement( hElt );
+ HEXA_NS::Quads hstarts;
+ int nbQuads = istarts.size();
+ for (int i = 0; i < nbQuads; ++i)
+ hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
- if ( res == HOK ) addOk = true;
+ HEXA_NS::Quad* hdest = getHexaPtr<HEXA_NS::Quad*>(idest);
+ HEXA_NS::Vertex* hva1 = getHexaPtr<HEXA_NS::Vertex*>(iva1);
+ HEXA_NS::Vertex* hvb1 = getHexaPtr<HEXA_NS::Vertex*>(ivb1);
+ HEXA_NS::Vertex* hva2 = getHexaPtr<HEXA_NS::Vertex*>(iva2);
+ HEXA_NS::Vertex* hvb2 = getHexaPtr<HEXA_NS::Vertex*>(ivb2);
- return addOk;
-}
+ HEXA_NS::Elements* helts = _hexaDocument->joinQuads(hstarts, hdest, hva1, hvb1, hva2, hvb2, tlen);
+ if (BadElement(helts))
+ return result;
-bool DocumentModel::removeGroupElement( const QModelIndex& igrp, int nro )
-{ //CS_TODO : remove child?
- HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
+ result = addElementsToTree(helts, _elementsDirItem);
- if ( hGroup )
- {
- if (hGroup->removeElement( nro ) == HOK)
- return true;
- }
- return false;
+ return result;
}
-bool DocumentModel::clearGroupElement( const QModelIndex& igrp )
+// ======== Quad Revolution
+QModelIndex DocumentModel::revolutionQuadUni(QModelIndex& istart, QModelIndex& icenter, QModelIndex& iaxis,
+ double angle, int nbre)
{
- HEXA_NS::Group* hGroup = data(igrp, HEXA_DATA_ROLE).value<HEXA_NS::Group *>();
-
- if ( hGroup )
- {
- hGroup->clearElement();
- return true;
- }
- return false;
-}
-
-// ************ LAWS ************
+ QModelIndex result;
-//
-QModelIndex DocumentModel::addLaw( const QString& name, int nbnodes )
-{
- QModelIndex iLaw;
+ HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
- HEXA_NS::Law* hLaw = _hexaDocument->addLaw( name.toLocal8Bit().constData(), nbnodes );
+ HEXA_NS::Elements* helts = _hexaDocument->revolutionQuadUni(hstart, hcenter, haxis, angle, nbre);
+ if (BadElement(helts))
+ return result;
- LawItem* lawItem = new LawItem(hLaw);
- _lawDirItem->appendRow(lawItem);
- iLaw = lawItem->index();
+ result = addElementsToTree(helts, _elementsDirItem);
- return iLaw;
+ return result;
}
-bool DocumentModel::setLaw( const QModelIndex& ilaw, int nbnodes, double coeff, KindLaw type )
+QModelIndex DocumentModel::revolutionQuad(QModelIndex& istart, QModelIndex& icenter, QModelIndex& iaxis,
+ std::vector<double>& angles)
{
- bool ret = false;
-
- HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
+ QModelIndex result;
- if ( hLaw ){
- int ok;
- ok = hLaw->setNodes( nbnodes );
- ( ok == HOK) ? ret = true : ret = false;
- ok = hLaw->setCoefficient( coeff );
- hLaw->setKind(type);
- }
-
- return ret;
-}
+ HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
-//
-bool DocumentModel::removeLaw( const QModelIndex& ilaw )
-{
- bool ret = false;
- HEXA_NS::Law* hLaw = data(ilaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
- int r = _hexaDocument->removeLaw( hLaw );
+ HEXA_NS::Elements* helts = _hexaDocument->revolutionQuad(hstart, hcenter, haxis, angles);
+ if (BadElement(helts))
+ return result;
- if ( r == HOK ){
- removeRow( ilaw.row(), ilaw.parent());
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return ret;
+ return result;
}
-bool DocumentModel::setPropagation( const QModelIndex& iPropagation, const QModelIndex& iLaw, bool way )
+QModelIndex DocumentModel::revolutionQuadsUni(QModelIndexList& istarts, QModelIndex& icenter, QModelIndex& iaxis,
+ double angle, int nbre)
{
- bool ret = false;
- HEXA_NS::Propagation* hPropagation = data(iPropagation, HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
- HEXA_NS::Law* hLaw = data(iLaw, HEXA_DATA_ROLE).value<HEXA_NS::Law *>();
-
- int r = hPropagation->setLaw( hLaw );
- hPropagation->setWay( way );
+ QModelIndex result;
- if ( r == HOK ){
- ret = true;
- } else if ( r == HERR ){
- ret = false;
- }
- return ret;
-}
+ HEXA_NS::Quads hstarts;
+ int nbQuads = istarts.count();
+ for (int i = 0; i < nbQuads; ++i)
+ hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
-QModelIndexList DocumentModel::getPropagation( const QModelIndex& iPropagation ) const
-{
- QModelIndexList iEdges;
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
- QModelIndexList iFound;
- HEXA_NS::Propagation* propa = iPropagation.data(HEXA_DATA_ROLE).value<HEXA_NS::Propagation *>();
- if ( !propa ) return iEdges;
+ HEXA_NS::Elements* helts = _hexaDocument->revolutionQuadsUni(hstarts, hcenter, haxis, angle, nbre);
+ if (BadElement(helts))
+ return result;
- const HEXA_NS::Edges& edges = propa->getEdges();
- for ( HEXA_NS::Edges::const_iterator anEdge = edges.begin();
- anEdge != edges.end();
- ++anEdge ){
- iFound = match( index(0, 0),
- HEXA_DATA_ROLE,
- QVariant::fromValue( *anEdge ),
- 1,
- Qt::MatchRecursive);
- if ( !iFound.isEmpty() )
- iEdges << iFound[0];
- }
+ result = addElementsToTree(helts, _elementsDirItem);
- return iEdges;
+ return result;
}
-HEXA_NS::Document* DocumentModel::documentImpl()
+QModelIndex DocumentModel::revolutionQuads(QModelIndexList& istarts, QModelIndex& icenter, QModelIndex& iaxis,
+ std::vector<double>& angles)
{
- return _hexaDocument;
-}
+ QModelIndex result;
-QString DocumentModel::documentEntry()
-{
- return _entry;
-}
+ HEXA_NS::Quads hstarts;
+ int nbQuads = istarts.count();
+ for (int i = 0; i < nbQuads; ++i)
+ hstarts.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
-// 8.3 Boite: éditer une loi CS_TODO
-// (idem création)
+ HEXA_NS::Vertex* hcenter = getHexaPtr<HEXA_NS::Vertex*>(icenter);
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
-/*****************************************************************
- PatternDataModel
-*****************************************************************/
+ HEXA_NS::Elements* helts = _hexaDocument->revolutionQuads(hstarts, hcenter, haxis, angles);
+ if (BadElement(helts))
+ return result;
-PatternDataModel::PatternDataModel( QObject * parent ) :
- QSortFilterProxyModel( parent )
-{
- QString dataRegExp = QString("(%1|%2|%3|%4|%5|%6|%7|%8)").
- arg(VERTEX_TREE).arg(EDGE_TREE).arg(QUAD_TREE).arg(HEXA_TREE).
- arg(VERTEX_DIR_TREE).arg(EDGE_DIR_TREE).arg(QUAD_DIR_TREE).arg(HEXA_DIR_TREE);
+ result = addElementsToTree(helts, _elementsDirItem);
- setFilterRole(HEXA_TREE_ROLE);
- setFilterRegExp ( QRegExp(dataRegExp) );
-}
+ return result;
-PatternDataModel::~PatternDataModel()
-{
}
-HEXA_NS::Document* PatternDataModel::documentImpl()
+// ==== PrismQuad or ExtrudeQuad
+QModelIndex DocumentModel::extrudeQuadTop(QModelIndex& istart, int nbre)
{
- HEXA_NS::Document* doc = NULL;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if (m) doc = m->documentImpl();
- return doc;
-}
+ QModelIndex result;
-QString PatternDataModel::documentEntry()
-{
- QString entry;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if (m) entry = m->documentEntry();
- return entry;
-}
+ HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
+ HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadTop(hstart, nbre);
+ if (BadElement(helts))
+ return result;
-Qt::ItemFlags PatternDataModel::flags(const QModelIndex &index) const
-{
-// MESSAGE("PatternDataModel::flags() "<< index.data().toString().toStdString() );
- Qt::ItemFlags flags;
+ result = addElementsToTree(helts, _elementsDirItem);
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- flags = m->flags( mapToSource(index) );
- }
- return flags;
+ return result;
}
-
-QVariant PatternDataModel::headerData ( int section, Qt::Orientation orientation, int role ) const
+QModelIndex DocumentModel::extrudeQuadUni(QModelIndex& istart, QModelIndex& dv, double len, int nbre)
{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
- return QVariant( "Data" );
- } else {
- return QSortFilterProxyModel::headerData ( section, orientation, role );
- }
-}
+ QModelIndex result;
+ HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
+ HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(dv);
-QStandardItem* PatternDataModel::itemFromIndex ( const QModelIndex & index ) const
-{
- QStandardItem *item = NULL;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- item = m->itemFromIndex( mapToSource(index) );
- }
- return item;
-}
+ HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadUni(hstart, hvec, len, nbre);
+ if (BadElement(helts))
+ return result;
-PatternBuilderModel::PatternBuilderModel( QObject * parent ) :
- QSortFilterProxyModel( parent )
-{
- QString builderRegExp =QString("(%1|%2|%3|%4|%5|%6|%7|%8|%9|%10)").
- arg(VECTOR_TREE).arg(CYLINDER_TREE).arg(PIPE_TREE).arg(ELEMENTS_TREE).
- arg(CROSSELEMENTS_TREE).arg(VECTOR_DIR_TREE).arg(CYLINDER_DIR_TREE).
- arg(PIPE_DIR_TREE).arg(ELEMENTS_DIR_TREE).arg(CROSSELEMENTS_DIR_TREE);
+ result = addElementsToTree(helts, _elementsDirItem);
- setFilterRole( HEXA_TREE_ROLE );
- setFilterRegExp ( QRegExp(builderRegExp ) );
+ return result;
}
-PatternBuilderModel::~PatternBuilderModel()
+QModelIndex DocumentModel::extrudeQuad(QModelIndex& istart, QModelIndex& dv, std::vector<double>& tlen)
{
-}
+ QModelIndex result;
-Qt::ItemFlags PatternBuilderModel::flags(const QModelIndex &index) const
-{
-// std::cout<<"PatternBuilderModel::flags()"<<std::endl;
- Qt::ItemFlags flags;
+ HEXA_NS::Quad* hstart = getHexaPtr<HEXA_NS::Quad*>(istart);
+ HEXA_NS::Vector* hvec = getHexaPtr<HEXA_NS::Vector*>(dv);
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- flags = m->flags( mapToSource(index) );
- }
- return flags;
-}
+ HEXA_NS::Elements* helts = _hexaDocument->extrudeQuad(hstart, hvec, tlen);
+ if (BadElement(helts))
+ return result;
+ result = addElementsToTree(helts, _elementsDirItem);
-QVariant PatternBuilderModel::headerData ( int section, Qt::Orientation orientation, int role ) const
-{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
- return QVariant( "Builder" );
- } else {
- return QSortFilterProxyModel::headerData ( section, orientation, role );
- }
+ return result;
}
-QStandardItem* PatternBuilderModel::itemFromIndex ( const QModelIndex & index ) const
+QModelIndex DocumentModel::extrudeQuadsTop (QModelIndexList& istarts, int nbre)
{
- QStandardItem *item = NULL;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- item = m->itemFromIndex( mapToSource(index) );
- }
- return item;
-}
+ QModelIndex result;
-AssociationsModel::AssociationsModel( QObject * parent ) :
- QSortFilterProxyModel( parent )
-{
- QString assocRegExp;// =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE); CS_TODO
+ HEXA_NS::Quads hquads;
+ int nbQuads = istarts.count();
+ for (int i = 0; i < nbQuads; ++i)
+ hquads.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
- setFilterRole( HEXA_TREE_ROLE );
- setFilterRegExp ( QRegExp(assocRegExp) );
-}
+ HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadsTop(hquads, nbre);
+ if (BadElement(helts))
+ return result;
+ result = addElementsToTree(helts, _elementsDirItem);
-AssociationsModel::~AssociationsModel()
-{
+ return result;
}
-Qt::ItemFlags AssociationsModel::flags(const QModelIndex &index) const
+QModelIndex DocumentModel::extrudeQuadsUni (QModelIndexList& istarts, QModelIndex& axis, double len, int nbre)
{
- Qt::ItemFlags flags;
-
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- flags = m->flags( mapToSource(index) );
- }
- return flags;
-}
+ QModelIndex result;
-QVariant AssociationsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
-{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
- return QVariant( "Associations" );
- } else {
- return QSortFilterProxyModel::headerData ( section, orientation, role );
- }
-}
+ HEXA_NS::Quads hquads;
+ int nbQuads = istarts.count();
+ for (int i = 0; i < nbQuads; ++i)
+ hquads.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
-QStandardItem* AssociationsModel::itemFromIndex ( const QModelIndex & index ) const
-{
- QStandardItem *item = NULL;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- item = m->itemFromIndex( mapToSource(index) );
- }
- return item;
-}
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(axis);
-GroupsModel::GroupsModel( QObject * parent ) :
- QSortFilterProxyModel( parent )
-{
- QString groupsRegExp =QString("(%1|%2)").arg(GROUP_TREE).arg(GROUP_DIR_TREE);
+ HEXA_NS::Elements* helts = _hexaDocument->extrudeQuadsUni(hquads, haxis, len, nbre);
+ if (BadElement(helts))
+ return result;
+ result = addElementsToTree(helts, _elementsDirItem);
- setFilterRole( HEXA_TREE_ROLE );
- setFilterRegExp ( QRegExp(groupsRegExp ) );
+ return result;
}
-GroupsModel::~GroupsModel()
+QModelIndex DocumentModel::extrudeQuads(QModelIndexList& istarts, QModelIndex& iaxis, std::vector<double>& tlen)
{
-}
+ QModelIndex result;
-Qt::ItemFlags GroupsModel::flags(const QModelIndex &index) const
-{
- Qt::ItemFlags flags;
+ HEXA_NS::Quads hquads;
+ int nbQuads = istarts.count();
+ for (int i=0; i < nbQuads; ++i)
+ hquads.push_back(getHexaPtr<HEXA_NS::Quad*>(istarts[i]));
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- flags = m->flags( mapToSource(index) );
- }
- return flags;
-}
+ HEXA_NS::Vector* haxis = getHexaPtr<HEXA_NS::Vector*>(iaxis);
-QVariant GroupsModel::headerData ( int section, Qt::Orientation orientation, int role ) const
-{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
- return QVariant( "Groups" );
- } else {
- return QSortFilterProxyModel::headerData ( section, orientation, role );
- }
-}
+ HEXA_NS::Elements* helts = _hexaDocument->extrudeQuads(hquads, haxis, tlen);
+ if (BadElement(helts))
+ return result;
+ result = addElementsToTree(helts, _elementsDirItem);
-QStandardItem* GroupsModel::itemFromIndex ( const QModelIndex & index ) const
-{
- QStandardItem *item = NULL;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- item = m->itemFromIndex( mapToSource(index) );
- }
- return item;
+ return result;
}
-QModelIndexList GroupsModel::getGroupElements( const QModelIndex& iGroup, DocumentModel::Group& kind ) const
+// ==== Cut Edge
+QModelIndex DocumentModel::cutUni(QModelIndex& iEdge, int nbre)
{
- QModelIndexList elements;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- elements = m->getGroupElements( mapToSource(iGroup), kind );
- }
- return elements;
-}
+ QModelIndex result;
-MeshModel::MeshModel( QObject * parent ) :
- QSortFilterProxyModel( parent )
-{
- QString meshRegExp =QString("(%1|%2|%3|%4)").arg(LAW_TREE).arg(LAW_DIR_TREE) .arg(PROPAGATION_TREE).arg(PROPAGATION_DIR_TREE);
+ HEXA_NS::Edge* hedge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
- setFilterRole( HEXA_TREE_ROLE );
- setFilterRegExp ( QRegExp(meshRegExp) );
-}
+ HEXA_NS::Elements* helts = _hexaDocument->cutUni(hedge, nbre);
+ if (BadElement(helts))
+ return result;
+ result = addElementsToTree(helts, _elementsDirItem);
-MeshModel::~MeshModel()
-{
+ return result;
}
-Qt::ItemFlags MeshModel::flags(const QModelIndex &index) const
+QModelIndex DocumentModel::cut(QModelIndex& iEdge, std::vector<double>& tlen)
{
- Qt::ItemFlags flags;
+ QModelIndex result;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- flags = m->flags( mapToSource(index) );
- }
- return flags;
-}
+ HEXA_NS::Edge* hedge = getHexaPtr<HEXA_NS::Edge*>(iEdge);
-QVariant MeshModel::headerData ( int section, Qt::Orientation orientation, int role ) const
-{
- if ( section == 0 and orientation == Qt::Horizontal and role == Qt::DisplayRole ){
- return QVariant( "Mesh" );
- } else {
- return QSortFilterProxyModel::headerData ( section, orientation, role );
- }
-}
+ HEXA_NS::Elements* helts = _hexaDocument->cut(hedge, tlen);
+ if (BadElement(helts))
+ return result;
+ result = addElementsToTree(helts, _elementsDirItem);
-QStandardItem* MeshModel::itemFromIndex ( const QModelIndex & index ) const
-{
- QStandardItem *item = NULL;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- item = m->itemFromIndex( mapToSource(index) );
- }
- return item;
+ return result;
}
-QModelIndexList MeshModel::getPropagation( const QModelIndex& iPropagation ) const
-{
- QModelIndexList edges;
- DocumentModel *m = dynamic_cast<DocumentModel *>( sourceModel() );
- if ( m != NULL ){
- edges = m->getPropagation( mapToSource(iPropagation) );
- }
- return edges;
-}
+// ================================== END NEW ==================================
