--- /dev/null
+// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File : GEOMToolsGUI_MaterialPropertiesDlg.cxx
+// Author : Margarita KARPUNINA, Open CASCADE S.A.S. (margarita.karpunina@opencascade.com)
+
+#include "GEOMToolsGUI_MaterialPropertiesDlg.h"
+
+#include "GeometryGUI.h"
+#include "GEOM_Constants.h"
+#include "GEOM_VTKPropertyMaterial.hxx"
+#include "GEOMBase.h"
+
+#include <QtxColorButton.h>
+#include <QtxDoubleSpinBox.h>
+#include <SUIT_Desktop.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_Session.h>
+#include <SUIT_ViewManager.h>
+#include <SALOME_ListIteratorOfListIO.hxx>
+#include <OCCViewer_ViewModel.h>
+#include <SVTK_ViewModel.h>
+#include <SVTK_ViewWindow.h>
+#include <SVTK_View.h>
+#include <LightApp_SelectionMgr.h>
+#include <SalomeApp_Application.h>
+#include <SalomeApp_Study.h>
+#include <SalomeApp_Tools.h>
+
+#include <QCheckBox>
+#include <QGridLayout>
+#include <QHBoxLayout>
+#include <QKeyEvent>
+#include <QLabel>
+#include <QMap>
+#include <QMenu>
+#include <QPushButton>
+#include <QVBoxLayout>
+
+#define MARGIN 9 // layout spacing
+#define SPACING 6 // layout margin
+
+/*!
+ \class GEOMToolsGUI_MaterialList
+ \brief Internal class, used to handle context menu event from materials list
+ \internal
+*/
+
+/*!
+ \brief Contructor
+ */
+GEOMToolsGUI_MaterialList::GEOMToolsGUI_MaterialList( QWidget* parent )
+ : QListWidget( parent )
+{}
+
+/*!
+ \brief Context menu event, emits context menu signal passing event as parameter
+*/
+void GEOMToolsGUI_MaterialList::contextMenuEvent( QContextMenuEvent* e )
+{
+ emit contextMenu( e );
+}
+
+/*!
+ \class GEOMToolsGUI_MaterialPropertiesDlg
+ \brief GEOM material properties dialog box class
+
+ The dialog box is used to set material properties for the presentation objects.
+*/
+
+/*!
+ \brief Constructor
+ \param parent parent widget
+*/
+GEOMToolsGUI_MaterialPropertiesDlg::GEOMToolsGUI_MaterialPropertiesDlg( QWidget* parent )
+ : QtxDialog( parent, true, true, OK | Close | Apply | Help )
+{
+ // Set title
+ setWindowTitle( tr( "MATERIAL_PROPERTIES_TLT" ) );
+
+ // main layout
+ QVBoxLayout* main = new QVBoxLayout( mainFrame() );
+ main->setMargin( 0 );
+ main->setSpacing( SPACING );
+
+ // add top-level frame box to enclose all main widgets (excluding buttons)
+ QFrame* fr = new QFrame( mainFrame() );
+ fr->setFrameStyle( QFrame::Box | QFrame::Sunken );
+ main->addWidget( fr );
+
+ // materials list widget
+ myMaterials = new GEOMToolsGUI_MaterialList( fr );
+ // properties widget
+ QWidget* propWidget = new QWidget( fr );
+
+ // layout main widgets
+ QHBoxLayout* frLayout = new QHBoxLayout( fr );
+ frLayout->setMargin( MARGIN );
+ frLayout->setSpacing( SPACING );
+ frLayout->addWidget( myMaterials );
+ frLayout->addWidget( propWidget );
+
+ // layout for material properties widgets
+ QGridLayout* propLayout = new QGridLayout( propWidget );
+ propLayout->setMargin( 0 );
+ propLayout->setSpacing( SPACING );
+
+ // current color widgets
+ myColorLab = new QLabel( tr( "CURRENT_COLOR" ), propWidget );
+ myColor = new QtxColorButton( propWidget );
+
+ // "physical" material type widgets
+ myPhysical = new QCheckBox( tr( "PHYSICAL" ), propWidget );
+
+ // reflection components widgets
+ for ( int i = Material_Model::Ambient; i <= Material_Model::Emissive; i++ )
+ {
+ Reflection refl;
+
+ refl.label = new QLabel( tr( QString( "REFLECTION_%1" ).arg( i ).toLatin1().data() ), propWidget );
+
+ refl.color = new QtxColorButton( propWidget );
+ //refl.color->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) );
+
+ refl.coef = new QtxDoubleSpinBox( propWidget );
+ refl.coef->setPrecision( 4 );
+ refl.coef->setDecimals( 4 );
+ refl.coef->setRange( 0., 1. );
+ refl.coef->setSingleStep( 0.05 );
+ refl.coef->setMinimumWidth( 80 );
+
+ refl.enabled = new QCheckBox( tr( "ENABLED" ), propWidget );
+
+ myReflection << refl;
+ }
+
+ // shininess widgets
+ QLabel* shininessLab = new QLabel( tr( "SHININESS" ), propWidget );
+ myShininess = new QtxDoubleSpinBox( propWidget );
+ myShininess->setPrecision( 4 );
+ myShininess->setDecimals( 4 );
+ myShininess->setRange( 0., 1. );
+ myShininess->setSingleStep( 0.05 );
+
+ // separator widgets
+ QFrame* line1 = new QFrame( propWidget );
+ line1->setFrameStyle( QFrame::HLine | QFrame::Sunken );
+ QFrame* line2 = new QFrame( propWidget );
+ line2->setFrameStyle( QFrame::HLine | QFrame::Sunken );
+
+ // add / remove material buttons
+ myAddButton = new QPushButton( tr( "ADD_MATERIAL" ), propWidget );
+ myDelButton = new QPushButton( tr( "DELETE_MATERIAL" ), propWidget );
+
+ // buttons layout
+ QHBoxLayout* btnLayout = new QHBoxLayout;
+ btnLayout->setMargin( 0 );
+ btnLayout->setSpacing( SPACING );
+ btnLayout->addWidget( myAddButton );
+ btnLayout->addWidget( myDelButton );
+
+ // layout all properties widgets together
+ propLayout->addWidget( myColorLab, 0, 0 );
+ propLayout->addWidget( myColor, 0, 1 );
+ propLayout->addWidget( line1, 1, 0, 1, 4 );
+ propLayout->addWidget( myPhysical, 2, 0, 1, 2 );
+ for ( int i = Material_Model::Ambient; i <= Material_Model::Emissive; i++ ) {
+ propLayout->addWidget( myReflection[i].label, i+3, 0 );
+ propLayout->addWidget( myReflection[i].color, i+3, 1 );
+ propLayout->addWidget( myReflection[i].coef, i+3, 2 );
+ propLayout->addWidget( myReflection[i].enabled, i+3, 3 );
+ }
+ propLayout->addWidget( shininessLab, 7, 0 );
+ propLayout->addWidget( myShininess, 7, 2 );
+ propLayout->addWidget( line2, 8, 0, 1, 4 );
+ propLayout->setRowStretch( 9, 5 );
+ propLayout->addLayout( btnLayout, 10, 0, 1, 4 );
+
+ // initialize dialog box
+ setButtonPosition( Right, Close );
+
+ // fill in the list of materials
+ QStringList globalMaterials = myResourceMgr.materials( Material_ResourceMgr::Global );
+ QStringList userMaterials = myResourceMgr.materials( Material_ResourceMgr::User );
+
+ QListWidgetItem* item;
+
+ // - current material
+ item = new QListWidgetItem( tr( "CURRENT_MATERIAL" ) );
+ item->setForeground( QColor( Qt::red ) );
+ item->setData( TypeRole, QVariant( Current ) );
+ myMaterials->addItem( item );
+ // - global materials
+ foreach( QString material, globalMaterials ) {
+ item = new QListWidgetItem( material );
+ item->setForeground( QColor( Qt::blue ) );
+ item->setData( TypeRole, QVariant( Global ) );
+ item->setData( NameRole, QVariant( material ) );
+ myMaterials->addItem( item );
+ }
+ // - user materials
+ foreach ( QString material, userMaterials ) {
+ item = new QListWidgetItem( material );
+ item->setData( TypeRole, QVariant( User ) );
+ item->setData( NameRole, QVariant( material ) );
+ item->setFlags( item->flags() | Qt::ItemIsEditable );
+ myMaterials->addItem( item );
+ }
+ // install event filter to the materials list to process key press events
+ myMaterials->installEventFilter( this );
+
+ // connect signals
+ // note: all widgets, that change material properties, are connected to the common signal
+ // changed(), instead of connecting directly to the slot - this allows easy temporary blocking
+ // of the change signal
+ connect( myPhysical, SIGNAL( toggled( bool ) ), this, SIGNAL( changed() ) );
+ for ( int i = Material_Model::Ambient; i <= Material_Model::Emissive; i++ ) {
+ connect( myReflection[i].color, SIGNAL( changed( QColor ) ), this, SIGNAL( changed() ) );
+ connect( myReflection[i].coef, SIGNAL( valueChanged( double ) ), this, SIGNAL( changed() ) );
+ connect( myReflection[i].enabled, SIGNAL( toggled( bool ) ), this, SIGNAL( changed() ) );
+ }
+ connect( myShininess, SIGNAL( valueChanged( double ) ), this, SIGNAL( changed() ) );
+ connect( myMaterials, SIGNAL( itemSelectionChanged() ),
+ this, SLOT( onMaterialChanged() ) );
+ connect( myMaterials, SIGNAL( itemChanged( QListWidgetItem* ) ),
+ this, SLOT( onItemChanged( QListWidgetItem* ) ) );
+ connect( myMaterials, SIGNAL( contextMenu( QContextMenuEvent* ) ),
+ this, SLOT( onContextMenu( QContextMenuEvent* ) ) );
+ connect( myAddButton, SIGNAL( clicked() ), this, SLOT( onAddMaterial() ) );
+ connect( myDelButton, SIGNAL( clicked() ), this, SLOT( onDeleteMaterial() ) );
+ connect( this, SIGNAL( dlgApply() ), this, SLOT( onApply() ) );
+ connect( this, SIGNAL( dlgHelp() ), this, SLOT( onHelp() ) );
+ connect( this, SIGNAL( changed() ), this, SLOT( onChanged() ) );
+
+ // initialize current material model according to the selection
+ myColor->setColor( SUIT_Session::session()->resourceMgr()->colorValue( "Geometry", "shading_color", QColor( 255, 0, 0 ) ) );
+ myCurrentModel.fromResources( SUIT_Session::session()->resourceMgr()->stringValue( "Geometry", "material", "Plastic" ) );
+ SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
+ SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
+ LightApp_SelectionMgr* selMgr = app->selectionMgr();
+ if ( study ) {
+ SALOME_ListIO selected;
+ selMgr->selectedObjects( selected );
+ if ( selected.Extent() > 0 ) {
+ Handle(SALOME_InteractiveObject) io = selected.First();
+ if ( !io.IsNull() ) {
+ SUIT_ViewWindow* window = app->desktop()->activeWindow();
+ if ( window ) {
+ int mgrId = window->getViewManager()->getGlobalId();
+ PropMap propMap = study->getObjectPropMap( mgrId, io->getEntry() );
+ QString matProp = propMap.value(MATERIAL_PROP).toString();
+ if ( !matProp.isEmpty() )
+ myCurrentModel.fromProperties( matProp );
+ QColor c = propMap.value(COLOR_PROP).value<QColor>();
+ if ( c.isValid() )
+ myColor->setColor( c );
+ }
+ }
+ }
+ }
+
+ // finally activate current material properties
+ myMaterials->setCurrentRow( 0 );
+}
+
+/*!
+ \brief Destructor
+*/
+GEOMToolsGUI_MaterialPropertiesDlg::~GEOMToolsGUI_MaterialPropertiesDlg()
+{
+}
+
+/*!
+ \brief Called when "OK" button is clicked
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::accept()
+{
+ onApply();
+ QtxDialog::accept();
+}
+
+/*!
+ \brief Event filter
+ \param o sender
+ \param e event
+*/
+bool GEOMToolsGUI_MaterialPropertiesDlg::eventFilter( QObject* o, QEvent* e )
+{
+ // process key press event from materials list
+ if ( o == myMaterials && e->type() == QEvent::KeyPress ) {
+ QKeyEvent* ke = (QKeyEvent*)e;
+ if ( ke->key() == Qt::Key_Delete ) {
+ onDeleteMaterial();
+ }
+ }
+ return QtxDialog::eventFilter( o, e );
+}
+
+/*!
+ \brief Initialize dialog box widgets from material model
+ \param model material model
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::fromModel( const Material_Model& model )
+{
+ // reflection components
+ for ( int i = Material_Model::Ambient; i <= Material_Model::Emissive; i++ )
+ {
+ myReflection[i].color->setColor( model.color( (Material_Model::ReflectionType)i ) );
+ myReflection[i].coef->setValue( model.reflection( (Material_Model::ReflectionType)i ) );
+ myReflection[i].enabled->setChecked( model.hasReflection( (Material_Model::ReflectionType)i ) );
+ }
+
+ // shininess
+ myShininess->setValue( model.shininess() );
+
+ // type (physical or no)
+ myPhysical->setChecked( model.isPhysical() );
+}
+
+/*!
+ \brief Save values from dialog box widgets to material model
+ \param model material model to be filled in
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::toModel( Material_Model& model ) const
+{
+ // type (physical or no)
+ model.setPhysical( myPhysical->isChecked() );
+
+ // shininess
+ model.setShininess( myShininess->value() );
+
+ // reflection components
+ for ( int i = Material_Model::Ambient; i <= Material_Model::Emissive; i++ )
+ {
+ model.setColor ( (Material_Model::ReflectionType)i, myReflection[i].color->color() );
+ model.setReflection( (Material_Model::ReflectionType)i, myReflection[i].coef->value() );
+ model.setReflection( (Material_Model::ReflectionType)i, myReflection[i].enabled->isChecked() );
+ }
+}
+
+/*!
+ \brief Find unique name for the material name
+ \param name material name template
+ \param item the item to be ignored when browsing through the materials list
+ \param addSuffix if \c true, the integrer suffix is always added to the material name (otherwise
+ suffix is added only if item name is not unique)
+ \return new unique material name
+*/
+QString GEOMToolsGUI_MaterialPropertiesDlg::findUniqueName( const QString& name, QListWidgetItem* item, bool addSuffix )
+{
+ bool found = false;
+ int idx = 0;
+ for( int i = 1; i < myMaterials->count(); i++ ) {
+ if ( item == myMaterials->item( i ) ) continue;
+ QString iname = myMaterials->item( i )->text();
+ if ( iname == name ) {
+ found = true;
+ }
+ else if ( iname.startsWith( name ) ) {
+ iname = iname.mid( name.length() ).trimmed();
+ bool ok = false;
+ int nx = iname.toInt( &ok );
+ if ( ok ) idx = qMax( idx, nx );
+ }
+ }
+ return found || addSuffix ? QString( "%1 %2" ).arg( name ).arg( idx+1 ) : name;
+}
+
+/*!
+ \brief Called when "Apply" button is pressed
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onApply()
+{
+ // save user materials
+ myResourceMgr.save();
+
+ // store selected material properties in the current model
+ toModel( myCurrentModel );
+
+ SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
+ LightApp_SelectionMgr* selMgr = app->selectionMgr();
+ SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
+
+ if ( !study ) return;
+
+ // get selection
+ SALOME_ListIO selected;
+ selMgr->selectedObjects( selected );
+ if ( selected.IsEmpty() ) return;
+
+ SUIT_ViewWindow* window = app->desktop()->activeWindow();
+ int mgrId = window->getViewManager()->getGlobalId();
+
+ // convert current material properties to the string representation
+ QString prop = myCurrentModel.toProperties();
+
+ if ( window && window->getViewManager()->getType() == SVTK_Viewer::Type() ) {
+ // for VTK viewer
+ SVTK_ViewWindow* vtkVW = dynamic_cast<SVTK_ViewWindow*>( window );
+ if ( !vtkVW )
+ return;
+
+ SVTK_View* aView = vtkVW->getView();
+
+ // get VTK material properties from the current model
+ GEOM_VTKPropertyMaterial* vtkProp = myCurrentModel.getMaterialVTKProperty();
+
+ SUIT_OverrideCursor wc();
+
+ for ( SALOME_ListIteratorOfListIO It( selected ); It.More(); It.Next() ) {
+ // set material property to the presentation
+ aView->SetMaterial( It.Value(), vtkProp );
+ // store chosen material in the property map
+ study->setObjectProperty( mgrId, It.Value()->getEntry(), MATERIAL_PROP, prop );
+ // set correct color for the non-physical material
+ if ( !myCurrentModel.isPhysical() ) {
+ aView->SetColor( It.Value(), myColor->color() );
+ study->setObjectProperty( mgrId, It.Value()->getEntry(), COLOR_PROP, myColor->color() );
+ }
+ }
+ aView->Repaint();
+ GeometryGUI::Modified();
+ }
+ else if ( window && window->getViewManager()->getType() == OCCViewer_Viewer::Type() ) {
+ // for OCC viewer
+ OCCViewer_Viewer* vm = dynamic_cast<OCCViewer_Viewer*>( window->getViewManager()->getViewModel() );
+ if ( !vm )
+ return;
+
+ Handle(AIS_InteractiveContext) ic = vm->getAISContext();
+
+ // get OCC material aspect from the current model
+ Graphic3d_MaterialAspect occAspect = myCurrentModel.getMaterialOCCAspect();
+
+ SUIT_OverrideCursor wc();
+
+ for ( SALOME_ListIteratorOfListIO It( selected ); It.More(); It.Next() ) {
+ Handle(GEOM_AISShape) aisShape = GEOMBase::ConvertIOinGEOMAISShape( It.Value(), true );
+ if ( !aisShape.IsNull() ) {
+ // set material property to the presentation
+ aisShape->SetMaterial( occAspect );
+ // store chosen material in the property map
+ study->setObjectProperty( mgrId, It.Value()->getEntry(), MATERIAL_PROP, prop );
+ // set correct color for the non-physical material
+ if ( !myCurrentModel.isPhysical() ) {
+ aisShape->SetShadingColor( SalomeApp_Tools::color( myColor->color() ) );
+ study->setObjectProperty( mgrId, It.Value()->getEntry(), COLOR_PROP, myColor->color() );
+ ic->RecomputePrsOnly( aisShape, Standard_False );
+ }
+ //if ( aisShape->DisplayMode() != AIS_Shaded/*aisShape->DisplayMode() == GEOM_AISShape::ShadingWithEdges*/)
+ ic->Redisplay( aisShape, Standard_False );
+ }
+ }
+ ic->UpdateCurrentViewer();
+ GeometryGUI::Modified();
+ }
+}
+
+/*!
+ \brief Called when "Help" button is pressed
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onHelp()
+{
+ LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
+ app->onHelpContextModule( "GEOM", "material_page.html" );
+}
+
+/*!
+ \brief Called when user selects any material item in the materials list
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onMaterialChanged()
+{
+ // get currently selected item
+ QListWidgetItem* item = myMaterials->currentItem();
+ if ( !item ) return;
+
+ bool blocked = blockSignals( true );
+
+ int type = item->data( TypeRole ).toInt();
+ if ( type == Current ) {
+ // initialize widgets from current material model
+ fromModel( myCurrentModel );
+ }
+ else {
+ // initialize widgets from chosen material model (using resources manager)
+ Material_Model model;
+ model.fromResources( item->data( NameRole ).toString(), &myResourceMgr );
+ fromModel( model );
+ }
+
+ blockSignals( blocked );
+
+ // update buttons state
+ updateState();
+}
+
+/*!
+ \brief Called when any material parameter is changed by the user
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onChanged()
+{
+ // get currently selected item
+ QListWidgetItem* item = myMaterials->currentItem();
+ int type = item->data( TypeRole ).toInt();
+ if ( !item ) return;
+
+ if ( type == Current ) {
+ // for the current model do not perform any actions except store changed values
+ toModel( myCurrentModel );
+ }
+ else if ( type == User ) {
+ // for the user model, simply store the changes in the resource manager
+ Material_Model model;
+ toModel( model );
+ // check if the user model is renamed
+ QString oldName = item->data( NameRole ).toString(), newName = item->text();
+ if ( oldName == newName ) {
+ // model is not renamed: store data using current name
+ model.toResources( oldName, &myResourceMgr );
+ }
+ else {
+ // model is renamed: remove model with old name and store model using new name
+ myResourceMgr.remove( oldName );
+ model.toResources( newName, &myResourceMgr );
+ item->setData( NameRole, newName );
+ }
+ }
+ else {
+ // it is no allowed to change global material
+ // user is asked about creating of a new user material model based on the currently selected one
+ if ( SUIT_MessageBox::question( this,
+ tr( "GEOM_WRN_WARNING" ),
+ tr( "QUE_CREATE_NEW_MATERIAL" ),
+ QMessageBox::Yes | QMessageBox::No,
+ QMessageBox::Yes ) == QMessageBox::Yes ) {
+ // user has chosen creation of new user model
+ onAddMaterial();
+ }
+ else {
+ // user has rejected creation of new user model: revert changes
+ bool blocked = blockSignals( true );
+ Material_Model model;
+ model.fromResources( item->data( NameRole ).toString(), &myResourceMgr );
+ fromModel( model );
+ blockSignals( blocked );
+ }
+ }
+
+ // update buttons state
+ updateState();
+}
+
+/*!
+ \brief Called when user material is renamed by the user
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onItemChanged( QListWidgetItem* item )
+{
+ // check new name to be unique (add suffix if necessary)
+ QString newName = item->text();
+ QString uniqueName = findUniqueName( newName, item );
+ if ( uniqueName != newName ) {
+ bool blocked = myMaterials->blockSignals( true );
+ item->setText( uniqueName );
+ myMaterials->blockSignals( blocked );
+ }
+ onChanged();
+}
+
+/*!
+ \brief Process context menu event from materials list
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onContextMenu( QContextMenuEvent* e )
+{
+ QListWidgetItem* item = myMaterials->itemAt( e->pos() );
+ QMap<QAction*, int> actionMap;
+ QMenu m;
+ // rename
+ if ( item && item->data( TypeRole ).toInt() == User ) {
+ actionMap[ m.addAction( tr( "RENAME_MATERIAL" ) ) ] = 0;
+ m.addSeparator();
+ }
+ // add user material
+ actionMap[ m.addAction( tr( "ADD_MATERIAL" ) ) ] = 1;
+ // delete user material
+ if ( item && item->data( TypeRole ).toInt() == User ) {
+ actionMap[ m.addAction( tr( "DELETE_MATERIAL" ) ) ] = 2;
+ }
+ QAction* a = m.exec( e->globalPos() );
+ switch( actionMap[ a ] ) {
+ case 0:
+ // rename
+ myMaterials->editItem( item );
+ break;
+ case 1:
+ // add user material
+ onAddMaterial();
+ break;
+ case 2:
+ // delete user material
+ onDeleteMaterial();
+ break;
+ default:
+ break;
+ }
+}
+
+/*!
+ \brief Delete currently selected user model
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onDeleteMaterial()
+{
+ QListWidgetItem* item = myMaterials->currentItem();
+ if ( item && item->data( TypeRole ).toInt() == User ) {
+ if ( SUIT_MessageBox::question( this,
+ tr( "GEOM_WRN_WARNING" ),
+ tr( "QUE_REMOVE_MATERIAL" ).arg( item->text() ),
+ QMessageBox::Yes | QMessageBox::No,
+ QMessageBox::Yes ) == QMessageBox::Yes ) {
+ myResourceMgr.remove( item->data( NameRole ).toString() );
+ delete item;
+ }
+ }
+}
+
+/*!
+ \brief Add new user material model
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::onAddMaterial()
+{
+ QString newName = findUniqueName( tr( "CUSTOM_MATERIAL" ), 0, true );
+ QListWidgetItem* item = new QListWidgetItem( newName );
+ item->setData( TypeRole, QVariant( User ) );
+ item->setData( NameRole, QVariant( newName ) );
+ item->setFlags( item->flags() | Qt::ItemIsEditable );
+ myMaterials->addItem( item );
+
+ Material_Model model;
+ toModel( model );
+ model.toResources( newName, &myResourceMgr );
+ myMaterials->setCurrentItem( item );
+ myMaterials->editItem( item );
+}
+
+/*!
+ \brief Update buttons state
+*/
+void GEOMToolsGUI_MaterialPropertiesDlg::updateState()
+{
+ QListWidgetItem* item = myMaterials->currentItem();
+ myDelButton->setEnabled( item && item->data( TypeRole ).toInt() == User );
+ myColorLab->setEnabled( !myPhysical->isChecked() );
+ myColor->setEnabled( !myPhysical->isChecked() );
+ myReflection[0].color->setEnabled( myPhysical->isChecked() );
+}
