-// Copyright (C) 2009-2013 CEA/DEN, EDF R&D
+// Copyright (C) 2009-2015 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 "Hex.hxx"
#include <iostream>
-#include <QtGui>
#include <QFlags>
+#include <QKeyEvent>
+#include <QStyledItemDelegate>
#include <SalomeApp_Application.h>
#include <SalomeApp_Study.h>
+#ifndef DISABLE_PYCONSOLE
#include <PyConsole_Console.h>
+#endif
#include <SalomeApp_Tools.h>
#include <Standard_GUID.hxx>
#include <GEOMBase.h>
+#include <utilities.h>
+
#define BUTTON_BOX_MIN_WIDTH 5
#define VERTEX_COORD_MIN -1000000
#define VERTEX_COORD_MAX 1000000
const QModelIndex &index) const{
QDoubleSpinBox *sb = new QDoubleSpinBox( parent );
sb->setMinimum(SPINBOX_POSITIVE_DOUBLE_MIN);
- /////// sb->setMaximum(1000000000000000); //10e15 Abu : Pb en 32 bits
sb->setMaximum(SPINBOX_DOUBLE_MAX); //10e9
sb->setDecimals(NB_DECIMALS);
return sb;
_strHexaWidgetType[GEOMEDGE_TREE] = tr( "GEOMEDGE" );
_strHexaWidgetType[GEOMFACE_TREE] = tr( "GEOMFACE" );
-
_strHexaWidgetType[GROUP_TREE] = tr( "GROUP" );
_strHexaWidgetType[LAW_TREE] = tr( "LAW" );
_strHexaWidgetType[PROPAGATION_TREE]= tr( "PROPAGATION" );
return iItems;
}
-// ============================================================= lockSizeToSizeHint
-void HexaBaseDialog::lockSizeToSizeHint()
-{
- setMaximumHeight(sizeHint().height());
- // setMaximumWidth(sizeHint().width());
- // setMinimumHeight(sizeHint().height());
- // setMinimumWidth(sizeHint().width());
-}
-// ============================================================= unlockSizeModification
-void HexaBaseDialog::unlockSizeModification()
+// ================================================================ computeAndSetDimension
+void HexaBaseDialog::computeAndSetDimension(const QModelIndex& elt)
{
- setMaximumHeight(MAX_HEIGHT);
- // setMaximumWidth(MAX_WIDTH);
- // setMinimumHeight(MIN_HEIGHT);
- // setMinimumWidth(MIN_WIDTH);
+ // * Check if everything is OK for the computing
+ DocumentModel* docModel = getDocumentModel();
+ if (docModel == NULL || _currentObj == NULL)
+ return;
+
+ int selectedType = elt.data(HEXA_TREE_ROLE).toInt();
+ if (selectedType != EDGE_TREE && selectedType != GEOMEDGE_TREE)
+ return;
+
+ QListWidget* list = dynamic_cast<QListWidget*>(_currentObj);
+ QDoubleSpinBox* spb = dynamic_cast<QDoubleSpinBox*>(_currentObj);
+
+ if (list == NULL && spb == NULL)
+ return;
+
+ // * Compute the value of the dimension
+ double value = 0.;
+
+ if (_currentObj->property("Radius").isValid())
+ value = docModel->getRadius(elt);
+ else if (_currentObj->property("Angle").isValid())
+ value = docModel->getAngle(elt);
+ else if (_currentObj->property("Length").isValid())
+ value = docModel->getLength(elt);
+
+ if (value == 0.)
+ return;
+
+ // * Set the value to the field (radius, length or height)
+ if (list != NULL)
+ {
+ QListWidgetItem* item = list->currentItem();
+ if (item != NULL)
+ {
+ if (value != 0.)
+ {
+ item->setText(QString::number(value));
+ list->editItem(item);
+ }
+ }
+ }
+ else if (spb != NULL)
+ {
+ spb->setValue(value);
+ spb->setFocus();
+ spb->selectAll();
+ }
}
// ============================================================= resetSizeAndShow
void HexaBaseDialog::resetSizeAndShow(QDockWidget* parent)
{
+ if (parent == NULL)
+ return;
+
//force the dialog to fit its contain
- lockSizeToSizeHint();
+// setMinimumWidth(sizeHint().width());
//set the dialog in the dockwidget
+ if (parent->widget())
+ parent->widget()->close();
parent->setWidget(this);
parent->setWindowTitle(windowTitle());
- parent->setVisible(true);
- show();
+ parent->show();
- unlockSizeModification();
+// setMinimumWidth(MIN_WIDTH);
}
QString HexaBaseDialog::getErrorMsg()
//Connect the graphic view and its model to the dialog box
connect( docGView->getPatternDataSelectionModel(), SIGNAL( selectionChanged ( const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
- connect( docGView->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection &) ),
- this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
+// connect( docGView->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection &) ),
+// this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
connect( docGView->getPatternGeomSelectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ), Qt::UniqueConnection );
connect( docGView->getGroupsSelectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection &) ),
disconnect(docGView->getPatternDataSelectionModel(), SIGNAL( selectionChanged ( const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
- disconnect(docGView->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection &) ),
- this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
+// disconnect(docGView->getPatternBuilderSelectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection &) ),
+// this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
disconnect(docGView->getPatternGeomSelectionModel(), SIGNAL( selectionChanged( const QItemSelection &, const QItemSelection &) ),
this, SLOT( onSelectionChanged(const QItemSelection &, const QItemSelection &) ) );
highlightSelectedAssocs();
}
+// ============================================================= clearCurrentObjectFocus
void HexaBaseDialog::clearCurrentObjectFocus()
{
QWidget* currentWidget = dynamic_cast<QWidget*>(_currentObj);
{
//reset the data selection pattern (forget all selections of the current context)
getPatternDataSelectionModel()->reset();
- getPatternBuilderSelectionModel()->reset();
+// getPatternBuilderSelectionModel()->reset();
getPatternGeomSelectionModel()->reset();
//Clear vtk selection
//Close the dialog box
if (parentWidget())
parentWidget()->close();
+
+ getPatternDataSelectionModel()->setInfoMode(true);
}
// ============================================================== onHelpRequested
highlightSelectedAssocs();
}
+bool HexaBaseDialog::isDimensionType(const QObject* obj)
+{
+ if (obj == NULL)
+ return false;
+
+ return (obj->property("Radius").isValid()) ||
+ (obj->property("Angle").isValid()) ||
+ (obj->property("Length").isValid());
+}
+
// ============================================================== getObjectViewType
HEXABLOCKGUI::ViewType HexaBaseDialog::getObjectViewType(QObject* obj)
{
if (obj == NULL)
return HEXABLOCKGUI::UNKNOWN;
- QVariant v = obj->property("GeomWidgetType");
- if ( v.isValid() )
- return HEXABLOCKGUI::OCC;
+ QVariant v1 = obj->property("GeomWidgetType");
+ QVariant v2 = obj->property("HexaWidgetType");
- v = obj->property("HexaWidgetType");
- if ( v.isValid() )
+ if (v1.isValid() && v2.isValid() && isDimensionType(obj))
+ return HEXABLOCKGUI::VTK_OCC;
+ else if (v1.isValid())
+ return HEXABLOCKGUI::OCC;
+ else if (v2.isValid())
return HEXABLOCKGUI::VTK;
-
- return HEXABLOCKGUI::UNKNOWN;
+ else
+ return HEXABLOCKGUI::UNKNOWN;
}
// ============================================================== _selectAndHighlight
// ============================================================== _allowVTKSelection
bool HexaBaseDialog::_allowVTKSelection( QObject* obj )
{
-
bool isOk = false;
QVariant v = obj->property("HexaWidgetType");
// ============================================================== _getSelector
QItemSelectionModel* HexaBaseDialog::_getSelector( QObject* obj )
{
+ if (obj == NULL)
+ return NULL;
+
QItemSelectionModel* selector = NULL;
HexaWidgetType wtype;
QVariant v = obj->property("HexaWidgetType");
- if ( !v.isValid() ) {
+ QVariant v2 = obj->property("GeomWidgetType");
+ if ( !v.isValid() || (v2.isValid() && isDimensionType(obj)) )
return NULL;
- }
wtype = v.value<HexaWidgetType>();
case VERTEX_TREE:
case EDGE_TREE:
case QUAD_TREE:
- case HEXA_TREE: selector = getPatternDataSelectionModel(); break;
- case VECTOR_TREE:
+ case HEXA_TREE:
+ case VECTOR_TREE: selector = getPatternDataSelectionModel(); break;
// case CYLINDER_TREE:
// case PIPE_TREE:
- case ELEMENTS_TREE:
- case CROSSELEMENTS_TREE: selector = getPatternBuilderSelectionModel(); break;
+// case ELEMENTS_TREE:
+// case CROSSELEMENTS_TREE: selector = getPatternBuilderSelectionModel(); break;
case GEOMPOINT_TREE:
case GEOMEDGE_TREE:
case GEOMFACE_TREE: selector = getPatternGeomSelectionModel(); break;
return selector;
}
+// ============================================================== getGeomObj
DocumentModel::GeomObj* HexaBaseDialog::getGeomObj(const QModelIndex& index)
{
HEXA_NS::NewShape* aSh = getDocumentModel()->getHexaPtr<HEXA_NS::NewShape*>(index);
*/
void HexaBaseDialog::onSelectionChanged( const QItemSelection& sel, const QItemSelection& unsel )
{
+ QModelIndexList l = sel.indexes();
+
+ if ( l.count() == 0 )
+ return;
+ QModelIndex selected = l[0];
+
// * no edition for Info Dialogs
- if ( _editMode == INFO_MODE )
+ if ( _editMode == INFO_MODE || _currentObj == NULL || !selected.isValid())
+ return;
+
+ if (isDimensionType(_currentObj))
+ {
+ // ** set the dimension of the selected object in the editor **/
+ int selectedType = selected.data(HEXA_TREE_ROLE).toInt();
+ if (selectedType == EDGE_TREE || selectedType == GEOMEDGE_TREE)
+ computeAndSetDimension(selected);
return;
+ }
- QLineEdit* aLineEdit = NULL;
- QListWidget* aListWidget = NULL;
+ QLineEdit* aLineEdit = dynamic_cast<QLineEdit*>(_currentObj);
+ QListWidget* aListWidget = dynamic_cast<QListWidget*>(_currentObj);
// * fill the lineedit with selection
- aLineEdit = dynamic_cast<QLineEdit*>(_currentObj);
if ( aLineEdit)
{
_onSelectionChanged( sel, aLineEdit );
}
// * fill the listWidget with selection
- aListWidget = dynamic_cast<QListWidget*>(_currentObj);
- if ( aListWidget)
+ if (aListWidget)
_onSelectionChanged( sel, aListWidget );
}
{
//Disconnection salome selection signals
if (HEXABLOCKGUI::selectionMgr() != NULL)
- {
disconnect( HEXABLOCKGUI::selectionMgr() , SIGNAL(currentSelectionChanged()),
this, SLOT(onCurrentSelectionChanged()) );
- }
//Disconnect vtk window activation signals
// if (HEXABLOCKGUI::currentDocGView->getViewWindow() != NULL)
//Disconnect model selection signals
disconnectDocumentGraphicView();
-
getDocumentModel()->allowEdition();
QDialog::hideEvent( event );
*/
void HexaBaseDialog::_highlightWidget(QObject *obj, Qt::GlobalColor clr)
{
- if (!_isLineOrListWidget(obj)) return;
+ QDoubleSpinBox* spb = dynamic_cast<QDoubleSpinBox*>(obj);
+ if (!_isLineOrListWidget(obj) && spb == NULL)
+ return;
- QWidget *widget = dynamic_cast<QWidget*>(obj); //sure it's not NULL (_isLineOrListWidget(obj))
+ QWidget *widget = dynamic_cast<QWidget*>(obj);
QPalette palette1 = widget->palette();
- palette1.setColor(widget->backgroundRole(), clr);
+ palette1.setColor(QPalette::Active, widget->backgroundRole(), clr);
widget->setPalette(palette1);
-
}//_highlightWidget
return false;
// * Focus In ------
-
- // allow vtk selection
- if (getObjectViewType(obj) == HEXABLOCKGUI::VTK)
+ HEXABLOCKGUI::ViewType vtype = getObjectViewType(obj);
+ if (vtype == HEXABLOCKGUI::VTK_OCC)
+ {
+ _allowVTKSelection(obj);
+ _allowOCCSelection(obj);
+ }
+ else if (vtype == HEXABLOCKGUI::VTK)
_allowVTKSelection( obj );
-
- //allow occ selection
- if (getObjectViewType(obj) == HEXABLOCKGUI::OCC)
+ else if (vtype == HEXABLOCKGUI::OCC)
_allowOCCSelection( obj );
//Depending on the focused widget type, get the right selector for it
_helpFileName = "gui_vertex.html";
setupUi( this );
_initWidget(editmode);
- // setFocusProxy( name_le );
if ( editmode == NEW_MODE ){
setWindowTitle( tr("Vertex Construction") );
}
QString newName = name_le->text();
- if ( !newName.isEmpty() )/*{*/
+ if ( !newName.isEmpty() )
getDocumentModel()->setName( iVertex, newName );
//the default name in the dialog box
// to select/highlight result
result = patternDataModel->mapFromSource(iVertex);
- // updateDialogBoxName(name_le, result);
- // const char *defaultName = getDocumentModel()->getHexaPtr(last)->getName();
return isOk;
}
setupUi( this );
_initWidget(editmode);
- // rb0->setFocusProxy( v0_le_rb0 );
- // rb1->setFocusProxy( vex_le_rb1 );
-
if ( editmode == INFO_MODE ){
setWindowTitle( tr("Edge Information") );
rb1->hide();
if (editmode == INFO_MODE)
name_le->setReadOnly(true);
- //connect( name_le, SIGNAL(returnPressed()), this, SLOT(updateName()) );
-
}
// ============================================================== Clear
if ( !getDocumentModel() ) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel ) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/ ) return false;
QModelIndex iEdge;
}
} else if ( rb1->isChecked() ){
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb1] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb1] );
+ QModelIndex ivec = patternDataModel->mapToSource( _index[vec_le_rb1] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb1] );
if ( ivex.isValid() && ivec.isValid() ){
iEdge = getDocumentModel()->addEdgeVector( ivex, ivec );
}
if ( editmode == INFO_MODE ){
setWindowTitle( tr("Hexahedron Information") );
+ quads_lw->viewport()->setAttribute( Qt::WA_TransparentForMouseEvents );
+ vertices_lw->viewport()->setAttribute( Qt::WA_TransparentForMouseEvents );
}
}
vertices_lw->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
vertices_lw->installEventFilter(this);
-
if ( editmode != INFO_MODE ) {
// delete item from listwidget
QShortcut* delQuadShortcut = new QShortcut( QKeySequence(Qt::Key_X), quads_lw );
if (editmode == INFO_MODE)
name_le->setReadOnly(true);
-
}
// ============================================================== clear
if ( !getDocumentModel() ) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/) return false;
QModelIndex iVector;
updateDefaultName(name_le, _value->getType());
// to select/highlight result
- result = patternBuilderModel->mapFromSource(iVector);
+ result = patternDataModel->mapFromSource(iVector);
+// result = patternBuilderModel->mapFromSource(iVector);
return true;
}
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndex iNewElts;
if ( rb0->isChecked() )
else if ( rb1->isChecked() )
{
QModelIndex icenter = patternDataModel->mapToSource( _index[center_le] );
- QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
- QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le] );
+ QModelIndex iaxis = patternDataModel->mapToSource( _index[axis_le] );
+ QModelIndex ibase = patternDataModel->mapToSource( _index[base_le] );
+ QModelIndex ivec = patternDataModel->mapToSource( _index[vec_le] );
+// QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
+// QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le] );
if ( icenter.isValid() && iaxis.isValid() && ibase.isValid() && ivec.isValid() )
{
} else if ( rb2->isChecked() )
{
QModelIndex icenter = patternDataModel->mapToSource( _index[center_le] );
- QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
- QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le] );
+ QModelIndex iaxis = patternDataModel->mapToSource( _index[axis_le] );
+ QModelIndex ibase = patternDataModel->mapToSource( _index[base_le] );
+ QModelIndex ivec = patternDataModel->mapToSource( _index[vec_le] );
+// QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
+// QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le] );
if ( icenter.isValid() && iaxis.isValid() && ibase.isValid() && ivec.isValid() )
{
iNewElts = docModel->makeCartesian( icenter, ibase, ivec, iaxis,
radius, angles, heights);
}
-
}
if ( !iNewElts.isValid() )
return false;
}
- result = patternBuilderModel->mapFromSource( iNewElts );
+ result = patternDataModel->mapFromSource(iNewElts);
+// result = patternBuilderModel->mapFromSource( iNewElts );
return true;
}
void MakeCylinderDialog::_initInputWidget( Mode editmode )
{
- origin_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE));
- axis_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
- base_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE));
-
installEventFilter(this);
- origin_le->installEventFilter(this);
- axis_le->installEventFilter(this);
- base_le->installEventFilter(this);
+ rb0->installEventFilter(this);
+ rb1->installEventFilter(this);
+ rb2->installEventFilter(this);
+
+ origin_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE));
+ origin_le->installEventFilter(this);
origin_le->setReadOnly(true);
+
+ axis_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
+ axis_le->installEventFilter(this);
axis_le->setReadOnly(true);
+
+ base_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE));
+ base_le->installEventFilter(this);
base_le->setReadOnly(true);
+ ext_radius_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ ext_radius_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ ext_radius_spb->setProperty("Radius", QVariant::fromValue(true));
+ ext_radius_spb->installEventFilter(this);
+
+ int_radius_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ int_radius_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ int_radius_spb->setProperty("Radius", QVariant::fromValue(true));
+ int_radius_spb->installEventFilter(this);
+
+ angle_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angle_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angle_spb->setProperty("Angle", QVariant::fromValue(true));
+ angle_spb->installEventFilter(this);
+
+ height_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_spb->setProperty("Length", QVariant::fromValue(true));
+ height_spb->installEventFilter(this);
+
+ radius_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ radius_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ radius_lw->setProperty("Radius", QVariant::fromValue(true));
+ radius_lw->installEventFilter(this);
+
+
+ angle_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angle_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angle_lw->setProperty("Angle", QVariant::fromValue(true));
+ angle_lw->installEventFilter(this);
+
+ height_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_lw->setProperty("Length", QVariant::fromValue(true));
+ height_lw->installEventFilter(this);
+
radius_lw->setItemDelegate(new HexaPositiveDoubleSpinBoxDelegate(radius_lw));
radius_lw->setEditTriggers(QAbstractItemView::DoubleClicked);
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndex iorigin = patternDataModel->mapToSource( _index[origin_le] );
- QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
- QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
+ QModelIndex iaxis = patternDataModel->mapToSource( _index[axis_le] );
+ QModelIndex ibase = patternDataModel->mapToSource( _index[base_le] );
+// QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
+// QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
double rext = ext_radius_spb->value();
double rint = int_radius_spb->value();
double angle = angle_spb->value();
return false;
}
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
axis_le->installEventFilter(this);
base_le->installEventFilter(this);
+ rb0->installEventFilter(this);
+ rb1->installEventFilter(this);
+ rb2->installEventFilter(this);
+
origin_le->setReadOnly(true);
axis_le->setReadOnly(true);
base_le->setReadOnly(true);
+ ext_radius_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ ext_radius_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ ext_radius_spb->setProperty("Radius", QVariant::fromValue(true));
+ ext_radius_spb->installEventFilter(this);
+
+ int_radius_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ int_radius_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ int_radius_spb->setProperty("Radius", QVariant::fromValue(true));
+ int_radius_spb->installEventFilter(this);
+
+ angle_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angle_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angle_spb->setProperty("Angle", QVariant::fromValue(true));
+ angle_spb->installEventFilter(this);
+
+ height_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_spb->setProperty("Length", QVariant::fromValue(true));
+ height_spb->installEventFilter(this);
+
+ radius_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ radius_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ radius_lw->setProperty("Radius", QVariant::fromValue(true));
+ radius_lw->installEventFilter(this);
+
+ angle_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angle_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angle_lw->setProperty("Angle", QVariant::fromValue(true));
+ angle_lw->installEventFilter(this);
+
+ height_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_lw->setProperty("Length", QVariant::fromValue(true));
+ height_lw->installEventFilter(this);
+
radius_lw->setItemDelegate(new HexaPositiveDoubleSpinBoxDelegate(radius_lw));
radius_lw->setEditTriggers(QAbstractItemView::DoubleClicked);
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndex iorigin = patternDataModel->mapToSource( _index[origin_le] );
- QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
- QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
+ QModelIndex iaxis = patternDataModel->mapToSource( _index[axis_le] );
+ QModelIndex ibase = patternDataModel->mapToSource( _index[base_le] );
+// QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
+// QModelIndex ibase = patternBuilderModel->mapToSource( _index[base_le] );
double rext = ext_radius_spb->value();
double rint = int_radius_spb->value();
double angle = angle_spb->value();
}
// to select/highlight result
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
direction_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
direction2_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
+ radius_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ radius_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ radius_spb->setProperty("Radius", QVariant::fromValue(true));
+ radius_spb->installEventFilter(this);
+
+ height_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_spb->setProperty("Length", QVariant::fromValue(true));
+ height_spb->installEventFilter(this);
+
+ radius2_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ radius2_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ radius2_spb->setProperty("Radius", QVariant::fromValue(true));
+ radius2_spb->installEventFilter(this);
+
+ height2_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height2_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height2_spb->setProperty("Length", QVariant::fromValue(true));
+ height2_spb->installEventFilter(this);
+
installEventFilter(this);
center_le->installEventFilter(this);
center2_le->installEventFilter(this);
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndex iElts;
QModelIndex icenter = patternDataModel->mapToSource( _index[center_le] );
QModelIndex icenter2 = patternDataModel->mapToSource( _index[center2_le] );
- QModelIndex idir = patternBuilderModel->mapToSource( _index[direction_le] );
- QModelIndex idir2 = patternBuilderModel->mapToSource( _index[direction2_le] );
+ QModelIndex idir = patternDataModel->mapToSource( _index[direction_le] );
+ QModelIndex idir2 = patternDataModel->mapToSource( _index[direction2_le] );
+// QModelIndex idir = patternBuilderModel->mapToSource( _index[direction_le] );
+// QModelIndex idir2 = patternBuilderModel->mapToSource( _index[direction2_le] );
if ( icenter.isValid() && icenter2.isValid() && idir.isValid() && idir2.isValid()){
double r1 = radius_spb->value();
return false;
}
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
dir_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
dir2_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
- installEventFilter(this);
+ ext_radius_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ ext_radius_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ ext_radius_spb->setProperty("Radius", QVariant::fromValue(true));
+ ext_radius_spb->installEventFilter(this);
+
+ int_radius_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ int_radius_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ int_radius_spb->setProperty("Radius", QVariant::fromValue(true));
+ int_radius_spb->installEventFilter(this);
+
+ height_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_spb->setProperty("Length", QVariant::fromValue(true));
+ height_spb->installEventFilter(this);
+
+ ext_radius2_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ ext_radius2_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ ext_radius2_spb->setProperty("Radius", QVariant::fromValue(true));
+ ext_radius2_spb->installEventFilter(this);
+
+ int_radius2_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ int_radius2_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ int_radius2_spb->setProperty("Radius", QVariant::fromValue(true));
+ int_radius2_spb->installEventFilter(this);
+
+ height2_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height2_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height2_spb->setProperty("Length", QVariant::fromValue(true));
+ height2_spb->installEventFilter(this);
+
origin_le->installEventFilter(this);
origin2_le->installEventFilter(this);
dir_le->installEventFilter(this);
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndex iorigin1 = patternDataModel->mapToSource( _index[origin_le] );
QModelIndex iorigin2 = patternDataModel->mapToSource( _index[origin2_le] );
- QModelIndex idir1 = patternBuilderModel->mapToSource( _index[dir_le] );
- QModelIndex idir2 = patternBuilderModel->mapToSource( _index[dir2_le] );
+ QModelIndex idir1 = patternDataModel->mapToSource( _index[dir_le] );
+ QModelIndex idir2 = patternDataModel->mapToSource( _index[dir2_le] );
+// QModelIndex idir1 = patternBuilderModel->mapToSource( _index[dir_le] );
+// QModelIndex idir2 = patternBuilderModel->mapToSource( _index[dir2_le] );
double rint1 = int_radius_spb->value();
double rext1 = ext_radius_spb->value();
double height1 = height_spb->value();
return false;
}
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
quads_lw->setProperty( "HexaWidgetType", QVariant::fromValue(QUAD_TREE) );
axis_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
+ length_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ length_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ length_spb->setProperty("Length", QVariant::fromValue(true));
+ length_spb->installEventFilter(this);
+
+
+ height_lw->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_lw->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_lw->setProperty("Length", QVariant::fromValue(true));
+ height_lw->installEventFilter(this);
+
installEventFilter(this);
quads_lw->installEventFilter(this);
axis_le->installEventFilter(this);
+ extrudeTop_rb->installEventFilter(this);
+ extrudeUni_rb->installEventFilter(this);
+ extrude_rb->installEventFilter(this);
+
axis_le->setReadOnly(true);
QShortcut* delQuadShortcut = new QShortcut( QKeySequence(Qt::Key_X), quads_lw );
_currentObj = NULL;
DocumentModel* docModel = getDocumentModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ PatternDataModel* patternDataModel = getPatternDataModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndexList iquads = getIndexList(quads_lw);
- QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
+ QModelIndex iaxis = patternDataModel->mapToSource( _index[axis_le] );
+// QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
double length = length_spb->value();
int nb = nb_spb->value();
return false;
}
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
vex2_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
vex3_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
+ height_lw->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_lw->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_lw->setProperty("Length", QVariant::fromValue(true));
+ height_lw->installEventFilter(this);
+
installEventFilter(this);
quad_dest_le->installEventFilter(this);
quads_lw->installEventFilter(this);
vex2_le->installEventFilter(this);
vex3_le->installEventFilter(this);
+ joinUni_rb->installEventFilter(this);
+ join_rb->installEventFilter(this);
+
QShortcut* delQuadShortcut = new QShortcut( QKeySequence(Qt::Key_X), quads_lw );
delQuadShortcut->setContext( Qt::WidgetShortcut );
connect( delQuadShortcut, SIGNAL(activated()), this, SLOT(removeQuad()) );
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndexList iquads;
QModelIndex iquad;
SUIT_MessageBox::critical( this, tr( "ERR_ERROR" ), tr( "CANNOT JOIN QUAD(S)" ) + "\n" + getErrorMsg() );
return false;
}
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
_currentObj = NULL;
if (getDocumentModel() == NULL) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/) return false;
QModelIndex iElts;
return false;
}
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
e_le->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
e_le->installEventFilter(this);
+ cutUni_rb->installEventFilter(this);
+ cut_rb->installEventFilter(this);
+
e_le->setReadOnly(true);
+ height_lw->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ height_lw->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ height_lw->setProperty("Length", QVariant::fromValue(true));
+ height_lw->installEventFilter(this);
+
height_lw->setItemDelegate(new HexaPositiveDoubleSpinBoxDelegate(height_lw));
height_lw->setEditTriggers(QAbstractItemView::DoubleClicked);
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndex iElts;
QModelIndex iedge = patternDataModel->mapToSource( _index[e_le] );
return false;
}
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
//Update the line edit
QVariant invalid;
QValidator *validator = new QRegExpValidator(rx, this);
installEventFilter(this);
+ rb0->installEventFilter(this);
+ rb1->installEventFilter(this);
+ rb2->installEventFilter(this);
vec_le_rb0->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
elts_le_rb0->setProperty( "HexaWidgetType", QVariant::fromValue(ELEMENTS_TREE) );
vec_le_rb2->installEventFilter(this);
elts_le_rb2->installEventFilter(this);
+ angle_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angle_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angle_spb->setProperty("Angle", QVariant::fromValue(true));
+ angle_spb->installEventFilter(this);
+
vec_le_rb0->setReadOnly(true);
elts_le_rb0->setReadOnly(true);
if (getDocumentModel() == NULL) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/) return false;
QModelIndex iNewElts;
if ( rb0->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb0] );
+ QModelIndex ielts = patternDataModel->mapToSource( _index[elts_le_rb0] );
+ QModelIndex ivec = patternDataModel->mapToSource( _index[vec_le_rb0] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb0] );
if ( ielts.isValid()
&& ivec.isValid() )
iNewElts = getDocumentModel()->makeTranslation( ielts, ivec );
} else if ( rb1->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+ QModelIndex ielts = patternDataModel->mapToSource( _index[elts_le_rb1] );
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb1] );
double k = k_spb->value();
iNewElts = getDocumentModel()->makeScale( ielts, ivex, k );
} else if ( rb2->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+ QModelIndex ielts = patternDataModel->mapToSource( _index[elts_le_rb2] );
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb2] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+ QModelIndex ivec = patternDataModel->mapToSource( _index[vec_le_rb2] );
double angle = angle_spb->value();
if ( ielts.isValid()
return false;
}
- result = patternBuilderModel->mapFromSource(iNewElts);
+ result = patternDataModel->mapFromSource(iNewElts);
+ if (result.isValid())
+ {
+ MESSAGE("======> Result is valid!");
+ HEXA_NS::Elements* elts = getDocumentModel()->getHexaPtr<HEXA_NS::Elements*>(result);
+ MESSAGE("======> " << elts->getName());
+ }
+ else
+ {
+ MESSAGE("======> Result is not valid!");
+ }
+// result = patternBuilderModel->mapFromSource(iNewElts);
return true;
}
_currentObj = NULL;
if (getDocumentModel() == NULL) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/) return false;
QModelIndex iNewElts;
if ( rb0->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
+ QModelIndex ielts = patternDataModel->mapToSource( _index[elts_le_rb0] );
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb0] );
if ( ielts.isValid()
} else if ( rb1->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+ QModelIndex ielts = patternDataModel->mapToSource( _index[elts_le_rb1] );
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb1] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb1] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb1] );
+ QModelIndex ivec = patternDataModel->mapToSource( _index[vec_le_rb1] );
if ( ielts.isValid()
&& ivex.isValid()
iNewElts = getDocumentModel()->makeSymmetryLine( ielts, ivex, ivec );
} else if ( rb2->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+ QModelIndex ielts = patternDataModel->mapToSource(_index[elts_le_rb2]);
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb2] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+ QModelIndex ivec = patternDataModel->mapToSource(_index[vec_le_rb2]);
if ( ielts.isValid()
&& ivex.isValid()
return false;
}
- result = patternBuilderModel->mapFromSource(iNewElts);
+// result = patternBuilderModel->mapFromSource(iNewElts);
+ result = patternDataModel->mapFromSource(iNewElts);
return true;
}
QRegExp rx("");
QValidator *validator = new QRegExpValidator(rx, this);
+ installEventFilter(this);
+ rb0->installEventFilter(this);
+ rb1->installEventFilter(this);
+ rb2->installEventFilter(this);
+
vec_le_rb0->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
elts_le_rb0->setProperty( "HexaWidgetType", QVariant::fromValue(ELEMENTS_TREE) );
vec_le_rb0->setValidator( validator );
vec_le_rb2->installEventFilter(this);
elts_le_rb2->installEventFilter(this);
+ angle_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angle_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angle_spb->setProperty("Angle", QVariant::fromValue(true));
+ angle_spb->installEventFilter(this);
+
vec_le_rb0->setReadOnly(true);
elts_le_rb0->setReadOnly(true);
vex_le_rb1->setReadOnly(true);
if (getDocumentModel() == NULL) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/) return false;
bool performed = false;
if ( rb0->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb0] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
+ QModelIndex ielts = patternDataModel->mapToSource(_index[elts_le_rb0]);
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb0] );
+ QModelIndex ivec = patternDataModel->mapToSource(_index[vec_le_rb0]);
if ( ielts.isValid()
&& ivec.isValid() )
performed = getDocumentModel()->performTranslation( ielts, ivec );
} else if ( rb1->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+ QModelIndex ielts = patternDataModel->mapToSource(_index[elts_le_rb1]);
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb1] );
double k = k_spb->value();
performed = getDocumentModel()->performScale( ielts, ivex, k );
} else if ( rb2->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+ QModelIndex ielts = patternDataModel->mapToSource(_index[elts_le_rb2]);
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb2] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+ QModelIndex ivec = patternDataModel->mapToSource(_index[vec_le_rb2]);
double angle = angle_spb->value();
if ( ielts.isValid()
if (getDocumentModel() == NULL) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/) return false;
bool performed = false;
if ( rb0->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb0] );
+ QModelIndex ielts = patternDataModel->mapToSource(_index[elts_le_rb0]);
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb0] );
if ( ielts.isValid()
performed = getDocumentModel()->performSymmetryPoint( ielts, ivex );
} else if ( rb1->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb1] );
+ QModelIndex ielts = patternDataModel->mapToSource(_index[elts_le_rb1]);
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb1] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb1] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb1] );
+ QModelIndex ivec = patternDataModel->mapToSource(_index[vec_le_rb1]);
if ( ielts.isValid()
&& ivex.isValid()
performed = getDocumentModel()->performSymmetryLine( ielts, ivex, ivec );
} else if ( rb2->isChecked() ){
- QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+// QModelIndex ielts = patternBuilderModel->mapToSource( _index[elts_le_rb2] );
+ QModelIndex ielts = patternDataModel->mapToSource(_index[elts_le_rb2]);
QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le_rb2] );
- QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le_rb2] );
+ QModelIndex ivec = patternDataModel->mapToSource(_index[vec_le_rb2]);
if ( ielts.isValid()
&& ivex.isValid()
quad_le->installEventFilter(this);
quad_le->setValidator( validator );
-
faces_lw->setProperty( "HexaWidgetType", QVariant::fromValue(GEOMFACE_TREE) );
faces_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_FACE) );
faces_lw->installEventFilter(this);
{
name_le->setReadOnly(true);
kind_cb->setEnabled(false);
+ eltBase_lw->viewport()->setAttribute( Qt::WA_TransparentForMouseEvents );
}
connect(eltBase_lw, SIGNAL(itemSelectionChanged()), this, SLOT(selectElementOfModel()), Qt::UniqueConnection);
{
_helpFileName = "gui_mesh.html";
setWindowTitle( tr("Compute mesh") );
- QVBoxLayout* layout = new QVBoxLayout;
- setLayout(layout);
-
- QHBoxLayout* up = new QHBoxLayout;
- QHBoxLayout* down = new QHBoxLayout;
-
- layout->addLayout(up);
- layout->addLayout(down);
-
- QVBoxLayout* vlg = new QVBoxLayout;
- QVBoxLayout* vld = new QVBoxLayout;
-
- up->addLayout(vlg);
- up->addLayout(vld);
-
- vlg->addWidget(new QLabel("Name"));
- vlg->addWidget(new QLabel("Dimension"));
- vlg->addWidget(new QLabel("Container"));
-
- _name = new QLineEdit("Mesh");
- _dim = new QSpinBox();
- _fact = new QLineEdit("FactoryServer");
-
- vld->addWidget(_name);
- vld->addWidget(_dim);
- vld->addWidget(_fact);
-
- _dim->setRange(1, 3);
- _dim->setValue(3);
-
+ setupUi( this );
_initWidget(editmode);
}
_currentObj = NULL;
if (getDocumentModel() == NULL) return false;
+#ifndef DISABLE_PYCONSOLE
QString command = QString("import hexablock ; %1 = hexablock.mesh(\"%2\", \"%1\", %3, \"%4\")")
.arg( _name->text() )
.arg( getDocumentModel()->getName() )
pyConsole->exec( command );
else
return false;
+#else
+ return false;
+#endif
return true;
}
QListWidgetItem* item = NULL;
//ListWidget content
- const PatternDataModel* patternDataModel = getPatternDataModel();
- if ( !patternDataModel ) return assocs;
int nbQuads = quads_lw->count();
for ( int r = 0; r < nbQuads; ++r ){
item = quads_lw->item(r);
- // iQuad = patternDataModel->mapToSource( item->data(LW_QMODELINDEX_ROLE).value<QModelIndex>() ); //unsafe
+ //iQuad = patternDataModel->mapToSource( item->data(LW_QMODELINDEX_ROLE).value<QModelIndex>() ); //unsafe
iQuad = getPatternDataSelectionModel()->indexBy(HEXA_DATA_ROLE, item->data(LW_DATA_ROLE));
- if ( iQuad.isValid() ) assocs << iQuad;
+ if ( iQuad.isValid() )
+ assocs << iQuad;
+ }
+
+ nbQuads = quads_lw_2->count();
+ for( int i = 0; i < nbQuads; ++i)
+ {
+ item = quads_lw_2->item(i);
+ iQuad = getPatternDataSelectionModel()->indexBy(HEXA_DATA_ROLE, item->data(LW_DATA_ROLE));
+ if (iQuad.isValid())
+ assocs << iQuad;
}
+
return assocs;
}
c1_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
c2_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
- c3_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
p1_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
p2_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
- p3_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
c1_le->installEventFilter(this);
c2_le->installEventFilter(this);
- c3_le->installEventFilter(this);
p1_le->installEventFilter(this);
p2_le->installEventFilter(this);
- p3_le->installEventFilter(this);
quads_lw->setProperty( "HexaWidgetType", QVariant::fromValue(QUAD_TREE) );
quads_lw->installEventFilter(this);
+ quads_lw_2->setProperty("HexaWidgetType", QVariant::fromValue(QUAD_TREE));
+ quads_lw_2->installEventFilter(this);
+
if ( editmode == NEW_MODE ){
QShortcut* delQuadShortcut = new QShortcut( QKeySequence(Qt::Key_X), quads_lw );
+ QShortcut* delQuadShortcut2 = new QShortcut( QKeySequence(Qt::Key_X), quads_lw_2 );
delQuadShortcut->setContext( Qt::WidgetShortcut );
-
+ delQuadShortcut2->setContext( Qt::WidgetShortcut );
connect( delQuadShortcut, SIGNAL(activated()), this, SLOT(deleteQuadItem()) );
connect( quads_lw, SIGNAL(currentRowChanged(int)), this, SLOT(updateButtonBox(int)) );
+ connect( delQuadShortcut2, SIGNAL(activated()), this, SLOT(deleteQuadItem2()));
+ connect( quads_lw_2, SIGNAL(currentRowChanged(int)), this, SLOT(updateButtonBox(int)) );
}
c1_le->setReadOnly(true);
c2_le->setReadOnly(true);
- c3_le->setReadOnly(true);
p1_le->setReadOnly(true);
p2_le->setReadOnly(true);
- p3_le->setReadOnly(true);
connect(quads_lw, SIGNAL(itemSelectionChanged()),
this, SLOT(selectElementOfModel()), Qt::UniqueConnection);
+
+ connect(quads_lw_2, SIGNAL(itemSelectionChanged()),
+ this, SLOT(selectElementOfModel()), Qt::UniqueConnection);
}
// ============================================================== clear
quads_lw->clear();
modelUnregister(quads_lw);
+ quads_lw_2->clear();
+ modelUnregister(quads_lw_2);
+
p1_le->clear();
modelUnregister(p1_le);
p2_le->clear();
modelUnregister(p2_le);
- p3_le->clear();
- modelUnregister(p3_le);
-
c1_le->clear();
modelUnregister(c1_le);
c2_le->clear();
modelUnregister(c2_le);
- c3_le->clear();
- modelUnregister(c3_le);
-
modelUnregister(this);
}
updateButtonBox();
}
+// ============================================================== deleteQuadItem2
+void ReplaceHexaDialog::deleteQuadItem2()
+{
+ delete quads_lw_2->currentItem();
+ updateButtonBox();
+}
+
// ============================================================== apply
bool ReplaceHexaDialog::apply(QModelIndex& result)
{
if ( !getDocumentModel() ) return false;
const PatternDataModel* patternDataModel = getPatternDataModel();
- const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
- if ( !patternDataModel || !patternBuilderModel) return false;
+// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+ if ( !patternDataModel /*|| !patternBuilderModel*/) return false;
QModelIndex ielts; //result
QListWidgetItem* item = NULL;
- QModelIndexList iquads;
+ QModelIndexList iquads_source;
QModelIndex iquad;
int nbQuads = quads_lw->count();
for ( int r = 0; r < nbQuads; ++r){
item = quads_lw->item(r);
iquad = patternDataModel->mapToSource( item->data(LW_QMODELINDEX_ROLE).value<QModelIndex>() );
if ( iquad.isValid() )
- iquads << iquad;
+ iquads_source << iquad;
+ }
+
+ QModelIndexList iquads_dest;
+ nbQuads = quads_lw_2->count();
+ for (int i = 0; i < nbQuads; ++i)
+ {
+ item = quads_lw_2->item(i);
+ iquad = patternDataModel->mapToSource( item->data(LW_QMODELINDEX_ROLE).value<QModelIndex>() );
+ if (iquad.isValid())
+ iquads_dest << iquad;
}
- QModelIndex ic1 = patternDataModel->mapToSource( _index[c1_le] );
- QModelIndex ic2 = patternDataModel->mapToSource( _index[c2_le] );
- QModelIndex ic3 = patternDataModel->mapToSource( _index[c3_le] );
+ QModelIndex ip1_source = patternDataModel->mapToSource( _index[p1_le] );
+ QModelIndex ip2_source = patternDataModel->mapToSource( _index[p2_le] );
- QModelIndex ip1 = patternDataModel->mapToSource( _index[p1_le] );
- QModelIndex ip2 = patternDataModel->mapToSource( _index[p2_le] );
- QModelIndex ip3 = patternDataModel->mapToSource( _index[p3_le] );
+ QModelIndex ic1_dest = patternDataModel->mapToSource( _index[c1_le] );
+ QModelIndex ic2_dest = patternDataModel->mapToSource( _index[c2_le] );
- if ( ic1.isValid() && ic2.isValid() && ic3.isValid()
- && ip1.isValid() && ip2.isValid() && ip3.isValid() ){
- ielts = getDocumentModel()->replace( iquads,
- ip1, ic1,
- ip2, ic2,
- ip3, ic3 );
+ bool ipts_ok = ip1_source.isValid() && ip2_source.isValid() &&
+ ic1_dest.isValid() && ic2_dest.isValid();
+
+ if (ipts_ok)
+ {
+ ielts = getDocumentModel()->replace( iquads_source, iquads_dest,
+ ip1_source, ic1_dest,
+ ip2_source, ic2_dest );
}
if ( !ielts.isValid() ){
return false;
}
_value = ielts.model()->data(ielts, HEXA_DATA_ROLE).value<HEXA_NS::Elements*>();
- result = patternBuilderModel->mapFromSource(ielts);
+// result = patternBuilderModel->mapFromSource(ielts);
+ result = patternDataModel->mapFromSource(ielts);
//update the list (indexes)
for ( int r = 0; r < nbQuads; ++r ){
center_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
axis_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
+ angle_spb->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angle_spb->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angle_spb->setProperty("Angle", QVariant::fromValue(true));
+ angle_spb->installEventFilter(this);
+
+ angles_lw->setProperty("HexaWidgetType", QVariant::fromValue(EDGE_TREE));
+ angles_lw->setProperty("GeomWidgetType", QVariant::fromValue(TopAbs_EDGE));
+ angles_lw->setProperty("Angle", QVariant::fromValue(true));
+ angles_lw->installEventFilter(this);
+
installEventFilter(this);
+ revolutionUni_rb->installEventFilter(this);
+ revolution_rb->installEventFilter(this);
+
quads_lw->installEventFilter(this);
center_le->installEventFilter(this);
axis_le->installEventFilter(this);
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QListWidgetItem* item = NULL;
}
QModelIndex icenter = patternDataModel->mapToSource( _index[center_le] );
- QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
+ QModelIndex iaxis = patternDataModel->mapToSource(_index[axis_le]);
+// QModelIndex iaxis = patternBuilderModel->mapToSource( _index[axis_le] );
int angle = angle_spb->value();
int nbre = nbre_spb->value();
return false;
}
_value = iElts.model()->data(iElts, HEXA_DATA_ROLE).value<HEXA_NS::Elements*>();
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
connect( sphereTop_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
connect( sphereUni_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
- connect( sphere2_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
- connect( sphere_rb, SIGNAL(clicked()), this, SLOT(clearVTKSelection()) );
- connect( sphere_rb, SIGNAL(clicked()), this, SLOT(clearCurrentObjectFocus()) );
+ connect( sphere2_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
+ connect( sphere_rb, SIGNAL(clicked()), this, SLOT(clearVTKSelection()) );
+ connect( sphere_rb, SIGNAL(clicked()), this, SLOT(clearCurrentObjectFocus()) );
connect( sphericalTop_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
connect( sphericalUni_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
- connect( spherical2_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
- connect( spherical_rb, SIGNAL(clicked()), this, SLOT(clearVTKSelection()) );
- connect( spherical_rb, SIGNAL(clicked()), this, SLOT(clearCurrentObjectFocus()) );
+ connect( spherical2_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
+ connect( spherical_rb, SIGNAL(clicked()), this, SLOT(clearVTKSelection()) );
+ connect( spherical_rb, SIGNAL(clicked()), this, SLOT(clearCurrentObjectFocus()) );
connect( rindTop_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
connect( rindUni_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
- connect( rind2_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
- connect( rind_rb, SIGNAL(clicked()), this, SLOT(clearVTKSelection()) );
- connect( rind_rb, SIGNAL(clicked()), this, SLOT(clearCurrentObjectFocus()) );
+ connect( rind2_rb, SIGNAL(clicked()), this, SLOT(updateHelpFileName()) );
+ connect( rind_rb, SIGNAL(clicked()), this, SLOT(clearVTKSelection()) );
+ connect( rind_rb, SIGNAL(clicked()), this, SLOT(clearCurrentObjectFocus()) );
}
// ============================================================== Destructeur
base_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
vplan_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
+ sphere_radext_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ sphere_radext_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ sphere_radext_spb->setProperty("Radius", QVariant::fromValue(true));
+
+ sphere_radint_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ sphere_radint_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ sphere_radint_spb->setProperty("Radius", QVariant::fromValue(true));
+
+ hole_rad_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ hole_rad_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ hole_rad_spb->setProperty("Radius", QVariant::fromValue(true));
+
+ radial_angle_spb->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ radial_angle_spb->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ radial_angle_spb->setProperty("Angle", QVariant::fromValue(true));
+
+ radius_lw_1->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ radius_lw_1->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ radius_lw_1->setProperty("Radius", QVariant::fromValue(true));
+
+ radius_lw_2->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ radius_lw_2->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ radius_lw_2->setProperty("Radius", QVariant::fromValue(true));
+
+ height_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ height_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ height_lw->setProperty("Length", QVariant::fromValue(true));
+
+ angle_lw->setProperty( "HexaWidgetType", QVariant::fromValue(EDGE_TREE) );
+ angle_lw->setProperty( "GeomWidgetType", QVariant::fromValue(TopAbs_EDGE) );
+ angle_lw->setProperty("Angle", QVariant::fromValue(true));
+
installEventFilter(this);
center_le->installEventFilter(this);
hole_axis_le->installEventFilter(this);
base_le->installEventFilter(this);
vplan_le->installEventFilter(this);
+ sphere_radext_spb->installEventFilter(this);
+ sphere_radint_spb->installEventFilter(this);
+ hole_rad_spb->installEventFilter(this);
+ radial_angle_spb->installEventFilter(this);
+ radius_lw_1->installEventFilter(this);
+ radius_lw_2->installEventFilter(this);
+ height_lw->installEventFilter(this);
+ angle_lw->installEventFilter(this);
+
+ sphere_rb->installEventFilter(this);
+ sphereTop_rb->installEventFilter(this);
+ sphereUni_rb->installEventFilter(this);
+ sphere2_rb->installEventFilter(this);
+ rind_rb->installEventFilter(this);
+ rindTop_rb->installEventFilter(this);
+ rindUni_rb->installEventFilter(this);
+ rind2_rb->installEventFilter(this);
+ spherical_rb->installEventFilter(this);
+ sphericalTop_rb->installEventFilter(this);
+ sphericalUni_rb->installEventFilter(this);
+ spherical2_rb->installEventFilter(this);
+
center_le->setReadOnly(true);
hole_axis_le->setReadOnly(true);
base_le->setReadOnly(true);
DocumentModel* docModel = getDocumentModel();
PatternDataModel* patternDataModel = getPatternDataModel();
- PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
+// PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
QModelIndex iElts;
QModelIndex icenter = patternDataModel->mapToSource( _index[center_le] );
QModelIndex ivplan = patternDataModel->mapToSource( _index[vplan_le] );
- QModelIndex ivecx = patternBuilderModel->mapToSource( _index[base_le] );
- QModelIndex ivecz = patternBuilderModel->mapToSource( _index[hole_axis_le] );
+ QModelIndex ivecx = patternDataModel->mapToSource(_index[base_le]);
+ QModelIndex ivecz = patternDataModel->mapToSource(_index[hole_axis_le]);
+// QModelIndex ivecx = patternBuilderModel->mapToSource( _index[base_le] );
+// QModelIndex ivecz = patternBuilderModel->mapToSource( _index[hole_axis_le] );
double radhole = hole_rad_spb->value();
double radext = sphere_radext_spb->value();
return false;
}
_value = iElts.model()->data(iElts, HEXA_DATA_ROLE).value<HEXA_NS::Elements*>();
- result = patternBuilderModel->mapFromSource(iElts);
+ result = patternDataModel->mapFromSource(iElts);
+// result = patternBuilderModel->mapFromSource(iElts);
return true;
}
AddShapeDialog::AddShapeDialog(QWidget* parent, Mode editmode, Qt::WindowFlags wf):
HexaBaseDialog(parent, editmode, wf)
{
- _helpFileName = "";
+ _helpFileName = "gui_add_geometry.html#guiaddgeometry";
setupUi( this );
_initWidget(editmode);
setWindowTitle(HEXABLOCKGUI::tr("ADD_SHAPE"));
return true;
}
-
-
-
-
-
-
-//***************************** OBSOLETE: A SUPPRIMER !!!! ************************************//
-
-// ============================================================== Constructeur
-CylinderDialog::CylinderDialog( QWidget* parent, Mode editmode, Qt::WindowFlags f )
-: HexaBaseDialog(parent, editmode, f),
- _value(0)
-{
- _helpFileName = "gui_cyl.html";
- setupUi( this );
- _initWidget(editmode);
-
- if ( editmode == INFO_MODE ){
- setWindowTitle( tr("Cylinder Information") );
- }
-}
-
-// ============================================================== Destructeur
-CylinderDialog::~CylinderDialog()
-{
-}
-
-// ============================================================== _initInputWidget
-void CylinderDialog::_initInputWidget( Mode editmode )
-{
- QRegExp rx("");
- QValidator *validator = new QRegExpValidator(rx, this);
-
- installEventFilter(this);
- name_le->installEventFilter(this);
-
- vex_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
- vec_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
-
- vex_le->setValidator( validator );
- vec_le->setValidator( validator );
-
- vex_le->installEventFilter(this);
- vec_le->installEventFilter(this);
-
- vex_le->setReadOnly(true);
- vec_le->setReadOnly(true);
-
- if (editmode == INFO_MODE)
- {
- name_le->setReadOnly(true);
- r_spb->setReadOnly(true);
- h_spb->setReadOnly(true);
- }
-
-}
-
-// ============================================================== clear
-void CylinderDialog::clear()
-{
- name_le->clear();
-
- vex_le->clear();
- modelUnregister(vex_le);
-
- vec_le->clear();
- modelUnregister(vec_le);
-
- r_spb->clear();
- h_spb->clear();
-
- modelUnregister(this);
-
-}
-
-// ============================================================== setValue
-void CylinderDialog::setValue(HEXA_NS::Cylinder* c)
-{
- HEXA_NS::Vertex* base = c->getBase();
- HEXA_NS::Vector* direction = c->getDirection();
- double r = c->getRadius();
- double h = c->getHeight();
-
- name_le->setText( c->getName() );
- vex_le->setText( base->getName() );
- vec_le->setText( direction->getName() );
- r_spb->setValue(r);
- h_spb->setValue(h);
-
- if ( getPatternDataSelectionModel() ){
- QModelIndex iCyl = getPatternDataSelectionModel()->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(c) );
- QModelIndex iBase = getPatternDataSelectionModel()->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(base) );
- QModelIndex iDirection = getPatternDataSelectionModel()->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(direction) );
-
- name_le->setProperty( "QModelIndex", QVariant::fromValue(iCyl) );
- vex_le->setProperty( "QModelIndex", QVariant::fromValue(iBase) );
- vec_le->setProperty( "QModelIndex", QVariant::fromValue(iDirection) );
- }
- _value = c;
-}
-
-// ============================================================== getValue
-HEXA_NS::Cylinder* CylinderDialog::getValue()
-{
- return _value;
-}
-
-// ============================================================== apply
-bool CylinderDialog::apply(QModelIndex& result)
-{
-// if (_currentObj != NULL) _highlightWidget(_currentObj, Qt::white);
-// _currentObj = NULL;
-//
-// if ( !getDocumentModel() ) return false;
-// const PatternDataModel* patternDataModel = getPatternDataModel();
-// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
-// if ( !patternDataModel || !patternBuilderModel) return false;
-//
-// QModelIndex iCyl;
-// QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le] );
-// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le] );
-// double r = r_spb->value();
-// double h = h_spb->value();
-//
-// if ( ivex.isValid()
-// && ivec.isValid() ){
-// iCyl = getDocumentModel()->addCylinder( ivex, ivec, r, h );
-// }
-//
-// if ( !iCyl.isValid() ){
-// SUIT_MessageBox::critical( this, tr( "ERR_ERROR" ), tr( "CANNOT ADD CYLINDER" ) );
-// return false;
-// }
-//
-// _value = iCyl.model()->data(iCyl, HEXA_DATA_ROLE).value<HEXA_NS::Cylinder *>();
-//
-// QString newName = name_le->text();
-// if (!newName.isEmpty()) /*{*/
-// getDocumentModel()->setName( iCyl, newName );
-//
-// //update the default name in the dialog box
-// if (_value != NULL)
-// updateDefaultName(name_le, _value->getType());
-//
-// // to select/highlight result
-// result = patternBuilderModel->mapFromSource(iCyl);
-
- return true;
-}
-
-//------------------------------- PipeDialog -----------------------------------
-
-// ============================================================== Constructeur
-
-PipeDialog::PipeDialog( QWidget* parent, Mode editmode, Qt::WindowFlags f )
-: HexaBaseDialog(parent, editmode, f),
- _value(0)
-{
- _helpFileName = "gui_pipe.html";
- setupUi( this );
- _initWidget(editmode);
- // setFocusProxy( vex_le );
-
- if ( editmode == INFO_MODE ){
- setWindowTitle( tr("Pipe Information") );
- }
-
-}
-
-// ============================================================== Destructeur
-PipeDialog::~PipeDialog()
-{
-}
-
-// ============================================================== _initInputWidget
-void PipeDialog::_initInputWidget( Mode editmode )
-{
- QRegExp rx("");
- QValidator *validator = new QRegExpValidator(rx, this);
-
- installEventFilter(this);
- name_le->installEventFilter(this);
-
- //Vertex Field config
- vex_le->setProperty( "HexaWidgetType", QVariant::fromValue(VERTEX_TREE) );
- vex_le->installEventFilter(this);
- vex_le->setValidator( validator );
-
- //Vector Field config
- vec_le->setProperty( "HexaWidgetType", QVariant::fromValue(VECTOR_TREE) );
- vec_le->installEventFilter(this);
- vec_le->setValidator( validator );
-
-
- if ( editmode == INFO_MODE ){
- name_le->setReadOnly(true);
- ir_spb->setReadOnly(true);
- er_spb->setReadOnly(true);
- h_spb->setReadOnly(true);
- }
-
- vex_le->setReadOnly(true);
- vec_le->setReadOnly(true);
-
- //connect( name_le, SIGNAL(returnPressed()), this, SLOT(updateName()));
-}
-
-// ============================================================== clear
-void PipeDialog::clear()
-{
- name_le->clear();
-
- vex_le->clear();
- modelUnregister(vex_le);
-
- vec_le->clear();
- modelUnregister(vec_le);
-
- modelUnregister(this);
-}
-
-// ============================================================== setValue
-void PipeDialog::setValue(HEXA_NS::Pipe* p)
-{
- HEXA_NS::Vertex* base = p->getBase();
- HEXA_NS::Vector* direction = p->getDirection();
- double ir = p->getInternalRadius();
- double er = p->getRadius();
- double h = p->getHeight();
-
- name_le->setText( p->getName() );
- vex_le->setText( base->getName() );
- vec_le->setText( direction->getName() );
- ir_spb->setValue(ir);
- er_spb->setValue(er);
- h_spb->setValue(h);
-
- if ( getPatternDataSelectionModel() ){
- QModelIndex iPipe = getPatternDataSelectionModel()->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(p) );
- QModelIndex iBase = getPatternDataSelectionModel()->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(base) );
- QModelIndex iDirection = getPatternDataSelectionModel()->indexBy( HEXA_DATA_ROLE, QVariant::fromValue(direction) );
-
- name_le->setProperty( "QModelIndex", QVariant::fromValue(iPipe) );
- vex_le->setProperty( "QModelIndex", QVariant::fromValue(iBase) );
- vec_le->setProperty( "QModelIndex", QVariant::fromValue(iDirection) );
- }
- _value = p;
-}
-
-// ============================================================== getValue
-HEXA_NS::Pipe* PipeDialog::getValue()
-{
- return _value;
-}
-
-// ============================================================== apply
-bool PipeDialog::apply(QModelIndex& result)
-{
-// if (_currentObj != NULL) _highlightWidget(_currentObj, Qt::white);
-// _currentObj = NULL;
-//
-// if ( !getDocumentModel() ) return false;
-// const PatternDataModel* patternDataModel = getPatternDataModel();
-// const PatternBuilderModel* patternBuilderModel = getPatternBuilderModel();
-// if ( !patternDataModel || !patternBuilderModel) return false;
-//
-// QModelIndex iPipe;
-// QModelIndex ivex = patternDataModel->mapToSource( _index[vex_le] );
-// QModelIndex ivec = patternBuilderModel->mapToSource( _index[vec_le] );
-// double ir = ir_spb->value();
-// double er = er_spb->value();
-// double h = h_spb->value();
-//
-// if (ir >= er) {
-// SUIT_MessageBox::information( this, tr( "CANNOT ADD PIPE" ), tr( "External radius must be greather than Internal radius!" ) );
-// return false;
-// }
-//
-//
-// if ( ivex.isValid()
-// && ivec.isValid() ){
-// iPipe = getDocumentModel()->addPipe( ivex, ivec, ir, er, h );
-// }
-//
-// if ( !iPipe.isValid() ){
-// SUIT_MessageBox::critical( this, tr( "ERR_ERROR" ), tr( "CANNOT ADD PIPE" ) );
-// return false;
-// }
-// _value = iPipe.model()->data(iPipe, HEXA_DATA_ROLE).value<HEXA_NS::Pipe *>();
-//
-// QString newName = name_le->text();
-// if ( !newName.isEmpty() )/*{*/
-// getDocumentModel()->setName( iPipe, newName );
-//
-// //update the default name in the dialog box
-// if (_value != NULL)
-// updateDefaultName(name_le, _value->getType());
-//
-// // to select/highlight result
-// result = patternBuilderModel->mapFromSource(iPipe);
-
- return true;
-}
-// ************************************** FIN A SUPPRIMER ******************************************//
-
