mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2024-09-25 04:02:51 +05:00
942 lines
24 KiB
C++
942 lines
24 KiB
C++
// SMESH SMESHGUI : GUI for SMESH component
|
|
//
|
|
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
|
|
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 2.1 of the License.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
//
|
|
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
|
|
//
|
|
//
|
|
//
|
|
// File : SMESHGUI_aParameter.cxx
|
|
// Module : SMESH
|
|
// $Header$
|
|
|
|
#include "SMESHGUI_aParameter.h"
|
|
|
|
#include <qspinbox.h>
|
|
#include <qvalidator.h>
|
|
#include <qlineedit.h>
|
|
#include <qtextedit.h>
|
|
#include <qcombobox.h>
|
|
#include <qcheckbox.h>
|
|
#include <qtable.h>
|
|
#include <qvalidator.h>
|
|
#include <qpushbutton.h>
|
|
#include <qlayout.h>
|
|
|
|
#include <QtxDblSpinBox.h>
|
|
|
|
SMESHGUI_aParameter::~SMESHGUI_aParameter() {}
|
|
|
|
QString SMESHGUI_aParameter::sigValueChanged() const
|
|
{
|
|
return QString::null;
|
|
}
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_intParameter
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_intParameter::SMESHGUI_intParameter (const int theInitValue,
|
|
const QString& theLabel,
|
|
const int theBottom,
|
|
const int theTop)
|
|
:SMESHGUI_aParameter(theLabel),
|
|
_top(theTop), _bottom(theBottom), _initValue(theInitValue),
|
|
_newValue( theInitValue )
|
|
{
|
|
}
|
|
SMESHGUI_aParameter::Type SMESHGUI_intParameter::GetType() const
|
|
{
|
|
return SMESHGUI_aParameter::INT;
|
|
}
|
|
bool SMESHGUI_intParameter::GetNewInt (int & theValue) const
|
|
{
|
|
theValue = _newValue;
|
|
return _newValue != _initValue;
|
|
}
|
|
bool SMESHGUI_intParameter::GetNewDouble (double & Value) const
|
|
{
|
|
return false;
|
|
}
|
|
bool SMESHGUI_intParameter::GetNewText (QString & Value) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
QWidget* SMESHGUI_intParameter::CreateWidget( QWidget* parent ) const
|
|
{
|
|
return new QSpinBox( parent );
|
|
}
|
|
|
|
void SMESHGUI_intParameter::InitializeWidget (QWidget* theQWidget) const
|
|
{
|
|
QSpinBox * aSpin = dynamic_cast< QSpinBox *>(theQWidget);
|
|
if (aSpin) {
|
|
aSpin->setMinValue(_bottom);
|
|
aSpin->setMaxValue(_top);
|
|
aSpin->setValue(_initValue);
|
|
}
|
|
}
|
|
void SMESHGUI_intParameter::TakeValue (QWidget* theQWidget)
|
|
{
|
|
QSpinBox * aSpin = dynamic_cast< QSpinBox *>(theQWidget);
|
|
if (aSpin)
|
|
_newValue = aSpin->value();
|
|
}
|
|
|
|
QString SMESHGUI_intParameter::sigValueChanged() const
|
|
{
|
|
return SIGNAL( valueChanged( int ) );
|
|
}
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_doubleParameter
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_doubleParameter::SMESHGUI_doubleParameter (const double theInitValue,
|
|
const QString& theLabel,
|
|
const double theBottom,
|
|
const double theTop,
|
|
const double theStep,
|
|
const int theDecimals)
|
|
:SMESHGUI_aParameter(theLabel),
|
|
_top(theTop), _bottom(theBottom), _step(theStep),
|
|
_initValue(theInitValue), _decimals(theDecimals)
|
|
{
|
|
}
|
|
SMESHGUI_aParameter::Type SMESHGUI_doubleParameter::GetType() const
|
|
{
|
|
return SMESHGUI_aParameter::DOUBLE;
|
|
}
|
|
bool SMESHGUI_doubleParameter::GetNewInt (int & theValue) const
|
|
{
|
|
return false;
|
|
}
|
|
bool SMESHGUI_doubleParameter::GetNewDouble (double & Value) const
|
|
{
|
|
Value = _newValue;
|
|
return _newValue != _initValue;
|
|
}
|
|
bool SMESHGUI_doubleParameter::GetNewText (QString & Value) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
QWidget* SMESHGUI_doubleParameter::CreateWidget( QWidget* parent ) const
|
|
{
|
|
return new QtxDblSpinBox( parent );
|
|
}
|
|
|
|
void SMESHGUI_doubleParameter::InitializeWidget (QWidget* theQWidget) const
|
|
{
|
|
QtxDblSpinBox* aSpin = dynamic_cast<QtxDblSpinBox*>(theQWidget);
|
|
if (aSpin) {
|
|
aSpin->setPrecision(_decimals);
|
|
#ifdef NEW_GUI
|
|
aSpin->setDblPrecision(_bottom);
|
|
#endif
|
|
aSpin->setRange(_bottom, _top);
|
|
aSpin->setValue(_initValue);
|
|
aSpin->setLineStep(_step);
|
|
}
|
|
}
|
|
void SMESHGUI_doubleParameter::TakeValue (QWidget* theQWidget)
|
|
{
|
|
QtxDblSpinBox* aSpin = dynamic_cast<QtxDblSpinBox*>(theQWidget);
|
|
if (aSpin)
|
|
_newValue = aSpin->value();
|
|
}
|
|
|
|
QString SMESHGUI_doubleParameter::sigValueChanged() const
|
|
{
|
|
return SIGNAL( valueChanged( double ) );
|
|
}
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_strParameter
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_strParameter::SMESHGUI_strParameter (const QString& theInitValue,
|
|
const QString& theLabel)
|
|
:SMESHGUI_aParameter(theLabel),
|
|
_initValue(theInitValue)
|
|
{
|
|
}
|
|
SMESHGUI_aParameter::Type SMESHGUI_strParameter::GetType() const
|
|
{
|
|
return SMESHGUI_aParameter::STRING;
|
|
}
|
|
bool SMESHGUI_strParameter::GetNewInt (int & theValue) const
|
|
{
|
|
return false;
|
|
}
|
|
bool SMESHGUI_strParameter::GetNewDouble (double & Value) const
|
|
{
|
|
return false;
|
|
}
|
|
bool SMESHGUI_strParameter::GetNewText (QString & theValue) const
|
|
{
|
|
theValue = _newValue;
|
|
return _newValue != _initValue;
|
|
}
|
|
|
|
QWidget* SMESHGUI_strParameter::CreateWidget( QWidget* parent ) const
|
|
{
|
|
return new QLineEdit( parent );
|
|
}
|
|
|
|
void SMESHGUI_strParameter::InitializeWidget (QWidget* theQWidget) const
|
|
{
|
|
QLineEdit* anEdit = dynamic_cast< QLineEdit* >(theQWidget);
|
|
if (anEdit) {
|
|
anEdit->setText(_initValue);
|
|
}
|
|
}
|
|
void SMESHGUI_strParameter::TakeValue (QWidget* theQWidget)
|
|
{
|
|
QLineEdit* anEdit = dynamic_cast< QLineEdit* >(theQWidget);
|
|
if (anEdit)
|
|
_newValue = anEdit->text();
|
|
}
|
|
|
|
QString SMESHGUI_strParameter::sigValueChanged() const
|
|
{
|
|
return SIGNAL( textChanged( const QString& ) );
|
|
}
|
|
|
|
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_dependParameter
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_dependParameter::SMESHGUI_dependParameter( const QString& label )
|
|
: SMESHGUI_aParameter( label )
|
|
{
|
|
}
|
|
|
|
const SMESHGUI_dependParameter::ShownMap& SMESHGUI_dependParameter::shownMap() const
|
|
{
|
|
return myShownMap;
|
|
}
|
|
|
|
SMESHGUI_dependParameter::ShownMap& SMESHGUI_dependParameter::shownMap()
|
|
{
|
|
return myShownMap;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_enumParameter
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_enumParameter::SMESHGUI_enumParameter( const QStringList& values,
|
|
const int initValue,
|
|
const QString& label )
|
|
: SMESHGUI_dependParameter( label ),
|
|
myInitValue( initValue ),
|
|
myValue( initValue ),
|
|
myValues( values )
|
|
{
|
|
}
|
|
|
|
SMESHGUI_enumParameter::~SMESHGUI_enumParameter()
|
|
{
|
|
}
|
|
|
|
SMESHGUI_aParameter::Type SMESHGUI_enumParameter::GetType() const
|
|
{
|
|
return SMESHGUI_aParameter::ENUM;
|
|
}
|
|
|
|
bool SMESHGUI_enumParameter::GetNewInt( int& v ) const
|
|
{
|
|
v = myValue;
|
|
return myValue!=myInitValue;
|
|
}
|
|
|
|
bool SMESHGUI_enumParameter::GetNewDouble( double& ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool SMESHGUI_enumParameter::GetNewText( QString& v ) const
|
|
{
|
|
bool res = myValue>=0 && myValue<Count();
|
|
|
|
if( res )
|
|
v = myValues[ myValue ];
|
|
|
|
return res && v!=myInitValue;
|
|
}
|
|
|
|
QWidget* SMESHGUI_enumParameter::CreateWidget( QWidget* parent ) const
|
|
{
|
|
return new QComboBox( parent );
|
|
}
|
|
|
|
void SMESHGUI_enumParameter::InitializeWidget( QWidget* w ) const
|
|
{
|
|
if( w && w->inherits( "QComboBox" ) )
|
|
{
|
|
QComboBox* c = ( QComboBox* ) w;
|
|
c->clear();
|
|
c->insertStringList( myValues );
|
|
c->setCurrentItem( myInitValue );
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_enumParameter::TakeValue( QWidget* w )
|
|
{
|
|
if( w && w->inherits( "QComboBox" ) )
|
|
{
|
|
QComboBox* c = ( QComboBox* ) w;
|
|
myValue = c->currentItem();
|
|
}
|
|
}
|
|
|
|
int SMESHGUI_enumParameter::Count() const
|
|
{
|
|
return myValues.count();
|
|
}
|
|
|
|
QString SMESHGUI_enumParameter::sigValueChanged() const
|
|
{
|
|
return SIGNAL( activated( int ) );
|
|
}
|
|
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_boolParameter
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_boolParameter::SMESHGUI_boolParameter( const bool initValue,
|
|
const QString& label )
|
|
: SMESHGUI_dependParameter( label ),
|
|
myInitValue( initValue ),
|
|
myValue( myInitValue )
|
|
{
|
|
}
|
|
|
|
SMESHGUI_boolParameter::~SMESHGUI_boolParameter()
|
|
{
|
|
}
|
|
|
|
SMESHGUI_aParameter::Type SMESHGUI_boolParameter::GetType() const
|
|
{
|
|
return BOOL;
|
|
}
|
|
|
|
bool SMESHGUI_boolParameter::GetNewInt( int& v ) const
|
|
{
|
|
if( myValue )
|
|
v = 1;
|
|
else
|
|
v = 0;
|
|
return v!=myInitValue;
|
|
}
|
|
|
|
bool SMESHGUI_boolParameter::GetNewDouble( double& ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool SMESHGUI_boolParameter::GetNewText( QString& ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
QWidget* SMESHGUI_boolParameter::CreateWidget( QWidget* parent ) const
|
|
{
|
|
return new QCheckBox( parent );
|
|
}
|
|
|
|
void SMESHGUI_boolParameter::InitializeWidget( QWidget* w ) const
|
|
{
|
|
if( w && w->inherits( "QCheckBox" ) )
|
|
{
|
|
QCheckBox* box = ( QCheckBox* )w;
|
|
box->setChecked( myInitValue );
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_boolParameter::TakeValue( QWidget* w )
|
|
{
|
|
if( w && w->inherits( "QCheckBox" ) )
|
|
{
|
|
QCheckBox* box = ( QCheckBox* )w;
|
|
myValue = box->isChecked();
|
|
}
|
|
}
|
|
|
|
QString SMESHGUI_boolParameter::sigValueChanged() const
|
|
{
|
|
return SIGNAL( stateChanged( int ) );
|
|
}
|
|
|
|
|
|
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_doubleItem
|
|
// purpose : Custom table item which contains double and has double validator
|
|
//=================================================================================
|
|
class SMESHGUI_doubleItem: public QTableItem
|
|
{
|
|
public:
|
|
SMESHGUI_doubleItem( QTable*, EditType, const double );
|
|
virtual ~SMESHGUI_doubleItem();
|
|
|
|
void setValidator( const double, const double, const int );
|
|
void validator( double&, double&, int& );
|
|
virtual QWidget* createEditor() const;
|
|
|
|
private:
|
|
QDoubleValidator* myValidator;
|
|
};
|
|
|
|
SMESHGUI_doubleItem::SMESHGUI_doubleItem( QTable* t, EditType e, const double num )
|
|
: QTableItem( t, e, QString( "%1" ).arg( num ) ),
|
|
myValidator( new QDoubleValidator( 0.0, 1.0, 3, t ) )
|
|
{
|
|
}
|
|
|
|
SMESHGUI_doubleItem::~SMESHGUI_doubleItem()
|
|
{
|
|
}
|
|
|
|
void SMESHGUI_doubleItem::setValidator( const double bot, const double top, const int dec )
|
|
{
|
|
myValidator->setBottom( bot );
|
|
myValidator->setTop( top );
|
|
myValidator->setDecimals( dec );
|
|
}
|
|
|
|
void SMESHGUI_doubleItem::validator( double& bot, double& top, int& dec )
|
|
{
|
|
bot = myValidator->bottom();
|
|
top = myValidator->top();
|
|
dec = myValidator->decimals();
|
|
}
|
|
|
|
QWidget* SMESHGUI_doubleItem::createEditor() const
|
|
{
|
|
QWidget* res = QTableItem::createEditor();
|
|
if( res && res->inherits( "QLineEdit" ) )
|
|
{
|
|
QLineEdit* l = ( QLineEdit* )res;
|
|
l->setValidator( myValidator );
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_Table
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_Table::SMESHGUI_Table( int numRows, int numCols, QWidget* parent, const char* name )
|
|
: QTable( numRows, numCols, parent, name )
|
|
{
|
|
}
|
|
|
|
SMESHGUI_Table::~SMESHGUI_Table()
|
|
{
|
|
}
|
|
|
|
QSize SMESHGUI_Table::sizeHint() const
|
|
{
|
|
if( cachedSizeHint().isValid() )
|
|
return cachedSizeHint();
|
|
|
|
constPolish();
|
|
|
|
QSize sh = QScrollView::sizeHint();
|
|
if( sh.width()<400 )
|
|
sh.setWidth( 400 );
|
|
if( sh.height()<200 )
|
|
sh.setHeight( 200 );
|
|
|
|
setCachedSizeHint( sh );
|
|
return sh;
|
|
}
|
|
|
|
void SMESHGUI_Table::stopEditing()
|
|
{
|
|
endEdit( currEditRow(), currEditCol(), false, false );
|
|
}
|
|
|
|
void SMESHGUI_Table::validator( const int row, const int col, double& minV, double& maxV, int& dec )
|
|
{
|
|
SMESHGUI_doubleItem* it = dynamic_cast<SMESHGUI_doubleItem*>( item( row, col ) );
|
|
if( it )
|
|
it->validator( minV, maxV, dec );
|
|
}
|
|
|
|
void SMESHGUI_Table::setValidator( const double minV, const double maxV, const int dec,
|
|
const int rmin, const int rmax,
|
|
const int cmin, const int cmax )
|
|
{
|
|
int r1 = rmin>=0 ? rmin : 0,
|
|
r2 = rmax>=0 ? rmax : numRows(),
|
|
c1 = cmin>=0 ? cmin : 0,
|
|
c2 = cmax>=0 ? cmax : numCols();
|
|
|
|
for( int i=r1; i<=r2; i++ )
|
|
for( int j=c1; j<=c2; j++ )
|
|
{
|
|
SMESHGUI_doubleItem* it = dynamic_cast<SMESHGUI_doubleItem*>( item( i, j ) );
|
|
if( it )
|
|
it->setValidator( minV, maxV, dec );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_TableFrame
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_TableFrame::SMESHGUI_TableFrame( QWidget* parent )
|
|
: QFrame( parent )
|
|
{
|
|
QVBoxLayout* main = new QVBoxLayout( this, 0, 0 );
|
|
|
|
myTable = new SMESHGUI_Table( 1, 1, this );
|
|
|
|
QFrame* aButFrame = new QFrame( this );
|
|
QHBoxLayout* butLay = new QHBoxLayout( aButFrame, 5, 5 );
|
|
|
|
myAddColumn = new QPushButton( "Add column", aButFrame );
|
|
|
|
myRemoveColumn = new QPushButton( "Remove column", aButFrame );
|
|
|
|
myAddRow = new QPushButton( "Add row", aButFrame );
|
|
|
|
myRemoveRow = new QPushButton( "Remove row", aButFrame );
|
|
|
|
butLay->addWidget( myAddColumn, 0 );
|
|
butLay->addWidget( myRemoveColumn, 0 );
|
|
butLay->addWidget( myAddRow, 0 );
|
|
butLay->addWidget( myRemoveRow, 0 );
|
|
butLay->addStretch( 1 );
|
|
|
|
main->addWidget( myTable, 1 );
|
|
main->addWidget( aButFrame, 0 );
|
|
|
|
connect( myAddColumn, SIGNAL( clicked() ), this, SLOT( onButtonClicked() ) );
|
|
connect( myRemoveColumn, SIGNAL( clicked() ), this, SLOT( onButtonClicked() ) );
|
|
connect( myAddRow, SIGNAL( clicked() ), this, SLOT( onButtonClicked() ) );
|
|
connect( myRemoveRow, SIGNAL( clicked() ), this, SLOT( onButtonClicked() ) );
|
|
}
|
|
|
|
SMESHGUI_TableFrame::~SMESHGUI_TableFrame()
|
|
{
|
|
}
|
|
|
|
SMESHGUI_Table* SMESHGUI_TableFrame::table() const
|
|
{
|
|
return myTable;
|
|
}
|
|
|
|
void SMESHGUI_TableFrame::setShown( const Button b, const bool sh )
|
|
{
|
|
if( button( b ) )
|
|
button( b )->setShown( sh );
|
|
}
|
|
|
|
bool SMESHGUI_TableFrame::isShown( const Button b ) const
|
|
{
|
|
bool res = false;
|
|
if( button( b ) )
|
|
res = button( b )->isShown();
|
|
return res;
|
|
}
|
|
|
|
QButton* SMESHGUI_TableFrame::button( const Button b ) const
|
|
{
|
|
QButton* res = 0;
|
|
switch( b )
|
|
{
|
|
case ADD_COLUMN:
|
|
res = myAddColumn;
|
|
break;
|
|
|
|
case REMOVE_COLUMN:
|
|
res = myRemoveColumn;
|
|
break;
|
|
|
|
case ADD_ROW:
|
|
res = myAddRow;
|
|
break;
|
|
|
|
case REMOVE_ROW:
|
|
res = myRemoveRow;
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
void SMESHGUI_TableFrame::onButtonClicked()
|
|
{
|
|
if( sender()==button( ADD_COLUMN ) )
|
|
emit toEdit( ADD_COLUMN, table()->currentColumn() );
|
|
|
|
else if( sender()==button( REMOVE_COLUMN ) )
|
|
emit toEdit( REMOVE_COLUMN, table()->currentColumn() );
|
|
|
|
else if( sender()==button( ADD_ROW ) )
|
|
emit toEdit( ADD_ROW, table()->currentRow() );
|
|
|
|
else if( sender()==button( REMOVE_ROW ) )
|
|
emit toEdit( REMOVE_ROW, table()->currentRow() );
|
|
}
|
|
|
|
|
|
//=================================================================================
|
|
// class : SMESHGUI_tableParameter
|
|
// purpose :
|
|
//=================================================================================
|
|
SMESHGUI_tableParameter::SMESHGUI_tableParameter( const double init,
|
|
const QString& label )
|
|
: SMESHGUI_aParameter( label ),
|
|
myInitValue( init ),
|
|
myColsInt( 1 ),
|
|
myRowsInt( 1 ),
|
|
myEditCols( false ),
|
|
myEditRows( false )
|
|
{
|
|
}
|
|
|
|
SMESHGUI_tableParameter::~SMESHGUI_tableParameter()
|
|
{
|
|
}
|
|
|
|
SMESHGUI_aParameter::Type SMESHGUI_tableParameter::GetType() const
|
|
{
|
|
return TABLE;
|
|
}
|
|
|
|
bool SMESHGUI_tableParameter::GetNewInt( int& ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool SMESHGUI_tableParameter::GetNewDouble( double& ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool SMESHGUI_tableParameter::GetNewText( QString& ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
QWidget* SMESHGUI_tableParameter::CreateWidget( QWidget* par ) const
|
|
{
|
|
SMESHGUI_TableFrame* t = new SMESHGUI_TableFrame( par );
|
|
connect( t, SIGNAL( toEdit( SMESHGUI_TableFrame::Button, int ) ),
|
|
this, SLOT ( onEdit( SMESHGUI_TableFrame::Button, int ) ) );
|
|
|
|
update( t );
|
|
return t;
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setItems( QWidget* w,
|
|
int old_row, int new_row,
|
|
int old_col, int new_col ) const
|
|
{
|
|
if( w && w->inherits( "SMESHGUI_TableFrame" ) )
|
|
{
|
|
QTable* tab = ( ( SMESHGUI_TableFrame* )w )->table();
|
|
|
|
if( old_row<0 )
|
|
old_row = 0;
|
|
if( new_row<0 )
|
|
new_row = tab->numRows();
|
|
if( old_col<0 )
|
|
old_col = 0;
|
|
if( new_col<0 )
|
|
new_col = tab->numCols();
|
|
|
|
for( int i=old_row, m=new_row; i<m; i++ )
|
|
for( int j=0, n=new_col; j<n; j++ )
|
|
tab->setItem( i, j, new SMESHGUI_doubleItem( tab, QTableItem::WhenCurrent, myInitValue ) );
|
|
|
|
for( int i=0, m=new_row; i<m; i++ )
|
|
for( int j=old_col, n=new_col; j<n; j++ )
|
|
tab->setItem( i, j, new SMESHGUI_doubleItem( tab, QTableItem::WhenCurrent, myInitValue ) );
|
|
|
|
for( int j=old_col; j<new_col; j++ )
|
|
tab->setColumnWidth( j, 50 );
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::InitializeWidget( QWidget* w ) const
|
|
{
|
|
setItems( w );
|
|
|
|
if( w && w->inherits( "SMESHGUI_TableFrame" ) )
|
|
{
|
|
SMESHGUI_Table* tab = ( ( SMESHGUI_TableFrame* )w )->table();
|
|
tab->stopEditing();
|
|
|
|
int col = tab->numCols(),
|
|
row = tab->numRows();
|
|
|
|
for( int i=0, m=row; i<m; i++ )
|
|
for( int j=0, n=col; j<n; j++ )
|
|
if( row*j+i<myData.length() )
|
|
tab->item( i, j )->setText( QString( "%1" ).arg( myData[row*j+i] ) );
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::TakeValue( QWidget* w )
|
|
{
|
|
if( w && w->inherits( "SMESHGUI_TableFrame" ) )
|
|
{
|
|
QTable* tab = ( ( SMESHGUI_TableFrame* )w )->table();
|
|
|
|
int col = tab->numCols(),
|
|
row = tab->numRows();
|
|
|
|
myData.length( col*row );
|
|
for( int i=0; i<row; i++ )
|
|
for( int j=0; j<col; j++ )
|
|
myData[ col*i+j ] = tab->text( i, j ).toDouble();
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::data( SMESH::double_array& v ) const
|
|
{
|
|
v = myData;
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setData( const SMESH::double_array& d )
|
|
{
|
|
myData = d;
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::update( QWidget* w ) const
|
|
{
|
|
if( w && w->inherits( "SMESHGUI_TableFrame" ) )
|
|
{
|
|
SMESHGUI_TableFrame* tabfr = ( SMESHGUI_TableFrame* ) w;
|
|
SMESHGUI_Table* tab = tabfr->table();
|
|
|
|
int old_col = tab->numCols(),
|
|
old_row = tab->numRows();
|
|
|
|
int col = myColsInt, row = myRowsInt;
|
|
if( myCols.get() )
|
|
myCols->GetNewInt( col );
|
|
|
|
if( myRows.get() )
|
|
myRows->GetNewInt( row );
|
|
|
|
if( col<=0 )
|
|
col = 1;
|
|
if( row<=0 )
|
|
row = 1;
|
|
|
|
if( col!=tab->numCols() )
|
|
tab->setNumCols( col );
|
|
|
|
if( row!=tab->numRows() )
|
|
tab->setNumRows( row );
|
|
|
|
tabfr->setShown( SMESHGUI_TableFrame::ADD_COLUMN, myEditCols );
|
|
tabfr->setShown( SMESHGUI_TableFrame::REMOVE_COLUMN, myEditCols );
|
|
tabfr->setShown( SMESHGUI_TableFrame::ADD_ROW, myEditRows );
|
|
tabfr->setShown( SMESHGUI_TableFrame::REMOVE_ROW, myEditRows );
|
|
|
|
setItems( w, old_row, row, old_col, col );
|
|
|
|
QMap< int, QString >::const_iterator aNIt = myColNames.begin(),
|
|
aNLast = myColNames.end();
|
|
for( ; aNIt!=aNLast; aNIt++ )
|
|
tab->horizontalHeader()->setLabel( aNIt.key(), aNIt.data() );
|
|
|
|
ValidatorsMap::const_iterator anIt = myValidators.begin(),
|
|
aLast = myValidators.end();
|
|
for( ; anIt!=aLast; anIt++ )
|
|
{
|
|
int row = anIt.key(), dec;
|
|
double minV, maxV;
|
|
validator( row, minV, maxV, dec );
|
|
tab->setValidator( minV, maxV, dec, -1, -1, col, col );
|
|
}
|
|
|
|
QSize s = tab->sizeHint();
|
|
tab->resize( s.width(), s.height() );
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setColCount( const int c, QWidget* w )
|
|
{
|
|
myColsInt = c;
|
|
update( w );
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setRowCount( const int c, QWidget* w )
|
|
{
|
|
myRowsInt = c;
|
|
update( w );
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setColCount( const SMESHGUI_aParameterPtr p, QWidget* w )
|
|
{
|
|
if( p.get() )
|
|
{
|
|
myCols = p;
|
|
update( w );
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setRowCount( const SMESHGUI_aParameterPtr p, QWidget* w )
|
|
{
|
|
if( p.get() )
|
|
{
|
|
myRows = p;
|
|
update( w );
|
|
}
|
|
}
|
|
|
|
QString SMESHGUI_tableParameter::sigValueChanged() const
|
|
{
|
|
return SIGNAL( valueChanged( int, int ) );
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setValidator( const int ind, const double minV, const double maxV, const int dec )
|
|
{
|
|
ValidatorInfo inf;
|
|
inf.myMin = minV;
|
|
inf.myMax = maxV;
|
|
inf.myDecimals = dec;
|
|
myValidators[ ind ] = inf;
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::validator( const int ind, double& minV, double& maxV, int& dec ) const
|
|
{
|
|
if( myValidators.contains( ind ) )
|
|
{
|
|
const ValidatorInfo& inf = myValidators[ ind ];
|
|
minV = inf.myMin;
|
|
maxV = inf.myMax;
|
|
dec = inf.myDecimals;
|
|
}
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setEditCols( const bool ed )
|
|
{
|
|
myEditCols = ed;
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setEditRows( const bool ed )
|
|
{
|
|
myEditRows = ed;
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::setColName( const int ind, const QString& name )
|
|
{
|
|
myColNames.insert( ind, name );
|
|
}
|
|
|
|
QString SMESHGUI_tableParameter::colName( const int ind ) const
|
|
{
|
|
if( myColNames.contains( ind ) )
|
|
return myColNames[ ind ];
|
|
else
|
|
return QString::null;
|
|
}
|
|
|
|
void SMESHGUI_tableParameter::onEdit( SMESHGUI_TableFrame::Button b, int n )
|
|
{
|
|
if( sender() && sender()->inherits( "SMESHGUI_TableFrame" ) )
|
|
{
|
|
SMESHGUI_TableFrame* fr = ( SMESHGUI_TableFrame* )sender();
|
|
SMESHGUI_Table* tab = fr->table();
|
|
|
|
switch( b )
|
|
{
|
|
case SMESHGUI_TableFrame::ADD_COLUMN:
|
|
{
|
|
if( !myEditCols || myCols.get() )
|
|
return;
|
|
|
|
myColsInt++; update( fr );
|
|
if( n>=0 )
|
|
for( int i=0; i<myRowsInt; i++ )
|
|
for( int j=myColsInt-1; j>=n; j-- )
|
|
if( j==n )
|
|
tab->setText( i, j, QString( "%1" ).arg( myInitValue ) );
|
|
else
|
|
tab->setText( i, j, tab->text( i, j-1 ) );
|
|
break;
|
|
}
|
|
|
|
case SMESHGUI_TableFrame::REMOVE_COLUMN:
|
|
{
|
|
if( !myEditCols || myCols.get() || myColsInt<=1 )
|
|
return;
|
|
|
|
if( n>=0 )
|
|
for( int i=0; i<myRowsInt; i++ )
|
|
for( int j=n; j<myColsInt-1; j++ )
|
|
tab->setText( i, j, tab->text( i, j+1 ) );
|
|
myColsInt--; update( fr );
|
|
|
|
break;
|
|
}
|
|
|
|
case SMESHGUI_TableFrame::ADD_ROW:
|
|
{
|
|
if( !myEditRows || myRows.get() )
|
|
return;
|
|
|
|
myRowsInt++; update( fr );
|
|
if( n>=0 )
|
|
for( int i=myRowsInt-1; i>=n; i-- )
|
|
for( int j=0; j<myColsInt; j++ )
|
|
if( i==n )
|
|
tab->setText( i, j, QString( "%1" ).arg( myInitValue ) );
|
|
else
|
|
tab->setText( i, j, tab->text( i-1, j ) );
|
|
break;
|
|
}
|
|
|
|
case SMESHGUI_TableFrame::REMOVE_ROW:
|
|
{
|
|
if( !myEditRows || myRows.get() || myRowsInt<=1 )
|
|
return;
|
|
|
|
if( n>=0 )
|
|
for( int i=n; i<myRowsInt-1; i++ )
|
|
for( int j=0; j<myColsInt; j++ )
|
|
tab->setText( i, j, tab->text( i+1, j ) );
|
|
myRowsInt--; update( fr );
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|