void Delegate::setEditorData(QWidget *editor, const QModelIndex &index) const { if ( index.column() == COLUMN_TYPE ){ setEditorData_TYPE(editor,index);return; } if ( index.column() == COLUMN_KEY_INV ){ setEditorData_KEY_INV(editor,index);return; } if ( index.column() == COLUMN_TAGE_LAMP || index.column() == COLUMN_TAGE_KEY || index.column() == COLUMN_TAGE_TIT){ setEditorData_LEdit(editor,index);return; } int value = index.model()->data(index, Qt::EditRole).toInt(); QSpinBox *spinBox = static_cast<QSpinBox*>(editor); spinBox->setValue(value); }
void FormDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const { const CGeorgesFormProxyModel * mp = dynamic_cast<const CGeorgesFormProxyModel *>(index.model()); const CGeorgesFormModel * m = dynamic_cast<const CGeorgesFormModel *>(mp->sourceModel()); const NLGEORGES::UType *type = m->getItem(mp->mapToSource(index))->getFormElm()->getType(); int numDefinitions = type->getNumDefinition(); QString value = index.model()->data(index, Qt::DisplayRole).toString(); if (numDefinitions) { QComboBox *cb = static_cast<QComboBox*>(editor); cb->setCurrentIndex(cb->findText(value)); //cb->setIconSize() } else { switch (type->getType()) { case NLGEORGES::UType::UnsignedInt: case NLGEORGES::UType::SignedInt: { QSpinBox *spinBox = static_cast<QSpinBox*>(editor); spinBox->setValue((int)value.toDouble()); break; } case NLGEORGES::UType::Double: { QDoubleSpinBox *spinBox = static_cast<QDoubleSpinBox*>(editor); spinBox->setValue(value.toDouble()); break; } case NLGEORGES::UType::Color: { break; } default: { QLineEdit *textEdit = static_cast<QLineEdit*>(editor); textEdit->setText(value); break; } } } }
void Moto::saveLimits( QSettings & set ) { QStringList names; QList<QSpinBox *> boxes; names << "maxThrottleCwMin" << "maxThrottleCwMax" << "maxThrottleCwVal" << "maxThrottleCcwMin" << "maxThrottleCcwMax" << "maxThrottleCcwVal" << "maxSpeedCwMin" << "maxSpeedCwMax" << "maxSpeedCwVal" << "maxSpeedCcwMin" << "maxSpeedCcwMax" << "maxSpeedCcwVal" << "throttleRampUpCwMin" << "throttleRampUpCwMax" << "throttleRampUpCwVal" << "throttleRampUpCcwMin" << "throttleRampUpCcwMax" << "throttleRampUpCcwVal" << "throttleRampDownCwMin" << "throttleRampDownCwMax" << "throttleRampDownCwVal" << "throttleRampDownCcwMin" << "throttleRampDownCcwMax" << "throttleRampDownCcwVal" << "stallThresholdMin" << "stallThresholdMax" << "stallThresholdVal" << "undervoltageCtrlMin" << "undervoltageCtrlMax" << "undervoltageCtrlVal" << "motorOvertempMin" << "motorOvertempMax" << "motorOvertempVal" << "controllerOvertempMin" << "cotrollerOvertempMax" << "controllerOvertempVal"; boxes << ui.maxThrottleCw << ui.maxThrottleCcw << ui.maxSpeedCw << ui.maxSpeedCcw << ui.throttleRampUpCw << ui.throttleRampUpCcw << ui.throttleRampDownCw << ui.throttleRampDownCcw << ui.stallThreshold << ui.undervoltageCtrl << ui.motorOvertemp << ui.controllerOvertemp; int index = 0; int cnt = boxes.size(); for ( int i=0; i<cnt; i++ ) { QSpinBox * s = boxes[i]; int f = s->minimum(); int t = s->maximum(); int v = s->value(); QString from = names.at( index ); QString to = names.at( index+1 ); QString val = names.at( index+2 ); index += 3; set.setValue( from, f ); set.setValue( to, t ); set.setValue( val, v ); } int v = ui.throttleMode->currentIndex(); set.setValue( "throttleModeVal", v ); v = ui.throttleType->currentIndex(); set.setValue( "throttleTypeVal", v ); v = ui.commutationMode->currentIndex(); set.setValue( "commutationModeVal", v ); v = set.value( "currentLimitVal", 0 ).toInt(); ui.currentLimit->setCurrentIndex( v ); }
void StatusDelegate::setModelData(QWidget *AEditor, QAbstractItemModel *AModel, const QModelIndex &AIndex) const { bool allowEmptyText = true; switch (AIndex.data(STR_COLUMN).toInt()) { case STC_NAME: allowEmptyText = false; case STC_MESSAGE: { QLineEdit *lineEdit = qobject_cast<QLineEdit *>(AEditor); if (lineEdit && (allowEmptyText || !lineEdit->text().trimmed().isEmpty())) { QString data = lineEdit->text(); AModel->setData(AIndex,data,Qt::DisplayRole); AModel->setData(AIndex,data,STR_VALUE); } break; } case STC_STATUS: { QComboBox *comboBox = qobject_cast<QComboBox *>(AEditor); if (comboBox) { int data = comboBox->itemData(comboBox->currentIndex()).toInt(); AModel->setData(AIndex,FStatusChanger->iconByShow(data),Qt::DecorationRole); AModel->setData(AIndex,FStatusChanger->nameByShow(data),Qt::DisplayRole); AModel->setData(AIndex,data,STR_VALUE); } break; } case STC_PRIORITY: { QSpinBox *spinBox = qobject_cast<QSpinBox *>(AEditor); if (spinBox) { int data = spinBox->value(); AModel->setData(AIndex,data,Qt::DisplayRole); AModel->setData(AIndex,data,STR_VALUE); } break; } default: QStyledItemDelegate::setModelData(AEditor,AModel,AIndex); } }
QWidget *TableDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const { if (index.column() == 0) // figure type { QComboBox *combo_editor; combo_editor = new QComboBox(parent); combo_editor->addItem(tr("Piramid")); combo_editor->addItem(tr("Prisme")); return combo_editor; } else if (index.column() == 1 || index.column() == 5) // base type { QLabel *l_base = new QLabel(parent); return l_base; } else if (index.column() == 2) // hight { QSpinBox *editor = new QSpinBox(parent); editor->setMinimum(0); editor->setMaximum(1000); return editor; } else if (index.column() == 3) // hight possicion { QRegExp rx; rx.setPattern("(\\([0-9\\-][0-9]{0,6},[0-9\\-][0-9]{0,6},[0-9\\-][0-9]{0,6}\\)){1,1}"); QRegExpValidator *validator = new QRegExpValidator(rx); QLineEdit *editor = new QLineEdit(parent); editor->setValidator(validator); QString currentText = index.model()->data(index, Qt::DisplayRole).toString(); editor->setText(currentText); return editor; } else //if (index.column() == 4) // base points { QRegExp rx; rx.setPattern("(\\([0-9\\-][0-9]{0,6},[0-9\\-][0-9]{0,6},[0-9\\-][0-9]{0,6}\\)){0," + max_number_sites + "}"); QRegExpValidator *validator = new QRegExpValidator(rx); QLineEdit *editor = new QLineEdit(parent); editor->setValidator(validator); QString currentText = index.model()->data(index, Qt::DisplayRole).toString(); editor->setText(currentText); return editor; } }
/*! \fn newViewDialog::slotPluginSelected() */ void newViewDialog::slotPluginSelected() { QString name = pluginsList->currentItem()->text(); okPushButton->setEnabled( TRUE ); QListIterator<pluginData> it(pl); while( it.hasNext() ){ pluginData data = it.next(); if ( data.name == name ){ maxSelect = data.numChannels; int comediSubdevice = comedi_find_subdevice_by_type(comediDevice,data.type_comedi,0); if( comediSubdevice >= 0){ maxChannels = comedi_get_n_channels(comediDevice, comediSubdevice); okPushButton->setEnabled(TRUE); status->setText(QString("comedi subdevice\ntype %1 found!").arg(data.type_comedi)); } else{ //comedi_perror( QString("error in %1 line %2").arg(__func__).arg(__LINE__).toStdString().c_str() ); okPushButton->setEnabled(FALSE); maxChannels = 0; status->setText(QString("comedi subdevice\ntype %1 not found!").arg(data.type_comedi)); } if( maxChannels < 0 ){ maxChannels = 0; comedi_perror( QString("error in %1 line %2").arg(__func__).arg(__LINE__).toStdString().c_str() ); } if(channelSelectors.count() < maxSelect) for( int i = channelSelectors.count(); i < maxSelect; i++ ) { QSpinBox *spinBox = new QSpinBox(); spinBox->setRange( 0, maxChannels-1 ); channelsListL->addWidget( spinBox ); channelSelectors << spinBox ; } else if(channelSelectors.count() > maxSelect) { channelSelectors.last(); for( int i = maxSelect; i< channelSelectors.count(); i++ ) delete channelSelectors.takeLast(); } } } }
void ColumnList::updateUnits() { // Replace widget suffices and table headers for(Column *col : columns) { col->colDisplayName = Unit::replacePlaceholders(col->colOrigDisplayName); QSpinBox *sb = col->getSpinBoxWidget(); if(sb != nullptr) sb->setSuffix(Unit::replacePlaceholders(sb->suffix(), col->colWidgetSuffix)); sb = col->getMinSpinBoxWidget(); if(sb != nullptr) sb->setSuffix(Unit::replacePlaceholders(sb->suffix(), col->colMinWidgetSuffix)); sb = col->getMaxSpinBoxWidget(); if(sb != nullptr) sb->setSuffix(Unit::replacePlaceholders(sb->suffix(), col->colMaxWidgetSuffix)); } if(minDistanceWidget != nullptr) minDistanceWidget->setSuffix( Unit::replacePlaceholders(minDistanceWidget->suffix(), minDistanceWidgetSuffix)); if(maxDistanceWidget != nullptr) maxDistanceWidget->setSuffix( Unit::replacePlaceholders(maxDistanceWidget->suffix(), maxDistanceWidgetSuffix)); }
QWidget *reDefaultItemEditorFactory::createEditor(QVariant::Type type, QWidget *parent) const { switch (type) { case QVariant::Bool: { QBooleanComboBox *cb = new QBooleanComboBox(parent); return cb; } case QVariant::UInt: { QSpinBox *sb = new QSpinBox(parent); sb->setFrame(false); sb->setMaximum(INT_MAX); return sb; } case QVariant::Int: { QSpinBox *sb = new QSpinBox(parent); sb->setFrame(false); sb->setMinimum(INT_MIN); sb->setMaximum(INT_MAX); return sb; } case QVariant::Date: { QDateTimeEdit *ed = new QDateEdit(parent); ed->setFrame(false); return ed; } case QVariant::Time: { QDateTimeEdit *ed = new QTimeEdit(parent); ed->setFrame(false); return ed; } case QVariant::DateTime: { QDateTimeEdit *ed = new QDateTimeEdit(parent); ed->setFrame(false); return ed; } case QVariant::Pixmap: return new QLabel(parent); case QVariant::Double: { QDoubleSpinBox *sb = new QDoubleSpinBox(parent); sb->setFrame(false); sb->setMinimum(-DBL_MAX); sb->setMaximum(DBL_MAX); return sb; } case QVariant::StringList: { QComboBox* cb = new QComboBox(parent); return cb; } case QVariant::String: default: { // the default editor is a lineedit QLineEdit *le = new QLineEdit(parent); //le->setFrame(le->style()->styleHint(QStyle::SH_ItemView_DrawDelegateFrame, 0, le)); //if (!le->style()->styleHint(QStyle::SH_ItemView_ShowDecorationSelected, 0, le)) //le->setWidgetOwnsGeometry(true); return le; } } return 0; }
void MainWindow::newFile() { QSpinBox *width = new QSpinBox; QSpinBox *height = new QSpinBox; QCheckBox *transparentBackground = new QCheckBox(tr("Transparent background")); QDialog *dialog = createNewFileDialog(width, height, transparentBackground); int ans = dialog->exec(); if (ans == QDialog::Accepted) { int w = width->value(); int h = height->value(); newFile(w, h, transparentBackground->isChecked()); } delete dialog; }
void UIPropertySetters::ChacheSizeSetter(QWidget* editor, SettingsPropertyMapper::WidgetType editorType, SettingsPropertyMapper::PropertyType propertyType, QVariant propertyValue) { if (editorType == SettingsPropertyMapper::SPINBOX) { QSpinBox* pSpinBox = qobject_cast<QSpinBox*>(editor); if (pSpinBox == NULL) { qCritical() << "SpinboxKBSetter support only ChacheSizeSetter. Unable to cast to ChacheSizeSetter."; return; } int val = propertyValue.toInt(); pSpinBox->setValue(val * 16); } else { qCritical() << "SpinboxKBSetter support only ChacheSizeSetter"; } }
void QtSpinBoxFactory::slotRangeChanged(QtProperty *property, int min, int max) { if (!m_createdEditors.contains(property)) return; QtIntPropertyManager *manager = this->propertyManager(property); if (!manager) return; QListIterator<QSpinBox *> itEditor(m_createdEditors[property]); while (itEditor.hasNext()) { QSpinBox *editor = itEditor.next(); editor->blockSignals(true); editor->setRange(min, max); editor->setValue(manager->value(property)); editor->blockSignals(false); } }
QSpinBox* new_spin_box (QBoxLayout *layout, const QString &label, int min, int max, int value, int step) { QHBoxLayout *lt_h = new QHBoxLayout; QLabel *l = new QLabel (label); QSpinBox *r = new QSpinBox; r->setSingleStep (step); r->setRange (min, max); r->setValue (value); lt_h->addWidget (l); lt_h ->addWidget (r); layout->addLayout (lt_h); return r; }
/*! Create and return the box used to modify number of states. */ QSpinBox* UiDigitalGenerator::createStatesBox() { GeneratorDevice* device = DeviceManager::instance().activeDevice() ->generatorDevice(); // Deallocation: // Toolbar takes ownership when adding this box by call to // toolBar->addWidget(mStatesBox) in createToolBar QSpinBox* box = new QSpinBox(); box->setToolTip(tr("The number of digital states to use")); box->setRange(2, device->maxNumDigitalStates()); connect(box, SIGNAL(valueChanged(int)), this, SLOT(setNumStates(int))); return box; }
QSpinBox* RenderSettingsWindow::create_integer_input( const string& widget_key, const int min, const int max, const QString& label) { QSpinBox* spinbox = create_integer_input(widget_key, min, max); const QString suffix = " " + label; spinbox->setSuffix(suffix); QString text; text.setNum(max); text.append(suffix); set_widget_width_for_text(spinbox, text, SpinBoxMargin, SpinBoxMinWidth); return spinbox; }
void x264ZoneTableDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const { int value; if (index.column() == 2) { QComboBox *comboBox = static_cast<QComboBox*>(editor); value = comboBox->currentIndex(); } else { QSpinBox *spinBox = static_cast<QSpinBox*>(editor); spinBox->interpretText(); value = spinBox->value(); } model->setData(index, value, Qt::EditRole); }
/*!\func ODelegate::setModelData * установить данные в модель * \param нет * \return нет */ void ODelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const { LOG(LOG_DEBUG, QString(__FUNCTION__) + " <" + QString::number(__LINE__) + ">"); switch(index.column()) { case 0: { IdentificatorEdit *spinBox = static_cast<IdentificatorEdit*>(editor); QString value = spinBox->text(); model->setData(index, value, Qt::EditRole); break; } case 1: { QSpinBox *spinBox = static_cast<QSpinBox*>(editor); if(spinBox) { spinBox->interpretText(); model->setData(index, spinBox->value(), Qt::EditRole); } break; } case 2: { LOG(LOG_DEBUG, QString(__FUNCTION__) + " <" + QString::number(__LINE__) + ">"); QComboBox *spinBox = static_cast<QComboBox*>(editor); if(spinBox) { QString value = spinBox->currentText(); model->setData(index, value, Qt::EditRole); } break; } case 3: { QLineEdit *spinBox = static_cast<QLineEdit*>(editor); if(spinBox) { model->setData(index, spinBox->text(), Qt::EditRole); } break; } } }
void TerrainWeightEditor::Initialize() { if (fw_->IsHeadless()) return; QUiLoader loader; loader.setLanguageChangeEnabled(true); QString str("./data/ui/terrainwtex_editor.ui"); QFile file(str); if(!file.exists()) { EnvironmentModule::LogError("Cannot find " +str.toStdString()+ " file"); return; } editor_widget_ = loader.load(&file, this); if (editor_widget_ == 0) return; // UiProxyWidget *editor_proxy = fw_->Ui()->AddWidgetToScene(this); // if (editor_proxy == 0) // return; // ui->AddWidgetToMenu(this, tr("Terrain Texture Weightmap Editor")); // ui->RegisterUniversalWidget("Weights", editor_proxy); QSpinBox *box = editor_widget_->findChild<QSpinBox*>("brush_size"); if(box) { brush_size_max_ = box->maximum(); brush_size_ = box->value(); } box = editor_widget_->findChild<QSpinBox*>("brush_modifier"); if(box) brush_modifier_ = box->maximum(); QDoubleSpinBox *dbox = editor_widget_->findChild<QDoubleSpinBox*>("brush_falloff"); if(dbox) falloff_percentage_ = dbox->value(); InitializeCanvases(); InitializeConnections(); emit BrushValueChanged(); }
QWidget* PreferencesDialog::getFontsPage() { QWidget* widget = new QWidget(); //--------------------- // Font //--------------------- GroupContainer *fontGroup = new GroupContainer; fontGroup->setTitle("Font"); //Font Size QSpinBox* fontSizeCombo = new QSpinBox; fontSizeCombo->setMinimum(8); fontSizeCombo->setMaximum(14); fontSizeCombo->setValue(QApplication::font().pointSize()); connect(fontSizeCombo, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), [=] (int i){UserPreferences().setFontSize(i);}); //Font Weight QComboBox *fontWeightCombo = new QComboBox; fontWeightCombo->addItems(QStringList() << "0" << "25" << "50" << "75"); fontWeightCombo->setCurrentText(QString::number(QApplication::font().weight())); connect(fontWeightCombo, static_cast<void(QComboBox::*)(const QString&)> (&QComboBox::currentTextChanged), [ = ] (const QString & value){UserPreferences().setFontWeight(value);}); QFormLayout *fontLayout = new QFormLayout; fontLayout->setRowWrapPolicy(QFormLayout::WrapLongRows); fontLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow); fontLayout->setFormAlignment(Qt::AlignHCenter | Qt::AlignTop); fontLayout->setLabelAlignment(Qt::AlignRight); fontLayout->addRow("Font Size", fontSizeCombo); fontLayout->addRow("Font Weight", fontWeightCombo); fontGroup->setContainerLayout(fontLayout); QVBoxLayout *mainLayout = new QVBoxLayout; mainLayout->setMargin(0); mainLayout->setSpacing(0); mainLayout->addWidget(fontGroup); mainLayout->addStretch(1); widget->setLayout(mainLayout); return widget; }
PhotoTimerDialog::PhotoTimerDialog( QWidget* parent, Qt::WFlags f ) : QDialog( parent, f ), mTimeout( 5 ), mNumber( 1 ), mInterval( 1 ), mIntervalSpin( 0 ) { setWindowTitle( tr( "Photo Timer" ) ); setModal( true); QGridLayout* layout = new QGridLayout( this ); // Add labels layout->addWidget( new QLabel( tr( "Timeout" ) ), 0, 0 ); QSpinBox* timeout = new CameraMinSecSpinBox( this ); timeout->setMinimum( 1 ); timeout->setMaximum( 120 ); timeout->setValue( mTimeout ); layout->addWidget( timeout, 0, 1 ); connect( timeout, SIGNAL(valueChanged(int)), this, SLOT(timeoutChanged(int)) ); layout->addWidget( new QLabel( tr( "Photos" ) ), 1, 0 ); QSpinBox* number = new NoEditSpinBox(this); number->setMinimum( 1 ); number->setMaximum( 50 ); number->setValue( mNumber ); layout->addWidget( number, 1, 1 ); connect( number, SIGNAL(valueChanged(int)), this, SLOT(numberChanged(int)) ); layout->addWidget( new QLabel( tr( "Interval" ) ), 2, 0 ); mIntervalSpin = new CameraMinSecSpinBox( this ); mIntervalSpin->setMinimum( 1 ); mIntervalSpin->setMaximum( 120 ); mIntervalSpin->setValue( mInterval ); mIntervalSpin->setEnabled( false ); layout->addWidget( mIntervalSpin, 2, 1 ); connect( mIntervalSpin, SIGNAL(valueChanged(int)), this, SLOT(intervalChanged(int)) ); setLayout( layout ); QtopiaApplication::setInputMethodHint(timeout,QtopiaApplication::AlwaysOff); QtopiaApplication::setInputMethodHint(number,QtopiaApplication::AlwaysOff); QtopiaApplication::setInputMethodHint(mIntervalSpin,QtopiaApplication::AlwaysOff); }
void readFromProperty(const value_type& v) { m_value = v; int prevNb = m_spinBox->value(); int nb = list_traits::size(m_value); if (prevNb != nb) { if (m_spinBox) m_spinBox->setValue(nb); resize(nb); } else { for (auto w : m_propertyWidgets) w->updateWidgetValue(); } }
void Delegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const { if ( index.column() == COLUMN_TYPE ){ setModelData_TYPE(editor,model,index);return; } if ( index.column() == COLUMN_KEY_INV ){ setModelData_KEY_INV(editor,model,index);return; } if ( index.column() == COLUMN_TAGE_LAMP || index.column() == COLUMN_TAGE_KEY || index.column() == COLUMN_TAGE_TIT){ setModelData_LEdit(editor,model,index);return; } QSpinBox *spinBox = static_cast<QSpinBox*>(editor); spinBox->interpretText(); int value = spinBox->value(); model->setData(index, value, Qt::EditRole); qDebug()<<QString("set model(%1,%2) :=%3").arg(index.column()).arg(index.row()).arg(value); }
std::pair<QWidget *, QWidget *> CSMPrefs::IntSetting::makeWidgets (QWidget *parent) { QLabel *label = new QLabel (QString::fromUtf8 (getLabel().c_str()), parent); QSpinBox *widget = new QSpinBox (parent); widget->setRange (mMin, mMax); widget->setValue (mDefault); if (!mTooltip.empty()) { QString tooltip = QString::fromUtf8 (mTooltip.c_str()); label->setToolTip (tooltip); widget->setToolTip (tooltip); } connect (widget, SIGNAL (valueChanged (int)), this, SLOT (valueChanged (int))); return std::make_pair (label, widget); }
Perlin3DObject * ImporterVSQ::Import(const std::string& path) { VSQReader reader(path); // Dialog box creation QDialog frameNbDialog; QVBoxLayout * layout = new QVBoxLayout; QSpinBox * sbNumber = new QSpinBox(&frameNbDialog); QPushButton * bOk = new QPushButton("Ok", &frameNbDialog); sbNumber->setMaximum(reader.getNbFrame()); layout->addWidget(sbNumber); layout->addWidget(bOk); frameNbDialog.setLayout(layout); QObject::connect(bOk, SIGNAL(clicked()), &frameNbDialog, SLOT(accept())); // We display the box frameNbDialog.exec(); // We get back the value int frameNumber = sbNumber->value(); int cubeSize = reader.getSize(); float * density = reader.readFrame(frameNumber); glm::ivec3 Size = glm::ivec3(); Size.x = cubeSize; Size.y = cubeSize; Size.z = cubeSize; Perlin3DObject * obj = new Perlin3DObject(Size); int cubeSizeSq = cubeSize * cubeSize; for (int i = 0; i < cubeSize; ++i) for (int j = 0; j < cubeSize; ++j) for (int k = 0; k < cubeSize; ++k){ obj->SetData(density[i * cubeSizeSq + j * cubeSize + k],j,i,k); } delete[] density; return obj; }
/*!\func IDelegate::createEditor * установить данные в виджет * \param нет * \return нет */ void IDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const { LOG(LOG_DEBUG, QString(__FUNCTION__) + " <" + QString::number(__LINE__) + ">"); switch(index.column()) { case 0: { LOG(LOG_DEBUG, QString(__FUNCTION__) + " <" + QString::number(__LINE__) + ">"); QString value = index.model()->data(index, Qt::EditRole).toString(); IdentificatorEdit *spinBox = static_cast<IdentificatorEdit*>(editor); spinBox->setText(value); } break; case 1: { LOG(LOG_DEBUG, QString(__FUNCTION__) + " <" + QString::number(__LINE__) + ">"); int value = index.model()->data(index, Qt::EditRole).toInt(); QSpinBox *spinBox = static_cast<QSpinBox*>(editor); spinBox->setValue(value); } break; case 2: { break; LOG(LOG_DEBUG, QString(__FUNCTION__) + " <" + QString::number(__LINE__) + ">"); QString value = index.model()->data(index, Qt::EditRole).toString(); QComboBox *spinBox = static_cast<QComboBox*>(editor); if(value == "reg") spinBox->setCurrentIndex(1); else spinBox->setCurrentIndex(0); } break; case 3: { LOG(LOG_DEBUG, QString(__FUNCTION__) + " <" + QString::number(__LINE__) + ">"); QString value = index.model()->data(index, Qt::EditRole).toString(); QLineEdit *spinBox = static_cast<QLineEdit*>(editor); spinBox->setText(value); } break; } }
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"); } }
void BlockBase::newEntry(const QString& text, int* value) { SettingsLock lock; QSpinBox *spinBox = new QSpinBox(this); spinBox->setMinimum(-1000000000); spinBox->setMaximum(1000000000); spinBox->setValue(*value); d_settingsLayout->addWidget(new QLabel(text,this),d_entryNum,0); d_settingsLayout->addWidget(spinBox,d_entryNum,1); connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(spinBoxChange(int)) ); spinBoxes[spinBox]=value; originalInt[value]=*value; d_entryNum++; }
QWidget *CColumnDelegate::createEditor(QWidget *parent,const QStyleOptionViewItem &option,const QModelIndex &index) const { if (columnindex==ContentIndex) { QTextEdit* editor = new QTextEdit(parent); // disable rich text, we just need multilined QLineEdit functionality :-) editor->setAcceptRichText(false); return editor; } else if (columnindex==FullIndex) { // for 'full' column(data type: boolean) we should use SpinBox editor QSpinBox* editor = new QSpinBox(parent); editor->setRange(0,1); return editor; } else return QStyledItemDelegate::createEditor(parent,option,index); }
void ProgressDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const { auto model = index.model(); auto id = model->data(model->index(index.row(), ListRoles::ID), Qt::DisplayRole); AnimePtr anime = User::sharedUser()->getAnimeByID(id.toString()); auto episodes_watched = anime->episodesWatched(); auto total_episodes = anime->totalEpisodes(); if (total_episodes == 0) { total_episodes = std::numeric_limits<int>::max(); } QSpinBox *spinBox = static_cast<QSpinBox *>(editor); spinBox->setMaximum(total_episodes); spinBox->setValue(episodes_watched); spinBox->setSuffix(" / " + QString::number(anime->totalEpisodes())); }
void qavimator::setupToolBar() { QToolBar *toolBar = ui->toolBar; QLabel *label = new QLabel("FPS:",this); QSpinBox *fpsSpin = new QSpinBox(this); fpsSpin->setMaximum(1); fpsSpin->setMaximum(50); fpsSpin->setValue(10); QIcon ico = QIcon(":/icons/resetcamera.png"); QPushButton *resetCamera = new QPushButton(ico,"",this); resetCamera->setToolTip("Reset camera view to default position"); toolBar->addWidget(label); toolBar->addWidget(fpsSpin); toolBar->addSeparator(); toolBar->addWidget(resetCamera); connect(fpsSpin,SIGNAL(valueChanged(int)),this,SLOT(onFpsSpinValueChanged(int))); connect(resetCamera,SIGNAL(clicked()),this,SLOT(onResetCamera())); }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ void USpravy_subs_Delegate::setEditorData(QWidget *editor, const QModelIndex &index) const { QSpinBox *spinbox; int value; if ( (index.column() == durationColumn_1) || (index.column() == durationColumn_2) || (index.column() == durationColumn_4) || (index.column() == durationColumn_3) || (index.column() == durationColumn_5) || (index.column() == durationColumn_6)) { value = index.model()->data(index, Qt::DisplayRole).toInt(); spinbox = qobject_cast<QSpinBox *>(editor); spinbox->setValue(value); spinbox->selectAll(); } else { QSqlRelationalDelegate::setEditorData(editor, index); } }