SMESHGUI Class Reference

#include <SMESHGUI.h>

Inheritance diagram for SMESHGUI:

Public Slots
virtual bool	deactivateModule (SUIT_Study *)
virtual bool	activateModule (SUIT_Study *)
virtual void	studyClosed (SUIT_Study *)
void	onViewClosed (SUIT_ViewWindow *)
	Signal handler closing(SUIT_ViewWindow*) of a view.
Signals
void	SignalDeactivateActiveDialog ()
void	SignalStudyFrameChanged ()
void	SignalCloseAllDialogs ()
void	SignalVisibilityChanged ()
Public Member Functions
	SMESHGUI ()
	~SMESHGUI ()
bool	isActiveStudyLocked ()
virtual LightApp_Displayer *	displayer ()
virtual QString	engineIOR () const
virtual void	initialize (CAM_Application *)
virtual void	windows (QMap< int, int > &) const
virtual void	viewManagers (QStringList &) const
QDialog *	GetActiveDialogBox ()
void	SetActiveDialogBox (QDialog *)
void	ResetState ()
void	SetState (int)
bool	DefineDlgPosition (QWidget *, int &, int &)
void	switchToOperation (int)
	Stops current operations and starts a given one.
virtual bool	OnGUIEvent (int)
virtual bool	OnMousePress (QMouseEvent *, SUIT_ViewWindow *)
virtual bool	OnMouseMove (QMouseEvent *, SUIT_ViewWindow *)
virtual bool	OnKeyPress (QKeyEvent *, SUIT_ViewWindow *)
virtual LightApp_Selection *	createSelection () const
virtual void	BuildPresentation (const Handle(SALOME_InteractiveObject)&, SUIT_ViewWindow *=0)
	Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO) Purpose: ensures that the actor for the given <theIO> exists in the active VTK view.
void	EmitSignalDeactivateDialog ()
void	EmitSignalStudyFrameChanged ()
void	EmitSignalCloseAllDialogs ()
void	EmitSignalVisibilityChanged ()
virtual void	contextMenuPopup (const QString &, QMenu *, QString &)
virtual void	createPreferences ()
virtual void	preferencesChanged (const QString &, const QString &)
virtual void	update (const int)
	Update something in accordance with update flags.
virtual void	storeVisualParameters (int savePoint)
	Store visual parameters.
virtual void	restoreVisualParameters (int savePoint)
	Restore visual parameters.
virtual void	addActorAsObserver (SMESH_Actor *theActor)
virtual bool	renameAllowed (const QString &) const
	Return true if object can be renamed.
virtual bool	renameObject (const QString &, const QString &)
	Rename object by entry.
SMESHGUI_ClippingPlaneInfoMap &	getClippingPlaneInfoMap ()
Static Public Member Functions
static SMESH::SMESH_Gen_var	GetSMESHGen ()
static SMESHGUI *	GetSMESHGUI ()
static LightApp_SelectionMgr *	selectionMgr ()
static SUIT_ResourceMgr *	resourceMgr ()
static SUIT_Desktop *	desktop ()
static SalomeApp_Study *	activeStudy ()
static bool	automaticUpdate (unsigned int requestedSize=0, bool *limitExceeded=0)
static void	Modified (bool=true)
static SALOMEDS::Color	getUniqueColor (const QList< SALOMEDS::Color > &)
Protected Member Functions
void	createSMESHAction (const int, const QString &, const QString &=QString(), const int=0, const bool=false, const QString &=QString())
void	createPopupItem (const int, const QString &, const QString &, const QString &=QString(), const int=-1)
virtual LightApp_Operation *	createOperation (const int) const
	Creates operation with given identifier.
virtual bool	isSelectionCompatible ()
	Return true if SMESH or GEOM objects are selected.
virtual bool	reusableOperation (const int id)
Static Protected Member Functions
static void	ProcessEvents (vtkObject *theObject, unsigned long theEvent, void *theClientData, void *theCallData)
Private Slots
void	OnGUIEvent ()
void	onViewManagerActivated (SUIT_ViewManager *)
void	onViewManagerRemoved (SUIT_ViewManager *)
void	onOperationCommited (SUIT_Operation *)
	Set default selection mode.
void	onOperationAborted (SUIT_Operation *)
	Set default selection mode.
void	onHypothesisEdit (int result)
	Actions after hypothesis edition Updates object browser after hypothesis edition.
Private Member Functions
void	OnEditDelete ()
int	addVtkFontPref (const QString &label, const int pId, const QString &param)
	Adds preferences for dfont of VTK viewer.
void	connectView (const SUIT_ViewWindow *)
	Connects or disconnects signals about activating and cloning view on the module slots.
Private Attributes
QDialog *	myActiveDialogBox
int	myState
QMap< int, QString >	myRules
LightApp_Displayer *	myDisplayer
SMESHGUI_FilterLibraryDlg *	myFilterLibraryDlg
SMESHGUI_StudyId2MarkerMap	myMarkerMap
SMESHGUI_ClippingPlaneInfoMap	myClippingPlaneInfoMap
vtkSmartPointer < vtkCallbackCommand >	myEventCallbackCommand
vtkFloatingPointType	myPriority
Static Private Attributes
static SMESH::SMESH_Gen_var	myComponentSMESH = SMESH::SMESH_Gen::_nil()

---

Detailed Description

Definition at line 85 of file SMESHGUI.h.

---

Constructor & Destructor Documentation

SMESHGUI::SMESHGUI

(

)

Definition at line 1547 of file SMESHGUI.cxx.

References SMESH.GetFilterManager(), SMESH.GetMeasurements(), SMESH.GetPattern(), SMESH.GetResourceMgr(), GetSMESHGen(), SMESH.InitAvailableHypotheses(), MESSAGE, myActiveDialogBox, myComponentSMESH, myDisplayer, myEventCallbackCommand, myFilterLibraryDlg, myPriority, myState, and ProcessEvents().

                   :
SalomeApp_Module( "SMESH" ),
LightApp_Module( "SMESH" )
{
  if ( CORBA::is_nil( myComponentSMESH ) )
  {
    CORBA::Boolean anIsEmbeddedMode;
    myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
    MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);

    //  0019923: EDF 765 SMESH : default values of hypothesis
    SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
    int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
    myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
    nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
    myComponentSMESH->SetDefaultNbSegments( nbSeg );
  }

  myActiveDialogBox = 0;
  myFilterLibraryDlg = 0;
  myState = -1;
  myDisplayer = 0;

  myEventCallbackCommand = vtkCallbackCommand::New();
  myEventCallbackCommand->Delete();
  myEventCallbackCommand->SetClientData( this );
  myEventCallbackCommand->SetCallback( SMESHGUI::ProcessEvents );
  myPriority = 0.0;

  SMESH::GetFilterManager();
  SMESH::GetPattern();
  SMESH::GetMeasurements();

  /* load resources for all available meshers */
  SMESH::InitAvailableHypotheses();
}

SMESHGUI::~SMESHGUI

(

)

Definition at line 1589 of file SMESHGUI.cxx.

References SMESH.GetFilterManager(), and SMESH.GetMeasurements().

{
#ifdef WITHGENERICOBJ
  SMESH::GetFilterManager()->UnRegister();
  SMESH::GetMeasurements()->UnRegister();
#endif
  SMESH::GetFilterManager() = SMESH::FilterManager::_nil();
  SMESH::GetMeasurements() = SMESH::Measurements::_nil();
}

---

Member Function Documentation

bool SMESHGUI::activateModule

(

SUIT_Study *

study

)

[virtual, slot]

Definition at line 4067 of file SMESHGUI.cxx.

References _PTR(), connectView(), GetSMESHGen(), and SMESH_AdvancedEditor.res.

{
  bool res = SalomeApp_Module::activateModule( study );

  setMenuShown( true );
  setToolShown( true );

  // import Python module that manages SMESH plugins (need to be here because SalomePyQt API uses active module)
  PyGILState_STATE gstate = PyGILState_Ensure();
  PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
  if(pluginsmanager==NULL)
    PyErr_Print();
  else
    {
      PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"smesh",tr("MEN_MESH").toStdString().c_str(),tr("SMESH_PLUGINS_OTHER").toStdString().c_str());
      if(result==NULL)
        PyErr_Print();
      Py_XDECREF(result);
    }
  PyGILState_Release(gstate);
  // end of GEOM plugins loading

  // Reset actions accelerator keys
  action(111)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_B)); // Import DAT
  action(112)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U)); // Import UNV
  action(113)->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M)); // Import MED

  action(  33)->setEnabled(true); // Delete: Key_Delete

  //  0020210. Make SMESH_Gen update meshes at switching GEOM->SMESH
  GetSMESHGen()->SetCurrentStudy(SALOMEDS::Study::_nil());
  if ( SalomeApp_Study* s = dynamic_cast<SalomeApp_Study*>( study ))
    if ( _PTR(Study) aStudy = s->studyDS()) {
      GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
      updateObjBrowser(); // objects can be removed
    }
  
  // get all view currently opened in the study and connect their signals  to
  // the corresponding slots of the class.
  SUIT_Desktop* aDesk = study->application()->desktop();
  if ( aDesk ) {
    QList<SUIT_ViewWindow*> wndList = aDesk->windows();
    SUIT_ViewWindow* wnd;
    foreach ( wnd, wndList )
      connectView( wnd );
  }

  return res;
}

SalomeApp_Study * SMESHGUI::activeStudy

(

)

[static]

Definition at line 1778 of file SMESHGUI.cxx.

Referenced by SMESHGUI_Make2DFrom3DOp.compute2DMesh(), SMESH.GetMeshesUsingAlgoOrHypothesis(), GetSMESHGUI(), SMESH.GetVisualObj(), SMESHGUI_GroupDlg.initDialog(), isActiveStudyLocked(), SMESHGUI_Make2DFrom3DOp.isValid(), SMESHGUI_Make2DFrom3DOp.selectionDone(), StdMeshersGUI_SubShapeSelectorWdg.setFilter(), switchToOperation(), SMESHGUI_ClippingDlg.updateActorList(), and SMESHGUI_FilterDlg.updateSelection().

{
  SUIT_Application* app = SUIT_Session::session()->activeApplication();
  if( app )
    return dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
  else
    return NULL;
}

void SMESHGUI::addActorAsObserver

(

SMESH_Actor *

theActor

)

[virtual]

Definition at line 4226 of file SMESHGUI.cxx.

References SMESH.DeleteActorEvent, myEventCallbackCommand, and myPriority.

{
  theActor->AddObserver( SMESH::DeleteActorEvent,
                         myEventCallbackCommand.GetPointer(),
                         myPriority );
}

int SMESHGUI::addVtkFontPref	(	const QString &	label,
		const int	pId,
		const QString &	param
	)		[private]

Adds preferences for dfont of VTK viewer.

Parameters:

label	label
pIf	group identifier
param	parameter

Returns:

identifier of preferences

Definition at line 5636 of file SMESHGUI.cxx.

References smeshDC.Custom.

Referenced by createPreferences().

{
  int tfont = addPreference( label, pId, LightApp_Preferences::Font, "SMESH", param );

  setPreferenceProperty( tfont, "mode", QtxFontEdit::Custom );

  QStringList fam;
  fam.append( tr( "SMESH_FONT_ARIAL" ) );
  fam.append( tr( "SMESH_FONT_COURIER" ) );
  fam.append( tr( "SMESH_FONT_TIMES" ) );

  setPreferenceProperty( tfont, "fonts", fam );

  int f = QtxFontEdit::Family | QtxFontEdit::Bold | QtxFontEdit::Italic | QtxFontEdit::Shadow;
  setPreferenceProperty( tfont, "features", f );

  return tfont;
}

bool SMESHGUI::automaticUpdate	(	unsigned int	requestedSize = 0,
		bool *	limitExceeded = 0
	)		[static]

Definition at line 1618 of file SMESHGUI.cxx.

Referenced by SMESHGUI_BuildCompoundDlg.ClickOnApply(), ExportMeshToFile(), and SMESHGUI_MeshPatternDlg.onApply().

{
  SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  if ( !resMgr )
    return false;

  bool autoUpdate  = resMgr->booleanValue( "SMESH", "auto_update",  false );
  long updateLimit = resMgr->integerValue( "SMESH", "update_limit", 500000 );
  bool exceeded = updateLimit > 0 && requestedSize > updateLimit;
  if ( limitExceeded ) *limitExceeded = autoUpdate && exceeded;
  return autoUpdate && !exceeded;
}

void SMESHGUI::BuildPresentation	(	const Handle(SALOME_InteractiveObject)&	theIO,
		SUIT_ViewWindow *	wnd = 0
	)		[virtual]

Method: BuildPresentation(const Handle(SALOME_InteractiveObject)& theIO) Purpose: ensures that the actor for the given <theIO> exists in the active VTK view.

Definition at line 3173 of file SMESHGUI.cxx.

References SMESH.eDisplay, and SMESH.UpdateView().

{
  if(theIO->hasEntry()){
    //SUIT_ViewWindow* wnd = SMESH::GetActiveWindow();
    SMESH::UpdateView(wnd,SMESH::eDisplay,theIO->getEntry());
  }
}

void SMESHGUI::connectView

(

const SUIT_ViewWindow *

pview

)

[private]

Connects or disconnects signals about activating and cloning view on the module slots.

Parameters:

pview

view which is connected/disconnected

Definition at line 5682 of file SMESHGUI.cxx.

References onViewClosed().

Referenced by activateModule(), and onViewManagerActivated().

                                                         {
  if(!pview)
    return;
  
  SUIT_ViewManager* viewMgr = pview->getViewManager();
  if ( viewMgr ) {
    disconnect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
                this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
    
    connect( viewMgr, SIGNAL( deleteView( SUIT_ViewWindow* ) ),
             this, SLOT( onViewClosed( SUIT_ViewWindow* ) ) );
  }
}

void SMESHGUI::contextMenuPopup	(	const QString &	client,
		QMenu *	menu,
		QString &	title
	)		[virtual]

Definition at line 4172 of file SMESHGUI.cxx.

References _PTR(), Handle(), and selectionMgr().

{
  SalomeApp_Module::contextMenuPopup( client, menu, title );
  SALOME_ListIO lst;
  selectionMgr()->selectedObjects( lst );
  if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
    Handle(SALOME_InteractiveObject) io = lst.First();
    SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
    _PTR(Study) study = appStudy->studyDS();
    _PTR(SObject) obj = study->FindObjectID( io->getEntry() );
    if ( obj ) {
      QString aName = QString( obj->GetName().c_str() );
      while ( aName.at( aName.length() - 1 ) == ' ' ) // Remove extraspaces in Name of Popup
          aName.remove( (aName.length() - 1), 1 );
      title = aName;
    }
  }
}

LightApp_Operation * SMESHGUI::createOperation

(

const int

id

)

const [protected, virtual]

Creates operation with given identifier.

Parameters:

id	- identifier of operation to be started

Returns:

Pointer on created operation or NULL if operation is not created

Virtual method redefined from the base class creates operation with given id. It is called called automatically from startOperation method of base class.

Definition at line 4711 of file SMESHGUI.cxx.

{
  LightApp_Operation* op = 0;
  // to do : create operation here
  switch( id )
  {
    case 417: //convert to quadratic
      op = new SMESHGUI_ConvToQuadOp();
    break;
    case 418: // create 2D mesh as boundary on 3D
      op = new SMESHGUI_Make2DFrom3DOp();
    break;
    case 701: // Compute mesh
      op = new SMESHGUI_ComputeOp();
    break;
    case 702: // Create mesh
      op = new SMESHGUI_MeshOp( true, true );
    break;
    case 703: // Create sub-mesh
      op = new SMESHGUI_MeshOp( true, false );
    break;
    case 704: // Edit mesh/sub-mesh
      op = new SMESHGUI_MeshOp( false );
    break;
    case 711: // Precompute mesh
      op = new SMESHGUI_PrecomputeOp();
    break;
    case 712: // Evaluate mesh
      op = new SMESHGUI_EvaluateOp();
    break;
    case 713: // Evaluate mesh
      op = new SMESHGUI_MeshOrderOp();
    break;
    case 806: // Create group on geom
      op = new SMESHGUI_GroupOnShapeOp();
      break;
    case 904: // Find element
      op = new SMESHGUI_FindElemByPointOp();
      break;
    case 4067: // make mesh pass through point
      op = new SMESHGUI_MakeNodeAtPointOp();
      break;
    default:
    break;
  }

  if( !op )
    op = SalomeApp_Module::createOperation( id );
  return op;
}

void SMESHGUI::createPopupItem	(	const int	id,
		const QString &	clients,
		const QString &	types,
		const QString &	theRule = QString(),
		const int	pId = -1
	)		[protected]

Definition at line 3212 of file SMESHGUI.cxx.

References myRules.

Referenced by initialize().

{
  int parentId = pId;
  if( pId!=-1 )
    parentId = popupMgr()->actionId( action( pId ) );

  if( !popupMgr()->contains( popupMgr()->actionId( action( id ) ) ) )
    popupMgr()->insert( action( id ), parentId, 0 );

  QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
  QString dc = "selcount"; // VSR : insetad of QtxPopupSelection::defSelCountParam()
  QString rule = "(%1) and (%2) and (%3)";
  rule = rule.arg( QString( "%1>0" ).arg( dc ) );
  if( clients.isEmpty() )
    rule = rule.arg( QString( "true" ) );
  else
    rule = rule.arg( QString( "%1client in {%2}" ).arg( lc ).arg( clients ) );
  rule = rule.arg( QString( "%1type in {%2}" ).arg( lc ).arg( types ) );
  rule += theRule;

  bool cont = myRules.contains( id );
  if( cont )
    rule = QString( "%1 or (%2)" ).arg( myRules[ id ] ).arg( rule );

  popupMgr()->setRule( action( id ), rule, QtxPopupMgr::VisibleRule );
  myRules[ id ] = QString( cont ? "%1" : "(%1)" ).arg( rule );
}

void SMESHGUI::createPreferences

(

)

[virtual]

Definition at line 4263 of file SMESHGUI.cxx.

References addVtkFontPref(), SMESH.GetResourceMgr(), and SMESH_test.ii.

{
  // General tab ------------------------------------------------------------------------
  int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) );

  int autoUpdate = addPreference( tr( "PREF_AUTO_UPDATE" ), genTab, LightApp_Preferences::Auto, "SMESH", "auto_update" );
  int lim = addPreference( tr( "PREF_UPDATE_LIMIT" ), autoUpdate, LightApp_Preferences::IntSpin, "SMESH", "update_limit" );
  setPreferenceProperty( lim, "min",  0 );
  setPreferenceProperty( lim, "max",  100000000 );
  setPreferenceProperty( lim, "step", 1000 );
  setPreferenceProperty( lim, "special", tr( "PREF_UPDATE_LIMIT_NOLIMIT" ) );

  int qaGroup = addPreference( tr( "PREF_GROUP_QUALITY" ), genTab );
  setPreferenceProperty( qaGroup, "columns", 2 );
  addPreference( tr( "PREF_DISPLAY_ENTITY" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "display_entity" );
  addPreference( tr( "PREF_PRECISION_USE" ), qaGroup, LightApp_Preferences::Bool, "SMESH", "use_precision" );
  int prec = addPreference( tr( "PREF_PRECISION_VALUE" ), qaGroup, LightApp_Preferences::IntSpin, "SMESH", "controls_precision" );
  setPreferenceProperty( prec, "min", 0 );
  setPreferenceProperty( prec, "max", 16 );

  int dispgroup = addPreference( tr( "PREF_DISPLAY_MODE" ), genTab );
  setPreferenceProperty( dispgroup, "columns", 2 );
  int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), dispgroup, LightApp_Preferences::Selector, "SMESH", "display_mode" );
  QStringList modes;
  modes.append( "Wireframe" );
  modes.append( "Shading" );
  modes.append( "Nodes" );
  modes.append( "Shrink" );
  QList<QVariant> indices;
  indices.append( 0 );
  indices.append( 1 );
  indices.append( 2 );
  indices.append( 3 );
  setPreferenceProperty( dispmode, "strings", modes );
  setPreferenceProperty( dispmode, "indexes", indices );

  int arcgroup = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), genTab );
  setPreferenceProperty( arcgroup, "columns", 2 );
  int quadraticmode = addPreference( tr( "QUADRATIC_REPRESENT_MODE" ), arcgroup, LightApp_Preferences::Selector, "SMESH", "quadratic_mode" );
  QStringList quadraticModes;
  quadraticModes.append("Lines");
  quadraticModes.append("Arcs");
  indices.clear();
  indices.append( 0 );
  indices.append( 1 );
  setPreferenceProperty( quadraticmode, "strings", quadraticModes );
  setPreferenceProperty( quadraticmode, "indexes", indices );

  int maxAngle = addPreference( tr( "MAX_ARC_ANGLE" ), arcgroup, LightApp_Preferences::IntSpin,
                              "SMESH", "max_angle" );
  setPreferenceProperty( maxAngle, "min", 1 );
  setPreferenceProperty( maxAngle, "max", 90 );



  int exportgroup = addPreference( tr( "PREF_GROUP_EXPORT" ), genTab );
  setPreferenceProperty( exportgroup, "columns", 2 );
  addPreference( tr( "PREF_AUTO_GROUPS" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "auto_groups" );
  addPreference( tr( "PREF_RENUMBER" ), exportgroup, LightApp_Preferences::Bool, "SMESH", "renumbering" );

  int computeGroup = addPreference( tr( "PREF_GROUP_COMPUTE" ), genTab );
  setPreferenceProperty( computeGroup, "columns", 2 );
  int notifyMode = addPreference( tr( "PREF_NOTIFY_MODE" ), computeGroup, LightApp_Preferences::Selector, "SMESH", "show_result_notification" );
  modes.clear();
  modes.append( tr( "PREF_NOTIFY_NEVER" ) );
  modes.append( tr( "PREF_NOTIFY_ERROR" ) );
  modes.append( tr( "PREF_NOTIFY_ALWAYS" ) );
  indices.clear();
  indices.append( 0 );
  indices.append( 1 );
  indices.append( 2 );
  setPreferenceProperty( notifyMode, "strings", modes );
  setPreferenceProperty( notifyMode, "indexes", indices );

  int infoGroup = addPreference( tr( "PREF_GROUP_INFO" ), genTab );
  setPreferenceProperty( computeGroup, "columns", 2 );
  int elemInfo = addPreference( tr( "PREF_ELEM_INFO" ), infoGroup, LightApp_Preferences::Selector, "SMESH", "mesh_elem_info" );
  modes.clear();
  modes.append( tr( "PREF_ELEM_INFO_SIMPLE" ) );
  modes.append( tr( "PREF_ELEM_INFO_TREE" ) );
  indices.clear();
  indices.append( 0 );
  indices.append( 1 );
  setPreferenceProperty( elemInfo, "strings", modes );
  setPreferenceProperty( elemInfo, "indexes", indices );

  int segGroup = addPreference( tr( "PREF_GROUP_SEGMENT_LENGTH" ), genTab );
  setPreferenceProperty( segGroup, "columns", 2 );
  int segLen = addPreference( tr( "PREF_SEGMENT_LENGTH" ), segGroup, LightApp_Preferences::IntSpin,
                              "SMESH", "segmentation" );
  setPreferenceProperty( segLen, "min", 1 );
  setPreferenceProperty( segLen, "max", 10000000 );
  int nbSeg = addPreference( tr( "PREF_NB_SEGMENTS" ), segGroup, LightApp_Preferences::IntSpin,
                             "SMESH", "nb_segments_per_edge" );
  setPreferenceProperty( nbSeg, "min", 1 );
  setPreferenceProperty( nbSeg, "max", 10000000 );

  // Quantities with individual precision settings
  int precGroup = addPreference( tr( "SMESH_PREF_GROUP_PRECISION" ), genTab );
  setPreferenceProperty( precGroup, "columns", 2 );

  const int nbQuantities = 6;
  int precs[nbQuantities], ii = 0;
  precs[ii++] = addPreference( tr( "SMESH_PREF_length_precision" ), precGroup,
                            LightApp_Preferences::IntSpin, "SMESH", "length_precision" );
  precs[ii++] = addPreference( tr( "SMESH_PREF_angle_precision" ), precGroup,
                            LightApp_Preferences::IntSpin, "SMESH", "angle_precision" );
  precs[ii++] = addPreference( tr( "SMESH_PREF_len_tol_precision" ), precGroup,
                            LightApp_Preferences::IntSpin, "SMESH", "len_tol_precision" );
  precs[ii++] = addPreference( tr( "SMESH_PREF_parametric_precision" ), precGroup,
                            LightApp_Preferences::IntSpin, "SMESH", "parametric_precision" );
  precs[ii++] = addPreference( tr( "SMESH_PREF_area_precision" ), precGroup,
                            LightApp_Preferences::IntSpin, "SMESH", "area_precision" );
  precs[ii  ] = addPreference( tr( "SMESH_PREF_vol_precision" ), precGroup,
                            LightApp_Preferences::IntSpin, "SMESH", "vol_precision" );

  // Set property for precision value for spinboxes
  for ( ii = 0; ii < nbQuantities; ii++ ){
    setPreferenceProperty( precs[ii], "min", -14 );
    setPreferenceProperty( precs[ii], "max", 14 );
    setPreferenceProperty( precs[ii], "precision", 2 );
  }

  // Mesh tab ------------------------------------------------------------------------
  int meshTab = addPreference( tr( "PREF_TAB_MESH" ) );
  int nodeGroup = addPreference( tr( "PREF_GROUP_NODES" ), meshTab );
  setPreferenceProperty( nodeGroup, "columns", 3 );

  addPreference( tr( "PREF_COLOR" ), nodeGroup, LightApp_Preferences::Color, "SMESH", "node_color" );

  int typeOfMarker = addPreference( tr( "PREF_TYPE_OF_MARKER" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "type_of_marker" );

  SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
  QList<QVariant> aMarkerTypeIndicesList;
  QList<QVariant> aMarkerTypeIconsList;
  for ( int i = VTK::MT_POINT; i < VTK::MT_USER; i++ ) {
    QString icoFile = QString( "ICON_VERTEX_MARKER_%1" ).arg( i );
    QPixmap pixmap = aResourceMgr->loadPixmap( "VTKViewer", tr( qPrintable( icoFile ) ) );
    aMarkerTypeIndicesList << i;
    aMarkerTypeIconsList << pixmap;
  }
  setPreferenceProperty( typeOfMarker, "indexes", aMarkerTypeIndicesList );
  setPreferenceProperty( typeOfMarker, "icons",   aMarkerTypeIconsList );

  int markerScale = addPreference( tr( "PREF_MARKER_SCALE" ), nodeGroup, LightApp_Preferences::Selector, "SMESH", "marker_scale" );

  QList<QVariant> aMarkerScaleIndicesList;
  QStringList     aMarkerScaleValuesList;
  for ( int i = VTK::MS_10; i <= VTK::MS_70; i++ ) {
    aMarkerScaleIndicesList << i;
    aMarkerScaleValuesList  << QString::number( (i-(int)VTK::MS_10)*0.5 + 1.0 );
  }
  setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList );
  setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList );

  int elemGroup = addPreference( tr( "PREF_GROUP_ELEMENTS" ), meshTab );
  setPreferenceProperty( elemGroup, "columns", 2 );

  addPreference( tr( "PREF_FILL"     ), elemGroup, LightApp_Preferences::Color, "SMESH", "fill_color" );
  addPreference( tr( "PREF_OUTLINE"  ), elemGroup, LightApp_Preferences::Color, "SMESH", "outline_color" );
  addPreference( tr( "PREF_BACKFACE" ), elemGroup, LightApp_Preferences::Color, "SMESH", "backface_color" );
  addPreference( tr( "PREF_COLOR_0D" ), elemGroup, LightApp_Preferences::Color, "SMESH", "elem0d_color" );

  int grpGroup = addPreference( tr( "PREF_GROUP_GROUPS" ), meshTab );
  setPreferenceProperty( grpGroup, "columns", 2 );

  addPreference( tr( "PREF_GRP_NAMES" ), grpGroup, LightApp_Preferences::Color, "SMESH", "group_name_color" );

  //int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
  //setPreferenceProperty( sp, "hstretch", 0 );
  //setPreferenceProperty( sp, "vstretch", 0 );

  int size0d = addPreference(tr("PREF_SIZE_0D"), elemGroup,
                             LightApp_Preferences::IntSpin, "SMESH", "elem0d_size");
  int sp = addPreference( "", elemGroup, LightApp_Preferences::Space );
  int elemW  = addPreference(tr("PREF_WIDTH"), elemGroup,
                             LightApp_Preferences::IntSpin, "SMESH", "element_width");
  int shrink = addPreference(tr("PREF_SHRINK_COEFF"), elemGroup,
                             LightApp_Preferences::IntSpin, "SMESH", "shrink_coeff");

  setPreferenceProperty( size0d, "min", 1 );
  setPreferenceProperty( size0d, "max", 10 );

  setPreferenceProperty( sp, "hstretch", 0 );
  setPreferenceProperty( sp, "vstretch", 0 );

  setPreferenceProperty( elemW, "min", 1 );
  setPreferenceProperty( elemW, "max", 5 );

  setPreferenceProperty( shrink, "min", 0 );
  setPreferenceProperty( shrink, "max", 100 );

  int orientGroup = addPreference( tr( "PREF_GROUP_FACES_ORIENTATION" ), meshTab );
  setPreferenceProperty( orientGroup, "columns", 1 );

  addPreference( tr( "PREF_ORIENTATION_COLOR" ), orientGroup, LightApp_Preferences::Color, "SMESH", "orientation_color" );
  int orientScale = addPreference( tr( "PREF_ORIENTATION_SCALE" ), orientGroup, LightApp_Preferences::DblSpin, "SMESH", "orientation_scale" );

  setPreferenceProperty( orientScale, "min", 0.05 );
  setPreferenceProperty( orientScale, "max", 0.5 );
  setPreferenceProperty( orientScale, "step", 0.05 );

  addPreference( tr( "PREF_ORIENTATION_3D_VECTORS" ), orientGroup, LightApp_Preferences::Bool, "SMESH", "orientation_3d_vectors" );

  // Selection tab ------------------------------------------------------------------------
  int selTab = addPreference( tr( "PREF_TAB_SELECTION" ) );

  int selGroup = addPreference( tr( "PREF_GROUP_SELECTION" ), selTab );
  setPreferenceProperty( selGroup, "columns", 2 );

  addPreference( tr( "PREF_OBJECT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_object_color" );
  addPreference( tr( "PREF_ELEMENT_COLOR" ), selGroup, LightApp_Preferences::Color, "SMESH", "selection_element_color" );
  int selW = addPreference( tr( "PREF_WIDTH" ), selGroup, LightApp_Preferences::IntSpin, "SMESH", "selection_width" );

  setPreferenceProperty( selW, "min", 1 );
  setPreferenceProperty( selW, "max", 5 );

  int preGroup = addPreference( tr( "PREF_GROUP_PRESELECTION" ), selTab );
  setPreferenceProperty( preGroup, "columns", 2 );

  addPreference( tr( "PREF_HIGHLIGHT_COLOR" ), preGroup, LightApp_Preferences::Color, "SMESH", "highlight_color" );
  int preW = addPreference( tr( "PREF_WIDTH" ), preGroup, LightApp_Preferences::IntSpin, "SMESH", "highlight_width" );

  setPreferenceProperty( preW, "min", 1 );
  setPreferenceProperty( preW, "max", 5 );

  int precSelGroup = addPreference( tr( "PREF_GROUP_PRECISION" ), selTab );
  setPreferenceProperty( precSelGroup, "columns", 2 );

  addPreference( tr( "PREF_NODES" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_node" );
  addPreference( tr( "PREF_ELEMENTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_element" );
  addPreference( tr( "PREF_OBJECTS" ), precSelGroup, LightApp_Preferences::Double, "SMESH", "selection_precision_object" );

  // Scalar Bar tab ------------------------------------------------------------------------
  int sbarTab = addPreference( tr( "SMESH_SCALARBAR" ) );
  int fontGr = addPreference( tr( "SMESH_FONT_SCALARBAR" ), sbarTab );
  setPreferenceProperty( fontGr, "columns", 2 );

  addVtkFontPref( tr( "SMESH_TITLE" ), fontGr, "scalar_bar_title_font" );
  addPreference( tr( "PREF_TITLE_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_title_color" );

  addVtkFontPref( tr( "SMESH_LABELS" ), fontGr, "scalar_bar_label_font" );
  addPreference( tr( "PREF_LABELS_COLOR" ), fontGr, LightApp_Preferences::Color, "SMESH", "scalar_bar_label_color" );

  int colorsLabelsGr = addPreference( tr( "SMESH_LABELS_COLORS_SCALARBAR" ), sbarTab );
  setPreferenceProperty( colorsLabelsGr, "columns", 2 );

  int numcol = addPreference( tr( "SMESH_NUMBEROFCOLORS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_colors" );
  setPreferenceProperty( numcol, "min", 2 );
  setPreferenceProperty( numcol, "max", 256 );

  int numlab = addPreference( tr( "SMESH_NUMBEROFLABELS" ), colorsLabelsGr, LightApp_Preferences::IntSpin, "SMESH", "scalar_bar_num_labels" );
  setPreferenceProperty( numlab, "min", 2 );
  setPreferenceProperty( numlab, "max", 65 );

  int orientGr = addPreference( tr( "SMESH_ORIENTATION" ), sbarTab );
  setPreferenceProperty( orientGr, "columns", 2 );
  int orient = addPreference( tr( "SMESH_ORIENTATION" ), orientGr, LightApp_Preferences::Selector, "SMESH", "scalar_bar_orientation" );
  QStringList orients;
  orients.append( tr( "SMESH_VERTICAL" ) );
  orients.append( tr( "SMESH_HORIZONTAL" ) );
  indices.clear(); indices.append( 0 ); indices.append( 1 );
  setPreferenceProperty( orient, "strings", orients );
  setPreferenceProperty( orient, "indexes", indices );

  int posVSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_VERTICAL" ), sbarTab );
  setPreferenceProperty( posVSizeGr, "columns", 2 );
  int xv = addPreference( tr( "SMESH_X_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_x" );
  int yv = addPreference( tr( "SMESH_Y_SCALARBAR" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_y" );
  int wv = addPreference( tr( "SMESH_WIDTH" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_width" );
  int hv = addPreference( tr( "SMESH_HEIGHT" ), posVSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_vertical_height" );
  setPreferenceProperty( xv, "step", 0.1 );
  setPreferenceProperty( xv, "min", 0.0 );
  setPreferenceProperty( xv, "max", 1.0 );
  setPreferenceProperty( yv, "step", 0.1 );
  setPreferenceProperty( yv, "min", 0.0 );
  setPreferenceProperty( yv, "max", 1.0 );
  setPreferenceProperty( wv, "step", 0.1 );
  setPreferenceProperty( wv, "min", 0.0 );
  setPreferenceProperty( wv, "max", 1.0 );
  setPreferenceProperty( hv, "min", 0.0 );
  setPreferenceProperty( hv, "max", 1.0 );
  setPreferenceProperty( hv, "step", 0.1 );

  int posHSizeGr = addPreference( tr( "SMESH_POSITION_SIZE_SCALARBAR" ) + " " + tr( "SMESH_HORIZONTAL" ), sbarTab );
  setPreferenceProperty( posHSizeGr, "columns", 2 );
  int xh = addPreference( tr( "SMESH_X_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_x" );
  int yh = addPreference( tr( "SMESH_Y_SCALARBAR" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_y" );
  int wh = addPreference( tr( "SMESH_WIDTH" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_width" );
  int hh = addPreference( tr( "SMESH_HEIGHT" ), posHSizeGr, LightApp_Preferences::DblSpin, "SMESH", "scalar_bar_horizontal_height" );
  setPreferenceProperty( xv, "min", 0.0 );
  setPreferenceProperty( xv, "max", 1.0 );
  setPreferenceProperty( xv, "step", 0.1 );
  setPreferenceProperty( xh, "min", 0.0 );
  setPreferenceProperty( xh, "max", 1.0 );
  setPreferenceProperty( xh, "step", 0.1 );
  setPreferenceProperty( yh, "min", 0.0 );
  setPreferenceProperty( yh, "max", 1.0 );
  setPreferenceProperty( yh, "step", 0.1 );
  setPreferenceProperty( wh, "min", 0.0 );
  setPreferenceProperty( wh, "max", 1.0 );
  setPreferenceProperty( wh, "step", 0.1 );
  setPreferenceProperty( hh, "min", 0.0 );
  setPreferenceProperty( hh, "max", 1.0 );
  setPreferenceProperty( hh, "step", 0.1 );
  
  int distributionGr = addPreference( tr( "SMESH_DISTRIBUTION_SCALARBAR" ), sbarTab, LightApp_Preferences::Auto, "SMESH", "distribution_visibility" );
  int coloringType = addPreference( tr( "SMESH_DISTRIBUTION_COLORING_TYPE" ), distributionGr, LightApp_Preferences::Selector, "SMESH", "distribution_coloring_type" );
  setPreferenceProperty( distributionGr, "columns", 3 );
  QStringList types;
  types.append( tr( "SMESH_MONOCOLOR" ) ); 
  types.append( tr( "SMESH_MULTICOLOR" ) );
  indices.clear(); indices.append( 0 ); indices.append( 1 );
  setPreferenceProperty( coloringType, "strings", types );
  setPreferenceProperty( coloringType, "indexes", indices );
  addPreference( tr( "SMESH_DISTRIBUTION_COLOR" ), distributionGr, LightApp_Preferences::Color, "SMESH", "distribution_color" );

}

LightApp_Selection * SMESHGUI::createSelection

(

)

const [virtual]

Definition at line 4191 of file SMESHGUI.cxx.

{
  return new SMESHGUI_Selection();
}

void SMESHGUI::createSMESHAction	(	const int	id,
		const QString &	po_id,
		const QString &	icon_id = QString(),
		const int	key = 0,
		const bool	toggle = false,
		const QString &	shortcutAction = QString()
	)		[protected]

Definition at line 3186 of file SMESHGUI.cxx.

References OnGUIEvent(), and resourceMgr().

Referenced by initialize().

{
  QIcon icon;
  QWidget* parent = application()->desktop();
  SUIT_ResourceMgr* resMgr = resourceMgr();
  QPixmap pix;
  if ( !icon_id.isEmpty() )
    pix = resMgr->loadPixmap( "SMESH", tr( icon_id.toLatin1().data() ) );
  else
    pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICO_%1" ).arg( po_id ).toLatin1().data() ), false );
  if ( !pix.isNull() )
    icon = QIcon( pix );

  QString tooltip    = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
          menu       = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
          status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );

  createAction( id, tooltip, icon, menu, status_bar, key, parent, 
                toggle, this, SLOT( OnGUIEvent() ), shortcutAction );
}

bool SMESHGUI::deactivateModule

(

SUIT_Study *

study

)

[virtual, slot]

Definition at line 4117 of file SMESHGUI.cxx.

References EmitSignalCloseAllDialogs().

{
  setMenuShown( false );
  setToolShown( false );

  EmitSignalCloseAllDialogs();

  // Unset actions accelerator keys
  action(111)->setShortcut(QKeySequence()); // Import DAT
  action(112)->setShortcut(QKeySequence()); // Import UNV
  action(113)->setShortcut(QKeySequence()); // Import MED

  action(  33)->setEnabled(false); // Delete: Key_Delete

  return SalomeApp_Module::deactivateModule( study );
}

bool SMESHGUI::DefineDlgPosition	(	QWidget *	aDlg,
		int &	x,
		int &	y
	)

Definition at line 1808 of file SMESHGUI.cxx.

References desktop().

{
  /* Here the position is on the bottom right corner - 10 */
  // aDlg->resize(QSize().expandedTo(aDlg->minimumSizeHint()));
  aDlg->adjustSize();
  SUIT_Desktop *PP = desktop();
  x = abs(PP->x() + PP->size().width() - aDlg->size().width() - 10);
  y = abs(PP->y() + PP->size().height() - aDlg->size().height() - 10);
  return true;
}

SUIT_Desktop * SMESHGUI::desktop

(

)

[static]

Definition at line 1764 of file SMESHGUI.cxx.

Referenced by SMESHGUI_FilterLibraryDlg.addFilterToLib(), checkLock(), SMESHGUI_MergeDlg.ClickOnApply(), DefineDlgPosition(), ExportMeshToFile(), SMESH.GetVisualObj(), ImportMeshesFromFile(), SMESH.InitAvailableHypotheses(), SMESHGUI_FilterLibraryDlg.isNameValid(), SMESHGUI_FilterLibraryDlg.isPermissionValid(), SMESHGUI_Operation.isStudyLocked(), SMESHGUI_FilterDlg.isValid(), SMESHGUI_FilterTable.IsValid(), SMESHGUI_FilterTable.AdditionalWidget.IsValid(), SMESHGUI_DeleteGroupDlg.isValid(), SMESHGUI_MakeNodeAtPointOp.onApply(), SMESHGUI_FilterLibraryDlg.onApply(), SMESHGUI_FilterLibraryDlg.onDeleteBtnPressed(), OnEditDelete(), OnGUIEvent(), SMESH.OnVisuException(), preferencesChanged(), SMESH.processHypothesisStatus(), SMESHGUI_FilterLibraryDlg.processNewLibrary(), and SaveDistribution().

{
  SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
  if( app )
    return app->desktop();
  else
    return 0;
}

LightApp_Displayer * SMESHGUI::displayer

(

)

[virtual]

Definition at line 4776 of file SMESHGUI.cxx.

References myDisplayer.

Referenced by restoreVisualParameters().

{
  if( !myDisplayer )
    myDisplayer = new SMESHGUI_Displayer( getApp() );
  return myDisplayer;
}

void SMESHGUI::EmitSignalCloseAllDialogs

(

)

Definition at line 1723 of file SMESHGUI.cxx.

References SignalCloseAllDialogs().

Referenced by deactivateModule().

{
  emit SignalCloseAllDialogs();
}

void SMESHGUI::EmitSignalDeactivateDialog

(

)

Definition at line 1703 of file SMESHGUI.cxx.

References SignalDeactivateActiveDialog().

Referenced by SMESHGUI_MeshInfoDlg.activate(), SMESHGUI_MeasureDlg.activate(), SMESHGUI_WhatIsDlg.ActivateThisDialog(), SMESHGUI_TranslationDlg.ActivateThisDialog(), SMESHGUI_SymmetryDlg.ActivateThisDialog(), SMESHGUI_StandardMeshInfosDlg.ActivateThisDialog(), SMESHGUI_SmoothingDlg.ActivateThisDialog(), SMESHGUI_SewingDlg.ActivateThisDialog(), SMESHGUI_ScaleDlg.ActivateThisDialog(), SMESHGUI_RotationDlg.ActivateThisDialog(), SMESHGUI_RevolutionDlg.ActivateThisDialog(), SMESHGUI_RenumberingDlg.ActivateThisDialog(), SMESHGUI_RemoveNodesDlg.ActivateThisDialog(), SMESHGUI_RemoveElementsDlg.ActivateThisDialog(), SMESHGUI_Preferences_ColorDlg.ActivateThisDialog(), SMESHGUI_NodesDlg.ActivateThisDialog(), SMESHGUI_MeshInfosDlg.ActivateThisDialog(), SMESHGUI_MergeDlg.ActivateThisDialog(), SMESHGUI_ExtrusionDlg.ActivateThisDialog(), SMESHGUI_ExtrusionAlongPathDlg.ActivateThisDialog(), SMESHGUI_CreatePolyhedralVolumeDlg.ActivateThisDialog(), SMESHGUI_CopyMeshDlg.ActivateThisDialog(), SMESHGUI_BuildCompoundDlg.ActivateThisDialog(), SMESHGUI_AddQuadraticElementDlg.ActivateThisDialog(), SMESHGUI_AddMeshElementDlg.ActivateThisDialog(), SMESHGUI_SingleEditDlg.enterEvent(), SMESHGUI_MultiEditDlg.enterEvent(), SMESHGUI_MoveNodesDlg.enterEvent(), SMESHGUI_MeshPatternDlg.enterEvent(), SMESHGUI_GroupOpDlg.enterEvent(), SMESHGUI_GroupDlg.enterEvent(), SMESHGUI_DuplicateNodesDlg.enterEvent(), SMESHGUI_DeleteGroupDlg.enterEvent(), SMESHGUI_CreatePatternDlg.enterEvent(), OnGUIEvent(), and SetDisplayMode().

{
  emit SignalDeactivateActiveDialog();
}

void SMESHGUI::EmitSignalStudyFrameChanged

(

)

Definition at line 1713 of file SMESHGUI.cxx.

References SignalStudyFrameChanged().

{
  emit SignalStudyFrameChanged();
}

void SMESHGUI::EmitSignalVisibilityChanged

(

)

Definition at line 1733 of file SMESHGUI.cxx.

References SignalVisibilityChanged().

Referenced by OnGUIEvent().

{
  emit SignalVisibilityChanged();
}

QString SMESHGUI::engineIOR

(

)

const [virtual]

Definition at line 4165 of file SMESHGUI.cxx.

References anORB, and GetSMESHGen().

Referenced by OnEditDelete().

{
  CORBA::ORB_var anORB = getApp()->orb();
  CORBA::String_var anIOR = anORB->object_to_string(GetSMESHGen());
  return QString( anIOR.in() );
}

QDialog * SMESHGUI::GetActiveDialogBox

(

)

Definition at line 1743 of file SMESHGUI.cxx.

References myActiveDialogBox.

{
  return myActiveDialogBox;
}

SMESHGUI_ClippingPlaneInfoMap& SMESHGUI.getClippingPlaneInfoMap

(

)

Definition at line 153 of file SMESHGUI.h.

Referenced by SMESHGUI_ClippingDlg.ClickOnApply(), and SMESHGUI_ClippingDlg.initializePlaneData().

{ return myClippingPlaneInfoMap; }

SMESH::SMESH_Gen_var SMESHGUI::GetSMESHGen

(

)

[static]

Definition at line 4150 of file SMESHGUI.cxx.

References _PTR(), and myComponentSMESH.

Referenced by activateModule(), SMESHGUI_CopyMeshDlg.ClickOnApply(), SMESHGUI_BuildCompoundDlg.ClickOnApply(), SMESHGUI_ShapeByMeshOp.commitOperation(), SMESHGUI_BoundingBox.compute(), SMESHGUI_MinDistance.compute(), SMESHGUI_BaseComputeOp.computeMesh(), SMESH.CreateHypothesis(), SMESHGUI_MeshOp.createMesh(), SMESHGUI_MeshOp.createSubMesh(), SMESHGUI_MeshOp.editMeshOrSubMesh(), engineIOR(), SMESHGUI_BaseComputeOp.evaluateMesh(), ExportMeshToFile(), SMESH.GetFilterManager(), StdMeshersGUI_SubShapeSelectorWdg.GetGeomObjectByEntry(), SMESHGUI_MeshOp.getInitParamsHypothesis(), SMESH.GetMeasurements(), SMESH.GetPattern(), GetSMESHGUI(), SMESH_Swig.Init(), SMESHGUI_GroupDlg.onApply(), OnGUIEvent(), StdMeshersGUI_LayerDistributionParamWdg.onHypTypePopup(), SMESHGUI_PrecomputeOp.onPreview(), SMESHGUI_BaseComputeOp.onPublishShape(), SMESHGUI_BaseComputeOp.onShowBadMesh(), renameObject(), SMESH.SetName(), and SMESHGUI().

{
  _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
  if ( CORBA::is_nil( myComponentSMESH ) )
    {
      SMESHGUI aGUI; //SRN BugID: IPAL9186: Create an instance of SMESHGUI to initialize myComponentSMESH
      if ( aStudy )
        aGUI.myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
      return aGUI.myComponentSMESH;
    }
  if ( aStudy )
    myComponentSMESH->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
  return myComponentSMESH;
}

SMESHGUI * SMESHGUI::GetSMESHGUI

(

)

[static]

Definition at line 1646 of file SMESHGUI.cxx.

References _PTR(), activeStudy(), and GetSMESHGen().

Referenced by SMESHGUI_MeshInfoDlg.activate(), SMESHGUI_MeasureDlg.activate(), SMESH.AddGroup(), SMESHGUI_NodesDlg.ClickOnApply(), SMESHGUI_CreatePolyhedralVolumeDlg.ClickOnApply(), SMESHGUI_AddQuadraticElementDlg.ClickOnApply(), SMESHGUI_AddMeshElementDlg.ClickOnApply(), SMESHGUI_BaseComputeOp.computeMesh(), SMESH.CreateActor(), SMESH.CreateHypothesis(), SMESHGUI_MakeNodeAtPointDlg.createMainFrame(), SMESHGUI_GenericHypothesisCreator.editHypothesis(), GetComponentGUI(), SMESH.TShapeDisplayer.hasViewWindow(), ImportMeshesFromFile(), StdMeshersGUI_SubShapeSelectorWdg.init(), StdMeshersGUI_ObjectReferenceParamWdg.init(), StdMeshersGUI_LayerDistributionParamWdg.init(), SMESH_Swig.Init(), SMESHGUI_GenericHypothesisCreator.onDialogFinished(), OnEditDelete(), OnGUIEvent(), SMESHGUI_MeshOp.onPublishShapeByMeshDlg(), SMESHGUI_MeshOp.selectionDone(), SetDisplayMode(), SMESHGUI_MeshOrderMgr.SetMeshOrder(), SMESH.TShapeDisplayer.Show(), SMESH.ShowHelpFile(), SMESHGUI_MeasureDlg.SMESHGUI_MeasureDlg(), and SMESHGUI_MeshInfoDlg.SMESHGUI_MeshInfoDlg().

{
  SMESHGUI* smeshMod = 0;
  SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
  if ( app )
  {
    CAM_Module* module = app->module( "Mesh" );
    smeshMod = dynamic_cast<SMESHGUI*>( module );
  }

  if ( smeshMod && smeshMod->application() && smeshMod->application()->activeStudy() )
  {
    SalomeApp_Study* study = dynamic_cast<SalomeApp_Study*>( smeshMod->application()->activeStudy() );
    if ( study )
    {
      _PTR(Study) aStudy = study->studyDS();
      if ( aStudy )
        GetSMESHGen()->SetCurrentStudy( _CAST(Study,aStudy)->GetStudy() );
    }
  }

  return smeshMod;
}

SALOMEDS::Color SMESHGUI::getUniqueColor

(

const QList< SALOMEDS::Color > &

theReservedColors

)

[static]

Definition at line 4783 of file SMESHGUI.cxx.

{
  int aHue = -1;
  int aTolerance = 64;
  int anIterations = 0;
  int aPeriod = 5;

  while( 1 )
  {
    anIterations++;
    if( anIterations % aPeriod == 0 )
    {
      aTolerance /= 2;
      if( aTolerance < 1 )
        break;
    }

    aHue = (int)( 360.0 * rand() / RAND_MAX );

    bool ok = true;
    QList<SALOMEDS::Color>::const_iterator it = theReservedColors.constBegin();
    QList<SALOMEDS::Color>::const_iterator itEnd = theReservedColors.constEnd();
    for( ; it != itEnd; ++it )
    {
      SALOMEDS::Color anAutoColor = *it;
      QColor aQColor( (int)( anAutoColor.R * 255.0 ), (int)( anAutoColor.G * 255.0 ), (int)( anAutoColor.B * 255.0 ) );

      int h, s, v;
      aQColor.getHsv( &h, &s, &v );
      if( abs( h - aHue ) < aTolerance )
      {
        ok = false;
        break;
      }
    }

    if( ok )
      break;
  }

  QColor aColor;
  aColor.setHsv( aHue, 255, 255 );

  SALOMEDS::Color aSColor;
  aSColor.R = (double)aColor.red() / 255.0;
  aSColor.G = (double)aColor.green() / 255.0;
  aSColor.B = (double)aColor.blue() / 255.0;

  return aSColor;
}

void SMESHGUI::initialize

(

CAM_Application *

app

)

[virtual]

Definition at line 3248 of file SMESHGUI.cxx.

References ex01_cube2build.algo, ALGORITHM, createPopupItem(), createSMESHAction(), GROUP, ex21_lamp.group, HYPOTHESIS, PAL_MESH_041_mesh.mesh, myRules, onViewManagerActivated(), onViewManagerRemoved(), SUBMESH, SUBMESH_COMPOUND, SUBMESH_EDGE, SUBMESH_FACE, SUBMESH_SOLID, SUBMESH_VERTEX, and SMESHGUI_Selection.typeName().

{
  SalomeApp_Module::initialize( app );

//   SUIT_ResourceMgr* mgr = app->resourceMgr();
//   if ( mgr )
  /* Automatic Update flag */
//     myAutomaticUpdate = mgr->booleanValue( "SMESH", "AutomaticUpdate", myAutomaticUpdate );

  // ----- create actions --------------

  createSMESHAction(  111, "DAT", "", (Qt::CTRL+Qt::Key_B) );
  createSMESHAction(  112, "UNV", "", (Qt::CTRL+Qt::Key_U) );
  createSMESHAction(  113, "MED", "", (Qt::CTRL+Qt::Key_M) );
  createSMESHAction(  114, "NUM" );
  createSMESHAction(  121, "DAT" );
  createSMESHAction(  122, "MED" );
  createSMESHAction(  123, "UNV" );
  createSMESHAction(  140, "STL" );
  createSMESHAction(  124, "EXPORT_DAT" );
  createSMESHAction(  125, "EXPORT_MED" );
  createSMESHAction(  126, "EXPORT_UNV" );
  createSMESHAction(  141, "EXPORT_STL" );
  createSMESHAction(  150, "FILE_INFO" );
  createSMESHAction(   33, "DELETE",          "ICON_DELETE", Qt::Key_Delete );
  createSMESHAction( 5105, "SEL_FILTER_LIB" );
  createSMESHAction(  701, "COMPUTE",         "ICON_COMPUTE" );
  createSMESHAction(  702, "CREATE_MESH",     "ICON_DLG_INIT_MESH" );
  createSMESHAction(  703, "CREATE_SUBMESH",  "ICON_DLG_ADD_SUBMESH" );
  createSMESHAction(  704, "EDIT_MESHSUBMESH","ICON_DLG_EDIT_MESH" );
  createSMESHAction(  705, "COPY_MESH",       "ICON_COPY_MESH" );
  createSMESHAction(  710, "BUILD_COMPOUND",  "ICON_BUILD_COMPOUND" );
  createSMESHAction(  711, "PRECOMPUTE",      "ICON_PRECOMPUTE" );
  createSMESHAction(  712, "EVALUATE",        "ICON_COMPUTE" );
  createSMESHAction(  713, "MESH_ORDER",      "ICON_COMPUTE" );
  createSMESHAction(  806, "CREATE_GEO_GROUP","ICON_CREATE_GEO_GROUP" );
  createSMESHAction(  801, "CREATE_GROUP",    "ICON_CREATE_GROUP" );
  createSMESHAction(  802, "CONSTRUCT_GROUP", "ICON_CONSTRUCT_GROUP" );
  createSMESHAction(  803, "EDIT_GROUP",      "ICON_EDIT_GROUP" );
  createSMESHAction(  815, "EDIT_GEOMGROUP_AS_GROUP", "ICON_EDIT_GROUP" );
  createSMESHAction(  804, "ADD" );
  createSMESHAction(  805, "REMOVE" );
  createSMESHAction(  810, "UN_GROUP",        "ICON_UNION" );
  createSMESHAction(  811, "INT_GROUP",       "ICON_INTERSECT" );
  createSMESHAction(  812, "CUT_GROUP",       "ICON_CUT" );
  createSMESHAction(  814, "UNDERLYING_ELEMS","ICON_UNDERLYING_ELEMS" );
  createSMESHAction(  813, "DEL_GROUP",       "ICON_DEL_GROUP" );
  createSMESHAction(  900, "ADV_INFO",        "ICON_ADV_INFO" );
  //createSMESHAction(  902, "STD_INFO",        "ICON_STD_INFO" );
  //createSMESHAction(  903, "WHAT_IS",         "ICON_WHAT_IS" ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
  createSMESHAction(  904, "FIND_ELEM",       "ICON_FIND_ELEM" );
  createSMESHAction( 6001, "LENGTH",          "ICON_LENGTH",        0, true );
  createSMESHAction( 6002, "FREE_EDGE",       "ICON_FREE_EDGE",     0, true );
  createSMESHAction( 6021, "FREE_FACES",      "ICON_FREE_FACES",    0, true );
  createSMESHAction( 6022, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
  createSMESHAction( 6023, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
  createSMESHAction( 6024, "BARE_BORDER_VOLUME","ICON_BARE_BORDER_VOLUME", 0, true );
  createSMESHAction( 6025, "BARE_BORDER_FACE","ICON_BARE_BORDER_FACE", 0, true );
  createSMESHAction( 6026, "OVER_CONSTRAINED_VOLUME","ICON_OVER_CONSTRAINED_VOLUME", 0, true );
  createSMESHAction( 6027, "OVER_CONSTRAINED_FACE","ICON_OVER_CONSTRAINED_FACE", 0, true );
  createSMESHAction( 6003, "FREE_BORDER",     "ICON_FREE_EDGE_2D",  0, true );
  createSMESHAction( 6004, "CONNECTION",      "ICON_CONNECTION",    0, true );
  createSMESHAction( 6005, "FREE_NODE",       "ICON_FREE_NODE",     0, true );
  createSMESHAction( 6011, "AREA",            "ICON_AREA",          0, true );
  createSMESHAction( 6012, "TAPER",           "ICON_TAPER",         0, true );
  createSMESHAction( 6013, "ASPECT",          "ICON_ASPECT",        0, true );
  createSMESHAction( 6014, "MIN_ANG",         "ICON_ANGLE",         0, true );
  createSMESHAction( 6015, "WARP",            "ICON_WARP",          0, true );
  createSMESHAction( 6016, "SKEW",            "ICON_SKEW",          0, true );
  createSMESHAction( 6017, "ASPECT_3D",       "ICON_ASPECT_3D",     0, true );
  createSMESHAction( 6018, "LENGTH_2D",       "ICON_LENGTH_2D",     0, true );
  createSMESHAction( 6019, "CONNECTION_2D",   "ICON_CONNECTION_2D", 0, true );
  createSMESHAction( 6009, "VOLUME_3D",       "ICON_VOLUME_3D",     0, true );
  createSMESHAction( 4000, "NODE",            "ICON_DLG_NODE" );
  createSMESHAction( 4009, "ELEM0D",          "ICON_DLG_ELEM0D" );
  createSMESHAction( 4010, "EDGE",            "ICON_DLG_EDGE" );
  createSMESHAction( 4021, "TRIANGLE",        "ICON_DLG_TRIANGLE" );
  createSMESHAction( 4022, "QUAD",            "ICON_DLG_QUADRANGLE" );
  createSMESHAction( 4023, "POLYGON",         "ICON_DLG_POLYGON" );
  createSMESHAction( 4031, "TETRA",           "ICON_DLG_TETRAS" );
  createSMESHAction( 4032, "HEXA",            "ICON_DLG_HEXAS" );
  createSMESHAction( 4041, "REMOVE_NODES",    "ICON_DLG_REM_NODE" );
  createSMESHAction( 4042, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
  createSMESHAction( 4044, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
  createSMESHAction( 4043, "CLEAR_MESH"    ,  "ICON_CLEAR_MESH" );
  createSMESHAction( 4051, "RENUM_NODES",     "ICON_DLG_RENUMBERING_NODES" );
  createSMESHAction( 4052, "RENUM_ELEMENTS",  "ICON_DLG_RENUMBERING_ELEMENTS" );
  createSMESHAction( 4061, "TRANS",           "ICON_SMESH_TRANSLATION_VECTOR" );
  createSMESHAction( 4062, "ROT",             "ICON_DLG_MESH_ROTATION" );
  createSMESHAction( 4063, "SYM",             "ICON_SMESH_SYMMETRY_PLANE" );
  createSMESHAction( 4064, "SEW",             "ICON_SMESH_SEWING_FREEBORDERS" );
  createSMESHAction( 4065, "MERGE",           "ICON_SMESH_MERGE_NODES" );
  createSMESHAction( 4066, "MERGE_ELEMENTS",  "ICON_DLG_MERGE_ELEMENTS" );
  createSMESHAction( 4067, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
  createSMESHAction( 4068, "SCALE",           "ICON_DLG_MESH_SCALE" );
  createSMESHAction( 4069, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
  createSMESHAction(  407, "INV",             "ICON_DLG_MESH_DIAGONAL" );
  createSMESHAction(  408, "UNION2",          "ICON_UNION2TRI" );
  createSMESHAction(  409, "ORIENT",          "ICON_DLG_MESH_ORIENTATION" );
  createSMESHAction(  410, "UNION",           "ICON_UNIONTRI" );
  createSMESHAction(  411, "CUT",             "ICON_CUTQUAD" );
  createSMESHAction(  412, "SMOOTH",          "ICON_DLG_SMOOTHING" );
  createSMESHAction(  413, "EXTRUSION",       "ICON_EXTRUSION" );
  createSMESHAction(  414, "REVOLUTION",      "ICON_REVOLUTION" );
  createSMESHAction(  415, "MAP",             "ICON_MAP" );
  createSMESHAction(  416, "EXTRUSION_ALONG", "ICON_EXTRUSION_ALONG" );
  createSMESHAction(  417, "CONV_TO_QUAD",    "ICON_CONV_TO_QUAD" );
  createSMESHAction(  418, "2D_FROM_3D",      "ICON_2D_FROM_3D" );
  createSMESHAction(  419, "SPLIT_TO_TETRA",  "ICON_SPLIT_TO_TETRA" );
  createSMESHAction(  200, "RESET" );
  createSMESHAction(  201, "SCALAR_BAR_PROP" );
  createSMESHAction(  2021, "SAVE_DISTRIBUTION" );
  createSMESHAction(  2022, "SHOW_DISTRIBUTION","",0, true );
#ifndef DISABLE_PLOT2DVIEWER
  createSMESHAction(  2023, "PLOT_DISTRIBUTION" );
#endif
  createSMESHAction(  211, "WIRE",           "ICON_WIRE", 0, true );
  createSMESHAction(  212, "SHADE",          "ICON_SHADE", 0, true );
  createSMESHAction(  213, "SHRINK",         "ICON_SHRINK", 0, true );
  createSMESHAction(  214, "UPDATE",         "ICON_UPDATE" );
  createSMESHAction(  215, "NODES",          "ICON_POINTS", 0, true );
  createSMESHAction(  216, "ELEMS0D",        "ICON_DLG_ELEM0D", 0, true );
  createSMESHAction(  217, "EDGES",          "ICON_DLG_EDGE", 0, true );
  createSMESHAction(  218, "FACES",          "ICON_DLG_TRIANGLE", 0, true );
  createSMESHAction(  219, "VOLUMES",        "ICON_DLG_TETRAS", 0, true );
  createSMESHAction(  220, "ALL" );
  createSMESHAction(  221, "FACE_ORIENTATION", "", 0, true );

  createSMESHAction(  231, "LINE_REPRESENTATION", "", 0, true );
  createSMESHAction(  232, "ARC_REPRESENTATION", "", 0, true );

  createSMESHAction( 1100, "EDIT_HYPO" );
  createSMESHAction( 1102, "UNASSIGN" );
  createSMESHAction( 9010, "NUM_NODES", "", 0, true );
  createSMESHAction( 9011, "NUM_ELEMENTS", "", 0, true );
  createSMESHAction( 1131, "DISPMODE" );
  createSMESHAction( 1132, "COLORS" );
  createSMESHAction( 1133, "TRANSP" );
  createSMESHAction( 1134, "CLIP" );
  createSMESHAction( 1135, "DISP_ENT" );
  createSMESHAction( 1136, "AUTO_COLOR" );
  createSMESHAction( 1137, "DISABLE_AUTO_COLOR" );
  createSMESHAction( 2000, "CTRL" );

  createSMESHAction( 501, "MEASURE_MIN_DIST", "ICON_MEASURE_MIN_DIST" );
  createSMESHAction( 502, "MEASURE_BND_BOX",  "ICON_MEASURE_BND_BOX" );

  createSMESHAction( 300, "ERASE" );
  createSMESHAction( 301, "DISPLAY" );
  createSMESHAction( 302, "DISPLAY_ONLY" );
  createSMESHAction( 4033, "POLYHEDRON", "ICON_DLG_POLYHEDRON" );
  createSMESHAction( 4034, "QUADRATIC_EDGE", "ICON_DLG_QUADRATIC_EDGE" );
  createSMESHAction( 4035, "QUADRATIC_TRIANGLE", "ICON_DLG_QUADRATIC_TRIANGLE" );
  createSMESHAction( 4036, "QUADRATIC_QUADRANGLE", "ICON_DLG_QUADRATIC_QUADRANGLE" );
  createSMESHAction( 4037, "QUADRATIC_TETRAHEDRON", "ICON_DLG_QUADRATIC_TETRAHEDRON" );
  createSMESHAction( 4038, "QUADRATIC_PYRAMID", "ICON_DLG_QUADRATIC_PYRAMID" );
  createSMESHAction( 4039, "QUADRATIC_PENTAHEDRON", "ICON_DLG_QUADRATIC_PENTAHEDRON" );
  createSMESHAction( 4040, "QUADRATIC_HEXAHEDRON", "ICON_DLG_QUADRATIC_HEXAHEDRON" );

  // ----- create menu --------------
  int fileId    = createMenu( tr( "MEN_FILE" ),    -1,  1 ),
      editId    = createMenu( tr( "MEN_EDIT" ),    -1,  3 ),
      toolsId   = createMenu( tr( "MEN_TOOLS" ),   -1,  5, 50 ),
      meshId    = createMenu( tr( "MEN_MESH" ),    -1, 70, 10 ),
      ctrlId    = createMenu( tr( "MEN_CTRL" ),    -1, 60, 10 ),
      modifyId  = createMenu( tr( "MEN_MODIFY" ),  -1, 40, 10 ),
      measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
      viewId    = createMenu( tr( "MEN_VIEW" ),    -1,  2 );

  createMenu( separator(), fileId );

  int importId = createMenu( tr( "MEN_IMPORT" ), fileId, -1, 10 ),
      exportId = createMenu( tr( "MEN_EXPORT" ), fileId, -1, 10 ),
      nodeId   = createMenu( tr( "MEN_NODE_CTRL" ), ctrlId, -1, 10 ),
      edgeId   = createMenu( tr( "MEN_EDGE_CTRL" ), ctrlId, -1, 10 ),
      faceId   = createMenu( tr( "MEN_FACE_CTRL" ), ctrlId, -1, 10 ),
      volumeId = createMenu( tr( "MEN_VOLUME_CTRL" ), ctrlId, -1, 10 ),
      addId    = createMenu( tr( "MEN_ADD" ),    modifyId, 402 ),
      removeId = createMenu( tr( "MEN_REMOVE" ), modifyId, 403 ),
      renumId  = createMenu( tr( "MEN_RENUM" ),  modifyId, 404 ),
      transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 );

  createMenu( 111, importId, -1 );
  createMenu( 112, importId, -1 );
  createMenu( 113, importId, -1 );
  createMenu( 140, importId, -1 );

  createMenu( 121, exportId, -1 );
  createMenu( 122, exportId, -1 );
  createMenu( 123, exportId, -1 );
  createMenu( 141, exportId, -1 ); // export to stl STL

  createMenu( separator(), fileId, 10 );

  createMenu( 33, editId, -1 );

  createMenu( 5105, toolsId, -1 );

  createMenu( 702, meshId, -1 ); // "Mesh" menu
  createMenu( 703, meshId, -1 );
  createMenu( 704, meshId, -1 );
  createMenu( 710, meshId, -1 );
  createMenu( 705, meshId, -1 );
  createMenu( separator(), meshId, -1 );
  createMenu( 701, meshId, -1 );
  createMenu( 711, meshId, -1 );
  createMenu( 712, meshId, -1 );
  createMenu( 713, meshId, -1 );
  createMenu( separator(), meshId, -1 );
  createMenu( 801, meshId, -1 );
  createMenu( 806, meshId, -1 );
  createMenu( 802, meshId, -1 );
  createMenu( 803, meshId, -1 );
  createMenu( 815, meshId, -1 );
  createMenu( separator(), meshId, -1 );
  createMenu( 810, meshId, -1 );
  createMenu( 811, meshId, -1 );
  createMenu( 812, meshId, -1 );
  createMenu( separator(), meshId, -1 );
  createMenu( 814, meshId, -1 );
  createMenu( separator(), meshId, -1 );
  createMenu( 900, meshId, -1 );
  //createMenu( 902, meshId, -1 );
  //createMenu( 903, meshId, -1 ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
  createMenu( 904, meshId, -1 );
  createMenu( separator(), meshId, -1 );

  createMenu( 6005, nodeId, -1 );
  createMenu( 6002, edgeId, -1 );
  createMenu( 6003, edgeId, -1 );
  createMenu( 6001, edgeId, -1 );
  createMenu( 6004, edgeId, -1 );
  createMenu( 6021, faceId, -1 );
  createMenu( 6025, faceId, -1 );
  createMenu( 6027, faceId, -1 );
  createMenu( 6018, faceId, -1 );
  createMenu( 6019, faceId, -1 );
  createMenu( 6011, faceId, -1 );
  createMenu( 6012, faceId, -1 );
  createMenu( 6013, faceId, -1 );
  createMenu( 6014, faceId, -1 );
  createMenu( 6015, faceId, -1 );
  createMenu( 6016, faceId, -1 );
  createMenu( 6022, faceId, -1 );
  createMenu( 6017, volumeId, -1 );
  createMenu( 6009, volumeId, -1 );
  createMenu( 6023, volumeId, -1 );
  createMenu( 6024, volumeId, -1 );
  createMenu( 6026, volumeId, -1 );

  createMenu( 4000, addId, -1 );
  createMenu( 4009, addId, -1 );
  createMenu( 4010, addId, -1 );
  createMenu( 4021, addId, -1 );
  createMenu( 4022, addId, -1 );
  createMenu( 4023, addId, -1 );
  createMenu( 4031, addId, -1 );
  createMenu( 4032, addId, -1 );
  createMenu( 4033, addId, -1 );
  createMenu( separator(), addId, -1 );
  createMenu( 4034, addId, -1 );
  createMenu( 4035, addId, -1 );
  createMenu( 4036, addId, -1 );
  createMenu( 4037, addId, -1 );
  createMenu( 4038, addId, -1 );
  createMenu( 4039, addId, -1 );
  createMenu( 4040, addId, -1 );

  createMenu( 4041, removeId, -1 );
  createMenu( 4042, removeId, -1 );
  createMenu( 4044, removeId, -1 );
  createMenu( separator(), removeId, -1 );
  createMenu( 813, removeId, -1 );
  createMenu( separator(), removeId, -1 );
  createMenu( 4043, removeId, -1 );

  createMenu( 4051, renumId, -1 );
  createMenu( 4052, renumId, -1 );

  createMenu( 4061, transfId, -1 );
  createMenu( 4062, transfId, -1 );
  createMenu( 4063, transfId, -1 );
  createMenu( 4068, transfId, -1 );
  createMenu( 4064, transfId, -1 );
  createMenu( 4065, transfId, -1 );
  createMenu( 4066, transfId, -1 );
  createMenu( 4069, transfId, -1 );

  createMenu( 4067,modifyId, -1 );
  createMenu( 407, modifyId, -1 );
  createMenu( 408, modifyId, -1 );
  createMenu( 409, modifyId, -1 );
  createMenu( 410, modifyId, -1 );
  createMenu( 411, modifyId, -1 );
  createMenu( 419, modifyId, -1 );
  createMenu( 412, modifyId, -1 );
  createMenu( 413, modifyId, -1 );
  createMenu( 416, modifyId, -1 );
  createMenu( 414, modifyId, -1 );
  createMenu( 415, modifyId, -1 );
  createMenu( 417, modifyId, -1 );
  createMenu( 418, modifyId, -1 );

  createMenu( 501, measureId, -1 );
  createMenu( 502, measureId, -1 );
  createMenu( 214, viewId, -1 );

  // ----- create toolbars --------------
  int meshTb     = createTool( tr( "TB_MESH" ) ),
      ctrlTb     = createTool( tr( "TB_CTRL" ) ),
      addRemTb   = createTool( tr( "TB_ADD_REMOVE" ) ),
      modifyTb   = createTool( tr( "TB_MODIFY" ) ),
      dispModeTb = createTool( tr( "TB_DISP_MODE" ) );

  createTool( 702, meshTb );
  createTool( 703, meshTb );
  createTool( 704, meshTb );
  createTool( 710, meshTb );
  createTool( 705, meshTb );
  createTool( separator(), meshTb );
  createTool( 701, meshTb );
  createTool( 711, meshTb );
  createTool( 712, meshTb );
  createTool( 713, meshTb );
  createTool( separator(), meshTb );
  createTool( 801, meshTb );
  createTool( 806, meshTb );
  createTool( 802, meshTb );
  createTool( 803, meshTb );
  //createTool( 815, meshTb );
  createTool( separator(), meshTb );
  createTool( 900, meshTb );
  //createTool( 902, meshTb );
  //createTool( 903, meshTb ); // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
  createTool( 904, meshTb );
  createTool( separator(), meshTb );

  createTool( 6005, ctrlTb );
  createTool( separator(), ctrlTb );
  createTool( 6002, ctrlTb );
  createTool( 6003, ctrlTb );
  createTool( 6001, ctrlTb );
  createTool( 6004, ctrlTb );
  createTool( separator(), ctrlTb );
  createTool( 6021, ctrlTb );
  createTool( 6025, ctrlTb );
  createTool( 6027, ctrlTb );
  createTool( 6018, ctrlTb );
  createTool( 6019, ctrlTb );
  createTool( 6011, ctrlTb );
  createTool( 6012, ctrlTb );
  createTool( 6013, ctrlTb );
  createTool( 6014, ctrlTb );
  createTool( 6015, ctrlTb );
  createTool( 6016, ctrlTb );
  createTool( 6022, ctrlTb );
  createTool( separator(), ctrlTb );
  createTool( 6017, ctrlTb );
  createTool( 6009, ctrlTb );
  createTool( 6023, ctrlTb );
  createTool( 6024, ctrlTb );
  createTool( 6026, ctrlTb );
  createTool( separator(), ctrlTb );

  createTool( 4000, addRemTb );
  createTool( 4009, addRemTb );
  createTool( 4010, addRemTb );
  createTool( 4021, addRemTb );
  createTool( 4022, addRemTb );
  createTool( 4023, addRemTb );
  createTool( 4031, addRemTb );
  createTool( 4032, addRemTb );
  createTool( 4033, addRemTb );
  createTool( separator(), addRemTb );
  createTool( 4034, addRemTb );
  createTool( 4035, addRemTb );
  createTool( 4036, addRemTb );
  createTool( 4037, addRemTb );
  createTool( 4038, addRemTb );
  createTool( 4039, addRemTb );
  createTool( 4040, addRemTb );
  createTool( separator(), addRemTb );
  createTool( 4041, addRemTb );
  createTool( 4042, addRemTb );
  createTool( 4044, addRemTb );
  createTool( 4043, addRemTb );
  createTool( separator(), addRemTb );
  createTool( 4051, addRemTb );
  createTool( 4052, addRemTb );
  createTool( separator(), addRemTb );
  createTool( 4061, addRemTb );
  createTool( 4062, addRemTb );
  createTool( 4063, addRemTb );
  createTool( 4068, addRemTb );
  createTool( 4064, addRemTb );
  createTool( 4065, addRemTb );
  createTool( 4066, addRemTb );
  createTool( 4069, addRemTb );
  createTool( separator(), addRemTb );

  createTool( 4067,modifyTb );
  createTool( 407, modifyTb );
  createTool( 408, modifyTb );
  createTool( 409, modifyTb );
  createTool( 410, modifyTb );
  createTool( 411, modifyTb );
  createTool( 419, modifyTb );
  createTool( 412, modifyTb );
  createTool( 413, modifyTb );
  createTool( 416, modifyTb );
  createTool( 414, modifyTb );
  createTool( 415, modifyTb );
  createTool( 417, modifyTb );
  createTool( 418, modifyTb );

  createTool( 214, dispModeTb );

  QString lc = "$";        // VSR : instead of QtxPopupSelection::defEquality();
  QString dc = "selcount"; // VSR : instead of QtxPopupSelection::defSelCountParam()

  myRules.clear();
  QString OB = "'ObjectBrowser'",
          View = "'" + SVTK_Viewer::Type() + "'",
          pat = "'%1'",
          mesh    = pat.arg( SMESHGUI_Selection::typeName( MESH ) ),
          group   = pat.arg( SMESHGUI_Selection::typeName( GROUP ) ),
          hypo    = pat.arg( SMESHGUI_Selection::typeName( HYPOTHESIS ) ),
          algo    = pat.arg( SMESHGUI_Selection::typeName( ALGORITHM ) ),
          elems   = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
                       arg( SMESHGUI_Selection::typeName( SUBMESH_VERTEX ) ).
                       arg( SMESHGUI_Selection::typeName( SUBMESH_EDGE ) ).
                       arg( SMESHGUI_Selection::typeName( SUBMESH_FACE ) ).
                       arg( SMESHGUI_Selection::typeName( SUBMESH_SOLID ) ).
                       arg( SMESHGUI_Selection::typeName( SUBMESH_COMPOUND ) ).
                       arg( SMESHGUI_Selection::typeName( SUBMESH ) ),
          subMesh = elems,
          mesh_group = mesh + " " + subMesh + " " + group,
          hyp_alg = hypo + " " + algo;

  // popup for object browser
  QString
    isInvisible("not( isVisible )"),
    isEmpty("numberOfNodes = 0"),
    isNotEmpty("numberOfNodes <> 0"),

    // has nodes, edges, etc in VISIBLE! actor
    hasNodes("(numberOfNodes > 0 )"),//&& isVisible)"),
    hasElems("(count( elemTypes ) > 0)"),
    hasDifferentElems("(count( elemTypes ) > 1)"),
    hasElems0d("({'Elem0d'} in elemTypes)"),
    hasEdges("({'Edge'} in elemTypes)"),
    hasFaces("({'Face'} in elemTypes)"),
    hasVolumes("({'Volume'} in elemTypes)");

  createPopupItem( 150, OB, mesh, "&& selcount=1 && isImported" );      // FILE INFORMATION
  createPopupItem( 703, OB, mesh, "&& isComputable");      // CREATE_SUBMESH
  //createPopupItem( 703, OB, subMesh, "&& isComputable" );  // CREATE_SUBMESH
  createPopupItem( 704, OB, mesh, "&& isComputable");      // EDIT_MESHSUBMESH
  createPopupItem( 704, OB, subMesh, "&& isComputable" );  // EDIT_MESHSUBMESH
  createPopupItem( 803, OB, group );                       // EDIT_GROUP
  createPopupItem( 815, OB, group, "&& groupType = 'GroupOnGeom'" ); // EDIT_GROUP

  popupMgr()->insert( separator(), -1, 0 );
  createPopupItem( 701, OB, mesh, "&& isComputable" );     // COMPUTE
  createPopupItem( 711, OB, mesh, "&& isComputable && isPreComputable" ); // PRECOMPUTE
  createPopupItem( 712, OB, mesh, "&& isComputable" );     // EVALUATE
  createPopupItem( 713, OB, mesh, "&& isComputable" );     // MESH ORDER
  createPopupItem( 214, OB, mesh_group );                  // UPDATE
  createPopupItem( 900, OB, mesh_group );                  // ADV_INFO
  //createPopupItem( 902, OB, mesh );                        // STD_INFO
  //createPopupItem( 903, OB, mesh_group );                  // WHAT_IS  // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
  createPopupItem( 904, OB, mesh );                        // FIND_ELEM
  popupMgr()->insert( separator(), -1, 0 );
  createPopupItem( 801, OB, mesh );                        // CREATE_GROUP
  createPopupItem( 806, OB, mesh );                        // CREATE_GEO_GROUP
  createPopupItem( 802, OB, subMesh );                     // CONSTRUCT_GROUP
  popupMgr()->insert( separator(), -1, 0 );
  createPopupItem( 1100, OB, hypo);                        // EDIT HYPOTHESIS
  createPopupItem( 1102, OB, hyp_alg ); // REMOVE HYPOTHESIS / ALGORITHMS
  popupMgr()->insert( separator(), -1, 0 );
  createPopupItem( 4043, OB, mesh );                       // CLEAR_MESH
  popupMgr()->insert( separator(), -1, 0 );
  createPopupItem( 417, OB, mesh + " " + subMesh );        // convert to quadratic
  createPopupItem( 418, OB, mesh + " " + group,            // create 2D mesh from 3D
                   "&& dim>=2"); 
  popupMgr()->insert( separator(), -1, 0 );

  QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
  QString multiple_non_empty = QString( " && %1>0 && numberOfNodes>0" ).arg( dc );

  createPopupItem( 125, OB, mesh, multiple_non_empty );   // EXPORT_MED
  createPopupItem( 126, OB, mesh, only_one_non_empty );   // EXPORT_UNV
  createPopupItem( 141, OB, mesh, only_one_non_empty );   // EXPORT_STL
  //createPopupItem( 33, OB, subMesh + " " + group );       // DELETE
  createPopupItem(  33, OB, mesh_group + " " + hyp_alg ); // DELETE
  popupMgr()->insert( separator(), -1, 0 );

  // popup for viewer
  createPopupItem( 803, View, group ); // EDIT_GROUP
  createPopupItem( 804, View, elems ); // ADD
  createPopupItem( 805, View, elems ); // REMOVE

  popupMgr()->insert( separator(), -1, 0 );
  createPopupItem( 214, View, mesh_group ); // UPDATE
  createPopupItem( 900, View, mesh_group ); // ADV_INFO
  //createPopupItem( 902, View, mesh );       // STD_INFO
  //createPopupItem( 903, View, mesh_group ); // WHAT_IS // VSR: issue #0021242 (eliminate "Mesh Element Information" command)
  createPopupItem( 904, View, mesh );       // FIND_ELEM
  popupMgr()->insert( separator(), -1, 0 );

  createPopupItem( 1136, OB + " " + View, mesh, "&& (not isAutoColor)" ); // AUTO_COLOR
  createPopupItem( 1137, OB + " " + View, mesh, "&& isAutoColor" );       // DISABLE_AUTO_COLOR
  popupMgr()->insert( separator(), -1, 0 );

  int anId;
  QString aClient = QString( "%1client in {%2}" ).arg( lc ).arg( "'VTKViewer'" );
  QString aType = QString( "%1type in {%2}" ).arg( lc );
  aType = aType.arg( mesh_group );
  QString aMeshInVTK = aClient + "&&" + aType;

  aClient = "($client in {'VTKViewer' 'ObjectBrowser'})";
  QString anActiveVTK = QString("activeView = '%1'").arg(SVTK_Viewer::Type());
  QString aSelCount = QString( "%1 > 0" ).arg( dc );

  //-------------------------------------------------
  // Numbering
  //-------------------------------------------------
  anId = popupMgr()->insert( tr( "MEN_NUM" ), -1, -1 );

  popupMgr()->insert( action( 9010 ), anId, -1 );
  popupMgr()->setRule( action( 9010 ), aMeshInVTK + "&& isVisible &&" + hasNodes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 9010 ), "{'Point'} in labeledTypes", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 9011 ), anId, -1 );
  popupMgr()->setRule( action( 9011 ), aMeshInVTK + "&& isVisible &&" + hasElems, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 9011 ), "{'Cell'} in labeledTypes", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( separator(), -1, -1 );

  //-------------------------------------------------
  // Display Mode
  //-------------------------------------------------
  anId = popupMgr()->insert( tr( "MEN_DISPMODE" ), -1, -1 );

  popupMgr()->insert( action( 211 ), anId, -1 ); // WIRE
  popupMgr()->setRule( action( 211 ), aMeshInVTK + "&&" + hasElems, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 211 ), "displayMode = 'eEdge'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 212 ), anId, -1 ); // SHADE
  popupMgr()->setRule( action( 212 ),aMeshInVTK+ "&& (" + hasFaces + "||" + hasVolumes + ")", QtxPopupMgr::VisibleRule);
  popupMgr()->setRule( action( 212 ), "displayMode = 'eSurface'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 215 ), anId, -1 ); // POINTS
  popupMgr()->setRule( action( 215 ), aMeshInVTK + "&&" + hasNodes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 215 ), "displayMode = 'ePoint'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( separator(), anId, -1 );

  popupMgr()->insert( action( 213 ), anId, -1 ); // SHRINK
  popupMgr()->setRule( action( 213 ), aMeshInVTK + "&& shrinkMode <> 'IsNotShrinkable' && displayMode <> 'ePoint'", QtxPopupMgr::VisibleRule);
  popupMgr()->setRule( action( 213 ), "shrinkMode = 'IsShrunk'", QtxPopupMgr::ToggleRule );

  //-------------------------------------------------
  // Display Entity
  //-------------------------------------------------
  QString aDiffElemsInVTK = aMeshInVTK + "&&" + hasDifferentElems;

  anId = popupMgr()->insert( tr( "MEN_DISP_ENT" ), -1, -1 );

  popupMgr()->insert( action(216), anId, -1 ); // ELEMS 0D
  popupMgr()->setRule(action(216), aDiffElemsInVTK + "&& isVisible &&" + hasElems0d, QtxPopupMgr::VisibleRule);
  popupMgr()->setRule(action(216), "{'Elem0d'} in entityMode", QtxPopupMgr::ToggleRule);

  popupMgr()->insert( action( 217 ), anId, -1 ); // EDGES
  popupMgr()->setRule( action( 217 ), aDiffElemsInVTK + "&& isVisible &&" + hasEdges, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 217 ), "{'Edge'} in entityMode", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 218 ), anId, -1 ); // FACES
  popupMgr()->setRule( action( 218 ), aDiffElemsInVTK + "&& isVisible &&" + hasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 218 ), "{'Face'} in entityMode", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 219 ), anId, -1 ); // VOLUMES
  popupMgr()->setRule( action( 219 ), aDiffElemsInVTK + "&& isVisible &&" + hasVolumes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 219 ), "{'Volume'} in entityMode", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( separator(), anId, -1 );

  popupMgr()->insert( action( 220 ), anId, -1 ); // ALL
  popupMgr()->setRule( action( 220 ), aDiffElemsInVTK + "&& isVisible && not( elemTypes in entityMode )", QtxPopupMgr::VisibleRule );


  //-------------------------------------------------
  // Representation of the 2D Quadratic elements
  //-------------------------------------------------
  anId = popupMgr()->insert( tr( "MEN_QUADRATIC_REPRESENT" ), -1, -1 );
  popupMgr()->insert( action( 231 ), anId, -1 ); // LINE REPRESENTATION
  popupMgr()->setRule( action( 231 ), aMeshInVTK + "and isVisible",QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 231 ), "quadratic2DMode = 'eLines'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 232 ), anId, -1 ); // ARC REPRESENTATION
  popupMgr()->setRule( action( 232 ), aMeshInVTK + "and isVisible", QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 232 ), "quadratic2DMode = 'eArcs'", QtxPopupMgr::ToggleRule );

  //-------------------------------------------------
  // Orientation of faces
  //-------------------------------------------------
  popupMgr()->insert( action( 221 ), -1, -1 );
  popupMgr()->setRule( action( 221 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule);
  popupMgr()->setRule( action( 221 ), "facesOrientationMode = 'IsOriented'", QtxPopupMgr::ToggleRule );

  //-------------------------------------------------
  // Color / Size
  //-------------------------------------------------
  popupMgr()->insert( action( 1132 ), -1, -1 );
  popupMgr()->setRule( action( 1132 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );

  //-------------------------------------------------
  // Transparency
  //-------------------------------------------------
  popupMgr()->insert( action( 1133 ), -1, -1 );
  popupMgr()->setRule( action( 1133 ), aMeshInVTK + "&& isVisible", QtxPopupMgr::VisibleRule );

  //-------------------------------------------------
  // Controls
  //-------------------------------------------------
  QString
    aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
    aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
    aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
    aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;

  anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );

  popupMgr()->insert( action( 200 ), anId, -1 ); // RESET
  popupMgr()->setRule( action( 200 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );

  popupMgr()->insert( separator(), anId, -1 );

  int aSubId = popupMgr()->insert( tr( "MEN_NODE_CTRL" ), anId, -1 ); // NODE CONTROLS

  popupMgr()->insert( action( 6005 ), aSubId, -1 ); // FREE_NODE
  popupMgr()->setRule( action( 6005 ), aMeshInVtkHasNodes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6005 ), "controlMode = 'eFreeNodes'", QtxPopupMgr::ToggleRule );

  aSubId = popupMgr()->insert( tr( "MEN_EDGE_CTRL" ), anId, -1 ); // EDGE CONTROLS

  popupMgr()->insert( action( 6002 ), aSubId, -1 ); // FREE_EDGE
  popupMgr()->setRule( action( 6002 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6002 ), "controlMode = 'eFreeEdges'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 6003 ), aSubId, -1 ); // FREE_BORDER
  popupMgr()->setRule( action( 6003 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6003 ), "controlMode = 'eFreeBorders'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 6001 ), aSubId, -1 ); // LENGTH
  popupMgr()->setRule( action( 6001 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6001 ), "controlMode = 'eLength'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( action( 6004 ), aSubId, -1 ); // CONNECTION
  popupMgr()->setRule( action( 6004 ), aMeshInVtkHasEdges, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6004 ), "controlMode = 'eMultiConnection'", QtxPopupMgr::ToggleRule );

  aSubId = popupMgr()->insert( tr( "MEN_FACE_CTRL" ), anId, -1 ); // FACE CONTROLS

  popupMgr()->insert ( action( 6021 ), aSubId, -1 ); // FREE_FACE
  popupMgr()->setRule( action( 6021 ), aMeshInVtkHasFaces /*aMeshInVtkHasVolumes*/,
                                       QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6021 ), "controlMode = 'eFreeFaces'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6018 ), aSubId, -1 ); // LENGTH_2D
  popupMgr()->setRule( action( 6018 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6018 ), "controlMode = 'eLength2D'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6019 ), aSubId, -1 ); // CONNECTION_2D
  popupMgr()->setRule( action( 6019 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6019 ), "controlMode = 'eMultiConnection2D'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6011 ), aSubId, -1 ); // AREA
  popupMgr()->setRule( action( 6011 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6011 ), "controlMode = 'eArea'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6012 ), aSubId, -1 ); // TAPER
  popupMgr()->setRule( action( 6012 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6012 ), "controlMode = 'eTaper'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6013 ), aSubId, -1 ); // ASPECT
  popupMgr()->setRule( action( 6013 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6013 ), "controlMode = 'eAspectRatio'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6014 ), aSubId, -1 ); // MIN_ANG
  popupMgr()->setRule( action( 6014 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6014 ), "controlMode = 'eMinimumAngle'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6015 ), aSubId, -1 ); // WARP
  popupMgr()->setRule( action( 6015 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6015 ), "controlMode = 'eWarping'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6016 ), aSubId, -1 ); // SKEW
  popupMgr()->setRule( action( 6016 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6016 ), "controlMode = 'eSkew'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6022 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_2D
  popupMgr()->setRule( action( 6022 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6022 ), "controlMode = 'eMaxElementLength2D'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6025 ), aSubId, -1 ); // BARE_BORDER_FACE
  popupMgr()->setRule( action( 6025 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6025 ), "controlMode = 'eBareBorderFace'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6027 ), aSubId, -1 ); // OVER_CONSTRAINED_FACE
  popupMgr()->setRule( action( 6027 ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6027 ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );

  aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS

  popupMgr()->insert ( action( 6017 ), aSubId, -1 ); // ASPECT_3D
  popupMgr()->setRule( action( 6017 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6017 ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6009 ), aSubId, -1 ); // VOLUME_3D
  popupMgr()->setRule( action( 6009 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6009 ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6023 ), aSubId, -1 ); // MAX_ELEMENT_LENGTH_3D
  popupMgr()->setRule( action( 6023 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6023 ), "controlMode = 'eMaxElementLength3D'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6024 ), aSubId, -1 ); // BARE_BORDER_VOLUME
  popupMgr()->setRule( action( 6024 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6024 ), "controlMode = 'eBareBorderVolume'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert ( action( 6026 ), aSubId, -1 ); // OVER_CONSTRAINED_VOLUME
  popupMgr()->setRule( action( 6026 ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 6026 ), "controlMode = 'eOverConstrainedVolume'", QtxPopupMgr::ToggleRule );

  popupMgr()->insert( separator(), anId, -1 );

  popupMgr()->insert( action( 201 ), anId, -1 ); // SCALAR_BAR_PROP
  popupMgr()->setRule( action( 201 ), aMeshInVTK + "&& controlMode <> 'eNone'", QtxPopupMgr::VisibleRule );

  popupMgr()->insert( separator(), anId, -1 );

  aSubId = popupMgr()->insert( tr( "MEN_DISTRIBUTION_CTRL" ), anId, -1 ); // NODE CONTROLS

  popupMgr()->insert( action( 2021 ), aSubId, -1 ); // SAVE_DISTRIBUTION
  popupMgr()->setRule( action( 2021 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );

  popupMgr()->insert( action( 2022 ), aSubId, -1 ); // SHOW_DISTRIBUTION
  popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
  popupMgr()->setRule( action( 2022 ), aMeshInVTK + "&& isNumFunctor && isDistributionVisible", QtxPopupMgr::ToggleRule);

#ifndef DISABLE_PLOT2DVIEWER
  popupMgr()->insert( action( 2023 ), aSubId, -1 ); // PLOT_DISTRIBUTION
  popupMgr()->setRule( action( 2023 ), aMeshInVTK + "&& isNumFunctor", QtxPopupMgr::VisibleRule );
#endif

  //-------------------------------------------------
  // Display / Erase
  //-------------------------------------------------
  popupMgr()->insert( separator(), -1, -1 );
  QString aRule = "$component={'SMESH'} and ( type='Component' or (" + aClient + " and " +
    aType + " and " + aSelCount + " and " + anActiveVTK + " and " + isNotEmpty + " %1 ) )";
  popupMgr()->insert( action( 301 ), -1, -1 ); // DISPLAY
  popupMgr()->setRule( action( 301 ), aRule.arg( "and (not isVisible)" ), QtxPopupMgr::VisibleRule );

  popupMgr()->insert( action( 300 ), -1, -1 ); // ERASE
  popupMgr()->setRule( action( 300 ), aRule.arg( "and isVisible" ), QtxPopupMgr::VisibleRule );

  popupMgr()->insert( action( 302 ), -1, -1 ); // DISPLAY_ONLY
  popupMgr()->setRule( action( 302 ), aRule.arg( "" ), QtxPopupMgr::VisibleRule );

  popupMgr()->insert( separator(), -1, -1 );

  //-------------------------------------------------
  // Clipping
  //-------------------------------------------------
  popupMgr()->insert( action( 1134 ), -1, -1 );
  popupMgr()->setRule( action( 1134 ), "client='VTKViewer'", QtxPopupMgr::VisibleRule );

  popupMgr()->insert( separator(), -1, -1 );

  connect( application(), SIGNAL( viewManagerActivated( SUIT_ViewManager* ) ),
           this, SLOT( onViewManagerActivated( SUIT_ViewManager* ) ) );

  connect( application(), SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
           this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
}

bool SMESHGUI::isActiveStudyLocked

(

)

Definition at line 1843 of file SMESHGUI.cxx.

References _PTR(), activeStudy(), and checkLock().

Referenced by SMESHGUI_TranslationDlg.ClickOnApply(), SMESHGUI_SymmetryDlg.ClickOnApply(), SMESHGUI_SmoothingDlg.ClickOnApply(), SMESHGUI_SewingDlg.ClickOnApply(), SMESHGUI_ScaleDlg.ClickOnApply(), SMESHGUI_RotationDlg.ClickOnApply(), SMESHGUI_RevolutionDlg.ClickOnApply(), SMESHGUI_RenumberingDlg.ClickOnApply(), SMESHGUI_RemoveNodesDlg.ClickOnApply(), SMESHGUI_RemoveElementsDlg.ClickOnApply(), SMESHGUI_NodesDlg.ClickOnApply(), SMESHGUI_MergeDlg.ClickOnApply(), SMESHGUI_ExtrusionDlg.ClickOnApply(), SMESHGUI_ExtrusionAlongPathDlg.ClickOnApply(), SMESHGUI_CreatePolyhedralVolumeDlg.ClickOnApply(), SMESHGUI_CopyMeshDlg.ClickOnApply(), SMESHGUI_BuildCompoundDlg.ClickOnApply(), SMESHGUI_AddQuadraticElementDlg.ClickOnApply(), SMESHGUI_AddMeshElementDlg.ClickOnApply(), SMESHGUI_WhatIsDlg.ClickOnOk(), SMESHGUI_DeleteGroupDlg.isValid(), SMESHGUI_SingleEditDlg.onApply(), SMESHGUI_MultiEditDlg.onApply(), SMESHGUI_MoveNodesDlg.onApply(), SMESHGUI_GroupDlg.onApply(), and SMESHGUI_DuplicateNodesDlg.onApply().

{
  _PTR(Study) aStudy = activeStudy()->studyDS();
  return checkLock( aStudy );
}

bool SMESHGUI::isSelectionCompatible

(

)

[protected, virtual]

Return true if SMESH or GEOM objects are selected.

Is called form LightApp_Module.activateModule() which clear selection if not isSelectionCompatible()

Definition at line 4044 of file SMESHGUI.cxx.

References isCompatible(), and selectionMgr().

{
  bool isCompatible = true;
  SALOME_ListIO selected;
  if ( LightApp_SelectionMgr *Sel = selectionMgr() )
    Sel->selectedObjects( selected );

  SALOME_ListIteratorOfListIO It( selected );
  for ( ; isCompatible && It.More(); It.Next())
    isCompatible =
      ( strcmp("GEOM", It.Value()->getComponentDataType()) == 0 ) ||
      ( strcmp("SMESH", It.Value()->getComponentDataType()) == 0 );

  return isCompatible;
}

void SMESHGUI::Modified

(

bool

theIsUpdateActions = true

)

[static]

Definition at line 1792 of file SMESHGUI.cxx.

Referenced by SMESHGUI_TranslationDlg.ClickOnApply(), SMESHGUI_SymmetryDlg.ClickOnApply(), SMESHGUI_SmoothingDlg.ClickOnApply(), SMESHGUI_SewingDlg.ClickOnApply(), SMESHGUI_ScaleDlg.ClickOnApply(), SMESHGUI_RotationDlg.ClickOnApply(), SMESHGUI_RevolutionDlg.ClickOnApply(), SMESHGUI_RenumberingDlg.ClickOnApply(), SMESHGUI_RemoveNodesDlg.ClickOnApply(), SMESHGUI_RemoveElementsDlg.ClickOnApply(), SMESHGUI_NodesDlg.ClickOnApply(), SMESHGUI_MergeDlg.ClickOnApply(), SMESHGUI_ExtrusionDlg.ClickOnApply(), SMESHGUI_ExtrusionAlongPathDlg.ClickOnApply(), SMESHGUI_CreatePolyhedralVolumeDlg.ClickOnApply(), SMESHGUI_CopyMeshDlg.ClickOnApply(), SMESHGUI_BuildCompoundDlg.ClickOnApply(), SMESHGUI_AddQuadraticElementDlg.ClickOnApply(), SMESHGUI_AddMeshElementDlg.ClickOnApply(), SMESH.CreateHypothesis(), SMESHGUI_SingleEditDlg.onApply(), SMESHGUI_MultiEditDlg.onApply(), SMESHGUI_MoveNodesDlg.onApply(), SMESHGUI_MeshPatternDlg.onApply(), SMESHGUI_MeshOrderOp.onApply(), SMESHGUI_MeshOp.onApply(), SMESHGUI_MakeNodeAtPointOp.onApply(), SMESHGUI_Make2DFrom3DOp.onApply(), SMESHGUI_DimGroupDlg.onApply(), SMESHGUI_CutGroupsDlg.onApply(), SMESHGUI_IntersectGroupsDlg.onApply(), SMESHGUI_UnionGroupsDlg.onApply(), SMESHGUI_GroupOnShapeOp.onApply(), SMESHGUI_GroupDlg.onApply(), SMESHGUI_DuplicateNodesDlg.onApply(), SMESHGUI_DeleteGroupDlg.onApply(), SMESHGUI_ConvToQuadOp.onApply(), OnGUIEvent(), and onHypothesisEdit().

{
  if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
    if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
      appStudy->Modified();
      if( theIsUpdateActions )
        app->updateActions();
    }
  }
}

void SMESHGUI::OnEditDelete

(

)

[private]

Erase graphical object

Remove an object from data structures

Definition at line 1371 of file SMESHGUI.cxx.

References _PTR(), SMESH_controls.aGroup, CheckTypeObject(), desktop(), engineIOR(), SMESH.FindActorByEntry(), GetSMESHGUI(), Handle(), SMESH.ModifiedMesh(), SMESH.RemoveActor(), SMESH.RemoveHypothesisOrAlgorithmOnMesh(), selectionMgr(), and SMESH.SObjectToObject().

Referenced by OnGUIEvent().

  {
    // VSR 17/11/04: check if all objects selected belong to SMESH component --> start
    LightApp_SelectionMgr* aSel = SMESHGUI::selectionMgr();
    SALOME_ListIO selected; aSel->selectedObjects( selected, QString::null, false );

    _PTR(Study) aStudy = SMESH::GetActiveStudyDocument();
    _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
    _PTR(GenericAttribute) anAttr;
    _PTR(AttributeIOR) anIOR;

    int objectCount = 0;
    QString aNameList;
    QString aParentComponent = QString::null;
    Handle(SALOME_InteractiveObject) anIO;
    for( SALOME_ListIteratorOfListIO anIt( selected ); anIt.More(); anIt.Next() )
    {
      anIO = anIt.Value();
      QString cur = anIO->getComponentDataType();
      _PTR(SObject) aSO = aStudy->FindObjectID(anIO->getEntry());
      if (aSO) {
        // check if object is reference
        _PTR(SObject) aRefSObj;
        aNameList.append("\n    - ");
        if ( aSO->ReferencedObject( aRefSObj ) ) {
          QString aRefName = QString::fromStdString ( aRefSObj->GetName() );
          aNameList.append( aRefName );
          cur = QString::fromStdString ( aRefSObj->GetFatherComponent()->ComponentDataType() );
        }
        else
          aNameList.append(anIO->getName());
        objectCount++;
      }

      if( aParentComponent.isNull() )
        aParentComponent = cur;
      else if( !aParentComponent.isEmpty() && aParentComponent!=cur )
        aParentComponent = "";
    }

    if ( objectCount == 0 )
      return; // No Valid Objects Selected

    if ( aParentComponent != SMESHGUI::GetSMESHGUI()->name() )  {
      SUIT_MessageBox::warning( SMESHGUI::desktop(),
                                QObject::tr("ERR_ERROR"),
                                QObject::tr("NON_SMESH_OBJECTS_SELECTED").arg( SMESHGUI::GetSMESHGUI()->moduleName() ) );
      return;
    }
    // VSR 17/11/04: check if all objects selected belong to SMESH component <-- finish
    if (SUIT_MessageBox::warning
        (SMESHGUI::desktop(),
         QObject::tr("SMESH_WRN_WARNING"),
         QObject::tr("SMESH_REALLY_DELETE").arg( objectCount ).arg( aNameList ),
         SUIT_MessageBox::Yes | SUIT_MessageBox::No,
         SUIT_MessageBox::Yes) != SUIT_MessageBox::Yes)
      return;

    SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );

      SALOME_ListIteratorOfListIO It(selected);
      
      aStudyBuilder->NewCommand();  // There is a transaction
      for( ; It.More(); It.Next()){ // loop on selected IO's
        Handle(SALOME_InteractiveObject) IObject = It.Value();
        if(IObject->hasEntry()) {
          _PTR(SObject) aSO = aStudy->FindObjectID(IObject->getEntry());
          
          // disable removal of "SMESH" component object
          if(aSO->FindAttribute(anAttr, "AttributeIOR")){
            anIOR = anAttr;
            if ( engineIOR() == anIOR->Value().c_str() )
              continue;
          }
          //Check the referenced object
          _PTR(SObject) aRefSObject;
          if ( aSO && aSO->ReferencedObject( aRefSObject ) )
            aSO = aRefSObject; // Delete main Object instead of reference
          
          // put the whole hierarchy of sub-objects of the selected SO into a list and
          // then treat them all starting from the deepest objects (at list back)
          
          std::list< _PTR(SObject) > listSO;
          listSO.push_back( aSO );
          std::list< _PTR(SObject) >::iterator itSO = listSO.begin();
          for ( ; itSO != listSO.end(); ++itSO ) {
            _PTR(ChildIterator) it = aStudy->NewChildIterator( *itSO );
            for (it->InitEx(false); it->More(); it->Next())
              listSO.push_back( it->Value() );
          }
          
          // treat SO's in the list starting from the back
          
          std::list< _PTR(SObject) >::reverse_iterator ritSO = listSO.rbegin();
          for ( ; ritSO != listSO.rend(); ++ritSO ) {
            _PTR(SObject) SO = *ritSO;
            if ( !SO ) continue;
            std::string anEntry = SO->GetID();
            
          if(SO->FindAttribute(anAttr, "AttributeIOR")){
            ViewManagerList aViewMenegers = anApp->viewManagers();
            ViewManagerList::const_iterator it = aViewMenegers.begin();
            for( ; it != aViewMenegers.end(); it++) {         
              SUIT_ViewManager* vm = *it;
              int nbSf = vm ? vm->getViewsCount() : 0;
              if(vm) {
                QVector<SUIT_ViewWindow*> aViews = vm->getViews();
                for(int i = 0; i < nbSf; i++){
                  SUIT_ViewWindow *sf = aViews[i];
                  if(SMESH_Actor* anActor = SMESH::FindActorByEntry(sf,anEntry.c_str())){
                    SMESH::RemoveActor(sf,anActor);
                  }
                }
              }
            }
          }
            SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( SMESH::SObjectToObject( SO ));
            SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( SO ));
            if ( !aGroup->_is_nil() ) {                          // DELETE GROUP
              SMESH::SMESH_Mesh_var aMesh = aGroup->GetMesh();
              aMesh->RemoveGroup( aGroup );
            }
            else if ( !aSubMesh->_is_nil() ) {                   // DELETE SUBMESH
              SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
              aMesh->RemoveSubMesh( aSubMesh );
              
              _PTR(SObject) aMeshSO = SMESH::FindSObject(aMesh);
              if (aMeshSO)
                SMESH::ModifiedMesh(aMeshSO, false, aMesh->NbNodes()==0);
            }
            else {
              IObject = new SALOME_InteractiveObject
                ( anEntry.c_str(), engineIOR().toLatin1().data(), SO->GetName().c_str() );
              QString objType = CheckTypeObject(IObject);
              if ( objType == "Hypothesis" || objType == "Algorithm" ) {// DELETE HYPOTHESIS
                SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
                aStudyBuilder->RemoveObjectWithChildren( SO );
              }
              else {// default action: remove SObject from the study
                // san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
                //SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
                //op->start();
                aStudyBuilder->RemoveObjectWithChildren( SO );
                //op->finish();
              }
            }
          } /* listSO back loop */
        } /* IObject->hasEntry() */
      } /* more/next */
    
    aStudyBuilder->CommitCommand();

    /* Clear any previous selection */
    SALOME_ListIO l1;
    aSel->setSelectedObjects( l1 );

    SMESHGUI::GetSMESHGUI()->updateObjBrowser();
  }

bool SMESHGUI::OnGUIEvent

(

int

theCommandID

)

[virtual]

Definition at line 1854 of file SMESHGUI.cxx.

References _PTR(), SMESH.AddGroup(), SMESH_controls.aGroup, AutoColor(), SMESHGUI_MeshInfoDlg.BaseInfo, SMESHGUI_MeasureDlg.BoundingBox, checkLock(), Control(), desktop(), DisableAutoColor(), SMESH.EDGE, SMESH.eDisplay, SMESH.eDisplayOnly, SMESHGUI_FilterLibraryDlg.EDIT, SMESHGUI_GenericHypothesisCreator.edit(), SMESH.eErase, SMESHGUI_MeshInfoDlg.ElemInfo, EmitSignalDeactivateDialog(), EmitSignalVisibilityChanged(), SMESH_Actor.eNone, ExportMeshToFile(), SMESH.FACE, SMESH.FindActorByEntry(), SMESH.GetDesktop(), SMESH.GetHypothesisCreator(), SMESH.GetMeshByIO(), GetSMESHGen(), GetSMESHGUI(), Handle(), ImportMeshesFromFile(), SMESHGUI_FilterLibraryDlg.Init(), MESSAGE, SMESHGUI_MeasureDlg.MinDistance, Modified(), SMESH.ModifiedMesh(), myActiveDialogBox, myFilterLibraryDlg, myMarkerMap, myState, SMESH.NODE, SMESHGUI_GroupDlg.onAdd(), OnEditDelete(), onHypothesisEdit(), SMESHGUI_GroupDlg.onRemove(), SMESH.OnVisuException(), PlotDistribution(), SMESH.ProcessIn2DViewers(), QUAD_EDGE, QUAD_HEXAHEDRON, QUAD_PENTAHEDRON, QUAD_PYRAMID, QUAD_QUADRANGLE, QUAD_TETRAHEDRON, QUAD_TRIANGLE, SMESH.RemoveFrom2dViewer, SMESH.RemoveHypothesisOrAlgorithmOnMesh(), SMESH.RemoveVisualObjectWithActors(), resourceMgr(), SaveDistribution(), SMESHGUI_Preferences_ScalarBarDlg.ScalarBarProperties(), selectionMgr(), SetDisplayEntity(), SetDisplayMode(), ShowDistribution(), SMESHGUI_MeshInfoDlg.showInfo(), SMDSAbs_0DElement, SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMESH.SObjectToObject(), SMESH.UpdateView(), and SMESH.VOLUME.

{
  SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
  if( !anApp )
    return false;

  _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
  SUIT_ResourceMgr* mgr = resourceMgr();
  if( !mgr )
    return false;

  if (CORBA::is_nil(GetSMESHGen()->GetCurrentStudy())) {
    GetSMESHGen()->SetCurrentStudy(_CAST(Study,aStudy)->GetStudy());
  }

  SUIT_ViewWindow* view = application()->desktop()->activeWindow();
  SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );

  //QAction* act = action( theCommandID );

  switch (theCommandID) {
  case 33:                                      // DELETE
    if(checkLock(aStudy)) break;
    OnEditDelete();
    break;

  case 113:                                     // IMPORT
  case 112:
  case 111:
  case 140:
    {
      if(checkLock(aStudy)) break;
      ::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
      break;
    }

  case 150:    //MED FILE INFORMATION
    {
      SALOME_ListIO selected;
      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      if( aSel )
        aSel->selectedObjects( selected );
      if( selected.Extent() )
      {
        Handle(SALOME_InteractiveObject) anIObject = selected.First();
        SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(anIObject);
        if ( !aMesh->_is_nil() )
        {
          SMESHGUI_FileInfoDlg dlg( desktop(), aMesh->GetMEDFileInfo() );
          dlg.exec();
        }
      }
      break;
    }

  case 122:                                     // EXPORT MED
  case 121:
  case 123:
  case 124:
  case 125:
  case 126:
  case 141:
    {
      ::ExportMeshToFile(theCommandID);
      break;
    }

  case 200:                                     // SCALAR BAR
    {
      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      if( selected.Extent() ) {
        Handle(SALOME_InteractiveObject) anIO = selected.First();
        if( anIO->hasEntry() ) {
          if( SMESH_Actor* anActor = SMESH::FindActorByEntry( anIO->getEntry() ) ) {
            anActor->SetControlMode( SMESH_Actor::eNone );
#ifndef DISABLE_PLOT2DVIEWER
            SMESH::ProcessIn2DViewers(anActor,SMESH::RemoveFrom2dViewer);
#endif
          }
        }
      }
      break;
    }
  case 201:
    {
      SMESHGUI_Preferences_ScalarBarDlg::ScalarBarProperties( this );
      break;
    }
  case 2021:
    {
      // dump control distribution data to the text file
      ::SaveDistribution();
      break;
    }

  case 2022:
    {
      // show/ distribution
      ::ShowDistribution();
      break;
    }

#ifndef DISABLE_PLOT2DVIEWER
  case 2023:
    {
      // plot distribution
      ::PlotDistribution();
      break;
    }
#endif

    // Auto-color
  case 1136:
    ::AutoColor();
  break;

  case 1137:
    ::DisableAutoColor();
  break;

  case 1134: // Clipping
  case 1133: // Tranparency
  case 1132: // Colors / Size

    // Display Mode
  case 215: // Nodes
  case 213: // Nodes
  case 212: // Nodes
  case 211: // Nodes
    ::SetDisplayMode(theCommandID, myMarkerMap);
  break;

  //2D quadratic representation
  case 231:
  case 232:
    ::SetDisplayMode(theCommandID, myMarkerMap);
  break;

  // Display Entity
  case 216: // 0D elements
  case 217: // Edges
  case 218: // Faces
  case 219: // Volumes
  case 220: // All Entity
    ::SetDisplayEntity(theCommandID);
  break;

  case 221: // Orientation of faces
    {
      LightApp_SelectionMgr* mgr = selectionMgr();
      SALOME_ListIO selected; mgr->selectedObjects( selected );

      SALOME_ListIteratorOfListIO it(selected);
      for( ; it.More(); it.Next()) {
        Handle(SALOME_InteractiveObject) anIObject = it.Value();
        if(anIObject->hasEntry()) {
          if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
            anActor->SetFacesOriented( !anActor->GetFacesOriented() );
          }
        }
      }
      break;
    }

  case 214:                                     // UPDATE
    {
      if(checkLock(aStudy)) break;
      try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
        OCC_CATCH_SIGNALS;
#endif
        SMESH::UpdateView();
      }
      catch (std::bad_alloc) { // PAL16774 (Crash after display of many groups)
        SMESH::OnVisuException();
      }
      catch (...) { // PAL16774 (Crash after display of many groups)
        SMESH::OnVisuException();
      }

      SALOME_ListIO l;
      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      aSel->selectedObjects( l );
      aSel->setSelectedObjects( l );
      break;
    }

  case 300:                                     // ERASE
  case 301:                                     // DISPLAY
  case 302:                                     // DISPLAY ONLY
    {
      SMESH::EDisplaing anAction;
      switch (theCommandID) {
      case 300: anAction = SMESH::eErase; break;
      case 301: anAction = SMESH::eDisplay; break;
      case 302: anAction = SMESH::eDisplayOnly; break;
      }

      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO sel_objects, to_process;
      if (aSel)
        aSel->selectedObjects( sel_objects );

      if( theCommandID==302 )
      {
        MESSAGE("anAction = SMESH::eDisplayOnly");
        startOperation( myEraseAll );
      }

      extractContainers( sel_objects, to_process );

      try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
        OCC_CATCH_SIGNALS;
#endif
        if (vtkwnd) {
          SALOME_ListIteratorOfListIO It( to_process );
          for ( ; It.More(); It.Next()) {
                MESSAGE("---");
            Handle(SALOME_InteractiveObject) IOS = It.Value();
            if (IOS->hasEntry()) {
                MESSAGE("---");
              if (!SMESH::UpdateView(anAction, IOS->getEntry())) {
                SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
                break; // PAL16774 (Crash after display of many groups)
              }
              if (anAction == SMESH::eDisplayOnly)
              {
                MESSAGE("anAction = SMESH::eDisplayOnly");
                anAction = SMESH::eDisplay;
              }
            }
          }
        }

        // PAL13338 + PAL15161 -->
        if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy)) {
                MESSAGE("anAction = SMESH::eDisplayOnly");
          SMESH::UpdateView();
          SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
        }
        // PAL13338 + PAL15161 <--
      }
      catch (...) { // PAL16774 (Crash after display of many groups)
        SMESH::OnVisuException();
      }

      if (anAction == SMESH::eErase) {
        MESSAGE("anAction == SMESH::eErase");
        SALOME_ListIO l1;
        aSel->setSelectedObjects( l1 );
      }
      else
        aSel->setSelectedObjects( to_process );

      break;
    }

  case 4000:                                    // NODES
    {
      if(checkLock(aStudy)) break;

      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();

        ( new SMESHGUI_NodesDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"),
                                 tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }

  case 2151:  // FILTER
  {
    if ( vtkwnd )
    {
      EmitSignalDeactivateDialog();
      ( new SMESHGUI_FilterDlg( this, SMESH::EDGE ) )->show();
    }
    break;
  }

  case 701:                                     // COMPUTE MESH
  case 711:                                     // PRECOMPUTE MESH
  case 712:                                     // EVALUATE MESH
  case 713:                                     // MESH ORDER
    {
      if (checkLock(aStudy)) break;
      startOperation( theCommandID );
    }
    break;

  case 702: // Create mesh
  case 703: // Create sub-mesh
  case 704: // Edit mesh/sub-mesh
    startOperation( theCommandID );
    break;
  case 705: // copy mesh
    {
      if (checkLock(aStudy)) break;
      EmitSignalDeactivateDialog();
      ( new SMESHGUI_CopyMeshDlg( this ) )->show();
    }
    break;
  case 710: // Build compound mesh
    {
      if (checkLock(aStudy)) break;
      EmitSignalDeactivateDialog();
      ( new SMESHGUI_BuildCompoundDlg( this ) )->show();
    }
    break;

  case 407: // DIAGONAL INVERSION
  case 408: // Delete diagonal
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if ( checkLock( aStudy ) )
        break;

      /*Standard_Boolean aRes;
      SMESH::SMESH_Mesh_var aMesh = SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IObject);
      if ( aMesh->_is_nil() )
      {
        SUIT_MessageBox::warning(GetDesktop(), tr( "SMESH_WRN_WARNING" ),
          tr( "SMESH_BAD_SELECTION" ) );
        break;
      }
      */
      EmitSignalDeactivateDialog();
      if ( theCommandID == 407 )
        ( new SMESHGUI_TrianglesInversionDlg( this ) )->show();
      else
        ( new SMESHGUI_UnionOfTwoTrianglesDlg( this ) )->show();
      break;
    }
  case 409: // Change orientation
  case 410: // Union of triangles
  case 411: // Cutting of quadrangles
  case 419: // Splitting volumes into tetrahedra
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if ( checkLock( aStudy ) )
        break;

      EmitSignalDeactivateDialog();
      SMESHGUI_MultiEditDlg* aDlg = NULL;
      if ( theCommandID == 409 )
        aDlg = new SMESHGUI_ChangeOrientationDlg(this);
      else if ( theCommandID == 410 )
        aDlg = new SMESHGUI_UnionOfTrianglesDlg(this);
      else if ( theCommandID == 419 )
        aDlg = new SMESHGUI_CuttingIntoTetraDlg(this);
      else
        aDlg = new SMESHGUI_CuttingOfQuadsDlg(this);

      aDlg->show();
      break;
    }
  case 412: // Smoothing
    {
      if(checkLock(aStudy)) break;
      if( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_SmoothingDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 413: // Extrusion
    {
      if (checkLock(aStudy)) break;
      if (vtkwnd) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_ExtrusionDlg ( this ) )->show();
      } else {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 414: // Revolution
    {
      if(checkLock(aStudy)) break;
      if( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_RevolutionDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 415: // Pattern mapping
    {
      if ( checkLock( aStudy ) )
        break;
      if ( vtkwnd )
      {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_MeshPatternDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 416: // Extrusion along a path
    {
      if (checkLock(aStudy)) break;
      if (vtkwnd) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
      } else {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 417: // Convert mesh to quadratic
    {
    startOperation( 417 );
      /*      if (checkLock(aStudy)) break;
      if (vtkwnd) {
        EmitSignalDeactivateDialog();
        new SMESHGUI_ConvToQuadDlg();
      } else {
        SUIT_MessageBox::warning(desktop(),
                               tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
                               }*/
      break;
    }
  case 418: // create 2D mesh from 3D
    {
      startOperation( 418 );
      break;
    }
  case 806:                                     // CREATE GEO GROUP
    {
      startOperation( 806 );
      break;
    }
  case 801:                                     // CREATE GROUP
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if(checkLock(aStudy)) break;
      EmitSignalDeactivateDialog();
      SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_nil();

      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      int nbSel = selected.Extent();
      if (nbSel == 1) {
        // check if mesh is selected
        aMesh = SMESH::GetMeshByIO( selected.First() );
      }
      SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aMesh);
      aDlg->show();
      break;
    }

  case 802:                                     // CONSTRUCT GROUP
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if(checkLock(aStudy)) break;
      EmitSignalDeactivateDialog();

      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      int nbSel = selected.Extent();
      if (nbSel == 1) {
        // check if submesh is selected
        Handle(SALOME_InteractiveObject) IObject = selected.First();
        if (IObject->hasEntry()) {
          _PTR(SObject) aSObj = aStudy->FindObjectID(IObject->getEntry());
          if( aSObj ) {
            SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( SMESH::SObjectToObject( aSObj ) );
            if (!aSubMesh->_is_nil()) {
              try {
                SMESH::SMESH_Mesh_var aMesh = aSubMesh->GetFather();
                // get submesh elements list by types
                SMESH::long_array_var aNodes = aSubMesh->GetElementsByType(SMESH::NODE);
                SMESH::long_array_var aEdges = aSubMesh->GetElementsByType(SMESH::EDGE);
                SMESH::long_array_var aFaces = aSubMesh->GetElementsByType(SMESH::FACE);
                SMESH::long_array_var aVolumes = aSubMesh->GetElementsByType(SMESH::VOLUME);
                // create group for each type o elements
                QString aName = IObject->getName();
                QStringList anEntryList;
                if (aNodes->length() > 0) {
                  SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::NODE, aName + "_Nodes");
                  aGroup->Add(aNodes.inout());
                  if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
                    anEntryList.append( aSObject->GetID().c_str() );
                }
                if (aEdges->length() > 0) {
                  SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::EDGE, aName + "_Edges");
                  aGroup->Add(aEdges.inout());
                  if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
                    anEntryList.append( aSObject->GetID().c_str() );
                }
                if (aFaces->length() > 0) {
                  SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::FACE, aName + "_Faces");
                  aGroup->Add(aFaces.inout());
                  if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
                    anEntryList.append( aSObject->GetID().c_str() );
                }
                if (aVolumes->length() > 0) {
                  SMESH::SMESH_Group_var aGroup = SMESH::AddGroup(aMesh, SMESH::VOLUME, aName + "_Volumes");
                  aGroup->Add(aVolumes.inout());
                  if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( aGroup ) )
                    anEntryList.append( aSObject->GetID().c_str() );
                }
                updateObjBrowser();
                anApp->browseObjects( anEntryList );
              }
              catch(const SALOME::SALOME_Exception & S_ex){
                SalomeApp_Tools::QtCatchCorbaException(S_ex);
              }
            }
          }
        }
      }
      else if(nbSel==0) {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"),
                                 tr("SMESH_WRN_NO_AVAILABLE_DATA"));
      }
      break;
    }

  case 803:                                     // EDIT GROUP
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if(checkLock(aStudy)) break;
      EmitSignalDeactivateDialog();

      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      SALOME_ListIteratorOfListIO It (selected);
      int nbSelectedGroups = 0;
      for ( ; It.More(); It.Next() )
      {
        SMESH::SMESH_GroupBase_var aGroup =
          SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(It.Value());
        if (!aGroup->_is_nil()) {
          nbSelectedGroups++;
          SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup);
          aDlg->show();
        }
      }
      if (nbSelectedGroups == 0)
        {
          SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, SMESH::SMESH_GroupBase::_nil());
          aDlg->show();
        }
      break;
    }

  case 804:                                     // Add elements to group
    {
      if(checkLock(aStudy)) break;
      if (myState == 800) {
        SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
        if (aDlg) aDlg->onAdd();
      }
      break;
    }

  case 805:                                     // Remove elements from group
    {
      if(checkLock(aStudy)) break;
      if (myState == 800) {
        SMESHGUI_GroupDlg *aDlg = (SMESHGUI_GroupDlg*) myActiveDialogBox;
        if (aDlg) aDlg->onRemove();
      }
      break;
    }

  case 815:                                     // Edit GEOM GROUP as standalone
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if(checkLock(aStudy)) break;
      EmitSignalDeactivateDialog();

      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      SALOME_ListIteratorOfListIO It (selected);
      for ( ; It.More(); It.Next() )
      {
        SMESH::SMESH_GroupOnGeom_var aGroup =
          SMESH::IObjectToInterface<SMESH::SMESH_GroupOnGeom>(It.Value());
        if (!aGroup->_is_nil()) {
          SMESHGUI_GroupDlg *aDlg = new SMESHGUI_GroupDlg( this, aGroup, true );
          aDlg->show();
        }
      }
      break;
    }

    case 810: // Union Groups
    case 811: // Intersect groups
    case 812: // Cut groups
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if ( checkLock( aStudy ) )
        break;

      EmitSignalDeactivateDialog();

      SMESHGUI_GroupOpDlg* aDlg = 0;
      if ( theCommandID == 810 )
        aDlg = new SMESHGUI_UnionGroupsDlg( this );
      else if ( theCommandID == 811 )
        aDlg = new SMESHGUI_IntersectGroupsDlg( this );
      else
        aDlg = new SMESHGUI_CutGroupsDlg( this );

      aDlg->show();

      break;
    }

    case 814: // Create groups of entities from existing groups of superior dimensions
    {
      if ( checkLock( aStudy ) )
        break;

      EmitSignalDeactivateDialog();
      SMESHGUI_GroupOpDlg* aDlg = new SMESHGUI_DimGroupDlg( this );
      aDlg->show();

      break;
    }

    case 813: // Delete groups with their contents
    {
      if ( !vtkwnd )
      {
        SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
                                  tr( "NOT_A_VTK_VIEWER" ) );
        break;
      }

      if ( checkLock( aStudy ) )
        break;

      EmitSignalDeactivateDialog();

      ( new SMESHGUI_DeleteGroupDlg( this ) )->show();
      break;
    }

  case 900:                                     // MESH INFOS
  case 903:                                     // WHAT IS
    {
      int page = theCommandID == 900 ? SMESHGUI_MeshInfoDlg::BaseInfo : SMESHGUI_MeshInfoDlg::ElemInfo;
      EmitSignalDeactivateDialog();
      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      if ( selected.Extent() > 1 ) { // a dlg for each IO
        SALOME_ListIteratorOfListIO It( selected );
        for ( ; It.More(); It.Next() ) {
          SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
          dlg->showInfo( It.Value() ); 
          dlg->show();
        }
      }
      else {
        SMESHGUI_MeshInfoDlg* dlg = new SMESHGUI_MeshInfoDlg( SMESHGUI::desktop(), page );
        dlg->show();
      }
      break;
    }
    /*
  case 902:                                     // STANDARD MESH INFOS
    {
      EmitSignalDeactivateDialog();
      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      if ( selected.Extent() > 1 ) { // a dlg for each IO
        SALOME_ListIO IOs;
        SALOME_ListIteratorOfListIO It (selected);
        for ( ; It.More(); It.Next() ) {
          IOs.Clear();
          IOs.Append( It.Value() );
          aSel->setSelectedObjects( IOs );
          ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
        }
        // restore selection
        aSel->setSelectedObjects( selected );
      }
      else
        ( new SMESHGUI_StandardMeshInfosDlg( this ) )->show();
      break;
    }
  case 903:                                     // WHAT IS
    {
      EmitSignalDeactivateDialog();
      ( new SMESHGUI_WhatIsDlg( this ) )->show();
      break;
    }
    */

  case 904:                                     // FIND ELEM
    {
      startOperation( theCommandID );
      break;
    }

  case 1100:                                    // EDIT HYPOTHESIS
    {
      if(checkLock(aStudy)) break;

      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected );

      int nbSel = selected.Extent();

      if (nbSel == 1) {
        Handle(SALOME_InteractiveObject) anIObject = selected.First();
        SMESH::SMESH_Hypothesis_var aHypothesis = SMESH::IObjectToInterface<SMESH::SMESH_Hypothesis>(anIObject);

        /* Look for all mesh objects that have this hypothesis affected in order to flag as ModifiedMesh */
        /* At end below '...->updateObjBrowser(true)' will change icon of mesh objects                   */
        /* Warning : however by internal mechanism all subMeshes icons are changed !                     */
        if ( !aHypothesis->_is_nil() )
        {
          // BUG 0020378
          //SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
          SMESHGUI_GenericHypothesisCreator* aCreator = SMESH::GetHypothesisCreator(aHypothesis->GetName());
          if (aCreator) {
            aCreator->edit( aHypothesis.in(), anIObject->getName(), desktop(), this, SLOT( onHypothesisEdit( int ) ) );
          }
          else
          {
            // report error
          }
        }
      }
      break;
    }
  case 1102:                                    // REMOVE HYPOTHESIS / ALGORITHMS
    {
      if(checkLock(aStudy)) break;
      SUIT_OverrideCursor wc;

      LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr();
      SALOME_ListIO selected;
      if( aSel )
        aSel->selectedObjects( selected, QString::null, false );

      SALOME_ListIteratorOfListIO It(selected);
      for (int i = 0; It.More(); It.Next(), i++) {
        Handle(SALOME_InteractiveObject) IObject = It.Value();
        SMESH::RemoveHypothesisOrAlgorithmOnMesh(IObject);
      }
      SALOME_ListIO l1;
      aSel->setSelectedObjects( l1 );
      updateObjBrowser();
      break;
    }

  case 4009:                                    // ELEM0D
  case 4010:                                    // GEOM::EDGE
  case 4021:                                    // TRIANGLE
  case 4022:                                    // QUAD
  case 4023:                                    // POLYGON
  case 4031:                                    // TETRA
  case 4032:                                    // HEXA
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        SMDSAbs_ElementType type    = SMDSAbs_Edge;
        int                 nbNodes = 2;
        switch (theCommandID) {
        case 4009:                                      // ELEM0D
          type = SMDSAbs_0DElement; nbNodes = 1; break;
        case 4021:                                      // TRIANGLE
          type = SMDSAbs_Face; nbNodes = 3; break;
        case 4022:                                      // QUAD
          type = SMDSAbs_Face; nbNodes = 4; break;
        case 4031:                                      // TETRA
          type = SMDSAbs_Volume; nbNodes = 4; break;
        case 4023:                                      // POLYGON
          type = SMDSAbs_Face; nbNodes = 5; break;     // 5 - identificator for POLYGON
        case 4032:                                      // HEXA
          type = SMDSAbs_Volume; nbNodes = 8; break;
        case 4033:                                      // POLYHEDRE
          type = SMDSAbs_Volume; nbNodes = 9; break; // 9 - identificator for POLYHEDRE
        default:;
        }
        ( new SMESHGUI_AddMeshElementDlg( this, type, nbNodes ) )->show();
      }
      else {
        SUIT_MessageBox::warning(desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4033:                                    // POLYHEDRON
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4034:     // QUADRATIC EDGE
  case 4035:     // QUADRATIC TRIANGLE
  case 4036:     // QUADRATIC QUADRANGLE
  case 4037:     // QUADRATIC TETRAHEDRON
  case 4038:     // QUADRATIC PYRAMID
  case 4039:     // QUADRATIC PENTAHEDRON
  case 4040:     // QUADRATIC HEXAHEDRON
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        int type;

        switch (theCommandID) {
        case 4034:
          type = QUAD_EDGE; break;
        case 4035:
          type = QUAD_TRIANGLE; break;
        case 4036:
          type = QUAD_QUADRANGLE; break;
        case 4037:
          type = QUAD_TETRAHEDRON; break;
        case 4038:
          type = QUAD_PYRAMID; break;
        case 4039:
          type = QUAD_PENTAHEDRON; break;
        case 4040:
          type = QUAD_HEXAHEDRON;
          break;
        default:;
        }
         ( new SMESHGUI_AddQuadraticElementDlg( this, type ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4041:                                    // REMOVES NODES
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_RemoveNodesDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4042:                                    // REMOVES ELEMENTS
    {
      if(checkLock(aStudy)) break;
      if( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_RemoveElementsDlg( this ) )->show();
      }
      else
        {
          SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                   tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
        }
      break;
    }
  case 4043: {                                // CLEAR_MESH

    if(checkLock(aStudy)) break;

    SALOME_ListIO selected;
    if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
      aSel->selectedObjects( selected );

    SUIT_OverrideCursor wc;
    SALOME_ListIteratorOfListIO It (selected);
    for ( ; It.More(); It.Next() )
    {
      Handle(SALOME_InteractiveObject) IOS = It.Value();
      SMESH::SMESH_Mesh_var aMesh =
        SMESH::IObjectToInterface<SMESH::SMESH_Mesh>(IOS);
      if ( aMesh->_is_nil()) continue;
      try {
        SMESH::RemoveVisualObjectWithActors(IOS->getEntry(), true);
        aMesh->Clear();
        _PTR(SObject) aMeshSObj = SMESH::FindSObject(aMesh);
        SMESH::ModifiedMesh( aMeshSObj, false, true);
        // hide groups and submeshes
        _PTR(ChildIterator) anIter =
          SMESH::GetActiveStudyDocument()->NewChildIterator( aMeshSObj );
        for ( anIter->InitEx(true); anIter->More(); anIter->Next() )
        {
          _PTR(SObject) so = anIter->Value();
          SMESH::RemoveVisualObjectWithActors(so->GetID().c_str(), true);
        }
      }
      catch (const SALOME::SALOME_Exception& S_ex){
        wc.suspend();
        SalomeApp_Tools::QtCatchCorbaException(S_ex);
        wc.resume();
      }
    }
    SMESH::UpdateView();
    updateObjBrowser();
    break;
  }
  case 4044:                                     // REMOVE ORPHAN NODES
    {
      if(checkLock(aStudy)) break;
      SALOME_ListIO selected;
      if( LightApp_SelectionMgr *aSel = SMESHGUI::selectionMgr() )
        aSel->selectedObjects( selected );
      if ( selected.Extent() == 1 ) {
        Handle(SALOME_InteractiveObject) anIO = selected.First();
        SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO(anIO);
        if ( !aMesh->_is_nil() ) {
          bool confirm = SUIT_MessageBox::question( SMESHGUI::desktop(),
                                                    tr( "SMESH_WARNING" ),
                                                    tr( "REMOVE_ORPHAN_NODES_QUESTION"),
                                                    SUIT_MessageBox::Yes |
                                                    SUIT_MessageBox::No,
                                                    SUIT_MessageBox::No ) == SUIT_MessageBox::Yes;
          if( confirm ) {
            try {
              SMESH::SMESH_MeshEditor_var aMeshEditor = aMesh->GetMeshEditor();
              int removed = aMeshEditor->RemoveOrphanNodes();
              SUIT_MessageBox::information(SMESHGUI::desktop(),
                                           tr("SMESH_INFORMATION"),
                                           tr("NB_NODES_REMOVED").arg(removed));
              if ( removed > 0 ) {
                SMESH::UpdateView();
                SMESHGUI::Modified();
              }
            }
            catch (const SALOME::SALOME_Exception& S_ex) {
              SalomeApp_Tools::QtCatchCorbaException(S_ex);
            } 
            catch (...) {
            }
          }
        }
      }
      break;
    }
  case 4051:                                    // RENUMBERING NODES
    {
      if(checkLock(aStudy)) break;
      if( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_RenumberingDlg( this, 0 ) )->show();
      }
      else
        {
          SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                   tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
        }
      break;
    }
  case 4052:                                    // RENUMBERING ELEMENTS
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_RenumberingDlg( this, 1 ) )->show();
      }
      else
        {
          SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                   tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
        }
      break;
    }
  case 4061:                                   // TRANSLATION
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_TranslationDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4062:                                   // ROTATION
    {
      if(checkLock(aStudy)) break;
      if( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_RotationDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4063:                                   // SYMMETRY
    {
      if(checkLock(aStudy)) break;
      if(vtkwnd) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_SymmetryDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4064:                                   // SEWING
    {
      if(checkLock(aStudy)) break;
      if(vtkwnd) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_SewingDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4065:                                   // MERGE NODES
    {
      if(checkLock(aStudy)) break;
      if(vtkwnd) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_MergeDlg( this, 0 ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }
  case 4066:                                   // MERGE EQUAL ELEMENTS
    {
      if (checkLock(aStudy)) break;
      if (vtkwnd) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_MergeDlg( this, 1 ) )->show();
      } else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }

  case 4067: // MAKE MESH PASS THROUGH POINT
    startOperation( 4067 );
    break;

  case 4068: // SCALE
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_ScaleDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }

  case 4069: // DUPLICATE NODES
    {
      if(checkLock(aStudy)) break;
      if ( vtkwnd ) {
        EmitSignalDeactivateDialog();
        ( new SMESHGUI_DuplicateNodesDlg( this ) )->show();
      }
      else {
        SUIT_MessageBox::warning(SMESHGUI::desktop(),
                                 tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
      }
      break;
    }

  case 5105: // Library of selection filters
  {
    static QList<int> aTypes;
    if ( aTypes.isEmpty() )
    {
      aTypes.append( SMESH::NODE );
      aTypes.append( SMESH::EDGE );
      aTypes.append( SMESH::FACE );
      aTypes.append( SMESH::VOLUME );
    }
    if (!myFilterLibraryDlg)
      myFilterLibraryDlg = new SMESHGUI_FilterLibraryDlg( this, SMESH::GetDesktop( this ), aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
    else if (myFilterLibraryDlg->isHidden())
      myFilterLibraryDlg->Init( aTypes, SMESHGUI_FilterLibraryDlg::EDIT );
    myFilterLibraryDlg->raise();
  }
  break;

  case 6017:                                    // CONTROLS
  case 6016:
  case 6015:
  case 6014:
  case 6013:
  case 6012:
  case 6011:
  case 6001:
  case 6018:
  case 6019:
  case 6002:
  case 6003:
  case 6004:
  case 6005:
  case 6009:
  case 6021:
  case 6022:
  case 6023:
  case 6024:
  case 6025:
  case 6026:
  case 6027:
    if ( vtkwnd ) {

      LightApp_SelectionMgr* mgr = selectionMgr();
      SALOME_ListIO selected; mgr->selectedObjects( selected );

      if ( selected.Extent() == 1 && selected.First()->hasEntry() ) {
        _PTR(SObject) SO = aStudy->FindObjectID( selected.First()->getEntry() );
        if ( SO ) {
          CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
          SMESH::SMESH_Mesh_var      aMesh    = SMESH::SMESH_Mesh::_narrow( aObject );
          SMESH::SMESH_subMesh_var   aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
          SMESH::SMESH_GroupBase_var aGroup   = SMESH::SMESH_GroupBase::_narrow( aObject );
          if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
            ::Control( theCommandID );
            break;
          }
        }
      }
      SUIT_MessageBox::warning(desktop(),
                               tr( "SMESH_WRN_WARNING" ),
                               tr( "SMESH_BAD_SELECTION" ) );
      break;
    }
    else {
      SUIT_MessageBox::warning(desktop(),
                               tr( "SMESH_WRN_WARNING" ),
                               tr( "NOT_A_VTK_VIEWER" ) );
    }
    break;
  case 9010:
    {
      LightApp_SelectionMgr* mgr = selectionMgr();
      SALOME_ListIO selected; mgr->selectedObjects( selected );

      SALOME_ListIteratorOfListIO it(selected);
      for( ; it.More(); it.Next()) {
        Handle(SALOME_InteractiveObject) anIObject = it.Value();
        if(anIObject->hasEntry()) {
          if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
            anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
          }
        }
      }
      break;
    }
  case 9011:
    {
      LightApp_SelectionMgr* mgr = selectionMgr();
      SALOME_ListIO selected; mgr->selectedObjects( selected );

      SALOME_ListIteratorOfListIO it(selected);
      for( ; it.More(); it.Next()) {
        Handle(SALOME_InteractiveObject) anIObject = it.Value();
        if(anIObject->hasEntry())
          if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
            anActor->SetCellsLabeled( !anActor->GetCellsLabeled() );
          }
      }
      break;
    }
  case 501:
  case 502:
    {
      int page = theCommandID == 501 ? SMESHGUI_MeasureDlg::MinDistance : SMESHGUI_MeasureDlg::BoundingBox;
      EmitSignalDeactivateDialog();
      SMESHGUI_MeasureDlg* dlg = new SMESHGUI_MeasureDlg( SMESHGUI::desktop(), page );
      dlg->show();
      break;
    }
  }

  anApp->updateActions(); //SRN: To update a Save button in the toolbar
  //updateObjBrowser();
  return true;
}

void SMESHGUI::OnGUIEvent

(

)

[private, slot]

Definition at line 4140 of file SMESHGUI.cxx.

Referenced by createSMESHAction().

{
  const QObject* obj = sender();
  if ( !obj || !obj->inherits( "QAction" ) )
    return;
  int id = actionId((QAction*)obj);
  if ( id != -1 )
    OnGUIEvent( id );
}

void SMESHGUI::onHypothesisEdit

(

int

result

)

[private, slot]

Actions after hypothesis edition Updates object browser after hypothesis edition.

Definition at line 5659 of file SMESHGUI.cxx.

References Modified().

Referenced by OnGUIEvent().

{
  if( result == 1 )
    SMESHGUI::Modified();
  updateObjBrowser( true );
}

bool SMESHGUI::OnKeyPress	(	QKeyEvent *	pe,
		SUIT_ViewWindow *	wnd
	)		[virtual]

Definition at line 3163 of file SMESHGUI.cxx.

{
  return true;
}

bool SMESHGUI::OnMouseMove	(	QMouseEvent *	pe,
		SUIT_ViewWindow *	wnd
	)		[virtual]

Definition at line 3153 of file SMESHGUI.cxx.

{
  return true;
}

bool SMESHGUI::OnMousePress	(	QMouseEvent *	pe,
		SUIT_ViewWindow *	wnd
	)		[virtual]

Definition at line 3143 of file SMESHGUI.cxx.

{
  return false;
}

void SMESHGUI::onOperationAborted

(

SUIT_Operation *

)

[private, slot]

Set default selection mode.

SLOT called when operation aborted. Sets default selection mode

Definition at line 4693 of file SMESHGUI.cxx.

{
  SVTK_ViewWindow* vtkWnd =
    dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
  if ( vtkWnd )
    vtkWnd->SetSelectionMode( ActorSelection );
}

void SMESHGUI::onOperationCommited

(

SUIT_Operation *

)

[private, slot]

Set default selection mode.

SLOT called when operation commited. Sets default selection mode

Definition at line 4678 of file SMESHGUI.cxx.

{
  SVTK_ViewWindow* vtkWnd =
    dynamic_cast<SVTK_ViewWindow*>( application()->desktop()->activeWindow() );
  if ( vtkWnd )
    vtkWnd->SetSelectionMode( ActorSelection );
}

void SMESHGUI::onViewClosed

(

SUIT_ViewWindow *

pview

)

[slot]

Signal handler closing(SUIT_ViewWindow*) of a view.

Parameters:

pview

view being closed

Definition at line 5671 of file SMESHGUI.cxx.

References SMESH.ClearPlot2Viewers().

Referenced by connectView().

                                                    {
#ifndef DISABLE_PLOT2DVIEWER
  //Crear all Plot2d Viewers if need.
  SMESH::ClearPlot2Viewers(pview);
#endif  
}

void SMESHGUI::onViewManagerActivated

(

SUIT_ViewManager *

mgr

)

[private, slot]

Definition at line 4207 of file SMESHGUI.cxx.

References connectView(), and SMESH.UpdateSelectionProp().

Referenced by initialize().

{
  if ( dynamic_cast<SVTK_ViewManager*>( mgr ) ) {
    SMESH::UpdateSelectionProp( this );
    
    QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
    for(int i = 0; i < aViews.count() ; i++){
      SUIT_ViewWindow *sf = aViews[i];
      connectView( sf );
    }
  }
}

void SMESHGUI::onViewManagerRemoved

(

SUIT_ViewManager *

theViewManager

)

[private, slot]

Definition at line 4220 of file SMESHGUI.cxx.

References myClippingPlaneInfoMap.

Referenced by initialize().

{
  if( theViewManager && theViewManager->getType() == SVTK_Viewer::Type() )
    myClippingPlaneInfoMap.erase( theViewManager );
}

void SMESHGUI::preferencesChanged	(	const QString &	sect,
		const QString &	name
	)		[virtual]

Definition at line 4582 of file SMESHGUI.cxx.

References desktop(), SMESH.GetResourceMgr(), myComponentSMESH, and SMESH.UpdateSelectionProp().

{
  if( sect=="SMESH" ) {
    float sbX1,sbY1,sbW,sbH;
    float aTol = 1.00000009999999;
    std::string aWarning;
    SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
    if( name=="selection_object_color" || name=="selection_element_color" ||
        name=="selection_width" || name=="highlight_color" || name=="highlight_width" ||
        name=="selection_precision_node" || name=="selection_precision_element" ||
        name=="selection_precision_object")
      SMESH::UpdateSelectionProp( this );
    else if (name == QString("scalar_bar_vertical_x") || name == QString("scalar_bar_vertical_width")){
      sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_x", sbX1);
      sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_width", sbW);
      if(sbX1+sbW > aTol){
        aWarning = "Origin and Size Vertical: X+Width > 1\n";
        sbX1=0.01;
        sbW=0.08;
        aResourceMgr->setValue("SMESH", "scalar_bar_vertical_x", sbX1);
        aResourceMgr->setValue("SMESH", "scalar_bar_vertical_width", sbW);
      }
    }
    else if(name == QString("scalar_bar_vertical_y") || name == QString("scalar_bar_vertical_height")){
      sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_y", sbY1);
      sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_vertical_height",sbH);
      if(sbY1+sbH > aTol){
        aWarning = "Origin and Size Vertical: Y+Height > 1\n";
        aResourceMgr->setValue("SMESH", "scalar_bar_vertical_y", sbY1);
        aResourceMgr->setValue("SMESH", "scalar_bar_vertical_height",sbH);
      }
    }
    else if(name ==  QString("scalar_bar_horizontal_x") || name ==  QString("scalar_bar_horizontal_width")){
      sbX1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_x", sbX1);
      sbW = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_width", sbW);
      if(sbX1+sbW > aTol){
        aWarning = "Origin and Size Horizontal: X+Width > 1\n";
        sbX1=0.1;
        sbW=0.08;
        aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_x", sbX1);
        aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_width", sbW);
      }
    }
    else if(name ==  QString("scalar_bar_horizontal_y") || name ==  QString("scalar_bar_horizontal_height")){
      sbY1 = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_y", sbY1);
      sbH = aResourceMgr->doubleValue("SMESH", "scalar_bar_horizontal_height",sbH);
      if(sbY1+sbH > aTol){
        aWarning = "Origin and Size Horizontal: Y+Height > 1\n";
        sbY1=0.01;
        sbH=0.08;
        aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_y", sbY1);
        aResourceMgr->setValue("SMESH", "scalar_bar_horizontal_height",sbH);
      }
    }
    else if ( name == "segmentation" ) {
      int nbSeg = aResourceMgr->integerValue( "SMESH", "segmentation", 10 );
      myComponentSMESH->SetBoundaryBoxSegmentation( nbSeg );
    }
    else if ( name == "nb_segments_per_edge" ) {
      int nbSeg = aResourceMgr->integerValue( "SMESH", "nb_segments_per_edge", 15 );
      myComponentSMESH->SetDefaultNbSegments( nbSeg );
    }

    if(aWarning.size() != 0){
      aWarning += "The default values are applied instead.";
      SUIT_MessageBox::warning(SMESHGUI::desktop(),
                               QObject::tr("SMESH_ERR_SCALARBAR_PARAMS"),
                               QObject::tr(aWarning.c_str()));
    }
  }
}

void SMESHGUI::ProcessEvents	(	vtkObject *	theObject,
		unsigned long	theEvent,
		void *	theClientData,
		void *	theCallData
	)		[static, protected]

Definition at line 4233 of file SMESHGUI.cxx.

References SMESH.ClippingPlaneInfo.ActorList, and SMESH.DeleteActorEvent.

Referenced by SMESHGUI().

{
  if( SMESHGUI* aSMESHGUI = reinterpret_cast<SMESHGUI*>( theClientData ) ) {
    if( theObject && theEvent == SMESH::DeleteActorEvent ) {
      if( SMESH_Actor* anActor = SMESH_Actor::SafeDownCast( theObject ) ) {
        SMESHGUI_ClippingPlaneInfoMap& aClippingPlaneInfoMap = aSMESHGUI->getClippingPlaneInfoMap();
        SMESHGUI_ClippingPlaneInfoMap::iterator anIter1 = aClippingPlaneInfoMap.begin();
        for( ; anIter1 != aClippingPlaneInfoMap.end(); anIter1++ ) {
          SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = anIter1->second;
          SMESHGUI_ClippingPlaneInfoList::iterator anIter2 = aClippingPlaneInfoList.begin();
          for( ; anIter2 != aClippingPlaneInfoList.end(); anIter2++ ) {
            SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter2;
            std::list<vtkActor*>& anActorList = aClippingPlaneInfo.ActorList;
            SMESH::TActorList::iterator anIter3 = anActorList.begin();
            for ( ; anIter3 != anActorList.end(); anIter3++ ) {
              if( anActor == *anIter3 ) {
                anActorList.erase( anIter3 );
                break;
              }
            }
          }
        }
      }
    }
  }
}

bool SMESHGUI::renameAllowed

(

const QString &

entry

)

const [virtual]

Return true if object can be renamed.

Definition at line 5699 of file SMESHGUI.cxx.

References _PTR(), ALGORITHM, GROUP, HYPOTHESIS, SUBMESH, SUBMESH_COMPOUND, SUBMESH_EDGE, SUBMESH_FACE, SUBMESH_SOLID, SUBMESH_VERTEX, and SMESHGUI_Selection.type().

                                                        {
  SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
  if( !anApp )
    return false;

  _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
  if( !aStudy )
    return false;

  bool appRes = SalomeApp_Module::renameAllowed(entry);
  if( !appRes )
    return false;
  
  // check type to prevent renaming of inappropriate objects
  int aType = SMESHGUI_Selection::type(qPrintable(entry), aStudy);
  if (aType == MESH || aType == GROUP ||
      aType == SUBMESH || aType == SUBMESH_COMPOUND ||
      aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
      aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
      aType == HYPOTHESIS || aType == ALGORITHM)
    return true;

  return false;
}

bool SMESHGUI::renameObject	(	const QString &	entry,
		const QString &	name
	)		[virtual]

Rename object by entry.

Parameters:

entry	entry of the object
name	new name of the object Return true if rename operation finished successfully, false otherwise.

Definition at line 5730 of file SMESHGUI.cxx.

References _PTR(), ALGORITHM, SMESH.FindActorByEntry(), GetSMESHGen(), GROUP, Handle(), HYPOTHESIS, SUBMESH, SUBMESH_COMPOUND, SUBMESH_EDGE, SUBMESH_FACE, SUBMESH_SOLID, SUBMESH_VERTEX, and SMESHGUI_Selection.type().

                                                                      {
  
  SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( application() );
  if( !anApp )
    return false;
  
  _PTR(Study) aStudy = SMESH::GetActiveStudyDocument(); //Document OCAF de l'etude active
  if( !aStudy )
    return false;

  bool appRes = SalomeApp_Module::renameObject(entry,name);
  if( !appRes )
    return false;
  
  _PTR(SObject) obj = aStudy->FindObjectID( qPrintable(entry) );
  _PTR(GenericAttribute) anAttr;
  _PTR(AttributeName) aName;
  if ( obj ) {
    if ( obj->FindAttribute(anAttr, "AttributeName") ) {
      aName = anAttr;
      // check type to prevent renaming of inappropriate objects
      int aType = SMESHGUI_Selection::type( qPrintable(entry), aStudy );
      if (aType == MESH || aType == GROUP ||
          aType == SUBMESH || aType == SUBMESH_COMPOUND ||
          aType == SUBMESH_SOLID || aType == SUBMESH_FACE ||
          aType == SUBMESH_EDGE || aType == SUBMESH_VERTEX ||
          aType == HYPOTHESIS || aType == ALGORITHM) {
        if ( !name.isEmpty() ) {
          SMESHGUI::GetSMESHGen()->SetName(obj->GetIOR().c_str(), qPrintable(name) );
          
          // update name of group object and its actor
          Handle(SALOME_InteractiveObject) IObject = 
            new SALOME_InteractiveObject ( qPrintable(entry), "SMESH", qPrintable(name) );
          
          SMESH::SMESH_GroupBase_var aGroupObject = SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IObject);
          if( !aGroupObject->_is_nil() ) {
            aGroupObject->SetName( qPrintable(name) );
            if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( qPrintable(entry) ) )
              anActor->setName( qPrintable(name) );
          }
          return true;
        }
      }  
    }
  }
  return false;
}

void SMESHGUI::ResetState

(

)

Definition at line 1693 of file SMESHGUI.cxx.

References myState.

Referenced by SMESHGUI_WhatIsDlg.ClickOnCancel(), SMESHGUI_TranslationDlg.ClickOnCancel(), SMESHGUI_SymmetryDlg.ClickOnCancel(), SMESHGUI_SmoothingDlg.ClickOnCancel(), SMESHGUI_SewingDlg.ClickOnCancel(), SMESHGUI_ScaleDlg.ClickOnCancel(), SMESHGUI_RotationDlg.ClickOnCancel(), SMESHGUI_RenumberingDlg.ClickOnCancel(), SMESHGUI_RemoveNodesDlg.ClickOnCancel(), SMESHGUI_RemoveElementsDlg.ClickOnCancel(), SMESHGUI_Preferences_ColorDlg.ClickOnCancel(), SMESHGUI_NodesDlg.ClickOnCancel(), SMESHGUI_MergeDlg.ClickOnCancel(), SMESHGUI_CreatePolyhedralVolumeDlg.ClickOnCancel(), SMESHGUI_CopyMeshDlg.ClickOnCancel(), SMESHGUI_BuildCompoundDlg.ClickOnCancel(), SMESHGUI_AddQuadraticElementDlg.ClickOnCancel(), SMESHGUI_AddMeshElementDlg.ClickOnCancel(), SMESHGUI_Preferences_ColorDlg.ClickOnOk(), SMESHGUI_StandardMeshInfosDlg.closeEvent(), SMESHGUI_RevolutionDlg.closeEvent(), SMESHGUI_MeshInfosDlg.closeEvent(), SMESHGUI_ExtrusionDlg.closeEvent(), SMESHGUI_WhatIsDlg.DeactivateActiveDialog(), SMESHGUI_TranslationDlg.DeactivateActiveDialog(), SMESHGUI_SymmetryDlg.DeactivateActiveDialog(), SMESHGUI_SmoothingDlg.DeactivateActiveDialog(), SMESHGUI_SewingDlg.DeactivateActiveDialog(), SMESHGUI_ScaleDlg.DeactivateActiveDialog(), SMESHGUI_RotationDlg.DeactivateActiveDialog(), SMESHGUI_RevolutionDlg.DeactivateActiveDialog(), SMESHGUI_RenumberingDlg.DeactivateActiveDialog(), SMESHGUI_RemoveNodesDlg.DeactivateActiveDialog(), SMESHGUI_RemoveElementsDlg.DeactivateActiveDialog(), SMESHGUI_NodesDlg.DeactivateActiveDialog(), SMESHGUI_MergeDlg.DeactivateActiveDialog(), SMESHGUI_ExtrusionDlg.DeactivateActiveDialog(), SMESHGUI_ExtrusionAlongPathDlg.DeactivateActiveDialog(), SMESHGUI_CreatePolyhedralVolumeDlg.DeactivateActiveDialog(), SMESHGUI_CopyMeshDlg.DeactivateActiveDialog(), SMESHGUI_BuildCompoundDlg.DeactivateActiveDialog(), SMESHGUI_AddQuadraticElementDlg.DeactivateActiveDialog(), SMESHGUI_AddMeshElementDlg.DeactivateActiveDialog(), SMESHGUI_FilterDlg.enterEvent(), SMESHGUI_SingleEditDlg.onClose(), SMESHGUI_MultiEditDlg.onClose(), SMESHGUI_MoveNodesDlg.onClose(), SMESHGUI_MeshPatternDlg.onClose(), SMESHGUI_GroupOpDlg.onClose(), SMESHGUI_GroupDlg.onClose(), SMESHGUI_FilterLibraryDlg.onClose(), SMESHGUI_FilterDlg.onClose(), SMESHGUI_DuplicateNodesDlg.onClose(), SMESHGUI_DeleteGroupDlg.onClose(), SMESHGUI_CreatePatternDlg.onClose(), SMESHGUI_GroupDlg.onDeactivate(), SMESHGUI_DuplicateNodesDlg.onDeactivate(), SMESHGUI_FilterLibraryDlg.onOk(), SMESHGUI_FilterDlg.onOk(), SMESHGUI_CreatePatternDlg.onOk(), SMESHGUI_CreatePatternDlg.onSave(), and SMESHGUI_ExtrusionAlongPathDlg.reject().

{
  myState = -1;
}

SUIT_ResourceMgr * SMESHGUI::resourceMgr

(

)

[static]

Definition at line 1636 of file SMESHGUI.cxx.

Referenced by SMESHGUI_BoundingBox.compute(), SMESHGUI_MinDistance.compute(), createSMESHAction(), StdMeshersGUI_StdHypothesisCreator.icon(), SMESHGUI_TreeElemInfo.information(), SMESHGUI_SimpleElemInfo.information(), SMESH.InitAvailableHypotheses(), OnGUIEvent(), SMESHGUI_MeasureDlg.SMESHGUI_MeasureDlg(), SMESHGUI_MeshInfoDlg.SMESHGUI_MeshInfoDlg(), SMESHGUI_XmlHandler.startElement(), and StdMeshersGUI_QuadrangleParamWdg.StdMeshersGUI_QuadrangleParamWdg().

{
  return dynamic_cast<SUIT_ResourceMgr*>( SUIT_Session::session()->resourceMgr() );
}

void SMESHGUI::restoreVisualParameters

(

int

savePoint

)

[virtual]

Restore visual parameters.

This method is called after the study document is opened. Restore visual parameters from AttributeParameter attribue(s)

Definition at line 5121 of file SMESHGUI.cxx.

References _PTR(), TPlaneInfo.ActorList, SMESH.ClippingPlaneInfo.ActorList, SMESHGUI_ClippingDlg.AddPlane(), TPlaneData.Angle, displayer(), TPlaneData.Distance, SMESH.DownCast(), SMESH_Actor.eEdges, SMESH_Actor.eFaces, SMESH_Actor.eVolumes, SMESH_Actor.GetEntityMode(), Handle(), TPlaneData.Id, MESSAGE, myClippingPlaneInfoMap, myComponentSMESH, myMarkerMap, TPlaneData.Orientation, SMESH.ClippingPlaneInfo.Plane, TPlaneInfo.PlaneId, SMESH_Actor.RemoveAllClippingPlanes(), SMESH_Actor.SetBackSufaceColor(), SMESH_Actor.SetEdgeColor(), SMESH_Actor.SetEntityMode(), SMESH_Actor.SetLineWidth(), SMESH_Actor.SetNodeColor(), SMESH_Actor.SetShrinkFactor(), SMESH_Actor.SetSufaceColor(), and TPlaneInfo.ViewManager.

{
  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
  if (!appStudy || !appStudy->studyDS())
    return;
  _PTR(Study) studyDS = appStudy->studyDS();

  // componentName is used for encoding of entries when storing them in IParameters
  std::string componentName = myComponentSMESH->ComponentDataType();
  //_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
  //if (!aSComponent) return;

  // IParameters
  _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
                                                             componentName.c_str(),
                                                             savePoint);
  _PTR(IParameters) ip = ClientFactory::getIParameters(ap);

  // restore map of custom markers and map of clipping planes
  VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
  TPlaneDataMap aPlaneDataMap;

  std::vector<std::string> properties = ip->getProperties();
  for (std::vector<std::string>::iterator propIt = properties.begin(); propIt != properties.end(); ++propIt)
  {
    std::string property = *propIt;
    QString aPropertyName( property.c_str() );
    QString aPropertyValue( ip->getProperty( property ).c_str() );

    QStringList aPropertyNameList = aPropertyName.split( gSeparator, QString::SkipEmptyParts );
    if( aPropertyNameList.isEmpty() )
      continue;

    QString aPropertyType = aPropertyNameList[0];
    if( aPropertyType == "texture" )
    {
      if( aPropertyNameList.size() != 2 )
        continue;

      bool ok = false;
      int anId = aPropertyNameList[1].toInt( &ok );
      if( !ok || anId < 1 )
        continue;

      QStringList aPropertyValueList = aPropertyValue.split( gPathSep, QString::SkipEmptyParts );
      if( aPropertyValueList.size() != 2 )
        continue;

      std::string aMarkerFileName = aPropertyValueList[0].toStdString();
      QString aMarkerTextureString = aPropertyValueList[1];
      QStringList aMarkerTextureStringList = aMarkerTextureString.split( gDigitsSep, QString::SkipEmptyParts );
      if( aMarkerTextureStringList.size() != 3 )
        continue;

      ok = false;
      ushort aWidth = aMarkerTextureStringList[0].toUShort( &ok );
      if( !ok )
        continue;

      ok = false;
      ushort aHeight = aMarkerTextureStringList[1].toUShort( &ok );
      if( !ok )
        continue;

      VTK::MarkerTexture aMarkerTexture;
      aMarkerTexture.push_back( aWidth );
      aMarkerTexture.push_back( aHeight );

      QString aMarkerTextureData = aMarkerTextureStringList[2];
      for( int i = 0, n = aMarkerTextureData.length(); i < n; i++ )
      {
        QChar aChar = aMarkerTextureData.at( i );
        if( aChar.isDigit() )
          aMarkerTexture.push_back( aChar.digitValue() );
      }

      aMarkerMap[ anId ] = VTK::MarkerData( aMarkerFileName, aMarkerTexture );
    }
    else if( aPropertyType == "ClippingPlane" )
    {
      if( aPropertyNameList.size() != 3 )
        continue;

      bool ok = false;
      int aViewId = aPropertyNameList[1].toInt( &ok );
      if( !ok || aViewId < 0 )
        continue;

      ok = false;
      int aClippingPlaneId = aPropertyNameList[2].toInt( &ok );
      if( !ok || aClippingPlaneId < 0 )
        continue;

      QStringList aPropertyValueList = aPropertyValue.split( gDigitsSep, QString::SkipEmptyParts );
      if( aPropertyValueList.size() != 4 )
        continue;

      TPlaneData aPlaneData;
      aPlaneData.Id = aClippingPlaneId;

      ok = false;
      aPlaneData.Orientation = aPropertyValueList[0].toInt( &ok );
      if( !ok )
        continue;

      ok = false;
      aPlaneData.Distance = aPropertyValueList[1].toDouble( &ok );
      if( !ok )
        continue;

      ok = false;
      aPlaneData.Angle[0] = aPropertyValueList[2].toDouble( &ok );
      if( !ok )
        continue;

      ok = false;
      aPlaneData.Angle[1] = aPropertyValueList[3].toDouble( &ok );
      if( !ok )
        continue;

      TPlaneDataList& aPlaneDataList = aPlaneDataMap[ aViewId ];
      aPlaneDataList.push_back( aPlaneData );      
    }
  }

  TPlaneInfoMap aPlaneInfoMap;

  std::vector<std::string> entries = ip->getEntries();

  for (std::vector<std::string>::iterator entIt = entries.begin(); entIt != entries.end(); ++entIt)
  {
    // entry is a normal entry - it should be "decoded" (setting base adress of component)
    QString entry (ip->decodeEntry(*entIt).c_str());

    // Check that the entry corresponds to a real object in the Study
    // as the object may be deleted or modified after the visual state is saved.
    _PTR(SObject) so = studyDS->FindObjectID(entry.toLatin1().data());
    if (!so) continue; //Skip the not existent entry

    std::vector<std::string> paramNames = ip->getAllParameterNames( *entIt );
    std::vector<std::string> paramValues = ip->getAllParameterValues( *entIt );

    std::vector<std::string>::iterator namesIt = paramNames.begin();
    std::vector<std::string>::iterator valuesIt = paramValues.begin();

    // actors are stored in a map after displaying of them for
    // quicker access in the future: map < viewID to actor >
    NCollection_DataMap<int, SMESH_Actor*> vtkActors;

    for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt)
    {
      // visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
      // '_' is used as separator and should not be used in viewer type or parameter names.
      QStringList lst = QString((*namesIt).c_str()).split(gSeparator, QString::SkipEmptyParts);
      if (lst.size() != 3)
        continue;

      QString viewerTypStr = lst[0];
      QString viewIndexStr = lst[1];
      QString paramNameStr = lst[2];

      bool ok;
      int viewIndex = viewIndexStr.toUInt(&ok);
      if (!ok) // bad conversion of view index to integer
        continue;

      // viewers
      if (viewerTypStr == SVTK_Viewer::Type())
      {
        SMESH_Actor* aSmeshActor = 0;
        if (vtkActors.IsBound(viewIndex))
          aSmeshActor = vtkActors.Find(viewIndex);

        QList<SUIT_ViewManager*> lst;
        getApp()->viewManagers(viewerTypStr, lst);

        // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
        SUIT_ViewManager* vman = NULL;
        if (viewIndex >= 0 && viewIndex < lst.count())
          vman = lst.at(viewIndex);

        if (paramNameStr == "Visibility")
        {
          if (!aSmeshActor && displayer() && vman)
          {
            SUIT_ViewModel* vmodel = vman->getViewModel();
            // SVTK view model can be casted to SALOME_View
            displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));

            // store displayed actor in a temporary map for quicker
            // access later when restoring other parameters
            SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();
            vtkRenderer* Renderer = vtkView->getRenderer();
            VTK::ActorCollectionCopy aCopy(Renderer->GetActors());
            vtkActorCollection* theActors = aCopy.GetActors();
            theActors->InitTraversal();
            bool isFound = false;
            vtkActor *ac = theActors->GetNextActor();
            for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) {
              if (ac->IsA("SMESH_Actor")) {
                SMESH_Actor* aGeomAc = SMESH_Actor::SafeDownCast(ac);
                if (aGeomAc->hasIO()) {
                  Handle(SALOME_InteractiveObject) io =
                    Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO());
                  if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) {
                    isFound = true;
                    vtkActors.Bind(viewIndex, aGeomAc);
                  }
                }
              }
            }
          }
        } // if (paramNameStr == "Visibility")
        else
        {
          // the rest properties "work" with SMESH_Actor
          if (aSmeshActor)
          {
            QString val ((*valuesIt).c_str());

            // Representation
            if (paramNameStr == "Representation") {
              aSmeshActor->SetRepresentation((SMESH_Actor::EReperesent)val.toInt());
            }
            // IsShrunk
            else if (paramNameStr == "IsShrunk") {
              if (val.toInt()) {
                if (!aSmeshActor->IsShrunk())
                  aSmeshActor->SetShrink();
              }
              else {
                if (aSmeshActor->IsShrunk())
                  aSmeshActor->UnShrink();
              }
            }
            // Displayed entities
            else if (paramNameStr == "Entities") {
              QStringList mode = val.split(gDigitsSep, QString::SkipEmptyParts);
              if (mode.count() == 6) {
                if (mode[0] != "e" || mode[2]  != "f" || mode[4] != "v") {
                  MESSAGE("Invalid order of data in Entities, must be: "
                          "e:0/1:f:0/1:v:0/1");
                }
                else {
                  unsigned int aMode = aSmeshActor->GetEntityMode();
                  unsigned int aNewMode =
                    (int(SMESH_Actor::eEdges  ) * mode[1].toInt()) |
                    (int(SMESH_Actor::eFaces  ) * mode[3].toInt()) |
                    (int(SMESH_Actor::eVolumes) * mode[5].toInt());
                  if (aNewMode != aMode)
                    aSmeshActor->SetEntityMode(aNewMode);
                }
              }
            }
            // Colors
            else if (paramNameStr == "Colors") {
              QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts);
              if (colors.count() == 16) {
                if (colors[0] != "surface" || colors[4]  != "backsurface" ||
                    colors[8] != "edge"    || colors[12] != "node") {
                  MESSAGE("Invalid order of data in Colors, must be: "
                          "surface:r:g:b:backsurface:r:g:b:edge:r:g:b:node:r:g:b");
                }
                else {
                  aSmeshActor->SetSufaceColor(colors[1].toFloat(), colors[2].toFloat(), colors[3].toFloat());
                  aSmeshActor->SetBackSufaceColor(colors[5].toFloat(), colors[6].toFloat(), colors[7].toFloat());
                  aSmeshActor->SetEdgeColor(colors[9].toFloat(), colors[10].toFloat(), colors[11].toFloat());
                  aSmeshActor->SetNodeColor(colors[13].toFloat(), colors[14].toFloat(), colors[15].toFloat());
                }
              }
            }
            // Sizes of lines and points
            else if (paramNameStr == "Sizes") {
              QStringList sizes = val.split(gDigitsSep, QString::SkipEmptyParts);
              if (sizes.count() == 4) {
                if (sizes[0] != "line" || sizes[2] != "shrink") {
                  MESSAGE("Invalid order of data in Sizes, must be: "
                          "line:int:shrink:float");
                }
                else {
                  aSmeshActor->SetLineWidth(sizes[1].toInt());
                  aSmeshActor->SetShrinkFactor(sizes[3].toFloat());
                }
              }
              else if (sizes.count() == 6) { // just to support old format
                if (sizes[0] != "line" || sizes[2]  != "node" || sizes[4] != "shrink") {
                  MESSAGE("Invalid order of data in Sizes, must be: "
                          "line:int:node:int:shrink:float");
                }
                else {
                  aSmeshActor->SetLineWidth(sizes[1].toInt());
                  //aSmeshActor->SetNodeSize(sizes[3].toInt()); // made obsolete
                  aSmeshActor->SetShrinkFactor(sizes[5].toFloat());
                }
              }
            }
            // Point marker
            else if (paramNameStr == "PointMarker") {
              QStringList data = val.split(gDigitsSep, QString::SkipEmptyParts);
              if( data.count() >= 2 ) {
                bool ok = false;
                int aParam1 = data[1].toInt( &ok );
                if( ok ) {
                  if( data[0] == "std" && data.count() == 3 ) {
                    int aParam2 = data[2].toInt( &ok );
                    aSmeshActor->SetMarkerStd( (VTK::MarkerType)aParam1, (VTK::MarkerScale)aParam2 );
                  }
                  else if( data[0] == "custom" ) {
                    VTK::MarkerMap::const_iterator markerIt = aMarkerMap.find( aParam1 );
                    if( markerIt != aMarkerMap.end() ) {
                      VTK::MarkerData aMarkerData = markerIt->second;
                      aSmeshActor->SetMarkerTexture( aParam1, aMarkerData.second );
                    }
                  }
                }
              }
            }
            // Opacity
            else if (paramNameStr == "Opacity") {
              aSmeshActor->SetOpacity(val.toFloat());
            }
            // Clipping
            else if (paramNameStr.startsWith("ClippingPlane")) {
              QStringList vals = val.split(gDigitsSep, QString::SkipEmptyParts);
              // old format - val looks like "Off" or "0:0.5:0:0" (orientation, distance, two angles)
              // new format - val looks like "Off" or "0" (plane id)
              // (note: in new format "Off" value is used only for consistency,
              //  so it is processed together with values in old format)
              bool anIsOldFormat = ( vals.count() == 4 || val == "Off" );
              if( anIsOldFormat ) {
                if (paramNameStr == "ClippingPlane1" || val == "Off")
                  aSmeshActor->RemoveAllClippingPlanes();
                if (val != "Off") {
                  SMESH::Orientation anOrientation = (SMESH::Orientation)vals[0].toInt();
                  double aDistance = vals[1].toFloat();
                  vtkFloatingPointType anAngle[2];
                  anAngle[0] = vals[2].toFloat();
                  anAngle[1] = vals[3].toFloat();

                  QList<SUIT_ViewManager*> lst;
                  getApp()->viewManagers(viewerTypStr, lst);
                  // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager
                  if (viewIndex >= 0 && viewIndex < lst.count()) {
                    SUIT_ViewManager* vman = lst.at(viewIndex);
                    SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView();

                    SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ vman ];

                    SMESH::TActorList anActorList;
                    anActorList.push_back( aSmeshActor );
                    SMESH::OrientedPlane* aPlane =
                      SMESHGUI_ClippingDlg::AddPlane(anActorList, vtkView, anOrientation, aDistance, anAngle);
                    if( aPlane ) {
                      SMESH::ClippingPlaneInfo aClippingPlaneInfo;
                      aClippingPlaneInfo.Plane = aPlane;
                      aClippingPlaneInfo.ActorList = anActorList;
                      aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
                    }
                  }
                }
              }
              else {
                bool ok = false;
                int aPlaneId = val.toInt( &ok );
                if( ok && aPlaneId >= 0 ) {
                  bool anIsDefinedPlane = false;
                  TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ viewIndex ];
                  TPlaneInfoList::iterator anIter = aPlaneInfoList.begin();
                  for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
                    TPlaneInfo& aPlaneInfo = *anIter;
                    if( aPlaneInfo.PlaneId == aPlaneId ) {
                      aPlaneInfo.ActorList.push_back( aSmeshActor );
                      anIsDefinedPlane = true;
                      break;
                    }
                  }
                  if( !anIsDefinedPlane ) {
                    TPlaneInfo aPlaneInfo;
                    aPlaneInfo.PlaneId = aPlaneId;
                    aPlaneInfo.ActorList.push_back( aSmeshActor );
                    aPlaneInfo.ViewManager = vman;

                    // to make the list sorted by plane id
                    anIter = aPlaneInfoList.begin();
                    for( ; anIter != aPlaneInfoList.end(); anIter++ ) {
                      const TPlaneInfo& aPlaneInfoRef = *anIter;
                      if( aPlaneInfoRef.PlaneId > aPlaneId )
                        break;
                    }
                    aPlaneInfoList.insert( anIter, aPlaneInfo );
                  }
                }
              }
            }
          } // if (aSmeshActor)
        } // other parameters than Visibility
      }
    } // for names/parameters iterator
  } // for entries iterator

  // take into account planes with empty list of actors referred to them
  QList<SUIT_ViewManager*> aVMList;
  getApp()->viewManagers(SVTK_Viewer::Type(), aVMList);

  TPlaneDataMap::const_iterator aPlaneDataIter = aPlaneDataMap.begin();
  for( ; aPlaneDataIter != aPlaneDataMap.end(); aPlaneDataIter++ ) {
    int aViewId = aPlaneDataIter->first;
    if( aViewId >= 0 && aViewId < aVMList.count() ) {
      SUIT_ViewManager* aViewManager = aVMList.at( aViewId );

      const TPlaneDataList& aPlaneDataList = aPlaneDataIter->second;

      TPlaneInfoList& aPlaneInfoList = aPlaneInfoMap[ aViewId ];
      TPlaneDataList::const_iterator anIter2 = aPlaneDataList.begin();
      for( ; anIter2 != aPlaneDataList.end(); anIter2++ ) {
        const TPlaneData& aPlaneData = *anIter2;
        int aPlaneId = aPlaneData.Id;

        bool anIsFound = false;
        TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
        for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
          const TPlaneInfo& aPlaneInfo = *anIter3;
          if( aPlaneInfo.PlaneId == aPlaneId ) {
            anIsFound = true;
            break;
          }
        }

        if( !anIsFound ) {
          TPlaneInfo aPlaneInfo; // ActorList field is empty
          aPlaneInfo.PlaneId = aPlaneId;
          aPlaneInfo.ViewManager = aViewManager;

          // to make the list sorted by plane id
          TPlaneInfoList::iterator anIter4 = aPlaneInfoList.begin();
          for( ; anIter4 != aPlaneInfoList.end(); anIter4++ ) {
            const TPlaneInfo& aPlaneInfoRef = *anIter4;
            if( aPlaneInfoRef.PlaneId > aPlaneId )
              break;
          }
          aPlaneInfoList.insert( anIter4, aPlaneInfo );
        }
      }
    }
  }

  // add clipping planes to actors according to the restored parameters
  // and update the clipping plane map
  TPlaneInfoMap::const_iterator anIter1 = aPlaneInfoMap.begin();
  for( ; anIter1 != aPlaneInfoMap.end(); anIter1++ ) {
    int aViewId = anIter1->first;
    const TPlaneInfoList& aPlaneInfoList = anIter1->second;

    TPlaneDataMap::const_iterator anIter2 = aPlaneDataMap.find( aViewId );
    if( anIter2 == aPlaneDataMap.end() )
      continue;
    const TPlaneDataList& aPlaneDataList = anIter2->second;

    TPlaneInfoList::const_iterator anIter3 = aPlaneInfoList.begin();
    for( ; anIter3 != aPlaneInfoList.end(); anIter3++ ) {
      const TPlaneInfo& aPlaneInfo = *anIter3;
      int aPlaneId = aPlaneInfo.PlaneId;
      const TActorList& anActorList = aPlaneInfo.ActorList;
      SUIT_ViewManager* aViewManager = aPlaneInfo.ViewManager;
      if( !aViewManager )
        continue;

      SVTK_ViewWindow* aViewWindow = dynamic_cast<SVTK_ViewWindow*>( aViewManager->getActiveView() );
      if( !aViewWindow )
        continue;

      SMESHGUI_ClippingPlaneInfoList& aClippingPlaneInfoList = myClippingPlaneInfoMap[ aViewManager ];

      TPlaneDataList::const_iterator anIter4 = aPlaneDataList.begin();
      for( ; anIter4 != aPlaneDataList.end(); anIter4++ ) {
        const TPlaneData& aPlaneData = *anIter4;
        if( aPlaneData.Id == aPlaneId ) {
          SMESH::OrientedPlane* aPlane =
            SMESHGUI_ClippingDlg::AddPlane( anActorList,
                                            aViewWindow,
                                            (SMESH::Orientation)aPlaneData.Orientation,
                                            aPlaneData.Distance,
                                            aPlaneData.Angle );
          if( aPlane ) {
            SMESH::ClippingPlaneInfo aClippingPlaneInfo;
            aClippingPlaneInfo.Plane = aPlane;
            aClippingPlaneInfo.ActorList = anActorList;
            aClippingPlaneInfoList.push_back( aClippingPlaneInfo );
          }
          break;
        }
      }
    }
  }

  // update all VTK views
  QList<SUIT_ViewManager*> lst;
  getApp()->viewManagers(lst);
  for (QList<SUIT_ViewManager*>::Iterator it = lst.begin(); it != lst.end(); it++) {
    SUIT_ViewModel* vmodel = (*it)->getViewModel();
    if (vmodel && vmodel->getType() == SVTK_Viewer::Type()) {
      SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) (*it)->getActiveView();
      vtkView->getRenderer()->ResetCameraClippingRange();
      vtkView->Repaint();
    }
  }
}

bool SMESHGUI::reusableOperation

(

const int

id

)

[protected, virtual]

Definition at line 4061 of file SMESHGUI.cxx.

{
  // compute, evaluate and precompute are not reusable operations
  return ( id == 701 || id == 711 || id == 712 ) ? false : SalomeApp_Module::reusableOperation( id );
}

LightApp_SelectionMgr * SMESHGUI::selectionMgr

(

)

[static]

Definition at line 1604 of file SMESHGUI.cxx.

Referenced by CheckHomogeneousSelection(), contextMenuPopup(), Control(), SMESHGUI_MeshInfoDlg.deactivate(), SMESHGUI_MeasureDlg.deactivate(), SMESHGUI_BoundingBox.deactivate(), SMESHGUI_MinDistance.deactivate(), DisableAutoColor(), ExportMeshToFile(), isSelectionCompatible(), OnEditDelete(), OnGUIEvent(), PlotDistribution(), SMESHGUI_MeshInfoDlg.reject(), SMESHGUI_MeasureDlg.reject(), SaveDistribution(), SMESHGUI_BoundingBox.selectionChanged(), SMESHGUI_MinDistance.selectionChanged(), SetDisplayEntity(), SetDisplayMode(), ShowDistribution(), SMESHGUI_MeshInfoDlg.updateInfo(), SMESHGUI_MeshInfoDlg.updateSelection(), SMESHGUI_BoundingBox.updateSelection(), SMESHGUI_MinDistance.updateSelection(), and SMESH.UpdateView().

{
  SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
  if( anApp )
    return dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
  else
    return 0;
}

void SMESHGUI::SetActiveDialogBox

(

QDialog *

aDlg

)

Definition at line 1753 of file SMESHGUI.cxx.

References myActiveDialogBox.

Referenced by SMESHGUI_MeshInfoDlg.activate(), SMESHGUI_MeasureDlg.activate(), SMESHGUI_WhatIsDlg.ActivateThisDialog(), SMESHGUI_TranslationDlg.ActivateThisDialog(), SMESHGUI_SymmetryDlg.ActivateThisDialog(), SMESHGUI_SmoothingDlg.ActivateThisDialog(), SMESHGUI_SewingDlg.ActivateThisDialog(), SMESHGUI_ScaleDlg.ActivateThisDialog(), SMESHGUI_RotationDlg.ActivateThisDialog(), SMESHGUI_RevolutionDlg.ActivateThisDialog(), SMESHGUI_RenumberingDlg.ActivateThisDialog(), SMESHGUI_RemoveNodesDlg.ActivateThisDialog(), SMESHGUI_RemoveElementsDlg.ActivateThisDialog(), SMESHGUI_MergeDlg.ActivateThisDialog(), SMESHGUI_ExtrusionDlg.ActivateThisDialog(), SMESHGUI_ExtrusionAlongPathDlg.ActivateThisDialog(), SMESHGUI_CreatePolyhedralVolumeDlg.ActivateThisDialog(), SMESHGUI_CopyMeshDlg.ActivateThisDialog(), SMESHGUI_BuildCompoundDlg.ActivateThisDialog(), SMESHGUI_WhatIsDlg.DeactivateActiveDialog(), SMESHGUI_TranslationDlg.DeactivateActiveDialog(), SMESHGUI_SymmetryDlg.DeactivateActiveDialog(), SMESHGUI_SmoothingDlg.DeactivateActiveDialog(), SMESHGUI_SewingDlg.DeactivateActiveDialog(), SMESHGUI_ScaleDlg.DeactivateActiveDialog(), SMESHGUI_RotationDlg.DeactivateActiveDialog(), SMESHGUI_RevolutionDlg.DeactivateActiveDialog(), SMESHGUI_RenumberingDlg.DeactivateActiveDialog(), SMESHGUI_RemoveNodesDlg.DeactivateActiveDialog(), SMESHGUI_RemoveElementsDlg.DeactivateActiveDialog(), SMESHGUI_NodesDlg.DeactivateActiveDialog(), SMESHGUI_MergeDlg.DeactivateActiveDialog(), SMESHGUI_ExtrusionDlg.DeactivateActiveDialog(), SMESHGUI_ExtrusionAlongPathDlg.DeactivateActiveDialog(), SMESHGUI_CreatePolyhedralVolumeDlg.DeactivateActiveDialog(), SMESHGUI_CopyMeshDlg.DeactivateActiveDialog(), SMESHGUI_BuildCompoundDlg.DeactivateActiveDialog(), SMESHGUI_AddQuadraticElementDlg.DeactivateActiveDialog(), SMESHGUI_AddMeshElementDlg.DeactivateActiveDialog(), SMESHGUI_GroupDlg.enterEvent(), SMESHGUI_FilterDlg.enterEvent(), SMESHGUI_DuplicateNodesDlg.enterEvent(), SMESHGUI_SingleEditDlg.Init(), SMESHGUI_RenumberingDlg.Init(), SMESHGUI_RemoveNodesDlg.Init(), SMESHGUI_RemoveElementsDlg.Init(), SMESHGUI_NodesDlg.Init(), SMESHGUI_MultiEditDlg.Init(), SMESHGUI_MoveNodesDlg.Init(), SMESHGUI_MeshPatternDlg.Init(), SMESHGUI_MergeDlg.Init(), SMESHGUI_GroupOpDlg.Init(), SMESHGUI_FilterDlg.Init(), SMESHGUI_DuplicateNodesDlg.Init(), SMESHGUI_DeleteGroupDlg.Init(), SMESHGUI_CreatePolyhedralVolumeDlg.Init(), SMESHGUI_CreatePatternDlg.Init(), SMESHGUI_BuildCompoundDlg.Init(), SMESHGUI_AddQuadraticElementDlg.Init(), SMESHGUI_AddMeshElementDlg.Init(), SMESHGUI_GroupDlg.initDialog(), SMESHGUI_DuplicateNodesDlg.onDeactivate(), SMESHGUI_CopyMeshDlg.SMESHGUI_CopyMeshDlg(), SMESHGUI_CreatePolyhedralVolumeDlg.SMESHGUI_CreatePolyhedralVolumeDlg(), SMESHGUI_ExtrusionAlongPathDlg.SMESHGUI_ExtrusionAlongPathDlg(), SMESHGUI_ExtrusionDlg.SMESHGUI_ExtrusionDlg(), SMESHGUI_MeshInfosDlg.SMESHGUI_MeshInfosDlg(), SMESHGUI_Preferences_ColorDlg.SMESHGUI_Preferences_ColorDlg(), SMESHGUI_RevolutionDlg.SMESHGUI_RevolutionDlg(), SMESHGUI_RotationDlg.SMESHGUI_RotationDlg(), SMESHGUI_ScaleDlg.SMESHGUI_ScaleDlg(), SMESHGUI_SewingDlg.SMESHGUI_SewingDlg(), SMESHGUI_SmoothingDlg.SMESHGUI_SmoothingDlg(), SMESHGUI_StandardMeshInfosDlg.SMESHGUI_StandardMeshInfosDlg(), SMESHGUI_SymmetryDlg.SMESHGUI_SymmetryDlg(), SMESHGUI_TranslationDlg.SMESHGUI_TranslationDlg(), and SMESHGUI_WhatIsDlg.SMESHGUI_WhatIsDlg().

{
  myActiveDialogBox = (QDialog *) aDlg;
  return;
}

void SMESHGUI::SetState

(

int

aState

)

Definition at line 1683 of file SMESHGUI.cxx.

References myState.

Referenced by SMESHGUI_GroupDlg.enterEvent(), and SMESHGUI_GroupDlg.initDialog().

{
  myState = aState;
}

void SMESHGUI.SignalCloseAllDialogs

(

)

[signal]

Referenced by EmitSignalCloseAllDialogs().

void SMESHGUI.SignalDeactivateActiveDialog

(

)

[signal]

Referenced by EmitSignalDeactivateDialog().

void SMESHGUI.SignalStudyFrameChanged

(

)

[signal]

Referenced by EmitSignalStudyFrameChanged().

void SMESHGUI.SignalVisibilityChanged

(

)

[signal]

Referenced by EmitSignalVisibilityChanged().

void SMESHGUI::storeVisualParameters

(

int

savePoint

)

[virtual]

Store visual parameters.

This method is called just before the study document is saved. Store visual parameters in AttributeParameter attribue(s)

Definition at line 4844 of file SMESHGUI.cxx.

References _PTR(), SMESH.ClippingPlaneInfo.ActorList, SMESH_Actor.eEdges, SMESH_Actor.eFaces, SMESH_Actor.eVolumes, gDigitsSep, SMESH_Actor.GetBackSufaceColor(), SMESH.OrientedPlane.GetDistance(), SMESH_Actor.GetEdgeColor(), SMESH_Actor.GetEntityMode(), SMESH_Actor.GetLineWidth(), SMESH_Actor.GetNodeColor(), SMESH.OrientedPlane.GetOrientation(), SMESH_Actor.GetSufaceColor(), gPathSep, gSeparator, Handle(), SMESH.OrientedPlane.myAngle, myClippingPlaneInfoMap, myComponentSMESH, myMarkerMap, and SMESH.ClippingPlaneInfo.Plane.

{
  SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
  if (!appStudy || !appStudy->studyDS())
    return;
  _PTR(Study) studyDS = appStudy->studyDS();

  // componentName is used for encoding of entries when storing them in IParameters
  std::string componentName = myComponentSMESH->ComponentDataType();
  //_PTR(SComponent) aSComponent = studyDS->FindComponent("SMESH");
  //if (!aSComponent) return;

  // IParameters
  _PTR(AttributeParameter) ap = studyDS->GetModuleParameters("Interface Applicative",
                                                             componentName.c_str(),
                                                             savePoint);
  _PTR(IParameters) ip = ClientFactory::getIParameters(ap);

  // store map of custom markers
  const VTK::MarkerMap& aMarkerMap = myMarkerMap[ studyDS->StudyId() ];
  if( !aMarkerMap.empty() )
  {
    VTK::MarkerMap::const_iterator anIter = aMarkerMap.begin();
    for( ; anIter != aMarkerMap.end(); anIter++ )
    {
      int anId = anIter->first;
      VTK::MarkerData aMarkerData = anIter->second;
      std::string aMarkerFileName = aMarkerData.first;
      VTK::MarkerTexture aMarkerTexture = aMarkerData.second;
      if( aMarkerTexture.size() < 3 )
        continue; // should contain at least width, height and the first value

      QString aPropertyName( "texture" );
      aPropertyName += gSeparator;
      aPropertyName += QString::number( anId );

      QString aPropertyValue = aMarkerFileName.c_str();
      aPropertyValue += gPathSep;

      VTK::MarkerTexture::const_iterator aTextureIter = aMarkerTexture.begin();
      ushort aWidth = *aTextureIter++;
      ushort aHeight = *aTextureIter++;
      aPropertyValue += QString::number( aWidth ); aPropertyValue += gDigitsSep;
      aPropertyValue += QString::number( aHeight ); aPropertyValue += gDigitsSep;
      for( ; aTextureIter != aMarkerTexture.end(); aTextureIter++ )
        aPropertyValue += QString::number( *aTextureIter );

      ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
    }
  }

  // viewers counters are used for storing view_numbers in IParameters
  int vtkViewers = 0;

  // main cycle to store parameters of displayed objects
  QList<SUIT_ViewManager*> lst;
  QList<SUIT_ViewManager*>::Iterator it;
  getApp()->viewManagers(lst);
  for (it = lst.begin(); it != lst.end(); it++)
  {
    SUIT_ViewManager* vman = *it;
    QString vType = vman->getType();

    // saving VTK actors properties
    if (vType == SVTK_Viewer::Type())
    {
      // store the clipping planes attached to the view manager
      SMESHGUI_ClippingPlaneInfoList aClippingPlaneInfoList;
      SMESHGUI_ClippingPlaneInfoMap::const_iterator anIter = myClippingPlaneInfoMap.find( vman );
      if( anIter != myClippingPlaneInfoMap.end() )
        aClippingPlaneInfoList = anIter->second;

      if( !aClippingPlaneInfoList.empty() ) {
        SMESHGUI_ClippingPlaneInfoList::const_iterator anIter = aClippingPlaneInfoList.begin();
        for( int anId = 0; anIter != aClippingPlaneInfoList.end(); anIter++, anId++ )
        {
          const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter;
          SMESH::OrientedPlane* aPlane = aClippingPlaneInfo.Plane;

          QString aPropertyName( "ClippingPlane" );
          aPropertyName += gSeparator;
          aPropertyName += QString::number( vtkViewers );
          aPropertyName += gSeparator;
          aPropertyName += QString::number( anId );

          QString aPropertyValue = QString::number( (int)aPlane->GetOrientation() ).toLatin1().constData();
          aPropertyValue += gDigitsSep;
          aPropertyValue += QString::number( aPlane->GetDistance() ).toLatin1().constData();
          aPropertyValue += gDigitsSep;
          aPropertyValue += QString::number( aPlane->myAngle[0] ).toLatin1().constData();
          aPropertyValue += gDigitsSep;
          aPropertyValue += QString::number( aPlane->myAngle[1] ).toLatin1().constData();

          ip->setProperty( aPropertyName.toStdString(), aPropertyValue.toStdString() );
        }
      }

      QVector<SUIT_ViewWindow*> views = vman->getViews();
      for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++)
      {
        if (SVTK_ViewWindow* vtkView = dynamic_cast<SVTK_ViewWindow*>(views[i]))
        {
          VTK::ActorCollectionCopy aCopy(vtkView->getRenderer()->GetActors());
          vtkActorCollection* allActors = aCopy.GetActors();
          allActors->InitTraversal();
          while (vtkActor* actor = allActors->GetNextActor())
          {
            if (actor->GetVisibility()) // store only visible actors
            {
              SMESH_Actor* aSmeshActor = 0;
              if (actor->IsA("SMESH_Actor"))
                aSmeshActor = SMESH_Actor::SafeDownCast(actor);
              if (aSmeshActor && aSmeshActor->hasIO())
              {
                Handle(SALOME_InteractiveObject) io = aSmeshActor->getIO();
                if (io->hasEntry())
                {
                  // entry is "encoded" = it does NOT contain component adress,
                  // since it is a subject to change on next component loading
                  std::string entry = ip->encodeEntry(io->getEntry(), componentName);

                  std::string param, vtkParam = vType.toLatin1().data();
                  vtkParam += gSeparator;
                  vtkParam += QString::number(vtkViewers).toLatin1().data();
                  vtkParam += gSeparator;

                  // Visibility
                  param = vtkParam + "Visibility";
                  ip->setParameter(entry, param, "On");

                  // Representation
                  param = vtkParam + "Representation";
                  ip->setParameter(entry, param, QString::number
                                   ((int)aSmeshActor->GetRepresentation()).toLatin1().data());

                  // IsShrunk
                  param = vtkParam + "IsShrunk";
                  ip->setParameter(entry, param, QString::number
                                   ((int)aSmeshActor->IsShrunk()).toLatin1().data());

                  // Displayed entities
                  unsigned int aMode = aSmeshActor->GetEntityMode();
                  bool isE = aMode & SMESH_Actor::eEdges;
                  bool isF = aMode & SMESH_Actor::eFaces;
                  bool isV = aMode & SMESH_Actor::eVolumes;

                  QString modeStr ("e");
                  modeStr += gDigitsSep; modeStr += QString::number(isE);
                  modeStr += gDigitsSep; modeStr += "f";
                  modeStr += gDigitsSep; modeStr += QString::number(isF);
                  modeStr += gDigitsSep; modeStr += "v";
                  modeStr += gDigitsSep; modeStr += QString::number(isV);

                  param = vtkParam + "Entities";
                  ip->setParameter(entry, param, modeStr.toLatin1().data());

                  // Colors (surface:edge:)
                  vtkFloatingPointType r, g, b;

                  aSmeshActor->GetSufaceColor(r, g, b);
                  QString colorStr ("surface");
                  colorStr += gDigitsSep; colorStr += QString::number(r);
                  colorStr += gDigitsSep; colorStr += QString::number(g);
                  colorStr += gDigitsSep; colorStr += QString::number(b);

                  aSmeshActor->GetBackSufaceColor(r, g, b);
                  colorStr += gDigitsSep; colorStr += "backsurface";
                  colorStr += gDigitsSep; colorStr += QString::number(r);
                  colorStr += gDigitsSep; colorStr += QString::number(g);
                  colorStr += gDigitsSep; colorStr += QString::number(b);

                  aSmeshActor->GetEdgeColor(r, g, b);
                  colorStr += gDigitsSep; colorStr += "edge";
                  colorStr += gDigitsSep; colorStr += QString::number(r);
                  colorStr += gDigitsSep; colorStr += QString::number(g);
                  colorStr += gDigitsSep; colorStr += QString::number(b);

                  aSmeshActor->GetNodeColor(r, g, b);
                  colorStr += gDigitsSep; colorStr += "node";
                  colorStr += gDigitsSep; colorStr += QString::number(r);
                  colorStr += gDigitsSep; colorStr += QString::number(g);
                  colorStr += gDigitsSep; colorStr += QString::number(b);

                  param = vtkParam + "Colors";
                  ip->setParameter(entry, param, colorStr.toLatin1().data());

                  // Sizes of lines and points
                  QString sizeStr ("line");
                  sizeStr += gDigitsSep; sizeStr += QString::number((int)aSmeshActor->GetLineWidth());
                  sizeStr += gDigitsSep; sizeStr += "shrink";
                  sizeStr += gDigitsSep; sizeStr += QString::number(aSmeshActor->GetShrinkFactor());

                  param = vtkParam + "Sizes";
                  ip->setParameter(entry, param, sizeStr.toLatin1().data());

                  // Point marker
                  QString markerStr;

                  VTK::MarkerType aMarkerType = aSmeshActor->GetMarkerType();
                  if( aMarkerType == VTK::MT_USER ) {
                    markerStr += "custom";
                    markerStr += gDigitsSep;
                    markerStr += QString::number( aSmeshActor->GetMarkerTexture() );
                  }
                  else {
                    markerStr += "std";
                    markerStr += gDigitsSep;
                    markerStr += QString::number( (int)aMarkerType );
                    markerStr += gDigitsSep;
                    markerStr += QString::number( (int)aSmeshActor->GetMarkerScale() );
                  }

                  param = vtkParam + "PointMarker";
                  ip->setParameter(entry, param, markerStr.toLatin1().data());

                  // Opacity
                  param = vtkParam + "Opacity";
                  ip->setParameter(entry, param,
                                   QString::number(aSmeshActor->GetOpacity()).toLatin1().data());

                  // Clipping
                  param = vtkParam + "ClippingPlane";
                  int aPlaneId = 0;
                  if( !aClippingPlaneInfoList.empty() ) {
                    SMESHGUI_ClippingPlaneInfoList::const_iterator anIter1 = aClippingPlaneInfoList.begin();
                    for( int anId = 0; anIter1 != aClippingPlaneInfoList.end(); anIter1++, anId++ )
                    {
                      const SMESH::ClippingPlaneInfo& aClippingPlaneInfo = *anIter1;
                      std::list<vtkActor*> anActorList = aClippingPlaneInfo.ActorList;
                      SMESH::TActorList::iterator anIter2 = anActorList.begin();
                      for ( ; anIter2 != anActorList.end(); anIter2++ ) {
                        if( aSmeshActor == *anIter2 ) {
                          ip->setParameter( entry, param + QString::number( ++aPlaneId ).toLatin1().constData(),
                                            QString::number( anId ).toLatin1().constData() );                          
                          break;
                        }
                      }
                    }
                  }
                  if( aPlaneId == 0 )
                    ip->setParameter( entry, param, "Off" );
                } // if (io->hasEntry())
              } // SMESH_Actor && hasIO
            } // isVisible
          } // while.. actors traversal
        } // if (vtkView)
      } // for (views)
      vtkViewers++;
    } // if (SVTK view model)
  } // for (viewManagers)
}

void SMESHGUI::studyClosed

(

SUIT_Study *

s

)

[virtual, slot]

Definition at line 4134 of file SMESHGUI.cxx.

References SMESH.RemoveVisuData().

{
  SMESH::RemoveVisuData( s->id() );
  SalomeApp_Module::studyClosed( s );
}

void SMESHGUI::switchToOperation

(

int

id

)

Stops current operations and starts a given one.

Parameters:

id	- The id of the operation to start

Definition at line 4769 of file SMESHGUI.cxx.

References _PTR(), and activeStudy().

Referenced by SMESHGUI_MeshOp.selectionDone().

{
  if ( _PTR(Study) aStudy = SMESH::GetActiveStudyDocument() )
    activeStudy()->abortAllOperations();
  startOperation( id );
}

void SMESHGUI::update

(

const int

flags

)

[virtual]

Update something in accordance with update flags.

Parameters:

theFlags

- update flags

Update viewer or/and object browser etc. in accordance with update flags ( see LightApp_UpdateFlags enumeration ).

Definition at line 4663 of file SMESHGUI.cxx.

References SMESH.UpdateView().

{
  if ( (flags & UF_Viewer) | (flags & UF_Forced) )
    SMESH::UpdateView();
  else
    SalomeApp_Module::update( flags );
}

void SMESHGUI::viewManagers

(

QStringList &

list

)

const [virtual]

Definition at line 4202 of file SMESHGUI.cxx.

{
  list.append( SVTK_Viewer::Type() );
}

void SMESHGUI::windows

(

QMap< int, int > &

aMap

)

const [virtual]

Definition at line 4196 of file SMESHGUI.cxx.

{
  aMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
  aMap.insert( SalomeApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
}

---

Field Documentation

QDialog* SMESHGUI.myActiveDialogBox [private]

Definition at line 211 of file SMESHGUI.h.

Referenced by GetActiveDialogBox(), OnGUIEvent(), SetActiveDialogBox(), and SMESHGUI().

SMESHGUI_ClippingPlaneInfoMap SMESHGUI.myClippingPlaneInfoMap [private]

Definition at line 219 of file SMESHGUI.h.

Referenced by onViewManagerRemoved(), restoreVisualParameters(), and storeVisualParameters().

SMESH::SMESH_Gen_var SMESHGUI::myComponentSMESH = SMESH::SMESH_Gen::_nil() [static, private]

Definition at line 210 of file SMESHGUI.h.

Referenced by GetSMESHGen(), preferencesChanged(), restoreVisualParameters(), SMESHGUI(), and storeVisualParameters().

LightApp_Displayer* SMESHGUI.myDisplayer [private]

Definition at line 214 of file SMESHGUI.h.

Referenced by displayer(), and SMESHGUI().

vtkSmartPointer<vtkCallbackCommand> SMESHGUI.myEventCallbackCommand [private]

Definition at line 221 of file SMESHGUI.h.

Referenced by addActorAsObserver(), and SMESHGUI().

SMESHGUI_FilterLibraryDlg* SMESHGUI.myFilterLibraryDlg [private]

Definition at line 216 of file SMESHGUI.h.

Referenced by OnGUIEvent(), and SMESHGUI().

SMESHGUI_StudyId2MarkerMap SMESHGUI.myMarkerMap [private]

Definition at line 218 of file SMESHGUI.h.

Referenced by OnGUIEvent(), restoreVisualParameters(), and storeVisualParameters().

vtkFloatingPointType SMESHGUI.myPriority [private]

Definition at line 222 of file SMESHGUI.h.

Referenced by addActorAsObserver(), and SMESHGUI().

QMap<int, QString> SMESHGUI.myRules [private]

Definition at line 213 of file SMESHGUI.h.

Referenced by createPopupItem(), and initialize().

int SMESHGUI.myState [private]

Definition at line 212 of file SMESHGUI.h.

Referenced by OnGUIEvent(), ResetState(), SetState(), and SMESHGUI().