#include <SMESHGUI_MergeDlg.h>

Inheritance diagram for SMESHGUI_MergeDlg:

Public Member Functions
	SMESHGUI_MergeDlg (SMESHGUI *, int)
	~SMESHGUI_MergeDlg ()
Private Types
typedef QList < SMESH::SMESH_GroupBase_var >	GrpList
Private Slots
void	ClickOnOk ()
void	ClickOnCancel ()
bool	ClickOnApply ()
void	ClickOnHelp ()
void	updateControls ()
void	onDetect ()
void	onAddGroup ()
void	onRemoveGroup ()
void	onSelectGroup ()
void	onSelectAll (bool)
void	onSelectElementFromGroup ()
void	onAddElement ()
void	onRemoveElement ()
void	onSetFirst ()
void	SetEditCurrentArgument ()
void	SelectionIntoArgument ()
void	DeactivateActiveDialog ()
void	ActivateThisDialog ()
void	onTypeChanged (int)
Private Member Functions
void	Init ()
void	closeEvent (QCloseEvent *)
void	enterEvent (QEvent *)
void	hideEvent (QHideEvent *)
void	keyPressEvent (QKeyEvent *)
void	onEditGroup ()
void	FindGravityCenter (TColStd_MapOfInteger &, std::list< gp_XYZ > &)
Private Attributes
SMESHGUI *	mySMESHGUI
LightApp_SelectionMgr *	mySelectionMgr
SVTK_Selector *	mySelector
QWidget *	myEditCurrentArgument
SMESH::SMESH_Mesh_var	myMesh
SMESH::SMESH_IDSource_var	mySubMeshOrGroup
SMESH_Actor *	myActor
SUIT_SelectionFilter *	myMeshOrSubMeshOrGroupFilter
SMESH::TIdPreview *	myIdPreview
int	myAction
bool	myIsBusy
int	myTypeId
QGroupBox *	GroupConstructors
QRadioButton *	RadioButton
QGroupBox *	GroupButtons
QPushButton *	buttonOk
QPushButton *	buttonCancel
QPushButton *	buttonApply
QPushButton *	buttonHelp
QGroupBox *	GroupMesh
QLabel *	TextLabelName
QPushButton *	SelectMeshButton
QLineEdit *	LineEditMesh
QGroupBox *	GroupCoincident
QWidget *	GroupCoincidentWidget
QLabel *	TextLabelTolerance
SMESHGUI_SpinBox *	SpinBoxTolerance
QPushButton *	DetectButton
QListWidget *	ListCoincident
QPushButton *	AddGroupButton
QPushButton *	RemoveGroupButton
QCheckBox *	SelectAllCB
QGroupBox *	GroupEdit
QListWidget *	ListEdit
QPushButton *	AddElemButton
QPushButton *	RemoveElemButton
QPushButton *	SetFirstButton
QGroupBox *	GroupExclude
QListWidget *	ListExclude
QGroupBox *	TypeBox
QButtonGroup *	GroupType
QString	myHelpFileName
QString	myEntry
GrpList	myGroups

Detailed Description

Definition at line 71 of file SMESHGUI_MergeDlg.h.

Member Typedef Documentation

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

Definition at line 92 of file SMESHGUI_MergeDlg.h.

Constructor & Destructor Documentation

SMESHGUI_MergeDlg::SMESHGUI_MergeDlg	(	SMESHGUI *	theModule,
		int	theAction
	)

Definition at line 309 of file SMESHGUI_MergeDlg.cxx.

References AddElemButton, AddGroupButton, buttonApply, buttonCancel, buttonHelp, buttonOk, DetectButton, SMESH.GetResourceMgr(), SMESH.GetViewWindow(), GroupButtons, GroupCoincident, GroupCoincidentWidget, GroupConstructors, GroupEdit, GroupExclude, GroupMesh, GroupType, IconFirst, Init(), LineEditMesh, ListCoincident, ListEdit, ListExclude, MARGIN, myAction, myIdPreview, mySMESHGUI, myTypeId, RadioButton, RemoveElemButton, RemoveGroupButton, SelectAllCB, SelectMeshButton, SetFirstButton, SPACING, SpinBoxTolerance, TextLabelName, TextLabelTolerance, and TypeBox.

  : QDialog(SMESH::GetDesktop(theModule)),
    mySMESHGUI(theModule),
    mySelectionMgr(SMESH::GetSelectionMgr(theModule)),
    myAction(theAction)
{
  setModal(false);
  setAttribute(Qt::WA_DeleteOnClose, true);
  setWindowTitle(myAction == 1 ? tr("SMESH_MERGE_ELEMENTS") : tr("SMESH_MERGE_NODES"));

  myIdPreview = new SMESH::TIdPreview(SMESH::GetViewWindow( mySMESHGUI ));

  SUIT_ResourceMgr* aResMgr = SMESH::GetResourceMgr( mySMESHGUI );
  QPixmap IconMergeNodes (aResMgr->loadPixmap("SMESH", tr("ICON_SMESH_MERGE_NODES")));
  QPixmap IconMergeElems (aResMgr->loadPixmap("SMESH", tr("ICON_DLG_MERGE_ELEMENTS")));
  QPixmap IconSelect     (aResMgr->loadPixmap("SMESH", tr("ICON_SELECT")));
  QPixmap IconAdd        (aResMgr->loadPixmap("SMESH", tr("ICON_APPEND")));
  QPixmap IconRemove     (aResMgr->loadPixmap("SMESH", tr("ICON_REMOVE")));

  setSizeGripEnabled(true);

  QVBoxLayout* DlgLayout = new QVBoxLayout(this);
  DlgLayout->setSpacing(SPACING);
  DlgLayout->setMargin(MARGIN);

  /***************************************************************/
  GroupConstructors = new QGroupBox(myAction == 1 ? 
                                    tr("SMESH_MERGE_ELEMENTS") : 
                                    tr("SMESH_MERGE_NODES"), 
                                    this);

  QButtonGroup* ButtonGroup = new QButtonGroup(this);
  QHBoxLayout* GroupConstructorsLayout = new QHBoxLayout(GroupConstructors);
  GroupConstructorsLayout->setSpacing(SPACING);
  GroupConstructorsLayout->setMargin(MARGIN);

  RadioButton = new QRadioButton(GroupConstructors);
  RadioButton->setIcon(myAction == 1 ? IconMergeElems : IconMergeNodes);
  RadioButton->setChecked(true);
  GroupConstructorsLayout->addWidget(RadioButton);
  ButtonGroup->addButton(RadioButton, 0);

  /***************************************************************/
  // Controls for mesh defining
  GroupMesh = new QGroupBox(tr("SMESH_SELECT_WHOLE_MESH"), this);
  QHBoxLayout* GroupMeshLayout = new QHBoxLayout(GroupMesh);
  GroupMeshLayout->setSpacing(SPACING);
  GroupMeshLayout->setMargin(MARGIN);

  TextLabelName = new QLabel(tr("SMESH_NAME"), GroupMesh);
  SelectMeshButton = new QPushButton(GroupMesh);
  SelectMeshButton->setIcon(IconSelect);
  LineEditMesh = new QLineEdit(GroupMesh);
  LineEditMesh->setReadOnly(true);

  GroupMeshLayout->addWidget(TextLabelName);
  GroupMeshLayout->addWidget(SelectMeshButton);
  GroupMeshLayout->addWidget(LineEditMesh);

  /***************************************************************/
  // Controls for switch dialog behaviour

  TypeBox = new QGroupBox( tr( "SMESH_MODE" ), this );
  GroupType = new QButtonGroup( this );
  QHBoxLayout* aTypeBoxLayout = new QHBoxLayout( TypeBox );
  aTypeBoxLayout->setMargin( MARGIN );
  aTypeBoxLayout->setSpacing( SPACING );

  QRadioButton* rb1 = new QRadioButton( tr( "SMESH_AUTOMATIC" ), TypeBox );
  QRadioButton* rb2 = new QRadioButton( tr( "SMESH_MANUAL" ),   TypeBox );
  GroupType->addButton( rb1, 0 );
  GroupType->addButton( rb2, 1 );
  aTypeBoxLayout->addWidget( rb1 );
  aTypeBoxLayout->addWidget( rb2 );

  myTypeId = 0;

  /***************************************************************/
  // Controls for coincident elements detecting
  GroupCoincident = new QGroupBox(myAction == 1 ? 
                                  tr("COINCIDENT_ELEMENTS") : 
                                  tr("COINCIDENT_NODES"), 
                                  this);

  QVBoxLayout* aCoincidentLayout = new QVBoxLayout(GroupCoincident);
  aCoincidentLayout->setSpacing(SPACING);
  aCoincidentLayout->setMargin(MARGIN);

  if (myAction == 0) { // case merge nodes
    QWidget* foo = new QWidget(GroupCoincident);
    TextLabelTolerance = new QLabel(tr("SMESH_TOLERANCE"), foo);
    SpinBoxTolerance = new SMESHGUI_SpinBox(foo);
    SpinBoxTolerance->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));

    GroupExclude = new QGroupBox(tr("EXCLUDE_GROUPS"), foo);
    GroupExclude->setCheckable( true );
    GroupExclude->setChecked( false );
    ListExclude = new QListWidget( GroupExclude );
    QVBoxLayout* GroupExcludeLayout = new QVBoxLayout(GroupExclude);
    GroupExcludeLayout->setSpacing(SPACING);
    GroupExcludeLayout->setMargin(MARGIN);
    GroupExcludeLayout->addWidget(ListExclude);

    QGridLayout* fooLayout = new QGridLayout( foo );
    fooLayout->setSpacing(SPACING);
    fooLayout->setMargin(0);
    fooLayout->addWidget(TextLabelTolerance, 0, 0 );
    fooLayout->addWidget(SpinBoxTolerance,   0, 1 );
    fooLayout->addWidget(GroupExclude,       1, 0, 1, 2 );
    aCoincidentLayout->addWidget(foo);
  }
  else {
    TextLabelTolerance = 0;
    SpinBoxTolerance = 0;
    GroupExclude = 0;
    ListExclude = 0;
  }

  GroupCoincidentWidget = new QWidget(GroupCoincident);
  QGridLayout* GroupCoincidentLayout = new QGridLayout(GroupCoincidentWidget);
  GroupCoincidentLayout->setSpacing(SPACING);
  GroupCoincidentLayout->setMargin(0);

  ListCoincident = new QListWidget(GroupCoincidentWidget);
  ListCoincident->setSelectionMode(QListWidget::ExtendedSelection);

  DetectButton      = new QPushButton(tr("DETECT"),           GroupCoincidentWidget);
  AddGroupButton    = new QPushButton(tr("SMESH_BUT_ADD"),    GroupCoincidentWidget);
  RemoveGroupButton = new QPushButton(tr("SMESH_BUT_REMOVE"), GroupCoincidentWidget);

  SelectAllCB = new QCheckBox(tr("SELECT_ALL"), GroupCoincidentWidget);

  GroupCoincidentLayout->addWidget(ListCoincident,    0,   0, 4, 2);
  GroupCoincidentLayout->addWidget(DetectButton,      0,   2);
  GroupCoincidentLayout->addWidget(AddGroupButton,    2, 2);
  GroupCoincidentLayout->addWidget(RemoveGroupButton, 3, 2);
  GroupCoincidentLayout->addWidget(SelectAllCB,       4, 0, 1, 3);
  GroupCoincidentLayout->setRowMinimumHeight(1, 10);
  GroupCoincidentLayout->setRowStretch(1, 5);

  aCoincidentLayout->addWidget(GroupCoincidentWidget);

  /***************************************************************/
  // Controls for editing the selected group
  GroupEdit = new QGroupBox(tr("EDIT_SELECTED_GROUP"), this);
  QGridLayout* GroupEditLayout = new QGridLayout(GroupEdit);
  GroupEditLayout->setSpacing(SPACING);
  GroupEditLayout->setMargin(MARGIN);

  ListEdit = new QListWidget(GroupEdit);
  //ListEdit->setRowMode(QListBox::FixedNumber);
  //ListEdit->setHScrollBarMode(QScrollView::AlwaysOn);
  //ListEdit->setVScrollBarMode(QScrollView::AlwaysOff);
  ListEdit->setFlow( QListView::LeftToRight );
  ListEdit->setSelectionMode(QListWidget::ExtendedSelection);

  AddElemButton = new QPushButton(GroupEdit);
  AddElemButton->setIcon(IconAdd);
  RemoveElemButton = new QPushButton(GroupEdit);
  RemoveElemButton->setIcon(IconRemove);
  SetFirstButton = new QPushButton(GroupEdit);
  SetFirstButton->setIcon(QPixmap(IconFirst));

  GroupEditLayout->addWidget(ListEdit,         0, 0, 2, 1);
  GroupEditLayout->addWidget(AddElemButton,    0, 1);
  GroupEditLayout->addWidget(RemoveElemButton, 0, 2);
  GroupEditLayout->addWidget(SetFirstButton,   1, 1, 1, 2);

  /***************************************************************/
  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);

  /***************************************************************/
  DlgLayout->addWidget(GroupConstructors);
  DlgLayout->addWidget(GroupMesh);
  DlgLayout->addWidget(TypeBox);
  DlgLayout->addWidget(GroupCoincident);
  DlgLayout->addWidget(GroupEdit);
  DlgLayout->addWidget(GroupButtons);

  GroupCoincidentWidget->setVisible( myAction != 0 );
  GroupCoincident->setVisible( myAction == 0 );
  //if GroupExclude->setVisible( myAction == 0 );
  GroupEdit->hide();

  this->resize(10,10);

  Init(); // Initialisations
}

SMESHGUI_MergeDlg::~SMESHGUI_MergeDlg ( )

Definition at line 523 of file SMESHGUI_MergeDlg.cxx.

References myIdPreview.

{
  delete myIdPreview;
}

Member Function Documentation

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

Definition at line 1203 of file SMESHGUI_MergeDlg.cxx.

References SMESHGUI.EmitSignalDeactivateDialog(), GroupButtons, GroupCoincident, GroupConstructors, GroupEdit, GroupMesh, mySelectionMgr, mySMESHGUI, SelectionIntoArgument(), SMESHGUI.SetActiveDialogBox(), and TypeBox.

Referenced by enterEvent().

{
  /* Emit a signal to deactivate the active dialog */
  mySMESHGUI->EmitSignalDeactivateDialog();
  GroupConstructors->setEnabled(true);
  TypeBox->setEnabled(true);
  GroupMesh->setEnabled(true);
  GroupCoincident->setEnabled(true);
  GroupEdit->setEnabled(true);
  GroupButtons->setEnabled(true);

  connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
  mySMESHGUI->SetActiveDialogBox((QDialog*)this);
  SelectionIntoArgument();
}

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

Definition at line 627 of file SMESHGUI_MergeDlg.cxx.

References SMESH_BelongToGeom.anIds, SMESHGUI.desktop(), SMESHGUI.isActiveStudyLocked(), ListCoincident, SMESHGUI.Modified(), myAction, myMesh, mySMESHGUI, myTypeId, onDetect(), and SMESH.UpdateView().

Referenced by ClickOnOk(), and Init().

{
  if (mySMESHGUI->isActiveStudyLocked() || myMesh->_is_nil())
    return false;

  try {
    if (myTypeId == 0)
      onDetect();

    SUIT_OverrideCursor aWaitCursor;
    SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();

    SMESH::long_array_var anIds = new SMESH::long_array;
    SMESH::array_of_long_array_var aGroupsOfElements = new SMESH::array_of_long_array;

    if ( ListCoincident->count() == 0) {
      if (myAction == 0)
        SUIT_MessageBox::warning(this,
                                 tr("SMESH_WARNING"),
                                 tr("SMESH_NO_NODES_DETECTED"));
      else
        SUIT_MessageBox::warning(this,
                                 tr("SMESH_WARNING"),
                                 tr("SMESH_NO_ELEMENTS_DETECTED"));
      return false;
    }

    aGroupsOfElements->length(ListCoincident->count());

    int anArrayNum = 0;
    for (int i = 0; i < ListCoincident->count(); i++) {
      QStringList aListIds = ListCoincident->item(i)->text().split(" ", QString::SkipEmptyParts);

      anIds->length(aListIds.count());
      for (int i = 0; i < aListIds.count(); i++)
        anIds[i] = aListIds[i].toInt();

      aGroupsOfElements[anArrayNum++] = anIds.inout();
    }

    if( myAction == 0 )
      aMeshEditor->MergeNodes (aGroupsOfElements.inout());
    else
      aMeshEditor->MergeElements (aGroupsOfElements.inout());

    if ( myTypeId == 0 ) {
      if (myAction ==0)
        SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INFORMATION"),
                                     tr("SMESH_MERGED_NODES").arg(QString::number(ListCoincident->count()).toLatin1().data()));
      else
        SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INFORMATION"),
                                     tr("SMESH_MERGED_ELEMENTS").arg(QString::number(ListCoincident->count()).toLatin1().data()));
    }
      

  } catch(...) {
  }
  
  ListCoincident->clear();
  
  SMESH::UpdateView();
  SMESHGUI::Modified();
  
  return true;
}

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

Definition at line 707 of file SMESHGUI_MergeDlg.cxx.

References SMESH.GetViewWindow(), myIdPreview, mySelectionMgr, mySMESHGUI, SMESHGUI.ResetState(), SMESH.SetPointRepresentation(), and SMESH.TIdPreview.SetPointsLabeled().

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

{
  myIdPreview->SetPointsLabeled(false);
  SMESH::SetPointRepresentation(false);
  disconnect(mySelectionMgr, 0, this, 0);
  disconnect(mySMESHGUI, 0, this, 0);
  mySMESHGUI->ResetState();

  mySelectionMgr->clearFilters();
  //mySelectionMgr->clearSelected();

  if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
    aViewWindow->SetSelectionMode(ActorSelection);

  reject();
}

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

Definition at line 728 of file SMESHGUI_MergeDlg.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_MergeDlg::ClickOnOk ( ) [private, slot]

Definition at line 697 of file SMESHGUI_MergeDlg.cxx.

References ClickOnApply(), and ClickOnCancel().

Referenced by Init().

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

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

Definition at line 1233 of file SMESHGUI_MergeDlg.cxx.

References ClickOnCancel().

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

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

Definition at line 1182 of file SMESHGUI_MergeDlg.cxx.

References GroupButtons, GroupCoincident, GroupConstructors, GroupEdit, GroupMesh, mySelectionMgr, mySMESHGUI, SMESHGUI.ResetState(), SMESHGUI.SetActiveDialogBox(), and TypeBox.

Referenced by Init().

{
  if (GroupConstructors->isEnabled()) {
    GroupConstructors->setEnabled(false);
    TypeBox->setEnabled(false);
    GroupMesh->setEnabled(false);
    GroupCoincident->setEnabled(false);
    GroupEdit->setEnabled(false);
    GroupButtons->setEnabled(false);
    mySMESHGUI->ResetState();
    mySMESHGUI->SetActiveDialogBox(0);
  }

  mySelectionMgr->clearSelected();
  disconnect(mySelectionMgr, 0, this, 0);
}

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

Definition at line 1223 of file SMESHGUI_MergeDlg.cxx.

References ActivateThisDialog(), and GroupConstructors.

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

void SMESHGUI_MergeDlg::FindGravityCenter	(	TColStd_MapOfInteger &	theElemsIdMap,
		std::list< gp_XYZ > &	theGrCentersXYZ
	)		`[private]`

Definition at line 592 of file SMESHGUI_MergeDlg.cxx.

References SMDS_Mesh.FindElement(), SMESH_Actor.GetObject(), myActor, ex29_refine.node(), SMDS_MeshElement.nodesIterator(), SMDS_MeshNode.X(), SMDS_MeshNode.Y(), and SMDS_MeshNode.Z().

Referenced by onSelectElementFromGroup(), and onSelectGroup().

{
  if (!myActor)
    return;

  SMDS_Mesh* aMesh = 0;
  aMesh = myActor->GetObject()->GetMesh();
  if (!aMesh)
    return;

  int nbNodes;

  TColStd_MapIteratorOfMapOfInteger idIter( theElemsIdMap );
  for( ; idIter.More(); idIter.Next() ) {
    const SMDS_MeshElement* anElem = aMesh->FindElement(idIter.Key());
    if ( !anElem )
      continue;

    gp_XYZ anXYZ(0., 0., 0.);
    SMDS_ElemIteratorPtr nodeIt = anElem->nodesIterator();
    for ( nbNodes = 0; nodeIt->more(); nbNodes++ ) {
      const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
      anXYZ.Add( gp_XYZ( node->X(), node->Y(), node->Z() ) );
    }
    anXYZ.Divide( nbNodes );
    
    theGrCentersXYZ.push_back( anXYZ );
  }
}

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

Definition at line 1243 of file SMESHGUI_MergeDlg.cxx.

References ClickOnCancel().

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

void SMESHGUI_MergeDlg::Init ( ) [private]

Definition at line 532 of file SMESHGUI_MergeDlg.cxx.

References AddElemButton, AddGroupButton, buttonApply, buttonCancel, buttonHelp, buttonOk, ClickOnApply(), ClickOnCancel(), ClickOnHelp(), ClickOnOk(), COORD_MAX, DeactivateActiveDialog(), DetectButton, SMESH.GetSelector(), SMESH.GetViewWindow(), GroupType, LineEditMesh, ListCoincident, ListEdit, myAction, myActor, myEditCurrentArgument, myHelpFileName, myIsBusy, mySelectionMgr, mySelector, mySMESHGUI, mySubMeshOrGroup, onAddElement(), onAddGroup(), onDetect(), onRemoveElement(), onRemoveGroup(), onSelectAll(), onSelectElementFromGroup(), onSelectGroup(), onSetFirst(), onTypeChanged(), RadioButton, SMESHGUI_SpinBox.RangeStepAndValidator(), RemoveElemButton, RemoveGroupButton, SelectAllCB, SelectionIntoArgument(), SelectMeshButton, SMESHGUI.SetActiveDialogBox(), SetEditCurrentArgument(), SetFirstButton, SMESHGUI_SpinBox.SetValue(), SpinBoxTolerance, and updateControls().

Referenced by SMESHGUI_MergeDlg().

{
  if (myAction == 0) {
    SpinBoxTolerance->RangeStepAndValidator(0.0, COORD_MAX, 0.00001, "len_tol_precision");
    SpinBoxTolerance->SetValue(1e-05);
  }

  RadioButton->setChecked(true);

  GroupType->button(0)->setChecked(true);

  myEditCurrentArgument = (QWidget*)LineEditMesh; 

  myActor = 0;
  mySubMeshOrGroup = SMESH::SMESH_subMesh::_nil();

  mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();

  mySMESHGUI->SetActiveDialogBox((QDialog*)this);
  myIsBusy = false;
  
  /* 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(SelectMeshButton, SIGNAL (clicked()), this, SLOT(SetEditCurrentArgument()));
  connect(DetectButton, SIGNAL (clicked()), this, SLOT(onDetect()));
  connect(ListCoincident, SIGNAL (itemSelectionChanged()), this, SLOT(onSelectGroup()));
  connect(AddGroupButton, SIGNAL (clicked()), this, SLOT(onAddGroup()));
  connect(RemoveGroupButton, SIGNAL (clicked()), this, SLOT(onRemoveGroup()));
  connect(SelectAllCB, SIGNAL(toggled(bool)), this, SLOT(onSelectAll(bool)));
  connect(ListEdit, SIGNAL (itemSelectionChanged()), this, SLOT(onSelectElementFromGroup()));
  connect(AddElemButton, SIGNAL (clicked()), this, SLOT(onAddElement()));
  connect(RemoveElemButton, SIGNAL (clicked()), this, SLOT(onRemoveElement()));
  connect(SetFirstButton, SIGNAL( clicked() ), this, SLOT( onSetFirst() ) );
  connect(GroupType, SIGNAL(buttonClicked(int)), this, SLOT(onTypeChanged(int)));

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

  // Init Mesh field from selection
  SelectionIntoArgument();

  // Update Buttons
  updateControls();
  
  if (myAction == 0)
    myHelpFileName = "merging_nodes_page.html";
  else
    myHelpFileName = "merging_elements_page.html";
}

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

Definition at line 1253 of file SMESHGUI_MergeDlg.cxx.

References ClickOnHelp().

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

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

void SMESHGUI_MergeDlg::onAddElement ( ) [private, slot]

Definition at line 994 of file SMESHGUI_MergeDlg.cxx.

References SMESH.GetNameOfSelectedNodes(), ListEdit, myActor, myIsBusy, mySelector, and onEditGroup().

Referenced by Init().

{
  if (!myActor)
    return;
  myIsBusy = true;

  QString aListStr = "";
  int aNbNnodes = 0;

  aNbNnodes = SMESH::GetNameOfSelectedNodes(mySelector, myActor->getIO(), aListStr);
  if (aNbNnodes < 1)
    return;

  QStringList aNodes = aListStr.split(" ", QString::SkipEmptyParts);

  for (QStringList::iterator it = aNodes.begin(); it != aNodes.end(); ++it) {
    QList<QListWidgetItem*> found = ListEdit->findItems(*it, Qt::MatchExactly);
    if ( found.count() == 0 ) {
      QListWidgetItem* anItem = new QListWidgetItem(*it);
      ListEdit->addItem(anItem);
      anItem->setSelected(true);
    }
    else {
      QListWidgetItem* anItem;
      foreach(anItem, found) anItem->setSelected(true);
    }
  }

  myIsBusy = false;
  onEditGroup();
}

void SMESHGUI_MergeDlg::onAddGroup ( ) [private, slot]

Definition at line 940 of file SMESHGUI_MergeDlg.cxx.

References SMESH.GetNameOfSelectedNodes(), LineEditMesh, ListCoincident, myActor, myMesh, mySelector, and updateControls().

Referenced by Init().

{
  if ( myMesh->_is_nil() || LineEditMesh->text().isEmpty() )
    return;

  QString anIDs = "";
  int aNbElements = 0;
  aNbElements = SMESH::GetNameOfSelectedNodes(mySelector, myActor->getIO(), anIDs);

  if (aNbElements < 1)
    return;
  
  ListCoincident->clearSelection();
  ListCoincident->addItem(anIDs);
  int nbGroups = ListCoincident->count();
  if (nbGroups) {
    ListCoincident->setCurrentRow(nbGroups-1);
    ListCoincident->item(nbGroups-1)->setSelected(true);
  }
  else {
    // VSR ? this code seems to be never executed!!!
    ListCoincident->setCurrentRow(0);
    //ListCoincident->setSelected(0, true); // VSR: no items - no selection
  }

  updateControls();
}

void SMESHGUI_MergeDlg::onDetect ( ) [private, slot]

Definition at line 787 of file SMESHGUI_MergeDlg.cxx.

References SMESH_controls.aGroup, SMESHGUI_SpinBox.GetValue(), GroupExclude, LineEditMesh, ListCoincident, ListEdit, ListExclude, myAction, myGroups, myMesh, mySubMeshOrGroup, SpinBoxTolerance, and updateControls().

Referenced by ClickOnApply(), and Init().

{
  if ( myMesh->_is_nil() || LineEditMesh->text().isEmpty() )
    return;

  try {
    SUIT_OverrideCursor aWaitCursor;
    SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();

    ListCoincident->clear();
    ListEdit->clear();

    SMESH::array_of_long_array_var aGroupsArray;
    SMESH::ListOfIDSources_var aExcludeGroups = new SMESH::ListOfIDSources;

    SMESH::SMESH_IDSource_var src;
    if ( mySubMeshOrGroup->_is_nil() ) src = SMESH::SMESH_IDSource::_duplicate( myMesh );
    else src = SMESH::SMESH_IDSource::_duplicate( mySubMeshOrGroup );

    switch (myAction) {
    case 0 :
      for ( int i = 0; GroupExclude->isChecked() && i < ListExclude->count(); i++ ) {
        if ( ListExclude->item( i )->checkState() == Qt::Checked ) {
          aExcludeGroups->length( aExcludeGroups->length()+1 );
          aExcludeGroups[ aExcludeGroups->length()-1 ] = SMESH::SMESH_IDSource::_duplicate( myGroups[i] );
        }
      }
      aMeshEditor->FindCoincidentNodesOnPartBut(src.in(),
                                                SpinBoxTolerance->GetValue(), 
                                                aGroupsArray.out(),
                                                aExcludeGroups.in());
      break;
    case 1 :
      aMeshEditor->FindEqualElements(src.in(), aGroupsArray.out());
      break;
    }
    
    for (int i = 0; i < aGroupsArray->length(); i++) {
      SMESH::long_array& aGroup = aGroupsArray[i];

      QStringList anIDs;
      for (int j = 0; j < aGroup.length(); j++)
        anIDs.append(QString::number(aGroup[j]));

      ListCoincident->addItem(anIDs.join(" "));
    }
   } catch(...) {
  }

  ListCoincident->selectAll();
  updateControls();
}

void SMESHGUI_MergeDlg::onEditGroup ( ) [private]

Definition at line 752 of file SMESHGUI_MergeDlg.cxx.

References ListCoincident, and ListEdit.

Referenced by onAddElement(), onRemoveElement(), and onSetFirst().

{
  QList<QListWidgetItem*> selItems = ListCoincident->selectedItems();
  if ( selItems.count() != 1 ) {
    ListEdit->clear();
    return;
  }

  QStringList aNewIds;

  for (int i = 0; i < ListEdit->count(); i++ )
    aNewIds.append(ListEdit->item(i)->text());

  ListCoincident->clearSelection();
  selItems.first()->setText(aNewIds.join(" "));
  selItems.first()->setSelected(true);
}

void SMESHGUI_MergeDlg::onRemoveElement ( ) [private, slot]

Definition at line 1030 of file SMESHGUI_MergeDlg.cxx.

References ListCoincident, ListEdit, myEditCurrentArgument, myIsBusy, and onEditGroup().

Referenced by Init().

{
  if (myEditCurrentArgument != (QWidget*)ListCoincident)
    return;
  myIsBusy = true;

  QList<QListWidgetItem*> selItems = ListEdit->selectedItems();
  QListWidgetItem* anItem;

  foreach(anItem, selItems)
    delete anItem;
  
  myIsBusy = false;
  onEditGroup();
}

void SMESHGUI_MergeDlg::onRemoveGroup ( ) [private, slot]

Definition at line 972 of file SMESHGUI_MergeDlg.cxx.

References ListCoincident, ListEdit, myEditCurrentArgument, myIsBusy, and updateControls().

Referenced by Init().

{
  if (myEditCurrentArgument != (QWidget*)ListCoincident)
    return;
  myIsBusy = true;

  QList<QListWidgetItem*> selItems = ListCoincident->selectedItems();
  QListWidgetItem* anItem;

  foreach(anItem, selItems)
    delete anItem;

  ListEdit->clear();
  updateControls();

  myIsBusy = false;
}

void SMESHGUI_MergeDlg::onSelectAll ( bool isToggled ) [private, slot]

Definition at line 893 of file SMESHGUI_MergeDlg.cxx.

References ListCoincident.

Referenced by Init().

{
  if ( isToggled )
    ListCoincident->selectAll();
  else
    ListCoincident->clearSelection();
}

void SMESHGUI_MergeDlg::onSelectElementFromGroup ( ) [private, slot]

Definition at line 905 of file SMESHGUI_MergeDlg.cxx.

References FindGravityCenter(), SMESH_Actor.GetObject(), ListEdit, myAction, myActor, myIdPreview, myIsBusy, mySelectionMgr, mySelector, SMESH.TIdPreview.SetElemsData(), SetFirstButton, SMESH.TIdPreview.SetPointsData(), and SMESH.TIdPreview.SetPointsLabeled().

Referenced by Init().

{
  if (myIsBusy || !myActor)
    return;

  TColStd_MapOfInteger anIndices;
  QList<QListWidgetItem*> selItems = ListEdit->selectedItems();
  QListWidgetItem* anItem;

  foreach(anItem, selItems)
    anIndices.Add(anItem->text().toInt());

  SetFirstButton->setEnabled(selItems.count() == 1);

  mySelector->AddOrRemoveIndex(myActor->getIO(), anIndices, false);
  SALOME_ListIO aList;
  aList.Append(myActor->getIO());
  mySelectionMgr->setSelectedObjects(aList);

  if (myAction == 0) {
    myIdPreview->SetPointsData(myActor->GetObject()->GetMesh(), anIndices);
    myIdPreview->SetPointsLabeled(!anIndices.IsEmpty(), myActor->GetVisibility());
  }
  else {
    std::list< gp_XYZ > aGrCentersXYZ;
    FindGravityCenter(anIndices, aGrCentersXYZ);
    myIdPreview->SetElemsData(anIndices, aGrCentersXYZ);
    myIdPreview->SetPointsLabeled(!anIndices.IsEmpty(), myActor->GetVisibility());
  }
}

void SMESHGUI_MergeDlg::onSelectGroup ( ) [private, slot]

Definition at line 844 of file SMESHGUI_MergeDlg.cxx.

References FindGravityCenter(), SMESH_Actor.GetObject(), ListCoincident, ListEdit, myAction, myActor, myEditCurrentArgument, myIdPreview, myIsBusy, mySelectionMgr, mySelector, SMESH.TIdPreview.SetElemsData(), SMESH.TIdPreview.SetPointsData(), SMESH.TIdPreview.SetPointsLabeled(), and updateControls().

Referenced by Init().

{
  if (myIsBusy || !myActor)
    return;
  myEditCurrentArgument = (QWidget*)ListCoincident;

  ListEdit->clear();
  
  TColStd_MapOfInteger anIndices;
  QList<QListWidgetItem*> selItems = ListCoincident->selectedItems();
  QListWidgetItem* anItem;
  QStringList aListIds;

  ListEdit->clear();

  foreach(anItem, selItems) {
    aListIds = anItem->text().split(" ", QString::SkipEmptyParts);
    for (int i = 0; i < aListIds.count(); i++)
      anIndices.Add(aListIds[i].toInt());
  }
  
  if (selItems.count() == 1) {
    ListEdit->addItems(aListIds);
    ListEdit->selectAll();
  }

  mySelector->AddOrRemoveIndex(myActor->getIO(), anIndices, false);
  SALOME_ListIO aList;
  aList.Append(myActor->getIO());
  mySelectionMgr->setSelectedObjects(aList,false);
  
  if (myAction == 0) {
    myIdPreview->SetPointsData(myActor->GetObject()->GetMesh(), anIndices);
    myIdPreview->SetPointsLabeled(!anIndices.IsEmpty(), myActor->GetVisibility());
  }
  else {
    std::list< gp_XYZ > aGrCentersXYZ;
    FindGravityCenter(anIndices, aGrCentersXYZ);
    myIdPreview->SetElemsData( anIndices, aGrCentersXYZ);
    myIdPreview->SetPointsLabeled(!anIndices.IsEmpty(), myActor->GetVisibility());
  }

  updateControls();
}

void SMESHGUI_MergeDlg::onSetFirst ( ) [private, slot]

Definition at line 1050 of file SMESHGUI_MergeDlg.cxx.

References ListCoincident, ListEdit, myEditCurrentArgument, myIsBusy, and onEditGroup().

Referenced by Init().

{
  if (myEditCurrentArgument != (QWidget*)ListCoincident)
    return;
  myIsBusy = true;
  
  QList<QListWidgetItem*> selItems = ListEdit->selectedItems();
  QListWidgetItem* anItem;
  
  foreach(anItem, selItems) {
    ListEdit->takeItem(ListEdit->row(anItem));
    ListEdit->insertItem(0, anItem);
  }

  myIsBusy = false;
  onEditGroup();
}

void SMESHGUI_MergeDlg::onTypeChanged ( int id ) [private, slot]

Definition at line 1269 of file SMESHGUI_MergeDlg.cxx.

References SMESH.GetViewWindow(), GROUP, GroupCoincident, GroupCoincidentWidget, GroupEdit, SMESH_LogicalFilter.LO_OR, MESHorSUBMESH, myAction, myIdPreview, myMeshOrSubMeshOrGroupFilter, mySelectionMgr, mySMESHGUI, myTypeId, SelectionIntoArgument(), SMESH.SetPointRepresentation(), SMESH.TIdPreview.SetPointsLabeled(), updateControls(), and SMESH.UpdateView().

Referenced by Init().

{
  if (myTypeId == id)
    return;

  myTypeId = id;
  switch (id)
  {
  case 0: // automatic
    myIdPreview->SetPointsLabeled(false);
    SMESH::SetPointRepresentation(false);
    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
      aViewWindow->SetSelectionMode(ActorSelection);
    mySelectionMgr->clearFilters();
    if (myAction == 0)
      GroupCoincidentWidget->hide();
    else
      GroupCoincident->hide();
    GroupEdit->hide();
    break;

  case 1: // manual
    SMESH::UpdateView();

    // Costruction of the logical filter
    SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter (MESHorSUBMESH);
    SMESH_TypeFilter* aSmeshGroupFilter    = new SMESH_TypeFilter (GROUP);
    
    QList<SUIT_SelectionFilter*> aListOfFilters;
    if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
    if (aSmeshGroupFilter)    aListOfFilters.append(aSmeshGroupFilter);
    
    myMeshOrSubMeshOrGroupFilter =
      new SMESH_LogicalFilter (aListOfFilters, SMESH_LogicalFilter::LO_OR);

    if (myAction == 0) {
      GroupCoincidentWidget->show();
      SMESH::SetPointRepresentation(true);
      if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
        aViewWindow->SetSelectionMode(NodeSelection);
    }
    else {
      GroupCoincident->show();
      if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
        aViewWindow->SetSelectionMode(CellSelection);
    }
    GroupEdit->show();
    break;
  }
  updateControls();

  qApp->processEvents();
  updateGeometry();
  resize(10,10);

  SelectionIntoArgument();
}

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

Definition at line 1098 of file SMESHGUI_MergeDlg.cxx.

References SMESH_controls.aGroup, SMESH.FindActorByEntry(), SMESH.FindActorByObject(), SMESH.GetMeshByIO(), SMESH.GetNameOfSelectedIObjects(), SMESH.GetViewWindow(), Handle(), LineEditMesh, ListCoincident, ListEdit, ListExclude, myAction, myActor, myEditCurrentArgument, myEntry, myGroups, myIdPreview, myMesh, myMeshOrSubMeshOrGroupFilter, mySelectionMgr, mySMESHGUI, mySubMeshOrGroup, myTypeId, SMESH.SetPointRepresentation(), SMESH.TIdPreview.SetPointsLabeled(), and updateControls().

Referenced by ActivateThisDialog(), Init(), onTypeChanged(), and SetEditCurrentArgument().

{
  if (myEditCurrentArgument == (QWidget*)LineEditMesh) {
    QString aString = "";
    LineEditMesh->setText(aString);
    
    ListCoincident->clear();
    ListEdit->clear();
    myActor = 0;
    QString aCurrentEntry = myEntry;
    
    int nbSel = SMESH::GetNameOfSelectedIObjects(mySelectionMgr, aString);
    if (nbSel != 1) {
      myIdPreview->SetPointsLabeled(false);
      SMESH::SetPointRepresentation(false);
      mySelectionMgr->clearFilters();
      if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
        aViewWindow->SetSelectionMode(ActorSelection);
      return;
    }

    SALOME_ListIO aList;
    mySelectionMgr->selectedObjects(aList);
    
    Handle(SALOME_InteractiveObject) IO = aList.First();
    myEntry = IO->getEntry();
    myMesh = SMESH::GetMeshByIO(IO);
    
    if (myMesh->_is_nil())
      return;

    LineEditMesh->setText(aString);
    
    myActor = SMESH::FindActorByEntry(IO->getEntry());
    if (!myActor)
      myActor = SMESH::FindActorByObject(myMesh);
    
    if ( myActor && myTypeId ==1 ) {
      mySubMeshOrGroup = SMESH::SMESH_IDSource::_nil();
      mySelectionMgr->installFilter(myMeshOrSubMeshOrGroupFilter);
      
      if ((!SMESH::IObjectToInterface<SMESH::SMESH_subMesh>(IO)->_is_nil() || //SUBMESH OR GROUP
           !SMESH::IObjectToInterface<SMESH::SMESH_GroupBase>(IO)->_is_nil()) &&
          !SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(IO)->_is_nil())
        mySubMeshOrGroup = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>(IO);
      
      if (myAction == 0) {
        SMESH::SetPointRepresentation(true);
        if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
          aViewWindow->SetSelectionMode(NodeSelection);
      }
      else
        if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
          aViewWindow->SetSelectionMode(CellSelection);
    }

    // process groups
    if ( myAction == 0 && !myMesh->_is_nil() && myEntry != aCurrentEntry ) {
      myGroups.clear();
      ListExclude->clear();
      SMESH::ListOfGroups_var 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));
            QListWidgetItem* item = new QListWidgetItem( aGroupName );
            item->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable );
            item->setCheckState( Qt::Unchecked );
            ListExclude->addItem( item );
          }
        }
      }
    }

    updateControls();
  }
}

void SMESHGUI_MergeDlg::SetEditCurrentArgument ( ) [private, slot]

Definition at line 1072 of file SMESHGUI_MergeDlg.cxx.

References SMESH.GetViewWindow(), LineEditMesh, myEditCurrentArgument, myMeshOrSubMeshOrGroupFilter, mySelectionMgr, mySMESHGUI, myTypeId, SelectionIntoArgument(), SelectMeshButton, and SMESH.SetPointRepresentation().

Referenced by Init().

{
  QPushButton* send = (QPushButton*)sender();

  disconnect(mySelectionMgr, 0, this, 0);
  mySelectionMgr->clearSelected();
  mySelectionMgr->clearFilters();

  if (send == SelectMeshButton) {
    myEditCurrentArgument = (QWidget*)LineEditMesh;
    SMESH::SetPointRepresentation(false);
    if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
      aViewWindow->SetSelectionMode(ActorSelection);
    if (myTypeId == 1)
      mySelectionMgr->installFilter(myMeshOrSubMeshOrGroupFilter);
  }

  myEditCurrentArgument->setFocus();
  connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
  SelectionIntoArgument();
}

void SMESHGUI_MergeDlg::updateControls ( ) [private, slot]

Definition at line 774 of file SMESHGUI_MergeDlg.cxx.

References buttonApply, buttonOk, ListCoincident, ListEdit, myMesh, myTypeId, and SetFirstButton.

Referenced by Init(), onAddGroup(), onDetect(), onRemoveGroup(), onSelectGroup(), onTypeChanged(), and SelectionIntoArgument().

{
  if (ListEdit->count() == 0)
    SetFirstButton->setEnabled(false);
  bool enable = !(myMesh->_is_nil()) && (ListCoincident->count() || (myTypeId == 0));
  buttonOk->setEnabled(enable);
  buttonApply->setEnabled(enable);
}