C++ QDial::setValue方法代码示例

void tst_QDial::valueChanged()
{
    QDial dial;
    dial.setMinimum(0);
    dial.setMaximum(100);
    QSignalSpy spy(&dial, SIGNAL(valueChanged(int)));
    dial.setValue(50);
    QCOMPARE(spy.count(), 1);
    spy.clear();
    dial.setValue(25);
    QCOMPARE(spy.count(), 1);
    spy.clear();
    // repeat!
    dial.setValue(25);
    QCOMPARE(spy.count(), 0);
}

/**
  @brief Initialise un widget avec une liste de parametres
  @param widget Widget parent
  @param list Liste des parametres
  @remarks Les noms des widgets doivent correspondres avec les noms de paramètres
*/
void Configurable::configToWidget(QObject* widget,ConfigParamList& list){

    //scan les elements enfants
    for(ConfigParamList::const_iterator cur = list.begin(); cur != list.end(); cur++){
        QString name = cur->first;
        QString value = cur->second->getValue();
        QWidget* child = widget->findChild<QWidget*>(name);
        if(child==0){
            QPRINT("configToWidget: "+name+" not found");
            continue;
        }

        // QLineEdit ?
        QLineEdit *lineEdit = qobject_cast<QLineEdit *>(child);
        if(lineEdit){
           lineEdit->setText(value);
           continue;
        }

        // QComboBox ?
        QComboBox *comboBox = qobject_cast<QComboBox *>(child);
        if(comboBox){
            comboBox->setCurrentIndex(comboBox->findText(value));
            continue;
         }

        // QSpinBox ?
        QSpinBox *spinBox = qobject_cast<QSpinBox *>(child);
        if(spinBox){
            spinBox->setValue(value.toInt());
            continue;
         }


        // QDoubleSpinBox ?
        QDoubleSpinBox *doubleSpinBox = qobject_cast<QDoubleSpinBox *>(child);
        if(doubleSpinBox){
            doubleSpinBox->setValue(value.toInt());
            continue;
         }

        // QTextEdit ?
        QTextEdit *textEdit = qobject_cast<QTextEdit *>(child);
        if(textEdit){
            textEdit->setPlainText(value);
            continue;
         }

        // QPlainTextEdit ?
        QPlainTextEdit *plainTextEdit = qobject_cast<QPlainTextEdit *>(child);
        if(plainTextEdit){
            plainTextEdit->setPlainText(value);
            continue;
         }

        // QTimeEdit ?
        QTimeEdit *timeEdit = qobject_cast<QTimeEdit *>(child);
        if(timeEdit){
            timeEdit->setTime(QTime::fromString(value));
            continue;
         }

        // QDateTimeEdit ?
        QDateTimeEdit *dateTimeEdit = qobject_cast<QDateTimeEdit *>(child);
        if(dateTimeEdit){
            timeEdit->setDateTime(QDateTime::fromString(value));
            continue;
         }

        // QDateEdit ?
        QDateEdit *dateEdit = qobject_cast<QDateEdit *>(child);
        if(dateEdit){
            dateEdit->setDate(QDate::fromString(value));
            continue;
         }

        // QDial ?
        QDial *dial = qobject_cast<QDial *>(child);
        if(dial){
            dial->setValue(value.toInt());
            continue;
         }

        // QSlider ?
        QSlider *slider = qobject_cast<QSlider *>(child);
        if(slider){
            slider->setValue(value.toInt());
            continue;
         }

    }

}

void tst_QDial::wrappingCheck()
{
    //This tests if dial will wrap past the maximum value back to the minimum
    //and vice versa when changing the value with a keypress
    QDial dial;
    dial.setMinimum(0);
    dial.setMaximum(100);
    dial.setSingleStep(1);
    dial.setWrapping(true);
    dial.setValue(99);
    dial.show();

    { //set value to maximum but do not wrap
        QTest::keyPress(&dial, Qt::Key_Up);
        QCOMPARE( dial.value(), 100);
    }

    { //step up once more and wrap clockwise to minimum + 1
        QTest::keyPress(&dial, Qt::Key_Up);
        QCOMPARE( dial.value(), 1);
    }

    { //step down once, and wrap anti-clockwise to minimum, then again to maximum - 1
        QTest::keyPress(&dial, Qt::Key_Down);
        QCOMPARE( dial.value(), 0);

        QTest::keyPress(&dial, Qt::Key_Down);
        QCOMPARE( dial.value(), 99);
    }

    { //when wrapping property is false no wrapping will occur
        dial.setWrapping(false);
        dial.setValue(100);

        QTest::keyPress(&dial, Qt::Key_Up);
        QCOMPARE( dial.value(), 100);

        dial.setValue(0);
        QTest::keyPress(&dial, Qt::Key_Down);
        QCOMPARE( dial.value(), 0);
    }

    { //When the step is really big or small, wrapping should still behave
        dial.setWrapping(true);
        dial.setValue(dial.minimum());
        dial.setSingleStep(305);

        QTest::keyPress(&dial, Qt::Key_Up);
        QCOMPARE( dial.value(), 5);

        dial.setValue(dial.minimum());
        QTest::keyPress(&dial, Qt::Key_Down);
        QCOMPARE( dial.value(), 95);

        dial.setMinimum(-30);
        dial.setMaximum(-4);
        dial.setSingleStep(200);
        dial.setValue(dial.minimum());
        QTest::keyPress(&dial, Qt::Key_Down);
        QCOMPARE( dial.value(), -22);
    }
}