void QgsRelationReferenceWidget::init()
{
if ( !mReadOnlySelector && mComboBox->count() == 0 && mReferencedLayer )
{
QApplication::setOverrideCursor( Qt::WaitCursor );
QSet<QString> requestedAttrs;
QgsVectorLayerCache* layerCache = new QgsVectorLayerCache( mReferencedLayer, 100000, this );
if ( !mFilterFields.isEmpty() )
{
Q_FOREACH ( const QString& fieldName, mFilterFields )
{
QVariantList uniqueValues;
int idx = mReferencedLayer->fields().lookupField( fieldName );
QComboBox* cb = new QComboBox();
cb->setProperty( "Field", fieldName );
cb->setProperty( "FieldAlias", mReferencedLayer->attributeDisplayName( idx ) );
mFilterComboBoxes << cb;
mReferencedLayer->uniqueValues( idx, uniqueValues );
cb->addItem( mReferencedLayer->attributeDisplayName( idx ) );
QVariant nullValue = QSettings().value( QStringLiteral( "qgis/nullValue" ), "NULL" );
cb->addItem( nullValue.toString(), QVariant( mReferencedLayer->fields().at( idx ).type() ) );
qSort( uniqueValues.begin(), uniqueValues.end(), qgsVariantLessThan );
Q_FOREACH ( const QVariant& v, uniqueValues )
{
cb->addItem( v.toString(), v );
}
void ParamWidget::AddEnum(const QString& name,
const EnumVector& items,
int initial_value,
DisplayHint display_hint) {
ExpectNameNotFound(name);
if (display_hint != DisplayHint::kComboBox) {
throw std::invalid_argument("Invalid display hint");
}
QComboBox* combobox = new QComboBox(this);
combobox->setProperty("param_widget_type", kParamEnum);
bool found_initial_value = false;
for (size_t i = 0; i < items.size(); ++i) {
const EnumItem& item = items[i];
combobox->addItem(item.first, item.second);
if (item.second == initial_value) {
found_initial_value = true;
combobox->setCurrentIndex(i);
}
}
if (!found_initial_value) {
throw std::invalid_argument("Invalid initial value");
}
widgets_[name] = combobox;
AddLabeledRow(name, combobox);
connect(combobox,
static_cast<void(QComboBox::*)(int)>(&QComboBox::activated),
[this, name](int val) {
emit ParamChanged(name);
});
}
void QgsRelationReferenceWidget::init()
{
if ( !mReadOnlySelector && mComboBox->count() == 0 && mReferencedLayer )
{
QApplication::setOverrideCursor( Qt::WaitCursor );
QSet<QString> requestedAttrs;
QgsVectorLayerCache* layerCache = new QgsVectorLayerCache( mReferencedLayer, 100000, this );
if ( mFilterFields.size() )
{
Q_FOREACH ( const QString& fieldName, mFilterFields )
{
QVariantList uniqueValues;
int idx = mReferencedLayer->fieldNameIndex( fieldName );
QComboBox* cb = new QComboBox();
cb->setProperty( "Field", fieldName );
mFilterComboBoxes << cb;
mReferencedLayer->uniqueValues( idx, uniqueValues );
cb->addItem( mReferencedLayer->attributeAlias( idx ).isEmpty() ? fieldName : mReferencedLayer->attributeAlias( idx ) );
QVariant nullValue = QSettings().value( "qgis/nullValue", "NULL" );
cb->addItem( nullValue.toString(), QVariant( mReferencedLayer->fields()[idx].type() ) );
Q_FOREACH ( const QVariant& v, uniqueValues )
{
cb->addItem( v.toString(), v );
}
foreach(sqlb::FieldPtr f, fields)
{
QTreeWidgetItem *tbitem = new QTreeWidgetItem(ui->treeWidget);
tbitem->setFlags(tbitem->flags() | Qt::ItemIsEditable);
tbitem->setText(kName, f->name());
QComboBox* typeBox = new QComboBox(ui->treeWidget);
typeBox->setProperty("column", f->name());
typeBox->setEditable(false);
typeBox->addItems(sqlb::Field::Datatypes);
int index = typeBox->findText(f->type(), Qt::MatchExactly);
if(index == -1)
{
// non standard named type
typeBox->addItem(f->type());
index = typeBox->count() - 1;
}
typeBox->setCurrentIndex(index);
connect(typeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateTypes()));
ui->treeWidget->setItemWidget(tbitem, kType, typeBox);
tbitem->setCheckState(kNotNull, f->notnull() ? Qt::Checked : Qt::Unchecked);
tbitem->setCheckState(kPrimaryKey, f->primaryKey() ? Qt::Checked : Qt::Unchecked);
tbitem->setCheckState(kAutoIncrement, f->autoIncrement() ? Qt::Checked : Qt::Unchecked);
tbitem->setCheckState(kUnique, f->unique() ? Qt::Checked : Qt::Unchecked);
tbitem->setText(kDefault, f->defaultValue());
tbitem->setText(kCheck, f->check());
ui->treeWidget->addTopLevelItem(tbitem);
}
QWidget *ZoomAction::createWidget(QWidget *parent)
{
QComboBox *comboBox = new QComboBox(parent);
if (m_comboBoxModel.isNull()) {
m_comboBoxModel = comboBox->model();
comboBox->addItem("10 %", 0.1);
comboBox->addItem("25 %", 0.25);
comboBox->addItem("50 %", 0.5);
comboBox->addItem("100 %", 1.0);
comboBox->addItem("200 %", 2.0);
comboBox->addItem("400 %", 4.0);
comboBox->addItem("800 %", 8.0);
comboBox->addItem("1600 %", 16.0);
} else {
comboBox->setModel(m_comboBoxModel.data());
}
comboBox->setCurrentIndex(3);
connect(comboBox, SIGNAL(currentIndexChanged(int)), SLOT(emitZoomLevelChanged(int)));
connect(this, SIGNAL(indexChanged(int)), comboBox, SLOT(setCurrentIndex(int)));
comboBox->setProperty("hideborder", true);
return comboBox;
}
void VCMatrixPresetSelection::displayProperties(RGBScript *script)
{
if (script == NULL)
return;
int gridRowIdx = 0;
QList<RGBScriptProperty> properties = script->properties();
if (properties.count() > 0)
m_propertiesGroup->show();
else
m_propertiesGroup->hide();
foreach(RGBScriptProperty prop, properties)
{
switch(prop.m_type)
{
case RGBScriptProperty::List:
{
QLabel *propLabel = new QLabel(prop.m_displayName);
m_propertiesLayout->addWidget(propLabel, gridRowIdx, 0);
QComboBox *propCombo = new QComboBox(this);
propCombo->addItems(prop.m_listValues);
propCombo->setProperty("pName", prop.m_name);
QString pValue = script->property(prop.m_name);
if (!pValue.isEmpty())
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
propCombo->setCurrentText(pValue);
#else
propCombo->setCurrentIndex(propCombo->findText(pValue));
#endif
connect(propCombo, SIGNAL(currentIndexChanged(QString)),
this, SLOT(slotPropertyComboChanged(QString)));
m_propertiesLayout->addWidget(propCombo, gridRowIdx, 1);
gridRowIdx++;
}
break;
case RGBScriptProperty::Range:
{
QLabel *propLabel = new QLabel(prop.m_displayName);
m_propertiesLayout->addWidget(propLabel, gridRowIdx, 0);
QSpinBox *propSpin = new QSpinBox(this);
propSpin->setRange(prop.m_rangeMinValue, prop.m_rangeMaxValue);
propSpin->setProperty("pName", prop.m_name);
QString pValue = script->property(prop.m_name);
if (!pValue.isEmpty())
propSpin->setValue(pValue.toInt());
connect(propSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotPropertySpinChanged(int)));
m_propertiesLayout->addWidget(propSpin, gridRowIdx, 1);
gridRowIdx++;
}
break;
default:
qWarning() << "Type" << prop.m_type << "not handled yet";
break;
}
}
}
QWidget* ComboBoxDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
// Create the combobox and populate it
QComboBox *cb = new QComboBox(parent);
cb->setProperty("combobox-delegate-index", QVariant::fromValue(index));
connect(cb, SIGNAL(currentIndexChanged(int)), SLOT(updateData()));
cb->insertItems(0, index.data(Qt::UserRole).toStringList());
return cb;
}
QWidget *BackgroundAction::createWidget(QWidget *parent)
{
QComboBox *comboBox = new QComboBox(parent);
comboBox->setFixedWidth(42);
for (int i = 0; i < colors().count(); ++i) {
comboBox->addItem(tr(""));
comboBox->setItemIcon(i, iconForColor((colors().at(i))));
}
comboBox->setCurrentIndex(0);
connect(comboBox, SIGNAL(currentIndexChanged(int)), SLOT(emitBackgroundChanged(int)));
comboBox->setProperty("hideborder", true);
return comboBox;
}
QWidget* CameraParamsWidget::createEditorFor(const calibration::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;
}
void EFXEditor::updateModeColumn(QTreeWidgetItem* item, EFXFixture* ef)
{
Q_ASSERT(item != NULL);
Q_ASSERT(ef != NULL);
if (m_tree->itemWidget(item, KColumnMode) == NULL)
{
QComboBox* combo = new QComboBox(m_tree);
combo->setAutoFillBackground(true);
combo->addItems(ef->modeList());
const int index = combo->findText(ef->modeToString(ef->mode ()) );
combo->setCurrentIndex(index);
//combo->setCurrentText (ef->modeToString (ef->mode ()));
m_tree->setItemWidget(item, KColumnMode, combo);
combo->setProperty(PROPERTY_FIXTURE, (qulonglong) ef);
connect(combo, SIGNAL(currentIndexChanged(int)),
this, SLOT(slotFixtureModeChanged(int)));
}
foreach(sqlb::FieldPtr f, fields)
{
QTreeWidgetItem *tbitem = new QTreeWidgetItem(ui->treeWidget);
tbitem->setFlags(tbitem->flags() | Qt::ItemIsEditable);
tbitem->setText(kName, f->name());
QComboBox* typeBox = new QComboBox(ui->treeWidget);
typeBox->setProperty("column", f->name());
typeBox->setEditable(true);
typeBox->addItems(sqlb::Field::Datatypes);
int index = typeBox->findText(f->type(), Qt::MatchExactly);
if(index == -1)
{
// non standard named type
typeBox->addItem(f->type());
index = typeBox->count() - 1;
}
typeBox->setCurrentIndex(index);
connect(typeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateTypes()));
ui->treeWidget->setItemWidget(tbitem, kType, typeBox);
tbitem->setCheckState(kNotNull, f->notnull() ? Qt::Checked : Qt::Unchecked);
tbitem->setCheckState(kPrimaryKey, pk.contains(f) ? Qt::Checked : Qt::Unchecked);
tbitem->setCheckState(kAutoIncrement, f->autoIncrement() ? Qt::Checked : Qt::Unchecked);
tbitem->setCheckState(kUnique, f->unique() ? Qt::Checked : Qt::Unchecked);
// For the default value check if it is surrounded by parentheses and if that's the case
// add a '=' character before the entire string to match the input format we're expecting
// from the user when using functions in the default value field.
if(f->defaultValue().startsWith('(') && f->defaultValue().endsWith(')'))
tbitem->setText(kDefault, "=" + f->defaultValue());
else
tbitem->setText(kDefault, f->defaultValue());
tbitem->setText(kCheck, f->check());
QSharedPointer<sqlb::ForeignKeyClause> fk = m_table.constraint(f, sqlb::Constraint::ForeignKeyConstraintType).dynamicCast<sqlb::ForeignKeyClause>();
if(fk)
tbitem->setText(kForeignKey, fk->toString());
ui->treeWidget->addTopLevelItem(tbitem);
}
QWidget *ZoomAction::createWidget(QWidget *parent)
{
QComboBox *comboBox = new QComboBox(parent);
if (m_comboBoxModel.isNull()) {
m_comboBoxModel = comboBox->model();
comboBox->addItem(QLatin1String("6.25 %"), 0.0625);
comboBox->addItem(QLatin1String("12.5 %"), 0.125);
comboBox->addItem(QLatin1String("25 %"), 0.25);
comboBox->addItem(QLatin1String("33 %"), 0.33);
comboBox->addItem(QLatin1String("50 %"), 0.5);
comboBox->addItem(QLatin1String("66 %"), 0.66);
comboBox->addItem(QLatin1String("75 %"), 0.75);
comboBox->addItem(QLatin1String("90 %"), 0.90);
comboBox->addItem(QLatin1String("100 %"), 1.0);
comboBox->addItem(QLatin1String("125 %"), 1.25);
comboBox->addItem(QLatin1String("150 %"), 1.5);
comboBox->addItem(QLatin1String("175 %"), 1.75);
comboBox->addItem(QLatin1String("200 %"), 2.0);
comboBox->addItem(QLatin1String("300 %"), 3.0);
comboBox->addItem(QLatin1String("400 %"), 4.0);
comboBox->addItem(QLatin1String("600 %"), 6.0);
comboBox->addItem(QLatin1String("800 %"), 8.0);
comboBox->addItem(QLatin1String("1000 %"), 10.0);
comboBox->addItem(QLatin1String("1600 %"), 16.0);
} else {
comboBox->setModel(m_comboBoxModel.data());
}
comboBox->setCurrentIndex(8);
connect(comboBox, SIGNAL(currentIndexChanged(int)), SLOT(emitZoomLevelChanged(int)));
connect(this, SIGNAL(indexChanged(int)), comboBox, SLOT(setCurrentIndex(int)));
comboBox->setProperty("hideborder", true);
return comboBox;
}
Channels::Channels(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, FirmwareInterface * firmware):
ModelPanel(parent, model, generalSettings, firmware)
{
QGridLayout * gridLayout = new QGridLayout(this);
bool minimize = false;
int col = 1;
if (firmware->getCapability(ChannelsName)) {
minimize=true;
addLabel(gridLayout, tr("Name"), col++);
}
addLabel(gridLayout, tr("Subtrim"), col++, minimize);
addLabel(gridLayout, tr("Min"), col++, minimize);
addLabel(gridLayout, tr("Max"), col++, minimize);
addLabel(gridLayout, tr("Direction"), col++, minimize);
if (IS_TARANIS(GetEepromInterface()->getBoard()))
addLabel(gridLayout, tr("Curve"), col++, minimize);
if (firmware->getCapability(PPMCenter))
addLabel(gridLayout, tr("PPM Center"), col++, minimize);
if (firmware->getCapability(SYMLimits))
addLabel(gridLayout, tr("Linear Subtrim"), col++, true);
for (int i=0; i<firmware->getCapability(Outputs); i++) {
col = 0;
// Channel label
QLabel *label = new QLabel(this);
label->setText(tr("Channel %1").arg(i+1));
label->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
gridLayout->addWidget(label, i+1, col++, 1, 1);
// Channel name
int nameLen = firmware->getCapability(ChannelsName);
if (nameLen > 0) {
QLineEdit * name = new QLineEdit(this);
name->setProperty("index", i);
name->setMaxLength(nameLen);
QRegExp rx(CHAR_FOR_NAMES_REGEX);
name->setValidator(new QRegExpValidator(rx, this));
name->setText(model.limitData[i].name);
connect(name, SIGNAL(editingFinished()), this, SLOT(nameEdited()));
gridLayout->addWidget(name, i+1, col++, 1, 1);
}
// Channel offset
limitsGroups << new LimitsGroup(firmware, gridLayout, i+1, col++, model.limitData[i].offset, -1000, 1000, 0);
// Channel min
limitsGroups << new LimitsGroup(firmware, gridLayout, i+1, col++, model.limitData[i].min, -model.getChannelsMax()*10, 0, -1000);
// Channel max
limitsGroups << new LimitsGroup(firmware, gridLayout, i+1, col++, model.limitData[i].max, 0, model.getChannelsMax()*10, 1000);
// Channel inversion
QComboBox * invCB = new QComboBox(this);
invCB->insertItems(0, QStringList() << tr("---") << tr("INV"));
invCB->setProperty("index", i);
invCB->setCurrentIndex((model.limitData[i].revert) ? 1 : 0);
connect(invCB, SIGNAL(currentIndexChanged(int)), this, SLOT(invEdited()));
gridLayout->addWidget(invCB, i+1, col++, 1, 1);
// Curve
if (IS_TARANIS(GetEepromInterface()->getBoard())) {
QComboBox * curveCB = new QComboBox(this);
curveCB->setProperty("index", i);
int numcurves = firmware->getCapability(NumCurves);
for (int j=-numcurves; j<=numcurves; j++) {
curveCB->addItem(CurveReference(CurveReference::CURVE_REF_CUSTOM, j).toString(), j);
}
curveCB->setCurrentIndex(model.limitData[i].curve.value+numcurves);
connect(curveCB, SIGNAL(currentIndexChanged(int)), this, SLOT(curveEdited()));
gridLayout->addWidget(curveCB, i+1, col++, 1, 1);
}
// PPM center
if (firmware->getCapability(PPMCenter)) {
QSpinBox * center = new QSpinBox(this);
center->setProperty("index", i);
center->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
center->setSuffix("us");
center->setMinimum(1375);
center->setMaximum(1625);
center->setValue(1500);
center->setValue(model.limitData[i].ppmCenter + 1500);
connect(center, SIGNAL(editingFinished()), this, SLOT(ppmcenterEdited()));
gridLayout->addWidget(center, i+1, col++, 1, 1);
}
// Symetrical limits
if (firmware->getCapability(SYMLimits)) {
QCheckBox * symlimits = new QCheckBox(this);
symlimits->setProperty("index", i);
symlimits->setChecked(model.limitData[i].symetrical);
connect(symlimits, SIGNAL(toggled(bool)), this, SLOT(symlimitsEdited()));
gridLayout->addWidget(symlimits, i+1, col++, 1, 1);
}
}
void ItemHandlerCombobox::Handle (const QDomElement& item, QWidget *pwidget)
{
QGridLayout *lay = qobject_cast<QGridLayout*> (pwidget->layout ());
QHBoxLayout *hboxLay = new QHBoxLayout;
QComboBox *box = new QComboBox (XSD_->GetWidget ());
hboxLay->addWidget (box);
XSD_->SetTooltip (box, item);
box->setObjectName (item.attribute ("property"));
box->setSizeAdjustPolicy (QComboBox::AdjustToContents);
if (item.hasAttribute ("maxVisibleItems"))
box->setMaxVisibleItems (item.attribute ("maxVisibleItems").toInt ());
bool mayHaveDataSource = item.hasAttribute ("mayHaveDataSource") &&
item.attribute ("mayHaveDataSource").toLower () == "true";
if (mayHaveDataSource)
{
const QString& prop = item.attribute ("property");
Factory_->RegisterDatasourceSetter (prop,
[this] (const QString& str, QAbstractItemModel *m, Util::XmlSettingsDialog *xsd)
{
SetDataSource (str, m, xsd);
});
Propname2Combobox_ [prop] = box;
Propname2Item_ [prop] = item;
}
hboxLay->addStretch ();
if (item.hasAttribute ("moreThisStuff"))
{
QPushButton *moreButt = new QPushButton (tr ("More stuff..."));
hboxLay->addWidget (moreButt);
moreButt->setObjectName (item.attribute ("moreThisStuff"));
connect (moreButt,
SIGNAL (released ()),
XSD_,
SLOT (handleMoreThisStuffRequested ()));
}
QDomElement option = item.firstChildElement ("option");
while (!option.isNull ())
{
const auto& images = XSD_->GetImages (option);
const auto& name = option.attribute ("name");
auto label = XSD_->GetLabel (option);
if (label.isEmpty ())
label = name;
if (!images.isEmpty ())
box->addItem (QPixmap::fromImage (images.at (0)), label, name);
else
box->addItem (label, name);
auto setColor = [&option, box] (const QString& attr, Qt::ItemDataRole role) -> void
{
if (option.hasAttribute (attr))
{
const QColor color (option.attribute (attr));
box->setItemData (box->count () - 1, color, role);
}
};
setColor ("color", Qt::ForegroundRole);
setColor ("bgcolor", Qt::BackgroundRole);
option = option.nextSiblingElement ("option");
}
connect (box,
SIGNAL (currentIndexChanged (int)),
this,
SLOT (updatePreferences ()));
QDomElement scriptContainer = item.firstChildElement ("scripts");
if (!scriptContainer.isNull ())
{
Scripter scripter (scriptContainer);
for (const auto& elm : scripter.GetOptions ())
box->addItem (scripter.HumanReadableOption (elm), elm);
}
int pos = box->findData (XSD_->GetValue (item));
if (pos != -1)
box->setCurrentIndex (pos);
else if (!mayHaveDataSource)
qWarning () << Q_FUNC_INFO
<< box
<< XSD_->GetValue (item)
<< "not found (and this item may not have a datasource)";
QLabel *label = new QLabel (XSD_->GetLabel (item));
label->setWordWrap (false);
box->setProperty ("ItemHandler", QVariant::fromValue<QObject*> (this));
box->setProperty ("SearchTerms", label->text ());
int row = lay->rowCount ();
lay->addWidget (label, row, 0, Qt::AlignRight);
lay->addLayout (hboxLay, row, 1);
}
void QgsRelationReferenceWidget::init()
{
if ( !mReadOnlySelector && mReferencedLayer )
{
QApplication::setOverrideCursor( Qt::WaitCursor );
QSet<QString> requestedAttrs;
if ( !mFilterFields.isEmpty() )
{
for ( const QString &fieldName : qgis::as_const( mFilterFields ) )
{
int idx = mReferencedLayer->fields().lookupField( fieldName );
if ( idx == -1 )
continue;
QComboBox *cb = new QComboBox();
cb->setProperty( "Field", fieldName );
cb->setProperty( "FieldAlias", mReferencedLayer->attributeDisplayName( idx ) );
mFilterComboBoxes << cb;
QVariantList uniqueValues = mReferencedLayer->uniqueValues( idx ).toList();
cb->addItem( mReferencedLayer->attributeDisplayName( idx ) );
QVariant nullValue = QgsApplication::nullRepresentation();
cb->addItem( nullValue.toString(), QVariant( mReferencedLayer->fields().at( idx ).type() ) );
std::sort( uniqueValues.begin(), uniqueValues.end(), qgsVariantLessThan );
const auto constUniqueValues = uniqueValues;
for ( const QVariant &v : constUniqueValues )
{
cb->addItem( v.toString(), v );
}
connect( cb, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsRelationReferenceWidget::filterChanged );
// Request this attribute for caching
requestedAttrs << fieldName;
mFilterLayout->addWidget( cb );
}
if ( mChainFilters )
{
QVariant nullValue = QgsApplication::nullRepresentation();
QgsFeature ft;
QgsFeatureIterator fit = mReferencedLayer->getFeatures();
while ( fit.nextFeature( ft ) )
{
const int count = std::min( mFilterComboBoxes.count(), mFilterFields.count() );
for ( int i = 0; i < count - 1; i++ )
{
QVariant cv = ft.attribute( mFilterFields.at( i ) );
QVariant nv = ft.attribute( mFilterFields.at( i + 1 ) );
QString cf = cv.isNull() ? nullValue.toString() : cv.toString();
QString nf = nv.isNull() ? nullValue.toString() : nv.toString();
mFilterCache[mFilterFields[i]][cf] << nf;
}
}
if ( !mFilterComboBoxes.isEmpty() )
{
QComboBox *cb = mFilterComboBoxes.first();
cb->setCurrentIndex( 0 );
disableChainedComboBoxes( cb );
}
}
}
else
{
mFilterContainer->hide();
}
mComboBox->setSourceLayer( mReferencedLayer );
mComboBox->setDisplayExpression( mReferencedLayer->displayExpression() );
mComboBox->setAllowNull( mAllowNull );
mComboBox->setIdentifierField( mReferencedField );
QVariant nullValue = QgsApplication::nullRepresentation();
if ( mChainFilters && mFeature.isValid() )
{
for ( int i = 0; i < mFilterFields.size(); i++ )
{
QVariant v = mFeature.attribute( mFilterFields[i] );
QString f = v.isNull() ? nullValue.toString() : v.toString();
mFilterComboBoxes.at( i )->setCurrentIndex( mFilterComboBoxes.at( i )->findText( f ) );
}
}
// Only connect after iterating, to have only one iterator on the referenced table at once
connect( mComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsRelationReferenceWidget::comboReferenceChanged );
//call it for the first time
emit mComboBox->currentIndexChanged( mComboBox->currentIndex() );
QApplication::restoreOverrideCursor();
mInitialized = true;
}
}
void ShaderParamsDialog::buildLayout()
{
QPushButton *loadButton = NULL;
QPushButton *saveButton = NULL;
QPushButton *removeButton = NULL;
QPushButton *applyButton = NULL;
QHBoxLayout *topButtonLayout = NULL;
QMenu *loadMenu = NULL;
QMenu *saveMenu = NULL;
QMenu *removeMenu = NULL;
struct video_shader *menu_shader = NULL;
struct video_shader *video_shader = NULL;
struct video_shader *avail_shader = NULL;
const char *shader_path = NULL;
unsigned i;
bool hasPasses = false;
getShaders(&menu_shader, &video_shader);
/* NOTE: For some reason, menu_shader_get() returns a COPY of what get_current_shader() gives us.
* And if you want to be able to change shader settings/parameters from both the raster menu and
* Qt at the same time... you must change BOTH or one will overwrite the other.
*
* AND, during a context reset, video_shader will be NULL but not menu_shader, so don't totally bail
* just because video_shader is NULL.
*
* Someone please fix this mess.
*/
if (video_shader)
{
avail_shader = video_shader;
if (video_shader->passes == 0)
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
}
/* Normally we'd only use video_shader, but the vulkan driver returns a NULL shader when there
* are zero passes, so just fall back to menu_shader.
*/
else if (menu_shader)
{
avail_shader = menu_shader;
if (menu_shader->passes == 0)
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
}
else
{
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
/* no shader is available yet, just keep retrying until it is */
QTimer::singleShot(0, this, SLOT(buildLayout()));
return;
}
clearLayout();
/* Only check video_shader for the path, menu_shader seems stale... e.g. if you remove all the shader passes,
* it still has the old path in it, but video_shader does not
*/
if (video_shader)
{
if (!string_is_empty(video_shader->path))
{
shader_path = video_shader->path;
setWindowTitle(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CURRENT_SHADER)) + ": " + QFileInfo(shader_path).fileName());
}
}
else if (menu_shader)
{
if (!string_is_empty(menu_shader->path))
{
shader_path = menu_shader->path;
setWindowTitle(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CURRENT_SHADER)) + ": " + QFileInfo(shader_path).fileName());
}
}
else
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
loadButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_LOAD), this);
saveButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SAVE), this);
removeButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_REMOVE), this);
applyButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_APPLY), this);
loadMenu = new QMenu(loadButton);
loadMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET), this, SLOT(onShaderLoadPresetClicked()));
loadMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SHADER_ADD_PASS), this, SLOT(onShaderAddPassClicked()));
loadButton->setMenu(loadMenu);
saveMenu = new QMenu(saveButton);
saveMenu->addAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_AS)) + "...", this, SLOT(onShaderSavePresetAsClicked()));
saveMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_CORE), this, SLOT(onShaderSaveCorePresetClicked()));
saveMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_PARENT), this, SLOT(onShaderSaveParentPresetClicked()));
saveMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_GAME), this, SLOT(onShaderSaveGamePresetClicked()));
saveButton->setMenu(saveMenu);
removeMenu = new QMenu(removeButton);
/* When there are no passes, at least on first startup, it seems video_shader erroneously shows 1 pass, with an empty source file.
* So we use menu_shader instead for that.
*/
if (menu_shader)
{
for (i = 0; i < menu_shader->passes; i++)
{
QFileInfo fileInfo(menu_shader->pass[i].source.path);
QString shaderBasename = fileInfo.completeBaseName();
QAction *action = removeMenu->addAction(shaderBasename, this, SLOT(onShaderRemovePassClicked()));
action->setData(i);
}
}
removeMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SHADER_CLEAR_ALL_PASSES), this, SLOT(onShaderClearAllPassesClicked()));
removeButton->setMenu(removeMenu);
connect(applyButton, SIGNAL(clicked()), this, SLOT(onShaderApplyClicked()));
topButtonLayout = new QHBoxLayout();
topButtonLayout->addWidget(loadButton);
topButtonLayout->addWidget(saveButton);
topButtonLayout->addWidget(removeButton);
topButtonLayout->addWidget(applyButton);
m_layout->addLayout(topButtonLayout);
/* NOTE: We assume that parameters are always grouped in order by the pass number, e.g., all parameters for pass 0 come first, then params for pass 1, etc. */
for (i = 0; avail_shader && i < avail_shader->passes; i++)
{
QFormLayout *form = NULL;
QGroupBox *groupBox = NULL;
QFileInfo fileInfo(avail_shader->pass[i].source.path);
QString shaderBasename = fileInfo.completeBaseName();
QHBoxLayout *filterScaleHBoxLayout = NULL;
QComboBox *filterComboBox = new QComboBox(this);
QComboBox *scaleComboBox = new QComboBox(this);
QToolButton *moveDownButton = NULL;
QToolButton *moveUpButton = NULL;
unsigned j = 0;
/* Sometimes video_shader shows 1 pass with no source file, when there are really 0 passes. */
if (shaderBasename.isEmpty())
continue;
hasPasses = true;
filterComboBox->setProperty("pass", i);
scaleComboBox->setProperty("pass", i);
moveDownButton = new QToolButton(this);
moveDownButton->setText("↓");
moveDownButton->setProperty("pass", i);
moveUpButton = new QToolButton(this);
moveUpButton->setText("↑");
moveUpButton->setProperty("pass", i);
/* Can't move down if we're already at the bottom. */
if (i < avail_shader->passes - 1)
connect(moveDownButton, SIGNAL(clicked()), this, SLOT(onShaderPassMoveDownClicked()));
else
moveDownButton->setDisabled(true);
/* Can't move up if we're already at the top. */
if (i > 0)
connect(moveUpButton, SIGNAL(clicked()), this, SLOT(onShaderPassMoveUpClicked()));
else
moveUpButton->setDisabled(true);
for (;;)
{
QString filterLabel = getFilterLabel(j);
if (filterLabel.isEmpty())
break;
if (j == 0)
filterLabel = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE);
filterComboBox->addItem(filterLabel, j);
j++;
}
for (j = 0; j < 7; j++)
{
QString label;
if (j == 0)
label = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE);
else
label = QString::number(j) + "x";
scaleComboBox->addItem(label, j);
}
filterComboBox->setCurrentIndex(static_cast<int>(avail_shader->pass[i].filter));
scaleComboBox->setCurrentIndex(static_cast<int>(avail_shader->pass[i].fbo.scale_x));
/* connect the signals only after the initial index is set */
connect(filterComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onFilterComboBoxIndexChanged(int)));
connect(scaleComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onScaleComboBoxIndexChanged(int)));
form = new QFormLayout();
groupBox = new QGroupBox(shaderBasename);
groupBox->setLayout(form);
groupBox->setProperty("pass", i);
groupBox->setContextMenuPolicy(Qt::CustomContextMenu);
connect(groupBox, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(onGroupBoxContextMenuRequested(const QPoint&)));
m_layout->addWidget(groupBox);
filterScaleHBoxLayout = new QHBoxLayout();
filterScaleHBoxLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Preferred));
filterScaleHBoxLayout->addWidget(new QLabel(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FILTER)) + ":", this));
filterScaleHBoxLayout->addWidget(filterComboBox);
filterScaleHBoxLayout->addWidget(new QLabel(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SCALE)) + ":", this));
filterScaleHBoxLayout->addWidget(scaleComboBox);
filterScaleHBoxLayout->addSpacerItem(new QSpacerItem(20, 0, QSizePolicy::Preferred, QSizePolicy::Preferred));
if (moveUpButton)
filterScaleHBoxLayout->addWidget(moveUpButton);
if (moveDownButton)
filterScaleHBoxLayout->addWidget(moveDownButton);
form->addRow("", filterScaleHBoxLayout);
for (j = 0; j < avail_shader->num_parameters; j++)
{
struct video_shader_parameter *param = &avail_shader->parameters[j];
if (param->pass != static_cast<int>(i))
continue;
addShaderParam(param, form);
}
}
if (!hasPasses)
{
QLabel *noParamsLabel = new QLabel(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SHADER_NO_PASSES), this);
noParamsLabel->setAlignment(Qt::AlignCenter);
m_layout->addWidget(noParamsLabel);
}
m_layout->addItem(new QSpacerItem(20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding));
/* Why is this required?? The layout is corrupt without both resizes. */
resize(width() + 1, height());
show();
resize(width() - 1, height());
}
