#include <SMESHGUI_NodesDlg.h>

Inheritance diagram for SMESHGUI_NodesDlg:

Public Member Functions
	SMESHGUI_NodesDlg (SMESHGUI *)
	~SMESHGUI_NodesDlg ()
Private Types
typedef QList < SMESH::SMESH_GroupBase_var >	GrpList
Private Slots
void	ClickOnOk ()
void	ClickOnCancel ()
bool	ClickOnApply ()
void	ClickOnHelp ()
void	DeactivateActiveDialog ()
void	ActivateThisDialog ()
void	SelectionIntoArgument ()
void	ValueChangedInSpinBox (double)
Private Member Functions
void	Init ()
void	enterEvent (QEvent *)
void	closeEvent (QCloseEvent *)
void	hideEvent (QHideEvent *)
void	keyPressEvent (QKeyEvent *)
bool	isValid ()
Private Attributes
LightApp_SelectionMgr *	mySelectionMgr
SVTK_Selector *	mySelector
SMESHGUI *	mySMESHGUI
SMESH::SMESH_Mesh_var	myMesh
SMESH::TNodeSimulation *	mySimulation
QString	myEntry
GrpList	myGroups
QGroupBox *	GroupConstructors
QRadioButton *	Constructor1
QGroupBox *	GroupCoordinates
SMESHGUI_SpinBox *	SpinBox_X
SMESHGUI_SpinBox *	SpinBox_Y
SMESHGUI_SpinBox *	SpinBox_Z
QLabel *	TextLabel_X
QLabel *	TextLabel_Y
QLabel *	TextLabel_Z
QGroupBox *	GroupGroups
QLabel *	TextLabel_GroupName
QComboBox *	ComboBox_GroupName
QGroupBox *	GroupButtons
QPushButton *	buttonApply
QPushButton *	buttonOk
QPushButton *	buttonCancel
QPushButton *	buttonHelp
QString	myHelpFileName

Detailed Description

Definition at line 60 of file SMESHGUI_NodesDlg.h.

Member Typedef Documentation

typedef QList<SMESH::SMESH_GroupBase_var> SMESHGUI_NodesDlg.GrpList [private]

Definition at line 69 of file SMESHGUI_NodesDlg.h.

Constructor & Destructor Documentation

SMESHGUI_NodesDlg::SMESHGUI_NodesDlg ( SMESHGUI * theModule )

Definition at line 231 of file SMESHGUI_NodesDlg.cxx.

References buttonApply, buttonCancel, buttonHelp, buttonOk, ComboBox_GroupName, Constructor1, SMESH.GetResourceMgr(), SMESH.GetViewWindow(), GroupButtons, GroupConstructors, GroupCoordinates, GroupGroups, Init(), MARGIN, myHelpFileName, mySimulation, mySMESHGUI, SPACING, SpinBox_X, SpinBox_Y, SpinBox_Z, TextLabel_GroupName, TextLabel_X, TextLabel_Y, and TextLabel_Z.

                                                         : 
  QDialog( SMESH::GetDesktop( theModule ) ),
  mySelector( SMESH::GetViewWindow( theModule )->GetSelector() ),
  mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
  mySMESHGUI( theModule )
{
  setModal( false );
  setAttribute( Qt::WA_DeleteOnClose, true );
  setWindowTitle( tr("MESH_NODE_TITLE") );
  setSizeGripEnabled( true );
  
  mySimulation = new SMESH::TNodeSimulation( SMESH::GetViewWindow( mySMESHGUI ) );
  
  QPixmap image0( SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap( "SMESH", 
                                                                   tr( "ICON_DLG_NODE" ) ) );
  
  QVBoxLayout* SMESHGUI_NodesDlgLayout = new QVBoxLayout( this );
  SMESHGUI_NodesDlgLayout->setSpacing( SPACING );
  SMESHGUI_NodesDlgLayout->setMargin( MARGIN );

  /***************************************************************/
  GroupConstructors = new QGroupBox( tr( "MESH_NODE" ), this );
  QButtonGroup* ButtonGroup = new QButtonGroup(this);
  QHBoxLayout* GroupConstructorsLayout = new QHBoxLayout( GroupConstructors );
  GroupConstructorsLayout->setSpacing( SPACING );
  GroupConstructorsLayout->setMargin( MARGIN );

  Constructor1 = new QRadioButton( GroupConstructors );
  Constructor1->setIcon( image0 );
  Constructor1->setChecked( true );
  
  GroupConstructorsLayout->addWidget( Constructor1 );
  ButtonGroup->addButton( Constructor1, 0 );

  /***************************************************************/
  GroupCoordinates = new QGroupBox( tr( "SMESH_COORDINATES" ), this );
  QHBoxLayout* GroupCoordinatesLayout = new QHBoxLayout(GroupCoordinates);
  GroupCoordinatesLayout->setSpacing(SPACING);
  GroupCoordinatesLayout->setMargin(MARGIN);

  TextLabel_X = new QLabel( tr( "SMESH_X" ), GroupCoordinates );
  SpinBox_X = new SMESHGUI_SpinBox( GroupCoordinates );

  TextLabel_Y = new QLabel( tr( "SMESH_Y" ), GroupCoordinates );
  SpinBox_Y = new SMESHGUI_SpinBox( GroupCoordinates );

  TextLabel_Z = new QLabel( tr( "SMESH_Z" ), GroupCoordinates );
  SpinBox_Z = new SMESHGUI_SpinBox( GroupCoordinates );

  GroupCoordinatesLayout->addWidget( TextLabel_X );
  GroupCoordinatesLayout->addWidget( SpinBox_X ); 
  GroupCoordinatesLayout->addWidget( TextLabel_Y);
  GroupCoordinatesLayout->addWidget( SpinBox_Y );
  GroupCoordinatesLayout->addWidget( TextLabel_Z );
  GroupCoordinatesLayout->addWidget( SpinBox_Z );
  GroupCoordinatesLayout->setStretch(1, 1);
  GroupCoordinatesLayout->setStretch(3, 1);
  GroupCoordinatesLayout->setStretch(5, 1);

  /***************************************************************/
  GroupGroups = new QGroupBox( tr( "SMESH_ADD_TO_GROUP" ), this );
  GroupGroups->setCheckable( true );
  QHBoxLayout* GroupGroupsLayout = new QHBoxLayout(GroupGroups);
  GroupGroupsLayout->setSpacing(SPACING);
  GroupGroupsLayout->setMargin(MARGIN);

  TextLabel_GroupName = new QLabel( tr( "SMESH_GROUP" ), GroupGroups );
  ComboBox_GroupName = new QComboBox( GroupGroups );
  ComboBox_GroupName->setEditable( true );

  GroupGroupsLayout->addWidget( TextLabel_GroupName );
  GroupGroupsLayout->addWidget( ComboBox_GroupName, 1 );

  /***************************************************************/
  GroupButtons = new QGroupBox( this );
  QHBoxLayout* GroupButtonsLayout = new QHBoxLayout( GroupButtons );
  GroupButtonsLayout->setSpacing( SPACING );
  GroupButtonsLayout->setMargin( MARGIN );
  buttonOk = new QPushButton( tr( "SMESH_BUT_APPLY_AND_CLOSE" ), GroupButtons );
  buttonOk->setAutoDefault( true );
  buttonOk->setDefault( true );
  buttonApply = new QPushButton( tr( "SMESH_BUT_APPLY" ), GroupButtons );
  buttonApply->setAutoDefault( true );
  buttonCancel = new QPushButton( tr( "SMESH_BUT_CLOSE" ), GroupButtons );
  buttonCancel->setAutoDefault( true );
  buttonHelp = new QPushButton( tr( "SMESH_BUT_HELP" ), GroupButtons );
  buttonHelp->setAutoDefault( true );

  GroupButtonsLayout->addWidget( buttonOk );
  GroupButtonsLayout->addSpacing( 10 );
  GroupButtonsLayout->addWidget( buttonApply );
  GroupButtonsLayout->addSpacing( 10 );
  GroupButtonsLayout->addStretch();
  GroupButtonsLayout->addWidget( buttonCancel );
  GroupButtonsLayout->addWidget( buttonHelp );

  /***************************************************************/
  SMESHGUI_NodesDlgLayout->addWidget( GroupConstructors );
  SMESHGUI_NodesDlgLayout->addWidget( GroupCoordinates );
  SMESHGUI_NodesDlgLayout->addWidget( GroupGroups );
  SMESHGUI_NodesDlgLayout->addWidget( GroupButtons );

  myHelpFileName = "adding_nodes_and_elements_page.html#adding_nodes_anchor";

  /* Initialisation and display */
  Init();
}

SMESHGUI_NodesDlg::~SMESHGUI_NodesDlg ( )

Definition at line 343 of file SMESHGUI_NodesDlg.cxx.

References mySimulation.

{
  delete mySimulation;
}

Member Function Documentation

void SMESHGUI_NodesDlg::ActivateThisDialog ( ) [private, slot]

Definition at line 689 of file SMESHGUI_NodesDlg.cxx.

References SMESHGUI.EmitSignalDeactivateDialog(), SMESH.GetViewWindow(), GroupButtons, GroupConstructors, GroupCoordinates, mySMESHGUI, SelectionIntoArgument(), and SMESH.SetPointRepresentation().

Referenced by enterEvent().

{
  mySMESHGUI->EmitSignalDeactivateDialog();
  GroupConstructors->setEnabled( true );
  GroupCoordinates->setEnabled( true );
  GroupButtons->setEnabled( true );

  SMESH::SetPointRepresentation( true );
  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ) )
    aViewWindow->SetSelectionMode( NodeSelection );

  SelectionIntoArgument();
}

bool SMESHGUI_NodesDlg::ClickOnApply ( ) [private, slot]

Definition at line 423 of file SMESHGUI_NodesDlg.cxx.

References SMESH.AddGroup(), SMESH.AddNode(), SMESH_controls.aGroup, ComboBox_GroupName, SMESH.GetCurrentVtkView(), SMESHGUI.GetSMESHGUI(), SMESHGUI_SpinBox.GetValue(), GroupGroups, SMESHGUI.isActiveStudyLocked(), isValid(), SMESHGUI.Modified(), myGroups, myMesh, mySelectionMgr, mySimulation, mySMESHGUI, SMESH.NODE, SMESH_AdvancedEditor.res, SMESH.SetPointRepresentation(), SMESH.TNodeSimulation.SetVisibility(), SpinBox_X, SpinBox_Y, SpinBox_Z, SMESH.UpdateView(), ex13_hole1partial.x, and ex13_hole1partial.y.

Referenced by ClickOnOk(), and Init().

{
  if ( mySMESHGUI->isActiveStudyLocked() )
    return false;

  if ( myMesh->_is_nil() ) {
    SUIT_MessageBox::warning( this, tr( "SMESH_WRN_WARNING" ),
                              tr( "MESH_IS_NOT_SELECTED" ) );
    return false;
  }

  if( !isValid() )
    return false;

  /* Recup args and call method */
  double x = SpinBox_X->GetValue();
  double y = SpinBox_Y->GetValue();
  double z = SpinBox_Z->GetValue();

  QStringList aParameters;
  aParameters << SpinBox_X->text();
  aParameters << SpinBox_Y->text();
  aParameters << SpinBox_Z->text();

  bool addToGroup = GroupGroups->isChecked();
  QString aGroupName;

  SMESH::SMESH_GroupBase_var aGroup;
  int idx = 0;
  if( addToGroup ) {
    aGroupName = ComboBox_GroupName->currentText();
    for ( int i = 1; i < ComboBox_GroupName->count(); i++ ) {
      QString aName = ComboBox_GroupName->itemText( i );
      if ( aGroupName == aName && ( i == ComboBox_GroupName->currentIndex() || idx == 0 ) )
        idx = i;
    }
    if ( idx > 0 ) {
      SMESH::SMESH_GroupOnGeom_var aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( myGroups[idx-1] );
      if ( !aGeomGroup->_is_nil() ) {
        int res = SUIT_MessageBox::question( this, tr( "SMESH_WRN_WARNING" ),
                                             tr( "MESH_STANDALONE_GRP_CHOSEN" ).arg( aGroupName ),
                                             tr( "SMESH_BUT_YES" ), tr( "SMESH_BUT_NO" ), 0, 1 );
        if ( res == 1 ) return false;
      }
      aGroup = myGroups[idx-1];
    }
  }
      
  mySimulation->SetVisibility( false );

  long aNodeId = SMESH::AddNode( myMesh, x, y, z, aParameters );

  SMESH::SetPointRepresentation( true );

  if ( aNodeId != -1 && addToGroup && !aGroupName.isEmpty() ) {
    SMESH::SMESH_Group_var aGroupUsed;
    if ( aGroup->_is_nil() ){
      // create new group 
      aGroupUsed = SMESH::AddGroup( myMesh, SMESH::NODE, aGroupName );
      if ( !aGroupUsed->_is_nil() ) {
        myGroups.append(SMESH::SMESH_GroupBase::_duplicate(aGroupUsed));
        ComboBox_GroupName->addItem( aGroupName );
      }
    }
    else {
      SMESH::SMESH_GroupOnGeom_var aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGroup );
      if ( !aGeomGroup->_is_nil() ) {
        aGroupUsed = myMesh->ConvertToStandalone( aGeomGroup );
        if ( !aGroupUsed->_is_nil() && idx > 0 ) {
          myGroups[idx-1] = SMESH::SMESH_GroupBase::_duplicate(aGroupUsed);
          SMESHGUI::GetSMESHGUI()->getApp()->updateObjectBrowser();
        }
      }
      else
        aGroupUsed = SMESH::SMESH_Group::_narrow( aGroup );
    }

    if ( !aGroupUsed->_is_nil() ) {
      SMESH::long_array_var anIdList = new SMESH::long_array;
      anIdList->length( 1 );
      anIdList[0] = aNodeId;
      aGroupUsed->Add( anIdList.inout() );
    }
  }

  // select myMesh
  SALOME_ListIO aList;
  mySelectionMgr->selectedObjects( aList );
  if ( aList.Extent() != 1 ) {
    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetCurrentVtkView() ) {
      VTK::ActorCollectionCopy aCopy(aViewWindow->getRenderer()->GetActors());
      vtkActorCollection *aCollection = aCopy.GetActors();
      aCollection->InitTraversal();
      while ( vtkActor *anAct = aCollection->GetNextActor() ) {
        if ( SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>( anAct ) ) {
          if ( anActor->hasIO() ) {
            if ( SMESH_MeshObj *aMeshObj = dynamic_cast<SMESH_MeshObj*>( anActor->GetObject().get() ) ) {
              if ( myMesh->_is_equivalent( aMeshObj->GetMeshServer() ) ) {
                aList.Clear();
                aList.Append( anActor->getIO() );
                mySelectionMgr->setSelectedObjects( aList, false );
                break;
              }
            }
          }
        }
      }
    }
  }

  SMESHGUI::Modified();
  SMESH::UpdateView();
  mySimulation->SetVisibility(false);

  return true;
}

void SMESHGUI_NodesDlg::ClickOnCancel ( ) [private, slot]

Definition at line 544 of file SMESHGUI_NodesDlg.cxx.

References SMESH.GetViewWindow(), mySelectionMgr, mySimulation, mySMESHGUI, SMESHGUI.ResetState(), SMESH.SetPointRepresentation(), and SMESH.TNodeSimulation.SetVisibility().

Referenced by ClickOnOk(), closeEvent(), hideEvent(), and Init().

{
  disconnect( mySelectionMgr, 0, this, 0 );
  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ) )
    aViewWindow->SetSelectionMode( ActorSelection );

  mySimulation->SetVisibility( false );
  SMESH::SetPointRepresentation( false );
  mySMESHGUI->ResetState();

  reject();
}

void SMESHGUI_NodesDlg::ClickOnHelp ( ) [private, slot]

Definition at line 561 of file SMESHGUI_NodesDlg.cxx.

References myHelpFileName, and mySMESHGUI.

Referenced by Init(), and keyPressEvent().

{
  LightApp_Application* app = (LightApp_Application*)( SUIT_Session::session()->activeApplication() );
  if ( app ) 
    app->onHelpContextModule( mySMESHGUI ? app->moduleName( mySMESHGUI->moduleName() ) : 
                              QString( "" ), myHelpFileName );
  else {
    QString platform;
#ifdef WIN32
    platform = "winapplication";
#else
    platform = "application";
#endif
    SUIT_MessageBox::warning( this, tr("WRN_WARNING"),
                              tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
                              arg( app->resourceMgr()->stringValue( "ExternalBrowser", 
                                                                    platform ) ).
                              arg( myHelpFileName ) );
  }
}

void SMESHGUI_NodesDlg::ClickOnOk ( ) [private, slot]

Definition at line 413 of file SMESHGUI_NodesDlg.cxx.

References ClickOnApply(), and ClickOnCancel().

Referenced by Init().

{
  if ( ClickOnApply() )
    ClickOnCancel();
}

void SMESHGUI_NodesDlg::closeEvent ( QCloseEvent * ) [private]

Definition at line 644 of file SMESHGUI_NodesDlg.cxx.

References ClickOnCancel().

{
  this->ClickOnCancel(); /* same than click on cancel button */
}

void SMESHGUI_NodesDlg::DeactivateActiveDialog ( ) [private, slot]

Definition at line 673 of file SMESHGUI_NodesDlg.cxx.

References GroupButtons, GroupConstructors, GroupCoordinates, mySimulation, mySMESHGUI, SMESHGUI.ResetState(), SMESHGUI.SetActiveDialogBox(), and SMESH.TNodeSimulation.SetVisibility().

Referenced by Init().

{
  if ( GroupConstructors->isEnabled() ) {
    GroupConstructors->setEnabled( false );
    GroupCoordinates->setEnabled( false );
    GroupButtons->setEnabled( false );
    mySimulation->SetVisibility( false );
    mySMESHGUI->ResetState();
    mySMESHGUI->SetActiveDialogBox( 0 );
  }
}

void SMESHGUI_NodesDlg::enterEvent ( QEvent * ) [private]

Definition at line 663 of file SMESHGUI_NodesDlg.cxx.

References ActivateThisDialog(), and GroupConstructors.

{
  if ( !GroupConstructors->isEnabled() )
    ActivateThisDialog();
}

void SMESHGUI_NodesDlg::hideEvent ( QHideEvent * ) [private]

Definition at line 653 of file SMESHGUI_NodesDlg.cxx.

References ClickOnCancel().

{
  if ( !isMinimized() )
    ClickOnCancel();
}

void SMESHGUI_NodesDlg::Init ( ) [private]

Definition at line 352 of file SMESHGUI_NodesDlg.cxx.

References buttonApply, buttonCancel, buttonHelp, buttonOk, ClickOnApply(), ClickOnCancel(), ClickOnHelp(), ClickOnOk(), COORD_MAX, COORD_MIN, DeactivateActiveDialog(), SMESH.GetViewWindow(), GroupGroups, mySelectionMgr, mySMESHGUI, SMESHGUI_SpinBox.RangeStepAndValidator(), SelectionIntoArgument(), SMESHGUI.SetActiveDialogBox(), SMESH.SetPointRepresentation(), SMESHGUI_SpinBox.SetValue(), SpinBox_X, SpinBox_Y, SpinBox_Z, and ValueChangedInSpinBox().

Referenced by SMESHGUI_NodesDlg().

{
  /* Get setting of step value from file configuration */
  double step = 25.0;

  /* min, max, step and decimals for spin boxes */
  SpinBox_X->RangeStepAndValidator( COORD_MIN, COORD_MAX, step, "length_precision" );
  SpinBox_Y->RangeStepAndValidator( COORD_MIN, COORD_MAX, step, "length_precision" );
  SpinBox_Z->RangeStepAndValidator( COORD_MIN, COORD_MAX, step, "length_precision" );
  SpinBox_X->SetValue( 0.0 );
  SpinBox_Y->SetValue( 0.0 );
  SpinBox_Z->SetValue( 0.0 );

  /* reset "Add to group" control */
  GroupGroups->setChecked( false );

  mySMESHGUI->SetActiveDialogBox( this );

  /* signals and slots connections */
  connect( buttonOk,     SIGNAL( clicked() ), this, SLOT( ClickOnOk() ) );
  connect( buttonCancel, SIGNAL( clicked() ), this, SLOT( ClickOnCancel() ) );
  connect( buttonApply,  SIGNAL( clicked() ), this, SLOT( ClickOnApply() ) );
  connect( buttonHelp,   SIGNAL( clicked() ), this, SLOT( ClickOnHelp() ) );

  connect( SpinBox_X, SIGNAL( valueChanged( double ) ), SLOT( ValueChangedInSpinBox( double ) ) );
  connect( SpinBox_Y, SIGNAL( valueChanged( double ) ), SLOT( ValueChangedInSpinBox( double ) ) );
  connect( SpinBox_Z, SIGNAL( valueChanged( double ) ), SLOT( ValueChangedInSpinBox( double ) ) );

  connect( mySelectionMgr, SIGNAL( currentSelectionChanged() ),      SLOT( SelectionIntoArgument() ) );
  connect( mySMESHGUI,     SIGNAL( SignalDeactivateActiveDialog() ), SLOT( DeactivateActiveDialog() ) );
  /* to close dialog if study frame change */
  connect( mySMESHGUI,     SIGNAL( SignalStudyFrameChanged() ),      SLOT( ClickOnCancel() ) );
  connect(mySMESHGUI,      SIGNAL(SignalCloseAllDialogs()),          SLOT(ClickOnCancel()));

  // set selection mode
  SMESH::SetPointRepresentation( true );
  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ) )
    aViewWindow->SetSelectionMode( NodeSelection );

  SelectionIntoArgument();
}

bool SMESHGUI_NodesDlg::isValid ( ) [private]

Definition at line 723 of file SMESHGUI_NodesDlg.cxx.

References ComboBox_GroupName, GroupGroups, SpinBox_X, SpinBox_Y, and SpinBox_Z.

Referenced by ClickOnApply().

{
  QString msg;
  bool ok = true;
  ok = SpinBox_X->isValid( msg, true ) && ok;
  ok = SpinBox_Y->isValid( msg, true ) && ok;
  ok = SpinBox_Z->isValid( msg, true ) && ok;

  if( !ok ) {
    QString str( tr( "SMESH_INCORRECT_INPUT" ) );
    if ( !msg.isEmpty() )
      str += "\n" + msg;
    SUIT_MessageBox::critical( this, tr( "SMESH_ERROR" ), str );
    return false;
  }

  if( GroupGroups->isChecked() && ComboBox_GroupName->currentText().isEmpty() ) {
    SUIT_MessageBox::warning( this, tr( "SMESH_WRN_WARNING" ), tr( "GROUP_NAME_IS_EMPTY" ) );
    return false;
  }
  return true;
}

void SMESHGUI_NodesDlg::keyPressEvent ( QKeyEvent * e ) [private]

Definition at line 707 of file SMESHGUI_NodesDlg.cxx.

References ClickOnHelp().

{
  QDialog::keyPressEvent( e );
  if ( e->isAccepted() )
    return;

  if ( e->key() == Qt::Key_F1 ) {
    e->accept();
    ClickOnHelp();
  }
}

void SMESHGUI_NodesDlg::SelectionIntoArgument ( ) [private, slot]

Definition at line 586 of file SMESHGUI_NodesDlg.cxx.

References SMESH_controls.aGroup, ComboBox_GroupName, SMESH.FindActorByObject(), SMESH.GetMeshByIO(), SMESH.GetNameOfSelectedNodes(), SMESHGUI_SpinBox.GetValue(), GroupConstructors, Handle(), myEntry, myGroups, myMesh, mySelector, mySimulation, SMESH.NODE, SMESH.SetPointRepresentation(), SMESH.TNodeSimulation.SetPosition(), SMESHGUI_SpinBox.SetValue(), SMESH.TNodeSimulation.SetVisibility(), SpinBox_X, SpinBox_Y, and SpinBox_Z.

Referenced by ActivateThisDialog(), and Init().

{
  if ( !GroupConstructors->isEnabled() )
    return;

  mySimulation->SetVisibility( false );
  SMESH::SetPointRepresentation( true );

  QString aCurrentEntry = myEntry;

  const SALOME_ListIO& aList = mySelector->StoredIObjects();
  if ( aList.Extent() == 1 ) {
    Handle(SALOME_InteractiveObject) anIO = aList.First();
    if ( anIO->hasEntry() ) {
      myEntry = anIO->getEntry();
      myMesh = SMESH::GetMeshByIO( anIO );
      if ( myMesh->_is_nil() ) return;
      QString aText;
      if ( SMESH::GetNameOfSelectedNodes( mySelector, anIO, aText ) == 1 ) {
        if ( SMESH_Actor* anActor = SMESH::FindActorByObject( myMesh.in() ) ) {
          if ( SMDS_Mesh* aMesh = anActor->GetObject()->GetMesh() ) {
            if ( const SMDS_MeshNode* aNode = aMesh->FindNode( aText.toInt() ) ) {
              SpinBox_X->SetValue( aNode->X() );
              SpinBox_Y->SetValue( aNode->Y() );
              SpinBox_Z->SetValue( aNode->Z() );
            }
          }
        }
      }
      mySimulation->SetPosition( SpinBox_X->GetValue(),
                                 SpinBox_Y->GetValue(),
                                 SpinBox_Z->GetValue() );
    }
  }

  // process groups
  if ( !myMesh->_is_nil() && myEntry != aCurrentEntry ) {
    myGroups.clear();
    ComboBox_GroupName->clear();
    ComboBox_GroupName->addItem( QString() );
    SMESH::ListOfGroups aListOfGroups = *myMesh->GetGroups();
    for( int i = 0, n = aListOfGroups.length(); i < n; i++ ) {
      SMESH::SMESH_GroupBase_var aGroup = aListOfGroups[i];
      if ( !aGroup->_is_nil() && aGroup->GetType() == SMESH::NODE ) {
        QString aGroupName( aGroup->GetName() );
        if ( !aGroupName.isEmpty() ) {
          myGroups.append(SMESH::SMESH_GroupBase::_duplicate(aGroup));
          ComboBox_GroupName->addItem( aGroupName );
        }
      }
    }
  }
}

void SMESHGUI_NodesDlg::ValueChangedInSpinBox ( double newValue ) [private, slot]

Definition at line 398 of file SMESHGUI_NodesDlg.cxx.

References SMESHGUI_SpinBox.GetValue(), myMesh, mySimulation, SMESH.TNodeSimulation.SetPosition(), SpinBox_X, SpinBox_Y, SpinBox_Z, SMESH_fixation.vx, SMESH_fixation.vy, and SMESH_fixation.vz.

Referenced by Init().

{
  if ( !myMesh->_is_nil() ) {
    double vx = SpinBox_X->GetValue();
    double vy = SpinBox_Y->GetValue();
    double vz = SpinBox_Z->GetValue();

    mySimulation->SetPosition( vx, vy, vz );
  }
}