Qt Utilities  6.1.0
Common Qt related C++ classes and routines used by my applications such as dialogs, widgets and models
paletteeditor.cpp
Go to the documentation of this file.
1 #include "./paletteeditor.h"
2 #include "./colorbutton.h"
3 
4 #include "ui_paletteeditor.h"
5 
6 #include <QHeaderView>
7 #include <QLabel>
8 #include <QMetaProperty>
9 #include <QPainter>
10 #include <QStyle>
11 #include <QToolButton>
12 
13 namespace QtUtilities {
14 
15 enum { BrushRole = 33 };
16 
18  : QDialog(parent)
19  , m_ui(new Ui::PaletteEditor)
20  , m_currentColorGroup(QPalette::Active)
21  , m_paletteModel(new PaletteModel(this))
22  , m_modelUpdated(false)
23  , m_paletteUpdated(false)
24  , m_compute(true)
25 {
26  m_ui->setupUi(this);
27  m_ui->paletteView->setModel(m_paletteModel);
28  updatePreviewPalette();
29  updateStyledButton();
30  m_ui->paletteView->setModel(m_paletteModel);
31  auto *const delegate = new ColorDelegate(this);
32  m_ui->paletteView->setItemDelegate(delegate);
33  m_ui->paletteView->setEditTriggers(QAbstractItemView::AllEditTriggers);
34  connect(m_paletteModel, &PaletteModel::paletteChanged, this, &PaletteEditor::paletteChanged);
35  m_ui->paletteView->setSelectionBehavior(QAbstractItemView::SelectRows);
36  m_ui->paletteView->setDragEnabled(true);
37  m_ui->paletteView->setDropIndicatorShown(true);
38  m_ui->paletteView->setRootIsDecorated(false);
39  m_ui->paletteView->setColumnHidden(2, true);
40  m_ui->paletteView->setColumnHidden(3, true);
41 }
42 
44 {
45 }
46 
47 QPalette PaletteEditor::palette() const
48 {
49  return m_editPalette;
50 }
51 
52 void PaletteEditor::setPalette(const QPalette &palette)
53 {
54  m_editPalette = palette;
55  const uint mask = palette.resolve();
56  for (int i = 0; i < static_cast<int>(QPalette::NColorRoles); ++i) {
57  if (mask & (1 << i)) {
58  continue;
59  }
60  m_editPalette.setBrush(
61  QPalette::Active, static_cast<QPalette::ColorRole>(i), m_parentPalette.brush(QPalette::Active, static_cast<QPalette::ColorRole>(i)));
62  m_editPalette.setBrush(
63  QPalette::Inactive, static_cast<QPalette::ColorRole>(i), m_parentPalette.brush(QPalette::Inactive, static_cast<QPalette::ColorRole>(i)));
64  m_editPalette.setBrush(
65  QPalette::Disabled, static_cast<QPalette::ColorRole>(i), m_parentPalette.brush(QPalette::Disabled, static_cast<QPalette::ColorRole>(i)));
66  }
67  m_editPalette.resolve(mask);
68  updatePreviewPalette();
69  updateStyledButton();
70  m_paletteUpdated = true;
71  if (!m_modelUpdated) {
72  m_paletteModel->setPalette(m_editPalette, m_parentPalette);
73  }
74  m_paletteUpdated = false;
75 }
76 
77 void PaletteEditor::setPalette(const QPalette &palette, const QPalette &parentPalette)
78 {
79  m_parentPalette = parentPalette;
81 }
82 
83 void PaletteEditor::handleBuildButtonColorChanged(const QColor &)
84 {
85  buildPalette();
86 }
87 
88 void PaletteEditor::handleActiveRadioClicked()
89 {
90  m_currentColorGroup = QPalette::Active;
91  updatePreviewPalette();
92 }
93 
94 void PaletteEditor::handleInactiveRadioClicked()
95 {
96  m_currentColorGroup = QPalette::Inactive;
97  updatePreviewPalette();
98 }
99 
100 void PaletteEditor::handleDisabledRadioClicked()
101 {
102  m_currentColorGroup = QPalette::Disabled;
103  updatePreviewPalette();
104 }
105 
106 void PaletteEditor::handleComputeRadioClicked()
107 {
108  if (m_compute) {
109  return;
110  }
111  m_ui->paletteView->setColumnHidden(2, true);
112  m_ui->paletteView->setColumnHidden(3, true);
113  m_compute = true;
114  m_paletteModel->setCompute(true);
115 }
116 
117 void PaletteEditor::handleDetailsRadioClicked()
118 {
119  if (!m_compute) {
120  return;
121  }
122  const int w = m_ui->paletteView->columnWidth(1);
123  m_ui->paletteView->setColumnHidden(2, false);
124  m_ui->paletteView->setColumnHidden(3, false);
125  auto *const header = m_ui->paletteView->header();
126  header->resizeSection(1, w / 3);
127  header->resizeSection(2, w / 3);
128  header->resizeSection(3, w / 3);
129  m_compute = false;
130  m_paletteModel->setCompute(false);
131 }
132 
133 void PaletteEditor::paletteChanged(const QPalette &palette)
134 {
135  m_modelUpdated = true;
136  if (!m_paletteUpdated) {
138  }
139  m_modelUpdated = false;
140 }
141 
142 void PaletteEditor::buildPalette()
143 {
144  const QColor btn(m_ui->buildButton->color());
145  const QPalette temp(btn);
146  setPalette(temp);
147 }
148 
149 void PaletteEditor::updatePreviewPalette()
150 {
151  const QPalette::ColorGroup g = currentColorGroup();
152  // build the preview palette
153  const QPalette currentPalette = palette();
154  QPalette previewPalette;
155  for (int i = QPalette::WindowText; i < QPalette::NColorRoles; ++i) {
156  const QPalette::ColorRole r = static_cast<QPalette::ColorRole>(i);
157  const QBrush br = currentPalette.brush(g, r);
158  previewPalette.setBrush(QPalette::Active, r, br);
159  previewPalette.setBrush(QPalette::Inactive, r, br);
160  previewPalette.setBrush(QPalette::Disabled, r, br);
161  }
162 }
163 
164 void PaletteEditor::updateStyledButton()
165 {
166  m_ui->buildButton->setColor(palette().color(QPalette::Active, QPalette::Button));
167 }
168 
169 QPalette PaletteEditor::getPalette(QWidget *parent, const QPalette &init, const QPalette &parentPal, int *ok)
170 {
171  PaletteEditor dlg(parent);
172  auto parentPalette(parentPal);
173  const uint mask = init.resolve();
174  for (int i = 0; i < static_cast<int>(QPalette::NColorRoles); ++i) {
175  if (mask & (1 << i)) {
176  continue;
177  }
178  parentPalette.setBrush(
179  QPalette::Active, static_cast<QPalette::ColorRole>(i), init.brush(QPalette::Active, static_cast<QPalette::ColorRole>(i)));
180  parentPalette.setBrush(
181  QPalette::Inactive, static_cast<QPalette::ColorRole>(i), init.brush(QPalette::Inactive, static_cast<QPalette::ColorRole>(i)));
182  parentPalette.setBrush(
183  QPalette::Disabled, static_cast<QPalette::ColorRole>(i), init.brush(QPalette::Disabled, static_cast<QPalette::ColorRole>(i)));
184  }
185  dlg.setPalette(init, parentPalette);
186 
187  const int result = dlg.exec();
188  if (ok) {
189  *ok = result;
190  }
191  return result == QDialog::Accepted ? dlg.palette() : init;
192 }
193 
195  : QAbstractTableModel(parent)
196  , m_compute(true)
197 {
198  const QMetaObject *meta = metaObject();
199  const QMetaProperty property = meta->property(meta->indexOfProperty("colorRole"));
200  const QMetaEnum enumerator = property.enumerator();
201  for (int r = QPalette::WindowText; r < QPalette::NColorRoles; ++r) {
202  m_roleNames[static_cast<QPalette::ColorRole>(r)] = QLatin1String(enumerator.key(r));
203  }
204 }
205 
206 int PaletteModel::rowCount(const QModelIndex &) const
207 {
208  return m_roleNames.count();
209 }
210 
211 int PaletteModel::columnCount(const QModelIndex &) const
212 {
213  return 4;
214 }
215 
216 QVariant PaletteModel::data(const QModelIndex &index, int role) const
217 {
218  if (!index.isValid() || index.row() < 0 || index.row() >= QPalette::NColorRoles || index.column() < 0 || index.column() >= 4) {
219  return QVariant();
220  }
221 
222  if (index.column() == 0) {
223  if (role == Qt::DisplayRole) {
224  return m_roleNames[static_cast<QPalette::ColorRole>(index.row())];
225  }
226  if (role == Qt::EditRole) {
227  const uint mask = m_palette.resolve();
228  if (mask & (1 << index.row()))
229  return true;
230  return false;
231  }
232  return QVariant();
233  }
234  if (role == BrushRole) {
235  return m_palette.brush(columnToGroup(index.column()), static_cast<QPalette::ColorRole>(index.row()));
236  }
237  return QVariant();
238 }
239 
240 bool PaletteModel::setData(const QModelIndex &index, const QVariant &value, int role)
241 {
242  if (!index.isValid()) {
243  return false;
244  }
245 
246  if (index.column() != 0 && role == BrushRole) {
247  const QBrush br = qvariant_cast<QBrush>(value);
248  const QPalette::ColorRole r = static_cast<QPalette::ColorRole>(index.row());
249  const QPalette::ColorGroup g = columnToGroup(index.column());
250  m_palette.setBrush(g, r, br);
251 
252  QModelIndex idxBegin = PaletteModel::index(r, 0);
253  QModelIndex idxEnd = PaletteModel::index(r, 3);
254  if (m_compute) {
255  m_palette.setBrush(QPalette::Inactive, r, br);
256  switch (r) {
257  case QPalette::WindowText:
258  case QPalette::Text:
259  case QPalette::ButtonText:
260  case QPalette::Base:
261  break;
262  case QPalette::Dark:
263  m_palette.setBrush(QPalette::Disabled, QPalette::WindowText, br);
264  m_palette.setBrush(QPalette::Disabled, QPalette::Dark, br);
265  m_palette.setBrush(QPalette::Disabled, QPalette::Text, br);
266  m_palette.setBrush(QPalette::Disabled, QPalette::ButtonText, br);
267  idxBegin = PaletteModel::index(0, 0);
268  idxEnd = PaletteModel::index(m_roleNames.count() - 1, 3);
269  break;
270  case QPalette::Window:
271  m_palette.setBrush(QPalette::Disabled, QPalette::Base, br);
272  m_palette.setBrush(QPalette::Disabled, QPalette::Window, br);
273  idxBegin = PaletteModel::index(QPalette::Base, 0);
274  break;
275  case QPalette::Highlight:
276  break;
277  default:
278  m_palette.setBrush(QPalette::Disabled, r, br);
279  break;
280  }
281  }
282  emit paletteChanged(m_palette);
283  emit dataChanged(idxBegin, idxEnd);
284  return true;
285  }
286  if (index.column() == 0 && role == Qt::EditRole) {
287  uint mask = m_palette.resolve();
288  const bool isMask = qvariant_cast<bool>(value);
289  const int r = index.row();
290  if (isMask) {
291  mask |= (1 << r);
292  } else {
293  m_palette.setBrush(
294  QPalette::Active, static_cast<QPalette::ColorRole>(r), m_parentPalette.brush(QPalette::Active, static_cast<QPalette::ColorRole>(r)));
295  m_palette.setBrush(QPalette::Inactive, static_cast<QPalette::ColorRole>(r),
296  m_parentPalette.brush(QPalette::Inactive, static_cast<QPalette::ColorRole>(r)));
297  m_palette.setBrush(QPalette::Disabled, static_cast<QPalette::ColorRole>(r),
298  m_parentPalette.brush(QPalette::Disabled, static_cast<QPalette::ColorRole>(r)));
299  mask &= ~(1 << index.row());
300  }
301  m_palette.resolve(mask);
302  emit paletteChanged(m_palette);
303  const QModelIndex idxEnd = PaletteModel::index(r, 3);
304  emit dataChanged(index, idxEnd);
305  return true;
306  }
307  return false;
308 }
309 
310 Qt::ItemFlags PaletteModel::flags(const QModelIndex &index) const
311 {
312  if (!index.isValid())
313  return Qt::ItemIsEnabled;
314  return Qt::ItemIsEditable | Qt::ItemIsEnabled;
315 }
316 
317 QVariant PaletteModel::headerData(int section, Qt::Orientation orientation, int role) const
318 {
319  if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
320  if (section == 0)
321  return tr("Color Role");
322  if (section == groupToColumn(QPalette::Active))
323  return tr("Active");
324  if (section == groupToColumn(QPalette::Inactive))
325  return tr("Inactive");
326  if (section == groupToColumn(QPalette::Disabled))
327  return tr("Disabled");
328  }
329  return QVariant();
330 }
331 
332 QPalette PaletteModel::getPalette() const
333 {
334  return m_palette;
335 }
336 
337 void PaletteModel::setPalette(const QPalette &palette, const QPalette &parentPalette)
338 {
339  m_parentPalette = parentPalette;
340  m_palette = palette;
341  const QModelIndex idxBegin = index(0, 0);
342  const QModelIndex idxEnd = index(m_roleNames.count() - 1, 3);
343  emit dataChanged(idxBegin, idxEnd);
344 }
345 
346 QPalette::ColorGroup PaletteModel::columnToGroup(int index) const
347 {
348  if (index == 1)
349  return QPalette::Active;
350  if (index == 2)
351  return QPalette::Inactive;
352  return QPalette::Disabled;
353 }
354 
355 int PaletteModel::groupToColumn(QPalette::ColorGroup group) const
356 {
357  if (group == QPalette::Active)
358  return 1;
359  if (group == QPalette::Inactive)
360  return 2;
361  return 3;
362 }
363 
364 BrushEditor::BrushEditor(QWidget *parent)
365  : QWidget(parent)
366  , m_button(new ColorButton(this))
367  , m_changed(false)
368 {
369  auto *const layout = new QHBoxLayout(this);
370  layout->setContentsMargins(0, 0, 0, 0);
371  layout->addWidget(m_button);
372  connect(m_button, &ColorButton::colorChanged, this, &BrushEditor::brushChanged);
373  setFocusProxy(m_button);
374 }
375 
376 void BrushEditor::setBrush(const QBrush &brush)
377 {
378  m_button->setColor(brush.color());
379  m_changed = false;
380 }
381 
382 QBrush BrushEditor::brush() const
383 {
384  return QBrush(m_button->color());
385 }
386 
387 void BrushEditor::brushChanged()
388 {
389  m_changed = true;
390  emit changed(this);
391 }
392 
394 {
395  return m_changed;
396 }
397 
398 RoleEditor::RoleEditor(QWidget *parent)
399  : QWidget(parent)
400  , m_label(new QLabel(this))
401  , m_edited(false)
402 {
403  QHBoxLayout *layout = new QHBoxLayout(this);
404  layout->setContentsMargins(0, 0, 0, 0);
405  layout->setSpacing(0);
406 
407  layout->addWidget(m_label);
408  m_label->setAutoFillBackground(true);
409  m_label->setIndent(3); // same value as textMargin in QItemDelegate
410  setFocusProxy(m_label);
411 
412  auto *const button = new QToolButton(this);
413  button->setToolButtonStyle(Qt::ToolButtonIconOnly);
414  button->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear")));
415  button->setIconSize(QSize(8, 8));
416  button->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::MinimumExpanding));
417  layout->addWidget(button);
418  connect(button, &QAbstractButton::clicked, this, &RoleEditor::emitResetProperty);
419 }
420 
421 void RoleEditor::setLabel(const QString &label)
422 {
423  m_label->setText(label);
424 }
425 
427 {
428  QFont font;
429  if (on == true) {
430  font.setBold(on);
431  }
432  m_label->setFont(font);
433  m_edited = on;
434 }
435 
436 bool RoleEditor::edited() const
437 {
438  return m_edited;
439 }
440 
441 void RoleEditor::emitResetProperty()
442 {
443  setEdited(false);
444  emit changed(this);
445 }
446 
448  : QItemDelegate(parent)
449 {
450 }
451 
452 QWidget *ColorDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &, const QModelIndex &index) const
453 {
454  if (index.column() == 0) {
455  auto *const editor = new RoleEditor(parent);
456  connect(editor, &RoleEditor::changed, this, &ColorDelegate::commitData);
457  return editor;
458  }
459 
460  using BrushEditorWidgetSignal = void (BrushEditor::*)(QWidget *);
461 
462  auto *const editor = new BrushEditor(parent);
463  connect(editor, static_cast<BrushEditorWidgetSignal>(&BrushEditor::changed), this, &ColorDelegate::commitData);
464  editor->setFocusPolicy(Qt::NoFocus);
465  editor->installEventFilter(const_cast<ColorDelegate *>(this));
466  return editor;
467 }
468 
469 void ColorDelegate::setEditorData(QWidget *ed, const QModelIndex &index) const
470 {
471  if (index.column() == 0) {
472  const auto mask = qvariant_cast<bool>(index.model()->data(index, Qt::EditRole));
473  auto *const editor = static_cast<RoleEditor *>(ed);
474  editor->setEdited(mask);
475  const auto colorName = qvariant_cast<QString>(index.model()->data(index, Qt::DisplayRole));
476  editor->setLabel(colorName);
477  } else {
478  const auto br = qvariant_cast<QBrush>(index.model()->data(index, BrushRole));
479  auto *const editor = static_cast<BrushEditor *>(ed);
480  editor->setBrush(br);
481  }
482 }
483 
484 void ColorDelegate::setModelData(QWidget *ed, QAbstractItemModel *model, const QModelIndex &index) const
485 {
486  if (index.column() == 0) {
487  const auto *const editor = static_cast<RoleEditor *>(ed);
488  const auto mask = editor->edited();
489  model->setData(index, mask, Qt::EditRole);
490  } else {
491  const auto *const editor = static_cast<BrushEditor *>(ed);
492  if (editor->changed()) {
493  QBrush br = editor->brush();
494  model->setData(index, br, BrushRole);
495  }
496  }
497 }
498 
499 void ColorDelegate::updateEditorGeometry(QWidget *ed, const QStyleOptionViewItem &option, const QModelIndex &index) const
500 {
501  QItemDelegate::updateEditorGeometry(ed, option, index);
502  ed->setGeometry(ed->geometry().adjusted(0, 0, -1, -1));
503 }
504 
505 void ColorDelegate::paint(QPainter *painter, const QStyleOptionViewItem &opt, const QModelIndex &index) const
506 {
507  QStyleOptionViewItem option = opt;
508  const auto mask = qvariant_cast<bool>(index.model()->data(index, Qt::EditRole));
509  if (index.column() == 0 && mask) {
510  option.font.setBold(true);
511  }
512  auto br = qvariant_cast<QBrush>(index.model()->data(index, BrushRole));
513  if (br.style() == Qt::LinearGradientPattern || br.style() == Qt::RadialGradientPattern || br.style() == Qt::ConicalGradientPattern) {
514  painter->save();
515  painter->translate(option.rect.x(), option.rect.y());
516  painter->scale(option.rect.width(), option.rect.height());
517  QGradient gr = *(br.gradient());
518  gr.setCoordinateMode(QGradient::LogicalMode);
519  br = QBrush(gr);
520  painter->fillRect(0, 0, 1, 1, br);
521  painter->restore();
522  } else {
523  painter->save();
524  painter->setBrushOrigin(option.rect.x(), option.rect.y());
525  painter->fillRect(option.rect, br);
526  painter->restore();
527  }
528  QItemDelegate::paint(painter, option, index);
529 
530  const QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &option));
531  const QPen oldPen = painter->pen();
532  painter->setPen(QPen(color));
533 
534  painter->drawLine(option.rect.right(), option.rect.y(), option.rect.right(), option.rect.bottom());
535  painter->drawLine(option.rect.x(), option.rect.bottom(), option.rect.right(), option.rect.bottom());
536  painter->setPen(oldPen);
537 }
538 
539 QSize ColorDelegate::sizeHint(const QStyleOptionViewItem &opt, const QModelIndex &index) const
540 {
541  return QItemDelegate::sizeHint(opt, index) + QSize(4, 4);
542 }
543 
544 } // namespace QtUtilities
QtUtilities::PaletteModel::rowCount
int rowCount(const QModelIndex &parent=QModelIndex()) const override
Definition: paletteeditor.cpp:206
QtUtilities::PaletteModel::setData
bool setData(const QModelIndex &index, const QVariant &value, int role) override
Definition: paletteeditor.cpp:240
QtUtilities::ColorDelegate::ColorDelegate
ColorDelegate(QObject *parent=nullptr)
Definition: paletteeditor.cpp:447
QtUtilities::ColorDelegate::updateEditorGeometry
void updateEditorGeometry(QWidget *ed, const QStyleOptionViewItem &option, const QModelIndex &index) const override
Definition: paletteeditor.cpp:499
QtUtilities::BrushEditor::setBrush
void setBrush(const QBrush &brush)
Definition: paletteeditor.cpp:376
colorbutton.h
QtUtilities::PaletteModel::data
QVariant data(const QModelIndex &index, int role) const override
Definition: paletteeditor.cpp:216
paletteeditor.h
QtUtilities::RoleEditor::setLabel
void setLabel(const QString &label)
Definition: paletteeditor.cpp:421
QtUtilities::PaletteModel::paletteChanged
void paletteChanged(const QPalette &palette)
QtUtilities::BrushEditor::BrushEditor
BrushEditor(QWidget *parent=nullptr)
Definition: paletteeditor.cpp:364
QtUtilities::PaletteEditor::palette
QPalette palette() const
Definition: paletteeditor.cpp:47
QtUtilities::ColorButton::colorChanged
void colorChanged(const QColor &color)
QtUtilities::PaletteEditor::PaletteEditor
PaletteEditor(QWidget *parent)
Definition: paletteeditor.cpp:17
QtUtilities::PaletteModel::headerData
QVariant headerData(int section, Qt::Orientation orientation, int role=Qt::DisplayRole) const override
Definition: paletteeditor.cpp:317
QtUtilities::BrushRole
@ BrushRole
Definition: paletteeditor.cpp:15
QtUtilities::BrushEditor::changed
bool changed() const
Definition: paletteeditor.cpp:393
QtUtilities::RoleEditor::setEdited
void setEdited(bool on)
Definition: paletteeditor.cpp:426
QtUtilities::PaletteModel
The PaletteModel class is used by PaletteEditor.
Definition: paletteeditor.h:75
QtUtilities::PaletteModel::flags
Qt::ItemFlags flags(const QModelIndex &index) const override
Definition: paletteeditor.cpp:310
QtUtilities::PaletteModel::columnCount
int columnCount(const QModelIndex &parent=QModelIndex()) const override
Definition: paletteeditor.cpp:211
QtUtilities::ColorButton
The ColorButton class is used by PaletteEditor.
Definition: colorbutton.h:15
QtUtilities::RoleEditor
The RoleEditor class is used by PaletteEditor.
Definition: paletteeditor.h:140
QtUtilities::ColorDelegate::paint
void paint(QPainter *painter, const QStyleOptionViewItem &opt, const QModelIndex &index) const override
Definition: paletteeditor.cpp:505
QtUtilities::ColorDelegate::sizeHint
QSize sizeHint(const QStyleOptionViewItem &opt, const QModelIndex &index) const override
Definition: paletteeditor.cpp:539
QtUtilities::RoleEditor::RoleEditor
RoleEditor(QWidget *parent=nullptr)
Definition: paletteeditor.cpp:398
QtUtilities::PaletteEditor::setPalette
void setPalette(const QPalette &palette)
Definition: paletteeditor.cpp:52
QtUtilities::PaletteEditor
The PaletteEditor class provides a dialog to customize a QPalette.
Definition: paletteeditor.h:29
QtUtilities::PaletteEditor::getPalette
static QPalette getPalette(QWidget *parent, const QPalette &init=QPalette(), const QPalette &parentPal=QPalette(), int *result=nullptr)
Definition: paletteeditor.cpp:169
QtUtilities::ColorButton::setColor
void setColor(const QColor &color)
Definition: colorbutton.cpp:100
QtUtilities::PaletteModel::PaletteModel
PaletteModel(QObject *parent=nullptr)
Definition: paletteeditor.cpp:194
QtUtilities
!
Definition: trylocker.h:8
QtUtilities::PaletteModel::setCompute
void setCompute(bool on)
Definition: paletteeditor.h:95
QtUtilities::ColorDelegate::createEditor
QWidget * createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override
Definition: paletteeditor.cpp:452
QtUtilities::ColorDelegate::setModelData
void setModelData(QWidget *ed, QAbstractItemModel *model, const QModelIndex &index) const override
Definition: paletteeditor.cpp:484
QtUtilities::RoleEditor::changed
void changed(QWidget *widget)
QtUtilities::BrushEditor
The BrushEditor class is used by PaletteEditor.
Definition: paletteeditor.h:116
QtUtilities::PaletteModel::setPalette
void setPalette(const QPalette &palette, const QPalette &parentPalette)
Definition: paletteeditor.cpp:337
QtUtilities::ColorDelegate::setEditorData
void setEditorData(QWidget *ed, const QModelIndex &index) const override
Definition: paletteeditor.cpp:469
QtUtilities::BrushEditor::brush
QBrush brush() const
Definition: paletteeditor.cpp:382
QtUtilities::PaletteEditor::~PaletteEditor
~PaletteEditor() override
Definition: paletteeditor.cpp:43
QtUtilities::ColorDelegate
The ColorDelegate class is used by PaletteEditor.
Definition: paletteeditor.h:163
QtUtilities::QtUtilitiesResources::init
QT_UTILITIES_EXPORT void init()
Initiates the resources used and provided by this library.
Definition: resources.cpp:51
QtUtilities::RoleEditor::edited
bool edited() const
Definition: paletteeditor.cpp:436
QtUtilities::ColorButton::color
QColor color() const
Definition: colorbutton.cpp:108
QtUtilities::PaletteModel::getPalette
QPalette getPalette() const
Definition: paletteeditor.cpp:332