Esempio n. 1
0
bool Widgets::slider( QWidget *parent, const QString& title, const QString& text, int minValue, int maxValue, int step, int &result )
{
    KDialog dlg( parent );
    kapp->setTopWidget( &dlg );
    dlg.setCaption( title );
    dlg.setButtons( KDialog::Ok|KDialog::Cancel );
    dlg.setModal( true );
    dlg.setDefaultButton( KDialog::Ok );

    KVBox* vbox = new KVBox( &dlg );
    dlg.setMainWidget( vbox );

    QLabel label (vbox);
    label.setText (text);
    QSlider slider (vbox);
    slider.setMinimum( minValue );
    slider.setMaximum( maxValue );
    slider.setSingleStep( step );
    slider.setTickPosition ( QSlider::TicksAbove );
    slider.setOrientation( Qt::Horizontal );
    handleXGeometry(&dlg);

    const bool retcode = (dlg.exec() == QDialog::Accepted);

    if (retcode)
        result = slider.value();

    return retcode;
}
QWidget* CameraParamsWidget::createEditorFor(const camera_v4l2::CameraParam& param)
{
	if(!param.choices.empty())
	{
		QComboBox* box = new QComboBox(m_w);
		for(uint i = 0; i < param.choices.size(); ++i)
		{
			box->addItem(
				param.choices[i].label.c_str(),
				param.choices[i].value
			);
			if(param.choices[i].value == param.value)
				box->setCurrentIndex(i);
		}

		box->setProperty("paramID", param.id);

		connect(box, SIGNAL(activated(int)), SLOT(updateComboBox()));

		return box;
	}

	if(param.minimum == 0 && param.maximum == 1)
	{
		QCheckBox* box = new QCheckBox(m_w);
		box->setChecked(param.value);

		box->setProperty("paramID", param.id);

		connect(box, SIGNAL(clicked(bool)), SLOT(updateCheckBox(bool)));

		return box;
	}

	QSlider* slider = new QSlider(Qt::Horizontal, m_w);
	slider->setMinimum(param.minimum);
	slider->setMaximum(param.maximum);
	slider->setValue(param.value);

	slider->setProperty("paramID", param.id);

	connect(slider, SIGNAL(valueChanged(int)), SLOT(updateSlider(int)));

	return slider;
}
Esempio n. 3
0
MyWidget::MyWidget(QWidget *parent)
     : QWidget(parent)
 {
    setWindowTitle(tr("Test thread project"));
    setFixedSize(550, 420);

    bQuit = new QPushButton(tr("&Quit"));
    bRnd = new QPushButton ("&RND");
    bCountDown = new QPushButton ("&Start CountDown");

    bQuit->setFont(QFont("Courier", 18, QFont::Bold));
    bRnd->setFont(QFont("Courier", 18, QFont::Bold));
    bCountDown->setFont(QFont("Courier", 18, QFont::Bold));

    lcd = new QLCDNumber();
    lcd->setSegmentStyle(QLCDNumber::Filled);
    lcd->setAutoFillBackground(1);
    lcd->display(0);

    QSlider *slider = new QSlider(Qt::Horizontal);
    slider->setRange(0, 999);
    slider->setValue(0);

    // line3 =    new QLineEdit (this);
    lnMSTime = new QLineEdit (this);

    QVBoxLayout *layout = new QVBoxLayout;
    QHBoxLayout *hLayout = new QHBoxLayout;
    connect(bQuit, SIGNAL(clicked()), qApp, SLOT(quit()));
    
    connect(bCountDown, SIGNAL(clicked()), this, SLOT (StartMyThread()));
    connect(bRnd, SIGNAL(clicked ()), this, SLOT (setValue ()));
    connect(slider, SIGNAL(valueChanged(int)), lcd, SLOT(display(int)));
    
    layout->addWidget(lcd);
    layout->addWidget(slider);
    layout->addWidget(lnMSTime);

    hLayout->addWidget(bRnd);
    hLayout->addWidget(bQuit);
    hLayout->addWidget(bCountDown);
    layout->addLayout(hLayout);
    
    setLayout(layout);
 }
void QtSliderFactory::slotRangeChanged(QtProperty *property, int min, int max)
{
    if (!m_createdEditors.contains(property))
        return;

    QtIntPropertyManager *manager = this->propertyManager(property);
    if (!manager)
        return;

    QListIterator<QSlider *> itEditor(m_createdEditors[property]);
    while (itEditor.hasNext()) {
        QSlider *editor = itEditor.next();
        editor->blockSignals(true);
        editor->setRange(min, max);
        editor->setValue(manager->value(property));
        editor->blockSignals(false);
    }
}
Esempio n. 5
0
ConnectWidget::ConnectWidget( QWidget *parent, const char *name) : QVBox(parent,name){
   QPushButton *button = new QPushButton("Sair",this,"quit");

   connect(button, SIGNAL(clicked()), qApp, SLOT(quit()));

   QLCDNumber *lcd = new QLCDNumber(2,this,"lcd");
   QSlider *slider = new QSlider(Horizontal,this,"Slider");
   slider->setRange(0, 99);
   slider->setValue(0);
   slider->setPageStep(1);

   connect( slider, SIGNAL(valueChanged(int)), lcd, SLOT(display(int)) );

   QPushButton *add = new QPushButton("Somar",this,"add");
   connect(add, SIGNAL(clicked()), slider, SLOT(addStep()));
   QPushButton *subtract = new QPushButton("Subtrair",this,"subtract");
   connect(subtract, SIGNAL(clicked()), slider, SLOT(subtractStep()));
} 
Esempio n. 6
0
void ParamWidget::SetDouble(const QString& name, double val) {
  QWidget* widget = GetWidget(name);
  QDoubleSpinBox* spinbox = dynamic_cast<QDoubleSpinBox*>(widget);
  if (spinbox) {
    spinbox->setValue(val);
    return;
  }
  QSlider* slider = dynamic_cast<QSlider*>(widget);
  if (slider) {
    const double min = slider->property("min").toDouble();
    const double step = slider->property("step").toDouble();
    const int position = static_cast<int>(round((val - min) / step));
    slider->setValue(position);
    return;
  }
  throw std::runtime_error("Unable to determine widget type for param " +
      name.toStdString());
}
Esempio n. 7
0
void QxtSpanSliderPrivate::handleMousePress(const QPoint& pos, QStyle::SubControl& control, int value, SpanHandle handle)
{
    QStyleOptionSlider opt;
    initStyleOption(&opt, handle);
    QSlider* p = &qxt_p();
    const QStyle::SubControl oldControl = control;
    control = p->style()->hitTestComplexControl(QStyle::CC_Slider, &opt, pos, p);
    const QRect sr = p->style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, p);
    if (control == QStyle::SC_SliderHandle)
    {
        position = value;
        offset = pick(pos - sr.topLeft());
        lastPressed = handle;
        p->setSliderDown(true);
    }
    if (control != oldControl)
        p->update(sr);
}
Esempio n. 8
0
Console::Console(QWidget *parent) : QWidget(parent)
{
    QPushButton* NewWorld = new QPushButton("New world", this);
    NewWorld->setFixedSize(100, 30);

    connect(NewWorld, SIGNAL(clicked(bool)), parent, SLOT(SetNewWorld()));

    QPushButton* Load = new QPushButton("Load world", this);
    Load->setFixedSize(100, 30);

    fd_load = new QFileDialog(this, "Loading");
    fd_load->setFileMode(QFileDialog::ExistingFile);

    connect(Load, SIGNAL(clicked()), fd_load, SLOT(show()));
    connect(fd_load, SIGNAL(fileSelected(const QString&)), this, SLOT(FileChosenLoad(const QString&)));

    QPushButton* Save = new QPushButton("Save world", this);
    Save->setFixedSize(100, 30);

    connect(Save, SIGNAL(clicked()), parent, SLOT(SaveFile()));

    Pause = new QPushButton("Start", this);
    Pause->setFixedSize(100, 30);

    connect(Pause, SIGNAL(clicked(bool)), parent, SLOT(Pause()));
    connect(parent, SIGNAL(Paused(const QString&)), this, SLOT(ChangeText(const QString&)));

    QSlider* slider = new QSlider(this);
    slider->setRange(0, 500);
    slider->setValue(250);
    slider->setOrientation(Qt::Horizontal);
    connect(slider, SIGNAL(valueChanged(int)), parent, SLOT(SetPeriod(int)));

    QLabel* label = new QLabel("<p align = center>- Speed +</p>", this);

    QVBoxLayout* vl = new QVBoxLayout(this);
    vl->addWidget(NewWorld);
    vl->addWidget(Load);
    vl->addWidget(Save);
    vl->addWidget(Pause);
    vl->addWidget(slider);
    vl->addWidget(label);
    setLayout(vl);
}
Esempio n. 9
0
void MainWidget::onElementSizeChanged(int value)
{
	QSlider* notifier = qobject_cast<QSlider*>(sender());
	QSlider* fbslider;

	// Zdecyduj dla ktorej kontrolki wywolano zdarzenie
	if(notifier == hsXElementSize)
	{
		lbXElementSize->setText(QLatin1String("Horizontal: ") + 
			QString::number(2 * value + 1));
		fbslider = hsYElementSize;
	}
	else
	{
		lbYElementSize->setText(QString::fromLatin1("Vertical: ") + 
			QString::number(2 * value + 1));
		fbslider = hsXElementSize;
	}

	// Jesli mamy zaznaczone 1:1 ratio
	if (cbSquare->checkState() == Qt::Checked)
	{
		if (fbslider->value() != value)
		{
			disableRecomputing = true;
			fbslider->setValue(value);
		}
	}

	emit structuringElementChanged();

	// Czy trzeba ponownie wykonac obliczenia w zwiazku ze zmiana 
	// rozmiaru elementu strukturalnego
	if (!disableRecomputing)
	{
		if((cbAutoTrigger->isChecked() && !rbNone->isChecked()) ||
		   cameraOn)
		{
			emit recomputeNeeded();
		}
	}		

	disableRecomputing = false;
}
Esempio n. 10
0
QWidget *dSettingWindow::createWidget()
{
    QWidget * widget =  new QWidget();
    
    QVBoxLayout *layout = new QVBoxLayout;
    layout->setMargin(1);
    layout->setSpacing(5);
    layout->addWidget( new QLabel("Непрозрачноть окна (заначения от 0 до 100).<br>Прозрачные окна имеют проблемы с прорисовкой!") ); 

        QSpinBox *opacitySpinBox = new QSpinBox;
        opacitySpinBox->setRange(30, 100);
        opacitySpinBox->setSingleStep(1);
        opacitySpinBox->setValue(int(window->windowOpacity()*100));
        connect(opacitySpinBox, SIGNAL(valueChanged(int)), this, SLOT(opacityValueChanged(int)));
        
        QSlider *opacitySlider = new QSlider(Qt::Horizontal);
        opacitySlider->setFocusPolicy(Qt::StrongFocus);
        opacitySlider->setTickPosition(QSlider::TicksBothSides);
        opacitySlider->setTickInterval(10);
        opacitySlider->setSingleStep(1);
        opacitySlider->setMaximum ( 100 );
        opacitySlider->setMinimum ( 30 );
        opacitySlider->setValue(opacitySpinBox->value());
        connect(opacitySlider, SIGNAL(valueChanged(int)), opacitySpinBox, SLOT(setValue(int)));
        connect(opacitySpinBox, SIGNAL(valueChanged(int)), opacitySlider, SLOT(setValue(int)));
    
        QHBoxLayout *opacityLayout = new QHBoxLayout;
        opacityLayout->setSpacing(15);
        opacityLayout->addWidget( opacitySpinBox );   
        opacityLayout->addWidget( opacitySlider );   
    
    layout->addItem( opacityLayout );   

        layout->addWidget( new QLabel("Изменение рамки окна. Есть возможность использовать стандартное окно,<br> но тогда пропадет эффект \"магнетизма\" окон.") );     
        QHBoxLayout *skinLayout = new QHBoxLayout;
        skinLayout->setSpacing(15);
        skinPushButton = new QPushButton(tr("Load skin"));
        skinPushButton->setDefault(true);
        skinPushButton->setIcon(QIcon(tr("pic/open32x32.png")));
        connect(skinPushButton, SIGNAL(clicked(bool)), this, SLOT(clickedSkinButton(bool)));
        skinLayout->addWidget( skinPushButton );
    
    
        QCheckBox *standartFrameCheckBox = new QCheckBox(tr("Стандартная рамка окна"));    
        connect(standartFrameCheckBox, SIGNAL(stateChanged(int)), this, SLOT(stateChanged(int)));
        skinLayout->addWidget( standartFrameCheckBox );
        skinLayout->addStretch ( 1 );

    layout->addItem(skinLayout);

    widget->setLayout(layout); 

    return widget; 
};
void MusicSoundKMicroSettingPopWidget::initWidget()
{
    setFixedSize(54, 24);
    setTranslucentBackground();

    m_recordCore = nullptr;
    m_containWidget->setFixedSize(310, 190);
    m_containWidget->setStyleSheet(MusicUIObject::MBackgroundStyle08 + MusicUIObject::MColorStyle03);

    QCheckBox *checkBox = new QCheckBox(tr("Hear Yourself Singing"), m_containWidget);
    checkBox->setGeometry(10, 20, 280, 25);
    checkBox->setStyleSheet(MusicUIObject::MCheckBoxStyle05);

    QCheckBox *checkBox2 = new QCheckBox(tr("Noise Elimination"), m_containWidget);
    checkBox2->setGeometry(10, 50, 280, 25);
    checkBox2->setStyleSheet(MusicUIObject::MCheckBoxStyle05);

#ifdef Q_OS_UNIX
    checkBox->setFocusPolicy(Qt::NoFocus);
    checkBox2->setFocusPolicy(Qt::NoFocus);
#endif

    QLabel *microIconLabel = new QLabel(m_containWidget);
    microIconLabel->setGeometry(10, 92, 26, 18);

    QSlider *slider = new QSlider(Qt::Horizontal, m_containWidget);
    slider->setGeometry(36, 90, 150, 25);
    slider->setStyleSheet(QString("QSlider{%1}").arg(MusicUIObject::MBackgroundStyle01) + MusicUIObject::MSliderStyle01);
    slider->setRange(0, 100);
    slider->setValue(100);
    connect(slider, SIGNAL(valueChanged(int)), SLOT(volumeChanged(int)));

    QLabel *inputLabel = new QLabel(tr("Input"), m_containWidget);
    inputLabel->setGeometry(10, 120, 50, 25);
    inputLabel->setStyleSheet(MusicUIObject::MBackgroundStyle01);
    m_inputComboBox = new QComboBox(m_containWidget);
    m_inputComboBox->setGeometry(60, 120, 230, 25);
    m_inputComboBox->setStyleSheet(MusicUIObject::MBorderStyle04);
    m_inputComboBox->setItemDelegate(new QStyledItemDelegate(m_inputComboBox));
    m_inputComboBox->view()->setStyleSheet(MusicUIObject::MScrollBarStyle01);
    foreach(const QAudioDeviceInfo &info, QAudioDeviceInfo::availableDevices(QAudio::AudioInput))
    {
        m_inputComboBox->addItem(info.deviceName());
    }
void 
UnicornVolumeSlider::installFilters()
{
    QToolButton* muteButton = findChild<QToolButton*>();
    if( muteButton )
        muteButton->installEventFilter( this );
    
    QSlider* volumeSlider = findChild<QSlider*>();
    if( volumeSlider )
    {
        volumeSlider->setOrientation( Qt::Vertical );
        volumeSlider->installEventFilter( this );
        connect( volumeSlider, SIGNAL(valueChanged(int)), SLOT(onVolumeValueChanged(int)));
    }
    
    setFixedWidth( 30 );
    layout()->setContentsMargins( 0, 10, 0, 10);
    setAutoFillBackground( false );
}
Esempio n. 13
0
void ZerosEditor::on_instance_clicked(Metabot::Component *instance)
{
    auto anchor = instance->aboveAnchor();
    if (anchor) {
        auto anchors = robot->getAnchors();
        int n = 0;
        for (auto robotAnchor : anchors) {
            if (robotAnchor == anchor) {
                if (n < sliders.size()) {
                    this->activateWindow();
                    this->setFocus();
                    QSlider *slider = sliders[n];
                    slider->setFocus();
                }
            }
            n++;
        }
    }
}
void AbstractCameraManager::on_propertyCheckbox_changed(int state) {
    if( selectedItem == NULL ) return;
    CameraProperty* prop = reinterpret_cast<CameraProperty*>( sender()->property("CameraProperty").value<quintptr>() );
    qDebug() << sender() << prop->getName().c_str();
    prop->setAuto(state == Qt::Checked);
    cameraTree_recursiveSetProperty(selectedItem, prop);

    //(de)activate slider
    if( prop->getType() == CameraManager::AUTOTRIGGER ) return;
    QSlider* slider =  reinterpret_cast<QSlider*>( sender()->property("TreeWidgetSlider").value<quintptr>() );
    qDebug() << "Qslider" << slider;
    if(state != Qt::Checked) {
        slider->setEnabled(true);
        slider->setValue(prop->getValueToSlider());
    } else {
        slider->setEnabled(false);
    }

}
Esempio n. 15
0
void ParamWidget::AddInt(const QString& name,
    int min, int max, int step, int initial_value,
    DisplayHint display_hint) {
  ExpectNameNotFound(name);

  if (display_hint == DisplayHint::kSpinBox) {
    QSpinBox* spinbox = new QSpinBox(this);
    spinbox->setRange(min, max);
    spinbox->setSingleStep(step);
    spinbox->setValue(initial_value);
    spinbox->setProperty("param_widget_type", kParamInt);
    widgets_[name] = spinbox;
    AddLabeledRow(name, spinbox);
    connect(spinbox,
        static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
        [this, name](int val) {
          emit ParamChanged(name);
        });
  } else if (display_hint == DisplayHint::kSlider) {
    QWidget* row_widget = new QWidget(this);
    QHBoxLayout* row_hbox = new QHBoxLayout(row_widget);
    QSlider* slider = new QSlider(Qt::Horizontal, this);
    slider->setRange(min, max);
    slider->setSingleStep(step);
    slider->setValue(initial_value);
    slider->setProperty("param_widget_type", kParamInt);
    QLabel* label = new QLabel(this);
    label->setText(QString::number(initial_value));
    row_hbox->addWidget(new QLabel(name, this));
    row_hbox->addWidget(slider);
    row_hbox->addWidget(label);
    widgets_[name] = slider;
    layout_->addWidget(row_widget);
    connect(slider, &QSlider::valueChanged,
        [this, name, label](int value) {
          label->setText(QString::number(value));
          emit ParamChanged(name);
        });
  } else {
    throw std::invalid_argument("Invalid display hint");
  }
}
Esempio n. 16
0
void IntervalSlider::setupUi()
{
    QVBoxLayout* intervalLyt = new QVBoxLayout();
    setLayout(intervalLyt);

    QHBoxLayout* intervalNamesLyt = new QHBoxLayout();
    intervalLyt->addLayout(intervalNamesLyt);

    QSlider* slider = new QSlider(Qt::Horizontal);
    slider->setTickPosition(QSlider::TicksBelow);
    intervalLyt->addWidget(slider);

    QHBoxLayout* demiToneScaleLyt = new QHBoxLayout();
    intervalLyt->addLayout(demiToneScaleLyt);
    for (int i=0; i<15; ++i)
    {
        QLabel* demiToneMarkerLbl = new QLabel(QString::number(i));
        demiToneScaleLyt->addWidget(demiToneMarkerLbl);
    }
}
Esempio n. 17
0
void ZoomWidget::setZoom(qreal zoom)
{
    int intZoom = qRound(zoom * 100);
    d->mZoomLabel->setText(QString("%1%").arg(intZoom));

    // Don't change slider value if we come here because the slider change,
    // avoids choppy sliding scroll.
    if (!d->mZoomUpdatedBySlider) {
        QSlider* slider = d->mZoomSlider->slider();
        SignalBlocker blocker(slider);
        int value = sliderValueForZoom(zoom);

        if (value < slider->minimum()) {
            // It is possible that we are called *before* setMinimumZoom() as
            // been called. In this case, define the minimum ourself.
            d->mZoomSlider->setMinimum(value);
        }
        d->mZoomSlider->setValue(value);
    }
}
void AbstractCameraManager::updateProperties() {
    AbstractCamera* selected = selectedCamera;
    if( selected == NULL ) return ;
    for( int i = propertiesList.topLevelItemCount()-1; i>=0; i--) {
        QTreeWidgetItem* item = propertiesList.topLevelItem(i);
        QCheckBox* checkBox = qobject_cast<QCheckBox*>( propertiesList.itemWidget(item, Ui::PropertyAuto) );
        CameraManager::CameraProperty * prop = reinterpret_cast<CameraManager::CameraProperty*>( checkBox->property("CameraProperty").value<quintptr>() );
        QSlider* slider = reinterpret_cast<QSlider*>( checkBox->property("TreeWidgetSlider").value<quintptr>() );
        //qDebug() << "updating:" << prop->getName().c_str();

        selected->updateProperty(prop);
        item->setText(Ui::PropertyValue, prop->formatValue() );
        checkBox->setChecked(prop->getAuto());

        if( prop->getType() == CameraManager::AUTOTRIGGER ) continue;
        slider->setValue(prop->getValueToSlider());
        slider->setEnabled(!prop->getAuto());

    }
}
Esempio n. 19
0
QWidgetAction *ExampleController::getMenuWidget()
{
  QSlider* slider = new QSlider(nullptr);
  slider->setOrientation(Qt::Horizontal);
  slider->setMinimum(100);
  slider->setMaximum(1000);
  slider->setValue(speed);
  QLabel* label = new QLabel("Speed", nullptr);
  QHBoxLayout* layout = new QHBoxLayout(nullptr);
  layout->addWidget(label);
  layout->addWidget(slider);
  QWidget* widget = new QWidget(nullptr);
  widget->setLayout(layout);
  QWidgetAction* action = new QWidgetAction(nullptr);
  action->setDefaultWidget(widget);

  connect(slider, SIGNAL(valueChanged(int)),
                    this, SLOT(speedChanged(int)));
  return action;
}
Esempio n. 20
0
int main(int argc, char** argv) {
  QApplication app( argc, argv );
  
  QWidget* wid = new QWidget;
  QVBoxLayout* lay = new QVBoxLayout;

  int resolution = 1000;
    

// gui::screw_viewer* viewer = new gui::screw_viewer( wid );
  // gui::patch_viewer* viewer = new gui::patch_viewer( wid );
  gui::curve_viewer* viewer = new gui::curve_viewer( wid );
  viewer->resolution( resolution );

  QString filename(argv[1]);
  
  QSlider* slider = new QSlider ( Qt::Horizontal,  wid );
  slider->setMaximum( resolution );

  QPushButton* button = new QPushButton("&Add", wid);
  

  QObject::connect( slider, SIGNAL(valueChanged( int ) ),
		    viewer, SLOT( value( int ) ) );
  
  QObject::connect( button, SIGNAL(clicked() ),
		    viewer, SLOT( add_key() ) );
  

  QObject::connect( slider, SIGNAL(valueChanged( int ) ),
		    viewer, SLOT( updateGL( ) ) );
  
  lay->addWidget(viewer);
  lay->addWidget(slider);
  lay->addWidget(button);
  
  wid->setLayout( lay );
  wid->show();

  return app.exec();
}
Esempio n. 21
0
MyWidget::MyWidget(QWidget *parent) : QWidget(parent)
{
  QPushButton *quit = new QPushButton(tr("Quit"));
  quit->setFont(QFont("Times", 18, QFont::Bold));

  QLCDNumber *lcd = new QLCDNumber(2);
  lcd->setSegmentStyle(QLCDNumber::Filled);

  QSlider *slider = new QSlider(Qt::Horizontal);
  slider->setRange(0, 99);
  slider->setValue(0);

  connect(quit, SIGNAL(clicked()), qApp, SLOT(quit()));
  connect(slider, SIGNAL(valueChanged(int)), lcd, SLOT(display(int)));

  QVBoxLayout *layout = new QVBoxLayout;
  layout->addWidget(quit);
  layout->addWidget(lcd);
  layout->addWidget(slider);
  setLayout(layout);
}
Esempio n. 22
0
bool MainWindow::eventFilter(QObject * /*obj*/, QEvent *event)
{
    if (event->type() == QEvent::Wheel) {
        QWheelEvent *wheelEvent = (QWheelEvent*)event;
        QSlider *slider = nullptr;
        if (QApplication::keyboardModifiers() & Qt::ControlModifier) {
            slider = dock->zoomLevelSlider;
        } else if (QApplication::keyboardModifiers() & Qt::ShiftModifier) {
            slider = dock->fftSizeSlider;
        }
        if (slider != nullptr) {
            if (wheelEvent->angleDelta().y() > 0) {
                slider->setValue(slider->value() + 1);
            } else if (wheelEvent->angleDelta().y() < 0) {
                slider->setValue(slider->value() - 1);
            }
            return true;
        }
    }
    return false;
}
Esempio n. 23
0
int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	QWidget *window = new QWidget;
	window->setWindowTitle("Enter Your Age");
	QSpinBox *spinBox = new QSpinBox;
	QSlider *slider = new QSlider(Qt::Horizontal);
	spinBox->setRange(0, 130);
	slider->setRange(0, 130);
	QObject::connect(spinBox, SIGNAL(valueChanged(int)),
		slider, SLOT(setValue(int)));
	QObject::connect(slider, SIGNAL(valueChanged(int)),
		spinBox, SLOT(setValue(int)));
	spinBox->setValue(35);
	QHBoxLayout *layout = new QHBoxLayout;
	layout->addWidget(spinBox);
	layout->addWidget(slider);
	window->setLayout(layout);
	window->show();
	return app.exec();
}
Esempio n. 24
0
MultiSlidingValueDialog::MultiSlidingValueDialog(QString text, int defValue,
												 int min, int max, int count,
												 QWidget *parent) :
	QDialog(parent),
	mText(text)
{
	QVBoxLayout *vbl = new QVBoxLayout(this);
	QWidget *widget = new QWidget(this);
	vbl->addWidget(widget);

	QFormLayout *fl = new QFormLayout(widget);

	for (int i = 0; i < count; i++) {
		QLabel *label = new QLabel(text, this);
		QSlider *slider = new QSlider(Qt::Horizontal, this);
		mLabels << label;
		mSliders << slider;
		slider->setObjectName(QString::number(i));
		slider->setMinimum(min);
		slider->setMaximum(max);
		connect(slider, SIGNAL(valueChanged(int)), this, SLOT(updateText(int)));
		slider->setValue(defValue);
		updateText(slider->value());
		fl->addRow(label, slider);
	}

	QDialogButtonBox *dbb = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);
	connect(dbb, SIGNAL(accepted()), this, SLOT(accept()));
	connect(dbb, SIGNAL(rejected()), this, SLOT(reject()));
	vbl->addWidget(dbb);
}
Esempio n. 25
0
int main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  //Creo objects
  QWidget *window = new QWidget;
  QLabel *label = new QLabel("<h3><font color=red>Soy un label</color></h3><u>underline</u><b>bold</b><i>cursivo</i>");
  QPushButton *button = new QPushButton("Soy un boton");
  QLineEdit *textbox = new QLineEdit();
  QCheckBox *cajita = new QCheckBox();
  QRadioButton *botoncito = new QRadioButton();
  QSpinBox *spinbox = new QSpinBox;
  QSlider *slider = new QSlider;
  QHBoxLayout *principal = new QHBoxLayout;
  QVBoxLayout *layout = new QVBoxLayout;
  QHBoxLayout *l_botones = new QHBoxLayout;
  QHBoxLayout *l_barra = new QHBoxLayout;
  //Seteo parámetros a objetos
  window->setWindowTitle("Soy un título");
  spinbox->setRange(0,130);
  slider->setRange(0,130);
  //Conecto acciones
  QObject::connect(button, SIGNAL(clicked()), &app, SLOT(quit()));
  QObject::connect(spinbox, SIGNAL(valueChanged(int)), slider, SLOT(setValue(int)));
  QObject::connect(slider, SIGNAL(valueChanged(int)), spinbox, SLOT(setValue(int)));
  //Agrego objetos al panel
  principal->addLayout(l_barra);
  principal->addLayout(layout);
  l_barra->addWidget(slider);
  layout->addWidget(label);
  layout->addWidget(button);
  layout->addWidget(textbox);
  layout->addLayout(l_botones);
  layout->addWidget(spinbox);
  l_botones->addWidget(cajita);
  l_botones->addWidget(botoncito);
  //Inicio
  window->setLayout(principal);
  window->show();
  return app.exec();
}
Esempio n. 26
0
void QSoundProcessor::open_volume_dialog()
{
    QDialog dialog;
    dialog.setWindowTitle(tr("Volume level"));
    dialog.setFixedSize(160,80);

    QVBoxLayout Lcenter;
    QGroupBox GBbox(tr("Set volume level:"));
    QHBoxLayout layout;
    QSlider slider;
    slider.setOrientation(Qt::Horizontal);
    slider.setRange(1, VOLUME_STEPS);
    slider.setTickInterval(10);
    slider.setTickPosition(QSlider::TicksBothSides);
    QLabel lable(tr("error"));
    connect(&slider, SIGNAL(valueChanged(int)), &lable, SLOT(setNum(int)));
    if(pt_audioinput)
    {
        slider.setValue( VOLUME_STEPS * pt_audioinput->volume() );
    }
    connect(&slider, SIGNAL(sliderMoved(int)), this, SLOT(set_volume(int)));
    layout.addWidget(&slider);
    layout.addWidget(&lable, 2, Qt::AlignRight);
    GBbox.setLayout(&layout);
    Lcenter.addWidget(&GBbox);
    dialog.setLayout(&Lcenter);
    dialog.exec();
}
void lightweightdialog::drawSliders(int nlights)
{
    for (int slider = 0; slider < sliders.size(); ++slider) {
        delete sliders[slider];
    }
    sliders.clear();
    weights_ = std::vector<float>(nlights);
    delete slider_layout;


    slider_layout = new QHBoxLayout(this);
    nlights_ = nlights;
    int initial_slider_value = (1/(float)nlights_) * 100;
    std::vector<float> default_weights;
    for (auto i = 0; i < nlights; ++i) {
        default_weights.push_back(1/(float)nlights_);
    }

    for (int light = 0; light < nlights_; ++light) {
        QSlider *slider = new QSlider();
        slider->setMinimum(0);
        slider->setMaximum(100);
        slider->setValue(initial_slider_value);
        slider->setObjectName(QString::number(light));
        slider->setValue(default_weights[light] * 100);
        sliders.push_back(slider);
        slider_layout->addWidget(slider);
        slider_layout->addSpacing(20);
        connect(slider, SIGNAL(sliderReleased()), this, SLOT(handleSliderRelease()));
       // connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(handleSliderChange(int)));
    }
    this->adjustSize();
}
Esempio n. 28
0
int main(int argc, char *argv[])
{
    QApplication::setGraphicsSystem("raster");
    QApplication app(argc, argv);

    QMainWindow mainWindow;

    mainWindow.resize(500, 300);
    mainWindow.setWindowTitle("PS Move API Labs - Sensor Filter");

    QWidget centralWidget;
    QBoxLayout layout(QBoxLayout::LeftToRight);
    centralWidget.setLayout(&layout);

    QTimer timer;

    QSlider slider;
    layout.addWidget(&slider);

    slider.setRange(0, 100);

    MoveGraph moveGraph;
    layout.addWidget(&moveGraph);
    mainWindow.setCentralWidget(&centralWidget);

    QObject::connect(&timer, SIGNAL(timeout()),
            &moveGraph, SLOT(readSensors()));

    QObject::connect(&slider, SIGNAL(valueChanged(int)),
            &moveGraph, SLOT(setAlpha(int)));

    slider.setValue(50);
    moveGraph.setAlpha(50);

    timer.start(1);

    mainWindow.show();

    return app.exec();
}
Esempio n. 29
0
	// Move Action
	ThymioMoveAction::ThymioMoveAction( QGraphicsItem *parent ) :
		ThymioButton(false, 0.2, false, false, parent)
	{
		setData(0, "action");
		setData(1, "move");

		QTransform transMatrix(2.0,0.0,0.0,0.0,2.3,0.0,0.0,0.0,1.0);
				
		for(int i=0; i<2; i++)
		{
			QSlider *s = new QSlider(Qt::Vertical);
			s->setRange(-500,500);
			s->setStyleSheet("QSlider::groove:vertical { width: 14px; border: 2px solid #000000; "
							  "background: qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #00FF00, stop:0.25 #FFFF00, stop:0.5 #FF0000, stop:0.75 #FFFF00, stop:1 #00FF00 ); }"
						      "QSlider::handle:vertical { "
						      "background: #FFFFFF; "
						      "border: 2px solid #000000; height: 10px; width: 20px; margin: 0px 0; }");
			s->setSliderPosition(0);

			QGraphicsProxyWidget *w = new QGraphicsProxyWidget(this);
			w->setWidget(s);
			w->setPos(10+i*200, 15);
			w->setTransform(transMatrix);
			
			sliders.push_back(s);
			widgets.push_back(w);
			
			connect(s, SIGNAL(valueChanged(int)), this, SLOT(valueChangeDetected()));
			connect(s, SIGNAL(valueChanged(int)), this, SLOT(updateIRButton()));
		}		

		timer = new QTimeLine(2000);
		timer->setFrameRange(0, 100);
		timer->setCurveShape(QTimeLine::LinearCurve);
		animation = new QGraphicsItemAnimation(this);
		animation->setItem(thymioBody);
		animation->setTimeLine(timer);				
		thymioBody->setTransformOriginPoint(0,-14);//(pt[1]+pt[0]) == 0 ? 0 : (abs(pt[1])-abs(pt[0]))/(abs(pt[1])+abs(pt[0]))*22.2,-25);
	}
Esempio n. 30
0
QSlider *Window::createSliderXY()
{
    QSlider *slider = new QSlider(Qt::Vertical);
    slider->setRange(0, /*glWidget->n*/255);
    slider->setValue(100);
    slider->setSingleStep(16);
    slider->setPageStep(16);
    slider->setTickInterval(10);
    slider->setTickPosition(QSlider::TicksRight);
    return slider;
}