void PropertiesEditorItem::slotOpenColorEditor()
{
QColorDialog *dialog = new QColorDialog(parent());
dialog->setCurrentColor(mProperty.read(mObject.data()).value<QColor>());
if (dialog->exec() == QDialog::Accepted) {
mProperty.write(mObject.data(), QVariant::fromValue(dialog->currentColor()));
QPushButton *button = qobject_cast<QPushButton*>(mWidget.data());
button->setText(dialog->currentColor().name());
}
delete dialog;
}
bool VpGridDialog::eventFilter(QObject *obj, QEvent *ev)
{
if ((obj == m_ui->colorWell) || (obj == m_ui->referenceColorWell))
{
if (ev->type() == QEvent::MouseButtonRelease)
{
//QMouseEvent *event = static_cast<QMouseEvent*>(ev);
QColorDialog *colorDialog = new QColorDialog();
if (obj == m_ui->colorWell)
// Modify grid color.
colorDialog->setCurrentColor(getColor());
else
// Modify reference color.
colorDialog->setCurrentColor(getReferenceColor());
int retValue = colorDialog->exec();
if (retValue == QDialog::Accepted)
{
QColor selectedColor = colorDialog->currentColor();
if (obj == m_ui->colorWell)
// Modify grid color.
setColor(selectedColor);
else
// Modify reference color.
setReferenceColor(selectedColor);
}
delete colorDialog;
return true;
} else {
return false;
}
} else {
// Pass the event on to the parent class.
return QDialog::eventFilter(obj, ev);
}
}
void NodeConfigurationDialog::setNodeLabelColor(void)
{
if (!graph)
return;
if (!graph->numValidNodes) {
QMessageBox::information(this, tr("A Serious Lack of Nodes"), tr("No nodes to configure yet, sorry."));
return;
}
QColor clr(
graph->nodes[0].labelColor.r,
graph->nodes[0].labelColor.g,
graph->nodes[0].labelColor.b,
graph->nodes[0].labelColor.a);
QColorDialog *d = new QColorDialog(clr, this);
d->setOption(QColorDialog::ShowAlphaChannel, true);
d->exec();
if (QDialog::Accepted==d->result()) {
clr=d->currentColor();
watcher::Color c(clr.red(), clr.green(), clr.blue(), clr.alpha());
QString ss;
ss.sprintf("background-color: #%02x%02x%02x; color: #%02x%02x%02x",
clr.red(), clr.green(), clr.blue(),
(~clr.red())&0xFF, (~clr.green())&0xFF, (~clr.blue())&0xFF);
labelColorButton->setStyleSheet(ss);
if (useNodeId)
graph->nodes[curNodeId].labelColor=c;
else
for (size_t n=0; n<graph->numValidNodes; n++)
graph->nodes[n].labelColor=c;
}
}
void AdvancedSettings::onSelectorClicked()
{
int emitter = getEmitter (QObject::sender());
/* Configure the color dialog */
QString color;
QColorDialog dialog;
dialog.setCurrentColor (getColor (emitter));
dialog.setOption (QColorDialog::DontUseNativeDialog);
/* Get new color */
if (dialog.exec() == QColorDialog::Accepted)
color = QVariant (dialog.currentColor()).toString();
/* User clicked the 'Cancel' button in the color dialog */
else
return;
/* Update the line edit that matches the button that called this function */
switch (emitter) {
case Base:
ui.BaseEdit->setText (color);
break;
case Highlight:
ui.HighlightEdit->setText (color);
break;
case Background:
ui.BackgroundEdit->setText (color);
break;
case Foreground:
ui.ForegroundEdit->setText (color);
break;
}
}
void ColorEditor::slotClicked()
{
m_buttonPressed = true;
QColorDialog* dialog = new QColorDialog(this);
dialog->setCurrentColor(m_color);
if (dialog->exec()) m_color=dialog->currentColor();
delete dialog;
setFocusToParent();
emit(editingFinished());
}
void CWizPreferenceWindow::on_pushButtonBackgroundColor_clicked()
{
QColorDialog dlg;
dlg.setCurrentColor(m_app.userSettings().editorBackgroundColor());
if (dlg.exec() == QDialog::Accepted)
{
QString strColor = dlg.currentColor().name();
updateEditorBackgroundColor(strColor);
}
}
void SettingsDlg::colorDialog( const char * optionName, QString title )
{
QColorDialog dlg;
dlg.setWindowTitle(title);
dlg.setCurrentColor( getColor( optionName, 0x000000 ) );
if ( dlg.exec() == QDialog::Accepted ) {
setColor( optionName, dlg.currentColor() );
updateStyleSample();
}
}
void ChatBrowser::backGroundChanged()
{
QColorDialog dialog;
dialog.setCurrentColor(m_bgColor);
if(dialog.exec()==QDialog::Accepted)
{
m_bgColor=dialog.currentColor();
setStyleSheet(QString("QTextBrowser { background:%1;}").arg(m_bgColor.name()));
}
}
void PreferencesDialog::on_waveView_doubleClicked(const QModelIndex &index)
{
if (index.column() == 1) {
QColorDialog a;
if (!(index.flags() & Qt::ItemIsEnabled)) return;
quint32 color = index.data(Qt::UserRole).toUInt();
a.setCurrentColor(QColor((QRgb)color));
if (a.exec() == QColorDialog::Accepted) {
quint32 cv = a.currentColor().rgba();
waveFilterModel->setData(index, cv, Qt::UserRole);
waveFilterModel->setData(index, a.currentColor(), Qt::BackgroundRole);
}
}
}
void MainWindow::on_actionSet_background_color_2_triggered()
{
QColorDialog dialog;
dialog.setCurrentColor(mBackgroundColor);
int result = dialog.exec();
if (result)
{
mBackgroundColor = dialog.currentColor();
}
}
void QReportPropertyPageLineType::on_pushButtonSelectColor_clicked()
{
QColorDialog *dlg = new QColorDialog();
dlg->exec();
QPalette palette;
QBrush brush( dlg->currentColor() );
brush.setStyle(Qt::SolidPattern);
palette.setBrush(QPalette::Active, QPalette::Base, brush);
palette.setBrush(QPalette::Inactive, QPalette::Base, brush);
textBrowserColorBox->setPalette(palette);
//textBrowserColorBox->palette().setColor( QPalette::Base, dlg->currentColor() );
}
void Control3DWidget::onLightColorPicker()
{
QColorDialog* pDialog = new QColorDialog(this);
pDialog->setCurrentColor(m_colCurrentLightColor);
//Update all connected View3D's scene colors
connect(pDialog, &QColorDialog::currentColorChanged,
this, &Control3DWidget::onLightColorChanged);
pDialog->exec();
m_colCurrentLightColor = pDialog->currentColor();
//Set color of button new new scene color
ui->m_pushButton_lightColorPicker->setStyleSheet(QString("background-color: rgb(%1, %2, %3);").arg(m_colCurrentLightColor.red()).arg(m_colCurrentLightColor.green()).arg(m_colCurrentLightColor.blue()));
}
void CDialogIrcSettings::on_toolButtonChangeColorLink_clicked()
{
QColorDialog* dlgColor = new QColorDialog( this );
dlgColor->setCurrentColor( m_ColorLink );
int result = dlgColor->exec();
if ( result == QDialog::Accepted )
{
m_ColorLink = dlgColor->currentColor();
ui->labelColorLink->setStyleSheet( QString( "background-color: %1;" ).arg( m_ColorLink.name() ) );
ui->pushButtonApply->setEnabled( true );
}
}
//--------------------------------------------------------------------------------------
void RMapObjectTableViewDelegate::setModelData(QWidget *editor,
QAbstractItemModel *model,
const QModelIndex &index) const
{
switch (index.data(Qt::UserRole).toInt()) {
case RMapObjectModel::ET_COLOR_SELECTOR: {
QColorDialog *colorbox = static_cast<QColorDialog *>(editor);
if (colorbox->result() == QDialog::Accepted) {
QColor color = colorbox->currentColor();
model->setData(index, color, Qt::EditRole);
}
break;
}
case RMapObjectModel::ET_FONT_SELECTOR: {
RFontSelectorDialog *fontSelector = static_cast<RFontSelectorDialog *>(editor);
if (fontSelector->result() == QDialog::Accepted) {
const RFontDescriptor *fd = fontSelector->currentFontDescriptor();
model->setData(index, qVariantFromValue(fd), Qt::EditRole);
}
break;
}
case RMapObjectModel::ET_PICTURE_SELECTOR: {
RPictureSelectorDialog *pictureSelector = static_cast<RPictureSelectorDialog *>(editor);
if (pictureSelector->result() == QDialog::Accepted) {
const RImageDescriptor *id = pictureSelector->currentImageDescriptor();
model->setData(index, qVariantFromValue(id), Qt::EditRole);
}
break;
}
case RMapObjectModel::ET_REFS_SELECTOR: {
QComboBox *refsSelector = static_cast<QComboBox *>(editor);
int row = refsSelector->currentIndex();
int data = refsSelector->itemData(row).toInt();
const RRefsDescriptor *rd = &RMapRegistry::instance().getRefsDescriptorById(data);
model->setData(index, qVariantFromValue(rd), Qt::EditRole);
break;
}
default:
QItemDelegate::setModelData(editor, model, index);
break;
}
}
void ColorsIcon::pickColor(QPalette::ColorRole role)
{
// TODO: QColorDialog is bugged. Corrupts alpha when no adjustment occurs.
QColorDialog dlg;
dlg.setOption(QColorDialog::DontUseNativeDialog);
dlg.setOption(QColorDialog::ShowAlphaChannel);
dlg.setCurrentColor(role == QPalette::Foreground ? mPen : mBrush);
dlg.setWindowTitle(role == QPalette::Foreground ?
tr("Select pen color") :
tr("Select brush color"));
// Execute dialog
if(dlg.exec() == QDialog::Accepted) {
// Emit color change
emit colorPicked(role, dlg.currentColor());
}
}
void cQSettingsDialog::OnColorClicked( bool iChecked )
/**********************************************************************/
{
QPushButton *vSender = (QPushButton*)sender();
Ogre::ColourValue *iColor = (Ogre::ColourValue*)(qvariant_cast<void*>(vSender->property("OgreColor")));
QColorDialog vDialog;
vDialog.setCurrentColor( QColor( iColor->r * 255, iColor->g * 255, iColor->b * 255 ) );
if ( !vDialog.exec() ) return;
QColor vColor = vDialog.currentColor();
iColor->r = vColor.red() / 255.0f;
iColor->g = vColor.green() / 255.0f;
iColor->b = vColor.blue() / 255.0f;
QPixmap vPixmap( 24, 16 );
vPixmap.fill( vColor );
vSender->setIcon( QIcon( vPixmap ) );
}
void Control3DWidget::onSceneColorPicker()
{
QColorDialog* pDialog = new QColorDialog(this);
pDialog->setCurrentColor(m_colCurrentSceneColor);
//Update all connected View3D's scene colors
for(int i = 0; i<m_lView3D.size(); i++) {
connect(pDialog, &QColorDialog::currentColorChanged,
m_lView3D.at(i).data(), &View3D::setSceneColor);
}
pDialog->exec();
m_colCurrentSceneColor = pDialog->currentColor();
ui->m_pushButton_sceneColorPicker->setStyleSheet(QString("background-color: rgb(%1, %2, %3);").arg(m_colCurrentSceneColor.red()).arg(m_colCurrentSceneColor.green()).arg(m_colCurrentSceneColor.blue()));
}
QColor QgsColorDialog::getLiveColor( const QColor &initialColor, QObject *updateObject, const char *updateSlot, QWidget *parent, const QString &title, const bool allowAlpha )
{
QColor returnColor( initialColor );
QSettings settings;
//using native color dialogs?
bool useNative = settings.value( QStringLiteral( "/qgis/native_color_dialogs" ), false ).toBool();
if ( useNative )
{
QColorDialog* liveDialog = new QColorDialog( initialColor, parent );
liveDialog->setWindowTitle( title.isEmpty() ? tr( "Select Color" ) : title );
liveDialog->setOptions( allowAlpha ? QColorDialog::ShowAlphaChannel : ( QColorDialog::ColorDialogOption )0 );
connect( liveDialog, SIGNAL( currentColorChanged( const QColor& ) ),
updateObject, updateSlot );
if ( liveDialog->exec() )
{
returnColor = liveDialog->currentColor();
}
delete liveDialog;
}
else
{
QgsColorDialog* liveDialog = new QgsColorDialog( parent, 0, initialColor );
liveDialog->setWindowTitle( title.isEmpty() ? tr( "Select Color" ) : title );
if ( !allowAlpha )
{
liveDialog->setAllowAlpha( false );
}
connect( liveDialog, SIGNAL( currentColorChanged( const QColor& ) ),
updateObject, updateSlot );
if ( liveDialog->exec() )
{
returnColor = liveDialog->color();
}
delete liveDialog;
}
return returnColor;
}
bool DynamicObjectItemDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem&, const QModelIndex& index)
{
if (event->type() == QEvent::MouseButtonRelease)
{
auto* node = (DynamicObjectModel::Node*)index.internalPointer();
if (!node)
{
return false;
}
if (node->onClick && index.column() == 1)
{
QWidget* widget = qobject_cast<QWidget*>(parent());
QPoint pos = widget->mapToGlobal(QPoint(static_cast<QMouseEvent*>(event)->x(), static_cast<QMouseEvent*>(event)->y()));
node->onClick(widget, pos);
return true;
}
if (index.data().type() == QMetaType::QColor)
{
QColorDialog* dialog = new QColorDialog(index.data().value<QColor>());
dialog->setModal(true);
auto old_color = index.data().value<QColor>();
dialog->connect(dialog, &QColorDialog::rejected, [model, index, old_color]{
model->setData(index, old_color);
});
dialog->connect(dialog, &QColorDialog::currentColorChanged, [model, index, dialog]()
{
QColor color = dialog->currentColor();
Lumix::Vec3 value;
value.x = color.redF();
value.y = color.greenF();
value.z = color.blueF();
model->setData(index, color);
});
dialog->show();
}
else if (index.data().type() == QMetaType::Bool)
{
model->setData(index, !index.data().toBool());
return true;
}
}
return false;
}
void PreferencesDialog::on_eventTable_doubleClicked(const QModelIndex &index)
{
int row=index.row();
int col=index.column();
bool ok;
int id=ui->eventTable->item(row,3)->text().toInt(&ok);
if (col==1) {
QWidget *w=ui->eventTable->cellWidget(row,col);
QColorDialog a;
QColor color=w->palette().background().color();
a.setCurrentColor(color);
if (a.exec()==QColorDialog::Accepted) {
QColor c=a.currentColor();
QPalette p(c,c,c,c,c,c,c);
w->setPalette(p);
m_new_colors[id]=c;
//qDebug() << "Color accepted" << col << id;
}
}
}
QColor QgsColorDialog::getLiveColor( const QColor& initialColor, QObject* updateObject, const char* updateSlot,
QWidget* parent,
const QString& title,
const QColorDialog::ColorDialogOptions& options )
{
QColor returnColor( initialColor );
QColorDialog* liveDialog = new QColorDialog( initialColor, parent );
liveDialog->setWindowTitle( title.isEmpty() ? tr( "Select Color" ) : title );
liveDialog->setOptions( options );
connect( liveDialog, SIGNAL( currentColorChanged( const QColor& ) ),
updateObject, updateSlot );
if ( liveDialog->exec() )
{
returnColor = liveDialog->currentColor();
}
delete liveDialog;
liveDialog = nullptr;
return returnColor;
}
void alertas_ui::on_pushButton_Alert_changeColor_clicked()
{
if(!ui->tableWidget_AlertList->currentItem())
return;
else
if(ui->tableWidget_AlertList->currentItem()->text()=="")
return;
QString ALERTA_CODE;
QSqlQuery query;
ALERTA_CODE = ui->lineEdit_code->text();
QColor dfault = ui->tableWidget_AlertList->currentItem()->backgroundColor();
QColorDialog *palette = new QColorDialog();
palette->setCurrentColor(dfault);
palette->exec();
QColor color(palette->currentColor());
QString COLOR_VALUE = color.name();
int FILA = ui->tableWidget_AlertList->currentItem()->row();
setColorRow(ui->tableWidget_AlertList,FILA,COLOR_VALUE);
query.prepare("UPDATE e_alerta SET color=? WHERE alerta_pk="+ALERTA_CODE);
query.bindValue(0,COLOR_VALUE);
query.exec();
qDebug()<<color.rgb()<<" "<<COLOR_VALUE<<endl;
}
void BrainTreeDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
{
const BrainTreeModel* pBrainTreeModel = static_cast<const BrainTreeModel*>(index.model());
const AbstractTreeItem* pAbstractItem = static_cast<const AbstractTreeItem*>(pBrainTreeModel->itemFromIndex(index));
switch(pAbstractItem->type()) {
case BrainTreeModelItemTypes::SurfaceColorGyri: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, BrainTreeItemRoles::SurfaceColorGyri);
model->setData(index, data, Qt::DecorationRole);
return;
}
case BrainTreeModelItemTypes::SurfaceColorSulci: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, BrainTreeItemRoles::SurfaceColorSulci);
model->setData(index, data, Qt::DecorationRole);
return;
}
case BrainTreeModelItemTypes::SurfaceColorInfoOrigin: {
QComboBox* pColorDialog = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pColorDialog->currentText());
model->setData(index, data, BrainTreeItemRoles::SurfaceColorInfoOrigin);
model->setData(index, data, Qt::DisplayRole);
return;
}
case BrainTreeModelItemTypes::RTDataColormapType: {
QComboBox* pColorDialog = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pColorDialog->currentText());
model->setData(index, data, BrainTreeItemRoles::RTDataColormapType);
model->setData(index, data, Qt::DisplayRole);
return;
}
case BrainTreeModelItemTypes::RTDataNormalizationValue: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, BrainTreeItemRoles::RTDataNormalizationValue);
model->setData(index, data, Qt::DisplayRole);
break;
}
case BrainTreeModelItemTypes::RTDataTimeInterval: {
QSpinBox* pSpinBox = static_cast<QSpinBox*>(editor);
QVariant data;
data.setValue(pSpinBox->value());
model->setData(index, data, BrainTreeItemRoles::RTDataTimeInterval);
model->setData(index, data, Qt::DisplayRole);
break;
}
}
QItemDelegate::setModelData(editor, model, index);
}
void Data3DTreeDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
{
const Data3DTreeModel* pData3DTreeModel = static_cast<const Data3DTreeModel*>(index.model());
const AbstractTreeItem* pAbstractItem = static_cast<const AbstractTreeItem*>(pData3DTreeModel->itemFromIndex(index));
//Set data manually here so we can use our own item roles.
switch(pAbstractItem->type()) {
case MetaTreeItemTypes::SurfaceColorGyri: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, MetaTreeItemRoles::SurfaceColorGyri);
model->setData(index, data, Qt::DecorationRole);
break;
}
case MetaTreeItemTypes::SurfaceColorSulci: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, MetaTreeItemRoles::SurfaceColorSulci);
model->setData(index, data, Qt::DecorationRole);
break;
}
case MetaTreeItemTypes::ColormapType: {
QComboBox* pColorMapType = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pColorMapType->currentText());
model->setData(index, data, MetaTreeItemRoles::ColormapType);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::DataThreshold: {
if(Spline* pSpline = dynamic_cast<Spline*>(editor)) {
QVector3D returnVector;
returnVector = pSpline->getThreshold();
QString displayThreshold;
displayThreshold = QString("%1,%2,%3").arg(returnVector.x()).arg(returnVector.y()).arg(returnVector.z());
QVariant data;
data.setValue(displayThreshold);
model->setData(index, data, Qt::DisplayRole);
data.setValue(returnVector);
model->setData(index, data, MetaTreeItemRoles::DataThreshold);
}
break;
}
case MetaTreeItemTypes::StreamingTimeInterval: {
QSpinBox* pSpinBox = static_cast<QSpinBox*>(editor);
QVariant data;
data.setValue(pSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::StreamingTimeInterval);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::VisualizationType: {
QComboBox* pVisType = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pVisType->currentText());
model->setData(index, data, MetaTreeItemRoles::VisualizationType);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::Color: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, MetaTreeItemRoles::Color);
model->setData(index, data, Qt::DecorationRole);
break;
}
case MetaTreeItemTypes::NumberAverages: {
QSpinBox* pSpinBox = static_cast<QSpinBox*>(editor);
QVariant data;
data.setValue(pSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::NumberAverages);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::AlphaValue: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::AlphaValue);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::SurfaceTessInner: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::SurfaceTessInner);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::SurfaceTessOuter: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::SurfaceTessOuter);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::SurfaceTriangleScale: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::SurfaceTriangleScale);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::TranslateX: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::TranslateX);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::TranslateY: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::TranslateY);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::TranslateZ: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::TranslateZ);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::Scale: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::Scale);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::MaterialType: {
QComboBox* pComboBox = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pComboBox->currentText());
model->setData(index, data, MetaTreeItemRoles::SurfaceMaterial);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::CancelDistance: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::CancelDistance);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::InterpolationFunction: {
QComboBox* pColorMapType = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pColorMapType->currentText());
model->setData(index, data, MetaTreeItemRoles::InterpolationFunction);
model->setData(index, data, Qt::DisplayRole);
break;
}
// Handle all other item types via QItemDelegate::setModelData handling
default: {
QItemDelegate::setModelData(editor, model, index);
break;
}
}
}
void Data3DTreeDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
{
const Data3DTreeModel* pData3DTreeModel = static_cast<const Data3DTreeModel*>(index.model());
const AbstractTreeItem* pAbstractItem = static_cast<const AbstractTreeItem*>(pData3DTreeModel->itemFromIndex(index));
switch(pAbstractItem->type()) {
case MetaTreeItemTypes::SurfaceColorGyri: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, MetaTreeItemRoles::SurfaceColorGyri);
model->setData(index, data, Qt::DecorationRole);
return;
}
case MetaTreeItemTypes::SurfaceColorSulci: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, MetaTreeItemRoles::SurfaceColorSulci);
model->setData(index, data, Qt::DecorationRole);
return;
}
case MetaTreeItemTypes::RTDataColormapType: {
QComboBox* pColorMapType = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pColorMapType->currentText());
model->setData(index, data, MetaTreeItemRoles::RTDataColormapType);
model->setData(index, data, Qt::DisplayRole);
return;
}
case MetaTreeItemTypes::RTDataNormalizationValue: {
Spline* pSpline = static_cast<Spline*>(editor);
QVector3D returnVector;
returnVector = pSpline->getThreshold();
QString displayThreshold;
displayThreshold = QString("%1,%2,%3").arg(returnVector.x()).arg(returnVector.y()).arg(returnVector.z());
QVariant dataDisplay;
dataDisplay.setValue(displayThreshold);
model->setData(index, dataDisplay, Qt::DisplayRole);
model->setData(index, returnVector, MetaTreeItemRoles::RTDataNormalizationValue);
return;
}
case MetaTreeItemTypes::RTDataTimeInterval: {
QSpinBox* pSpinBox = static_cast<QSpinBox*>(editor);
QVariant data;
data.setValue(pSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::RTDataTimeInterval);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::RTDataVisualizationType: {
QComboBox* pVisType = static_cast<QComboBox*>(editor);
QVariant data;
data.setValue(pVisType->currentText());
model->setData(index, data, MetaTreeItemRoles::RTDataVisualizationType);
model->setData(index, data, Qt::DisplayRole);
return;
}
case MetaTreeItemTypes::SurfaceColor: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, MetaTreeItemRoles::SurfaceColor);
model->setData(index, data, Qt::DecorationRole);
return;
}
case MetaTreeItemTypes::PointColor: {
QColorDialog* pColorDialog = static_cast<QColorDialog*>(editor);
QColor color = pColorDialog->currentColor();
QVariant data;
data.setValue(color);
model->setData(index, data, MetaTreeItemRoles::PointColor);
model->setData(index, data, Qt::DecorationRole);
return;
}
case MetaTreeItemTypes::RTDataNumberAverages: {
QSpinBox* pSpinBox = static_cast<QSpinBox*>(editor);
QVariant data;
data.setValue(pSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::RTDataNumberAverages);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::SurfaceAlpha: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::SurfaceAlpha);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::SurfaceTranslateX: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::SurfaceTranslateX);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::SurfaceTranslateY: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::SurfaceTranslateY);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::SurfaceTranslateZ: {
QDoubleSpinBox* pDoubleSpinBox = static_cast<QDoubleSpinBox*>(editor);
QVariant data;
data.setValue(pDoubleSpinBox->value());
model->setData(index, data, MetaTreeItemRoles::SurfaceTranslateZ);
model->setData(index, data, Qt::DisplayRole);
break;
}
case MetaTreeItemTypes::NetworkThreshold: {
Spline* pSpline = static_cast<Spline*>(editor);
QVector3D returnVector;
returnVector = pSpline->getThreshold();
QString displayThreshold;
displayThreshold = QString("%1,%2,%3").arg(returnVector.x()).arg(returnVector.y()).arg(returnVector.z());
QVariant dataDisplay;
dataDisplay.setValue(displayThreshold);
model->setData(index, dataDisplay, Qt::DisplayRole);
model->setData(index, returnVector, MetaTreeItemRoles::NetworkThreshold);
return;
}
default: // do nothing;
break;
}
QItemDelegate::setModelData(editor, model, index);
}
