コード例 #1
0
ファイル: moc_qprog.cpp プロジェクト: Linux-enCaja/SIE
int QProg::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: valueChanged((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 1: setValue((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 2: setMaxValue((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 3: setMinValue((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 4: setFontDim((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 5: setPrecision((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 6: setBarColor((*reinterpret_cast< QColor(*)>(_a[1]))); break;
        default: ;
        }
        _id -= 7;
    }
#ifndef QT_NO_PROPERTIES
      else if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< double*>(_v) = value(); break;
        case 1: *reinterpret_cast< double*>(_v) = minValue(); break;
        case 2: *reinterpret_cast< double*>(_v) = maxValue(); break;
        case 3: *reinterpret_cast< int*>(_v) = font(); break;
        case 4: *reinterpret_cast< int*>(_v) = numPrec(); break;
        case 5: *reinterpret_cast< QColor*>(_v) = color(); break;
        }
        _id -= 6;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setValue(*reinterpret_cast< double*>(_v)); break;
        case 1: setMinValue(*reinterpret_cast< double*>(_v)); break;
        case 2: setMaxValue(*reinterpret_cast< double*>(_v)); break;
        case 3: setFontDim(*reinterpret_cast< int*>(_v)); break;
        case 4: setPrecision(*reinterpret_cast< int*>(_v)); break;
        case 5: setBarColor(*reinterpret_cast< QColor*>(_v)); break;
        }
        _id -= 6;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 6;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 6;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
コード例 #2
0
ファイル: doubleslider.cpp プロジェクト: alvatar/smartmatter
void DoubleSlider::setValues(float val1, float val2) {
    if (val1 < val2) {
        setMinValue(val1);
        setMaxValue(val2);
    }
    else {
        setMinValue(val2);
        setMaxValue(val1);
    }
}
コード例 #3
0
ファイル: doubleslider.cpp プロジェクト: alvatar/smartmatter
void DoubleSlider::moveSlider(float mousePos) {
    if (leftSliderActive_ && !rightSliderActive_)
        setMinValue(mousePos);
    if (rightSliderActive_ && !leftSliderActive_)
        setMaxValue(mousePos);
    if (rightSliderActive_ && leftSliderActive_) {
        float mouseDiff = normalizedMousePos_ - mousePos;
        setMinValue(mV1_ - mouseDiff);
        setMaxValue(mV2_ - mouseDiff);
    }
}
コード例 #4
0
void SettingsConstraints::loadFromConfig(const String & path_to_constraints, const Poco::Util::AbstractConfiguration & config)
{
    if (!config.has(path_to_constraints))
        throw Exception("There is no path '" + path_to_constraints + "' in configuration file.", ErrorCodes::NO_ELEMENTS_IN_CONFIG);

    Poco::Util::AbstractConfiguration::Keys names;
    config.keys(path_to_constraints, names);

    for (const String & name : names)
    {
        String path_to_name = path_to_constraints + "." + name;
        Poco::Util::AbstractConfiguration::Keys constraint_types;
        config.keys(path_to_name, constraint_types);
        for (const String & constraint_type : constraint_types)
        {
            auto get_constraint_value = [&]{ return config.getString(path_to_name + "." + constraint_type); };
            if (constraint_type == "min")
                setMinValue(name, get_constraint_value());
            else if (constraint_type == "max")
                setMaxValue(name, get_constraint_value());
            else if (constraint_type == "readonly")
                setReadOnly(name, true);
            else
                throw Exception("Setting " + constraint_type + " value for " + name + " isn't supported", ErrorCodes::NOT_IMPLEMENTED);
        }
    }
}
コード例 #5
0
caTable::caTable(QWidget *parent) : QTableWidget(parent)

{
    setPrecisionMode(Channel);
    setLimitsMode(Channel);
    setPrecision(0);
    setMinValue(0.0);
    setMaxValue(1.0);
    for(int i=0; i< MaxRows; i++) {
        setFormat(i, 1);
        for(int j=0; j< MaxCols; j++) tableItem[i][j] = (QTableWidgetItem*) 0;
    }

    thisItemFont = this->font();

    setColorMode(Static);
    setAlternatingRowColors(true);
    setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
    setEditTriggers(QTableWidget::NoEditTriggers);
    verticalHeader()->setDefaultSectionSize(20);
    horizontalHeader()->setResizeMode(QHeaderView::Stretch);

    defaultForeColor = palette().foreground().color();

    createActions();
    addAction(copyAct);

    connect(this, SIGNAL( cellDoubleClicked (int, int) ), this, SLOT(celldoubleclicked( int, int ) ) );
    //connect(this, SIGNAL( cellClicked (int, int) ), this, SLOT(cellclicked( int, int ) ) );
}
コード例 #6
0
bool IOAudioLevelControl::init(SInt32 initialValue,
                               SInt32 minValue,
                               SInt32 maxValue,
                               IOFixed minDB,
                               IOFixed maxDB,
                               UInt32 channelID,
                               const char *channelName,
                               UInt32 cntrlID,
                               UInt32 subType,
                               UInt32 usage,
                               OSDictionary *properties)
{
    bool result = true;
    OSNumber *number;
    
    number = OSNumber::withNumber(initialValue, sizeof(SInt32)*8);
    
    if ((number == NULL) || !super::init(kIOAudioControlTypeLevel, number, channelID, channelName, cntrlID, subType, usage, properties)) {
        result = false;
        goto Done;
    }

    setMinValue(minValue);
    setMaxValue(maxValue);
    setMinDB(minDB);
    setMaxDB(maxDB);

Done:
    if (number) {
        number->release();
    }
            
    return result;
}
コード例 #7
0
ファイル: lineargauge.cpp プロジェクト: emreaslan/zenom
void LinearGauge::loadSettings( QSettings& pSettings )
{
	// Scale
	Qt::Orientation orientation = (Qt::Orientation) pSettings.value("orientation", Qt::Vertical).toInt();
	QwtThermo::ScalePos scalePosition = (QwtThermo::ScalePos) pSettings.value("scalePosition", QwtThermo::LeftScale).toInt();
	setOrientation( orientation, scalePosition );
	setMinValue( pSettings.value("minValue", 0).toDouble() );
	setMaxValue( pSettings.value("maxValue", 10).toDouble() );

	// Ticks
	setScaleMaxMinor( pSettings.value("scaleMaxMinor", 4).toInt() );
	setScaleMaxMajor( pSettings.value("scaleMaxMajor", 12).toInt() );
	scaleDraw()->enableComponent( QwtAbstractScaleDraw::Labels, pSettings.value("labels", true).toBool() );
	setFont( QFont(	pSettings.value("font").toString(), pSettings.value("fontSize", 8).toDouble()) );

	// Pipe
	setValue( pSettings.value("value", 8).toDouble() );
	setPipeWidth( pSettings.value("pipeWidth", 10).toInt() );
	setFillBrush( QBrush( pSettings.value("pipeColor").toUInt() ) );

	// Alarm
	setAlarmLevel( pSettings.value("alarmLevel", 7).toDouble() );
	setAlarmBrush( QBrush( pSettings.value("alarmBrush").toUInt() ) );
	setAlarmEnabled( pSettings.value("alarmEnabled").toBool() );	

	// Color
	setTextColor( pSettings.value("textColor").toUInt() );
	setBackgroundColor( pSettings.value("backgroundColor").toUInt() );

	AbstractGauge::loadSettings( pSettings );
}
コード例 #8
0
void Slider::setLineStep (const double new_ls)
{
  lineStep = new_ls;
  setMinValue(minValue);
  setMaxValue(maxValue);
  setValue(value);
}
コード例 #9
0
void Slider::setDirection (const DIRECT new_dir)
{
  direction = new_dir;
  setMinValue(minValue);
  setMaxValue(maxValue);
  setValue(value);
}
コード例 #10
0
void Slider::reloadSlider()
{
    slider->hide();
    if (orientation == 0) {
      slider->setOrientation(Qt::Horizontal);
      slider->setGeometry(x()+10, height()/2-10, width()-20, 20);
    }
      else if (orientation == 1) {
             slider->setOrientation(Qt::Vertical);
             slider->setGeometry(width()/2-10, 10, 20, height()-20);
           }
    slider->setMinValue(-32768);
    slider->show();

    setTickmarks (tickmarks);
    setTickInterval (tickInterval);
    setTracking (tracking);
    setPageStep(pageStep);
    setMainColor(mainColor);
    setTickmarksColor(tickmarksColor);

    setMinValue(minValue);
    setMaxValue(maxValue);
    if (direction == 0) slider->setValue((int)(-32768 + (value-minValue)/lineStep));
      else if (direction == 1) slider->setValue((int)(-32768 + (maxValue-value)/lineStep));

    setNewMask();
}
コード例 #11
0
bool OSArgument::setMinValue(int minValue)
{
  if (m_type == OSArgumentType::Double) {
    double test = (double)minValue;
    return setMinValue(test);
  } else if (m_type != OSArgumentType::Integer) {
    return false;
  }

  double maxValue = std::numeric_limits<int>::max();
  if (hasDomain() && (m_domainType == OSDomainType::Interval)){
    std::vector<int> domain = domainAsInteger();
    if (domain.size() == 2){
      maxValue = domain[1];
    }
  }

  m_domainType = OSDomainType::Interval;
  m_domain.clear();
  m_domain.push_back(QVariant(minValue));
  m_domain.push_back(QVariant(maxValue));

  onChange();

  return true;
}
コード例 #12
0
ファイル: moc_qwt_counter.cpp プロジェクト: chongle/prorata
int QwtCounter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: buttonReleased((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 1: valueChanged((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 2: btnReleased(); break;
        case 3: btnClicked(); break;
        case 4: textChanged(); break;
        }
        _id -= 5;
    }
#ifndef QT_NO_PROPERTIES
      else if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< int*>(_v) = numButtons(); break;
        case 1: *reinterpret_cast< double*>(_v) = step(); break;
        case 2: *reinterpret_cast< double*>(_v) = minVal(); break;
        case 3: *reinterpret_cast< double*>(_v) = maxVal(); break;
        case 4: *reinterpret_cast< int*>(_v) = stepButton1(); break;
        case 5: *reinterpret_cast< int*>(_v) = stepButton2(); break;
        case 6: *reinterpret_cast< int*>(_v) = stepButton3(); break;
        case 7: *reinterpret_cast< double*>(_v) = value(); break;
        case 8: *reinterpret_cast< bool*>(_v) = editable(); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setNumButtons(*reinterpret_cast< int*>(_v)); break;
        case 1: setStep(*reinterpret_cast< double*>(_v)); break;
        case 2: setMinValue(*reinterpret_cast< double*>(_v)); break;
        case 3: setMaxValue(*reinterpret_cast< double*>(_v)); break;
        case 4: setStepButton1(*reinterpret_cast< int*>(_v)); break;
        case 5: setStepButton2(*reinterpret_cast< int*>(_v)); break;
        case 6: setStepButton3(*reinterpret_cast< int*>(_v)); break;
        case 7: setValue(*reinterpret_cast< double*>(_v)); break;
        case 8: setEditable(*reinterpret_cast< bool*>(_v)); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 9;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
コード例 #13
0
ファイル: cstatemodifier.cpp プロジェクト: busarobi/MDDAG
CNeuralNetworkStateModifier::CNeuralNetworkStateModifier(CStateProperties *originalState, unsigned int *l_dimensions, unsigned int l_numDim) : CStateModifier(getNumInitContinuousStates(originalState, l_dimensions, l_numDim),0)
{
	this->originalState = originalState;

	
	this->numDim = l_numDim;
	dimensions = new unsigned int[numDim];
	memcpy(dimensions, l_dimensions, sizeof(int) * numDim);

	normValues = false;

	for (unsigned int i = 0; i < getNumContinuousStates(); i++)
	{
		setMinValue(i, - 100000.0);
		setMaxValue(i,   100000.0);
	}
	input_mean = new ColumnVector(numDim);
	input_std = new ColumnVector(numDim);

	*input_mean = 0;
	*input_std = 1;

	// preserve normalization on the intervall [-1 1]

	for (unsigned int i = 0; i < numDim; i ++)
	{
		input_mean->element(i) =  (originalState->getMaxValue(dimensions[i]) + originalState->getMinValue(dimensions[i])) / 2.0;
		
		input_std->element(i) = (originalState->getMaxValue(dimensions[i]) - originalState->getMinValue(dimensions[i])) / 2.0;
	}

	buffVector = new ColumnVector(numDim);
}
コード例 #14
0
ファイル: cstatemodifier.cpp プロジェクト: busarobi/MDDAG
CStateVariablesChooser::CStateVariablesChooser(unsigned int numContStates,unsigned int *l_contStatesInd,unsigned int numDiscStates,unsigned int *l_discStatesInd, CStateProperties *originalState) :  CStateModifier(numContStates, numDiscStates)
{
	contStatesInd = NULL;
	discStatesInd = NULL;

	if (numContStates > 0)
	{
		contStatesInd = new unsigned int[numContStates];
		memcpy(contStatesInd, l_contStatesInd, sizeof(unsigned int) * numContStates);
	}
	if (numDiscStates > 0)
	{
		discStatesInd = new unsigned int[numDiscStates];

		memcpy(discStatesInd, l_discStatesInd, sizeof(unsigned int) * numDiscStates);
	}

	this->originalState = originalState;


	for (int i = 0; i < getNumContinuousStates(); i++)
	{
		setMinValue(i, originalState->getMinValue(contStatesInd[i]));
		setMaxValue(i, originalState->getMaxValue(contStatesInd[i]));
	}

	for (int i = 0; i < getNumDiscreteStates(); i++)
	{
		setDiscreteStateSize(i, originalState->getDiscreteStateSize(discStatesInd[i]));
	}

	
}
コード例 #15
0
ファイル: cstatemodifier.cpp プロジェクト: busarobi/MDDAG
CNeuralNetworkStateModifier::CNeuralNetworkStateModifier(CStateProperties *originalState) : CStateModifier(getNumInitContinuousStates(originalState, NULL, 0),0)
{
	this->originalState = originalState;

	for (unsigned int i = 0; i < getNumContinuousStates(); i++)
	{
		setMinValue(i, -10000.0);
		setMaxValue(i, 10000.0);
	}
	numDim = 0;
	dimensions = NULL;

	input_mean = new ColumnVector(numDim);
	input_std = new ColumnVector(numDim);

	*input_mean = 0;
	*input_std = 1;

	// preserve normalization on the intervall [-1 1]

	for (unsigned int i = 0; i < numDim; i ++)
	{
		input_mean->element(i) =  (originalState->getMaxValue(dimensions[i]) + originalState->getMinValue(dimensions[i])) / 2.0;
		
		input_std->element(i) = (originalState->getMaxValue(dimensions[i]) - originalState->getMinValue(dimensions[i])) / 2.0;
	}

	buffVector = new ColumnVector(numDim);
}
コード例 #16
0
void QmitkNumberPropertyEditor::adjustFactors(short newDecimalPlaces, bool newShowPercents)
{
    int oldMax = maxValue();
    int oldMin = minValue();

    m_DecimalPlaces = newDecimalPlaces;
    m_ShowPercents = newShowPercents;

    m_FactorPropertyToSpinbox = pow(10.0,m_DecimalPlaces);
    m_FactorSpinboxToDisplay = 1.0 / m_FactorPropertyToSpinbox;

    // commented line would set the default increase/decrease to 1.0, no matter how many decimal places are available
    //setLineStep( ROUND(m_FactorPropertyToSpinbox) );

    if ( m_ShowPercents )
    {
        m_FactorPropertyToSpinbox *= 100.0;
        //setLineStep( ROUND(0.01 *m_FactorPropertyToSpinbox) );
        setSuffix("%");
    }
    else
    {
        setSuffix("");
    }

    setMinValue(oldMin);
    setMaxValue(oldMax);
}
コード例 #17
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindMaxima::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
  reader->openFilterGroup(this, index);
  setSelectedCellArrayPath( reader->readDataArrayPath( "SelectedCellArrayPath", getSelectedCellArrayPath() ) );
  setMinValue( reader->readValue( "MinValue", getMinValue() ) );
  setNewCellArrayName( reader->readString( "NewCellArrayName", getNewCellArrayName() ) );
  reader->closeFilterGroup();
}
コード例 #18
0
/******************************************************************************
 * Set the spin box as valid or invalid.
 * If newly invalid, the value is displayed as asterisks.
 * If newly valid, the value is set to the minimum value.
 */
void TimeSpinBox::setValid(bool valid)
{
    if (valid  &&  mInvalid)
    {
        mInvalid = false;
        if (value() < mMinimumValue)
            SpinBox2::setValue(mMinimumValue);
        setSpecialValueText(QString());
        setMinValue(mMinimumValue);
    }
    else if (!valid  &&  !mInvalid)
    {
        mInvalid = true;
        setMinValue(mMinimumValue - 1);
        setSpecialValueText(QString::fromLatin1("**:**"));
        SpinBox2::setValue(mMinimumValue - 1);
    }
}
コード例 #19
0
void Normalization::init(Normalization::Type nt, double max, double min, double threshold, double amp, double elong)
{
	setType(nt);
	setMaxValue(max);
	setMinValue(min);
	setThreshold(threshold);
	setAmplitude(amp);
	setElongation(elong);
}
コード例 #20
0
ファイル: gridColorWidget.C プロジェクト: HeyJJ/ball
		void GridColorWidget::normalizationToggled(bool enabled)
		{
			if(enabled)
			{
				setMinValue(0.0f);
				setMidValue(0.5f);
				setMaxValue(1.0f);
			}
		}
コード例 #21
0
void KDoubleSpinBox::setRange( double lower, double upper, double step,
			       int precision ) {
  lower = kMin(upper, lower);
  upper = kMax(upper, lower);
  setPrecision( precision, true ); // disable bounds checking, since
  setMinValue( lower );            // it's done in set{Min,Max}Value
  setMaxValue( upper );            // anyway and we want lower, upper
  setLineStep( step );             // and step to have the right precision
}
コード例 #22
0
ファイル: moc_qwt_thermo.cpp プロジェクト: lolsborn/RovDash
int QwtThermo::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: setValue((*reinterpret_cast< double(*)>(_a[1]))); break;
        default: ;
        }
        _id -= 1;
    }
#ifndef QT_NO_PROPERTIES
      else if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< bool*>(_v) = alarmEnabled(); break;
        case 1: *reinterpret_cast< double*>(_v) = alarmLevel(); break;
        case 2: *reinterpret_cast< ScalePos*>(_v) = scalePosition(); break;
        case 3: *reinterpret_cast< int*>(_v) = spacing(); break;
        case 4: *reinterpret_cast< int*>(_v) = borderWidth(); break;
        case 5: *reinterpret_cast< double*>(_v) = maxValue(); break;
        case 6: *reinterpret_cast< double*>(_v) = minValue(); break;
        case 7: *reinterpret_cast< int*>(_v) = pipeWidth(); break;
        case 8: *reinterpret_cast< double*>(_v) = value(); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setAlarmEnabled(*reinterpret_cast< bool*>(_v)); break;
        case 1: setAlarmLevel(*reinterpret_cast< double*>(_v)); break;
        case 2: setScalePosition(*reinterpret_cast< ScalePos*>(_v)); break;
        case 3: setSpacing(*reinterpret_cast< int*>(_v)); break;
        case 4: setBorderWidth(*reinterpret_cast< int*>(_v)); break;
        case 5: setMaxValue(*reinterpret_cast< double*>(_v)); break;
        case 6: setMinValue(*reinterpret_cast< double*>(_v)); break;
        case 7: setPipeWidth(*reinterpret_cast< int*>(_v)); break;
        case 8: setValue(*reinterpret_cast< double*>(_v)); break;
        }
        _id -= 9;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 9;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 9;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
コード例 #23
0
KSimTimeSpinBox::KSimTimeSpinBox(const KSimTimeBase & time, QWidget * parent, const char * name)
	:	KSimDoubleUnitSpinBox(parent, name),
		m_time(time)
{
	setMinValue(1e-10);
	setMaxValue(1e6);
	setLineStep(1e-3);
	
	init();
}
コード例 #24
0
short ElemDDLSGOptions::importSGO(const ElemDDLSGOptions *sgo)
{
  if (sgo->isStartValueSpecified())
    {
      setStartValueSpec(TRUE);
      setStartValue(sgo->getStartValue());
    }

  if (sgo->isIncrementSpecified())
    {
      setIncrementSpec(TRUE);
      setIncrement(sgo->getIncrement());
    }

  if (sgo->isMinValueSpecified())
    {
      setMinValueSpec(TRUE);
      
      if (sgo->isNoMinValue())
        setNoMinValue(TRUE);
      else
        setMinValue(sgo->getMinValue());
    }

  if (sgo->isMaxValueSpecified())
    {
      setMaxValueSpec(TRUE);

      if (sgo->isNoMaxValue())
        setNoMaxValue(TRUE);
      else
        setMaxValue(sgo->getMaxValue());
    }

  if (sgo->isCacheSpecified())
    {
      setCacheSpec(TRUE);
      setCache(sgo->getCache());
    }

  if (sgo->isCycleSpecified())
    {
      setCycleSpec(TRUE);
      setCycle(sgo->isCycle());
    }

  if (sgo->isResetSpecified())
    {
      setResetSpec();
      setReset(sgo->isReset());
    }

  return 0;
}
コード例 #25
0
ファイル: customwidgets.cpp プロジェクト: NgoHuy/uim
void CustomSpinBox::update()
{
    if( !m_custom || m_custom->type != UCustom_Int )
        return;

    setValue( m_custom->value->as_int );
    setMinValue( m_custom->range->as_int.min );
    setMaxValue( m_custom->range->as_int.max );

    /* sync with Label */
    parentWidget()->setEnabled( m_custom->is_active );
}
コード例 #26
0
ファイル: moc_catable.cpp プロジェクト: boiarino17/epics
int caTable::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QTableWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
#ifndef QT_NO_PROPERTIES
      else if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QString*>(_v) = getPVS(); break;
        case 1: *reinterpret_cast< QString*>(_v) = getColumnSizes(); break;
        case 2: *reinterpret_cast< colMode*>(_v) = getColorMode(); break;
        case 3: *reinterpret_cast< int*>(_v) = getPrecision(); break;
        case 4: *reinterpret_cast< SourceMode*>(_v) = getPrecisionMode(); break;
        case 5: *reinterpret_cast< SourceMode*>(_v) = getLimitsMode(); break;
        case 6: *reinterpret_cast< double*>(_v) = getMaxValue(); break;
        case 7: *reinterpret_cast< double*>(_v) = getMinValue(); break;
        }
        _id -= 8;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setPVS(*reinterpret_cast< QString*>(_v)); break;
        case 1: setColumnSizes(*reinterpret_cast< QString*>(_v)); break;
        case 2: setColorMode(*reinterpret_cast< colMode*>(_v)); break;
        case 3: setPrecision(*reinterpret_cast< int*>(_v)); break;
        case 4: setPrecisionMode(*reinterpret_cast< SourceMode*>(_v)); break;
        case 5: setLimitsMode(*reinterpret_cast< SourceMode*>(_v)); break;
        case 6: setMaxValue(*reinterpret_cast< double*>(_v)); break;
        case 7: setMinValue(*reinterpret_cast< double*>(_v)); break;
        }
        _id -= 8;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 8;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
コード例 #27
0
Normalization &Normalization::operator=(const Normalization &nor)
{
	if(this != &nor){
		setMaxValue(nor.getMaxValue());
		setMinValue(nor.getMinValue());
		setThreshold(nor.getThreshold());
		setType(nor.getType());
		setAmplitude(nor.getAmplitude());
		setElongation(nor.getElongation());
	}
	return *this;
}
コード例 #28
0
/**
* Reset the colorbar parameters.
* @param cmap :: A new Mantid color map.
* @param minValue :: A new minimum value.
* @param maxValue :: A new maximum value.
* @param minPositive :: A new minimum positive value for the log scale.
* @param autoscaling :: Flag to set autoscaling of the color
*/
void InstrumentWidgetRenderTab::setupColorBar(const MantidColorMap &cmap,
                                              double minValue, double maxValue,
                                              double minPositive,
                                              bool autoscaling) {
  setMinValue(minValue, false);
  setMaxValue(maxValue, false);
  m_colorMapWidget->setMinPositiveValue(minPositive);
  m_colorMapWidget->setupColorBarScaling(cmap);
  m_autoscaling->blockSignals(true);
  m_autoscaling->setChecked(autoscaling);
  m_autoscaling->blockSignals(false);
}
コード例 #29
0
void RKSpinBox::setIntMode (int min, int max, int initial) {
	QValidator *new_validator = new QIntValidator (min, max, this);

	setMinValue (min);
	setMaxValue (max);
	setValue (initial);

	setValidator (new_validator);
	delete validator;
	validator = new_validator;
	mode = Integer;

	updateDisplay ();
}
コード例 #30
0
ファイル: moc_canumeric.cpp プロジェクト: boiarino17/epics
int caNumeric::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ENumeric::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    
#ifndef QT_NO_PROPERTIES
     if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QString*>(_v) = getPV(); break;
        case 1: *reinterpret_cast< QColor*>(_v) = getForeground(); break;
        case 2: *reinterpret_cast< QColor*>(_v) = getBackground(); break;
        case 3: *reinterpret_cast< SourceMode*>(_v) = getPrecisionMode(); break;
        case 4: *reinterpret_cast< bool*>(_v) = getFixedFormat(); break;
        case 5: *reinterpret_cast< SourceMode*>(_v) = getLimitsMode(); break;
        case 6: *reinterpret_cast< double*>(_v) = getMaxValue(); break;
        case 7: *reinterpret_cast< double*>(_v) = getMinValue(); break;
        }
        _id -= 8;
    } else if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: setPV(*reinterpret_cast< QString*>(_v)); break;
        case 1: setForeground(*reinterpret_cast< QColor*>(_v)); break;
        case 2: setBackground(*reinterpret_cast< QColor*>(_v)); break;
        case 3: setPrecisionMode(*reinterpret_cast< SourceMode*>(_v)); break;
        case 4: setFixedFormat(*reinterpret_cast< bool*>(_v)); break;
        case 5: setLimitsMode(*reinterpret_cast< SourceMode*>(_v)); break;
        case 6: setMaxValue(*reinterpret_cast< double*>(_v)); break;
        case 7: setMinValue(*reinterpret_cast< double*>(_v)); break;
        }
        _id -= 8;
    } else if (_c == QMetaObject::ResetProperty) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 8;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 8;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}