Differential D14815 Diff 39661 plugins/dockers/palettedocker/palettedocker_dock.cpp

Changeset View

Standalone View

View Options

plugins/dockers/palettedocker/palettedocker_dock.cpp

Context not available.
27#include <QColorDialog> 27​#include <QColorDialog>
28#include <QCompleter> 28​#include <QCompleter>
29#include <QComboBox> 29​#include <QComboBox>
30​#include <QAction>
31​#include <QMenu>
32​#include <QCheckBox>
33​#include <QFormLayout>
34​#include <QLineEdit>
30 35​
31#include <klocalizedstring.h> 36​#include <klocalizedstring.h>
32 ​
33#include <KoResourceServerProvider.h> 37​#include <KoResourceServerProvider.h>
34#include <KoColorSpaceRegistry.h> 38​#include <KoColorSpaceRegistry.h>
35 39​#include <KoFileDialog.h>
36#include <kis_icon.h> 40​#include <kis_icon.h>
37#include <kis_layer.h> ​
38#include <kis_node_manager.h> ​
39#include <kis_config.h> 41​#include <kis_config.h>
42​#include <kis_node_manager.h>
40#include <kis_workspace_resource.h> 43​#include <kis_workspace_resource.h>
41#include <kis_canvas_resource_provider.h> 44​#include <kis_canvas_resource_provider.h>
42#include <KisMainWindow.h> 45​#include <KisMainWindow.h>
Context not available.
45#include <kis_canvas2.h> 48​#include <kis_canvas2.h>
46#include <KoDialog.h> 49​#include <KoDialog.h>
47#include <kis_color_button.h> 50​#include <kis_color_button.h>
48#include <QCheckBox> 51​#include <KisDocument.h>
49#include <QFormLayout> 52​#include <KisPart.h>
50#include <QLineEdit> 53​
51#include <squeezedcombobox.h> 54​#include <KisPaletteModel.h>
55​#include <KisPaletteDelegate.h>
56​#include <kis_palette_view.h>
57​#include <KisPaletteListWidget.h>
58​
59​#include <KisPaletteEditor.h>
60​#include <dialogs/KisDlgPaletteEditor.h>
52 61​
53#include "KisPaletteModel.h" ​
54#include "ui_wdgpalettedock.h" 62​#include "ui_wdgpalettedock.h"
55#include "kis_palette_delegate.h" ​
56#include "kis_palette_view.h" ​
57#include <KisColorsetChooser.h> ​
58 63​
59PaletteDockerDock::PaletteDockerDock( ) 64​PaletteDockerDock::PaletteDockerDock( )
60 : QDockWidget(i18n("Palette")) 65​ : QDockWidget(i18n("Palette"))
61 , m_wdgPaletteDock(new Ui_WdgPaletteDock()) 66​ , m_ui(new Ui_WdgPaletteDock())
62 , m_currentColorSet(0) 67​ , m_model(new KisPaletteModel(this))
63 , m_resourceProvider(0) 68​ , m_paletteChooser(new KisPaletteListWidget(this))
64 , m_canvas(0) 69​ , m_view(Q_NULLPTR)
70​ , m_resourceProvider(Q_NULLPTR)
71​ , m_rServer(KoResourceServerProvider::instance()->paletteServer())
72​ , m_rAdapter(new KoResourceServerAdapter<KoColorSet>(KoResourceServerProvider::instance()->paletteServer()))
73​ , m_activeDocument(Q_NULLPTR)
74​ , m_paletteEditor(new KisPaletteEditor)
75​ , m_actAdd(new QAction(KisIconUtils::loadIcon("list-add"), i18n("Add foreground color")))
76​ , m_actRemove(new QAction(KisIconUtils::loadIcon("edit-delete"), i18n("Delete color")))
77​ , m_actModify(new QAction(KisIconUtils::loadIcon("edit-rename"), i18n("Modify this spot")))
78​ , m_actEditPalette(new QAction(KisIconUtils::loadIcon("groupLayer"), i18n("Edit this palette")))
65{ 79​{
66 QWidget* mainWidget = new QWidget(this); 80​ QWidget *mainWidget = new QWidget(this);
67 setWidget(mainWidget); 81​ setWidget(mainWidget);
68 m_wdgPaletteDock->setupUi(mainWidget); 82​ m_ui->setupUi(mainWidget);
69 m_wdgPaletteDock->bnAdd->setIcon(KisIconUtils::loadIcon("list-add")); 83​
70 m_wdgPaletteDock->bnAdd->setIconSize(QSize(16, 16)); 84​ m_ui->bnAdd->setDefaultAction(m_actAdd.data());
71 m_wdgPaletteDock->bnRemove->setIcon(KisIconUtils::loadIcon("edit-delete")); 85​ m_ui->bnRemove->setDefaultAction(m_actRemove.data());
72 m_wdgPaletteDock->bnRemove->setIconSize(QSize(16, 16)); 86​ m_ui->bnRename->setDefaultAction(m_actModify.data());
73 m_wdgPaletteDock->bnAdd->setEnabled(false); 87​ m_ui->bnEditPalette->setDefaultAction(m_actEditPalette.data());
74 m_wdgPaletteDock->bnRemove->setEnabled(false); 88​
75 m_wdgPaletteDock->bnAddDialog->setVisible(false); 89​ // to make sure their icons have the same size
76 m_wdgPaletteDock->bnAddGroup->setIcon(KisIconUtils::loadIcon("groupLayer")); 90​ m_ui->bnRemove->setIconSize(QSize(16, 16));
77 m_wdgPaletteDock->bnAddGroup->setIconSize(QSize(16, 16)); 91​ m_ui->bnRename->setIconSize(QSize(16, 16));
92​ m_ui->bnAdd->setIconSize(QSize(16, 16));
93​ m_ui->bnEditPalette->setIconSize(QSize(16, 16));
94​
95​ m_ui->paletteView->setPaletteModel(m_model);
96​ m_ui->paletteView->setAllowModification(true);
97​ m_ui->cmbNameList->setCompanionView(m_ui->paletteView);
98​
99​ m_paletteEditor->setPaletteModel(m_model);
100​
101​ connect(m_actAdd.data(), SIGNAL(triggered()), SLOT(slotAddColor()));
102​ connect(m_actRemove.data(), SIGNAL(triggered()), SLOT(slotRemoveColor()));
103​ connect(m_actModify.data(), SIGNAL(triggered()), SLOT(slotEditEntry()));
104​ connect(m_actEditPalette.data(), SIGNAL(triggered()), SLOT(slotEditPalette()));
105​ connect(m_ui->paletteView, SIGNAL(sigIndexSelected(QModelIndex)),
106​ SLOT(slotPaletteIndexSelected(QModelIndex)));
107​ connect(m_ui->paletteView, SIGNAL(clicked(QModelIndex)),
108​ SLOT(slotPaletteIndexClicked(QModelIndex)));
109​ connect(m_ui->paletteView, SIGNAL(doubleClicked(QModelIndex)),
110​ SLOT(slotPaletteIndexDoubleClicked(QModelIndex)));
111​
112​ m_viewContextMenu.addAction(m_actModify.data());
113​ m_viewContextMenu.addAction(m_actRemove.data());
114​ connect(m_ui->paletteView, SIGNAL(pressed(QModelIndex)), SLOT(slotContextMenu(QModelIndex)));
115​
116​ m_paletteChooser->setAllowModification(true);
117​ connect(m_paletteChooser, SIGNAL(sigPaletteSelected(KoColorSet*)), SLOT(slotSetColorSet(KoColorSet*)));
118​ connect(m_paletteChooser, SIGNAL(sigAddPalette()), SLOT(slotAddPalette()));
119​ connect(m_paletteChooser, SIGNAL(sigImportPalette()), SLOT(slotImportPalette()));
120​ connect(m_paletteChooser, SIGNAL(sigRemovePalette(KoColorSet*)), SLOT(slotRemovePalette(KoColorSet*)));
121​ connect(m_paletteChooser, SIGNAL(sigExportPalette(KoColorSet*)), SLOT(slotExportPalette(KoColorSet*)));
122​
123​ m_ui->bnColorSets->setIcon(KisIconUtils::loadIcon("hi16-palette_library"));
124​ m_ui->bnColorSets->setToolTip(i18n("Choose palette"));
125​ m_ui->bnColorSets->setPopupWidget(m_paletteChooser);
78 126​
79 ​
80 m_model = new KisPaletteModel(this); ​
81 m_wdgPaletteDock->paletteView->setPaletteModel(m_model); ​
82 ​
83 connect(m_wdgPaletteDock->bnAdd, SIGNAL(clicked(bool)), this, SLOT(addColorForeground())); ​
84 connect(m_wdgPaletteDock->bnRemove, SIGNAL(clicked(bool)), this, SLOT(removeColor())); ​
85 connect(m_wdgPaletteDock->bnAddGroup, SIGNAL(clicked(bool)), m_wdgPaletteDock->paletteView, SLOT(addGroupWithDialog())); ​
86 ​
87 connect(m_wdgPaletteDock->paletteView, SIGNAL(entrySelected(KoColorSetEntry)), this, SLOT(entrySelected(KoColorSetEntry))); ​
88 connect(m_wdgPaletteDock->paletteView, SIGNAL(entrySelectedBackGround(KoColorSetEntry)), this, SLOT(entrySelectedBack(KoColorSetEntry))); ​
89 ​
90 KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer(); ​
91 m_serverAdapter = QSharedPointer<KoAbstractResourceServerAdapter>(new KoResourceServerAdapter<KoColorSet>(rServer)); ​
92 m_serverAdapter->connectToResourceServer(); ​
93 rServer->addObserver(this); ​
94 ​
95 m_paletteChooser = new KisColorsetChooser(this); ​
96 connect(m_paletteChooser, SIGNAL(paletteSelected(KoColorSet*)), this, SLOT(setColorSet(KoColorSet*))); ​
97 ​
98 m_wdgPaletteDock->bnColorSets->setIcon(KisIconUtils::loadIcon("hi16-palette_library")); ​
99 m_wdgPaletteDock->bnColorSets->setToolTip(i18n("Choose palette")); ​
100 m_wdgPaletteDock->bnColorSets->setPopupWidget(m_paletteChooser); ​
101 ​
102 connect(m_wdgPaletteDock->cmbNameList, SIGNAL(currentIndexChanged(int)), this, SLOT(setColorFromNameList(int))); ​
103 KisConfig cfg(true); 127​ KisConfig cfg(true);
104 QString defaultPalette = cfg.defaultPalette(); 128​ QString defaultPaletteName = cfg.defaultPalette();
105 KoColorSet* defaultColorSet = rServer->resourceByName(defaultPalette); 129​ KoColorSet* defaultPalette = m_rServer->resourceByName(defaultPaletteName);
106 if (defaultColorSet) { 130​ if (defaultPalette) {
107 setColorSet(defaultColorSet); 131​ slotSetColorSet(defaultPalette);
132​ } else {
133​ m_ui->bnAdd->setEnabled(false);
134​ m_ui->bnRename->setEnabled(false);
135​ m_ui->bnRemove->setEnabled(false);
136​ m_ui->bnEditPalette->setEnabled(false);
137​ m_ui->paletteView->setAllowModification(false);
108 } 138​ }
109} 139​}
110 140​
111PaletteDockerDock::~PaletteDockerDock() 141​PaletteDockerDock::~PaletteDockerDock()
112{ 142​{ }
113 KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer(); ​
114 rServer->removeObserver(this); ​
115 ​
116 if (m_currentColorSet) { ​
117 KisConfig cfg(true); ​
118 cfg.setDefaultPalette(m_currentColorSet->name()); ​
119 } ​
120 ​
121 delete m_wdgPaletteDock->paletteView->itemDelegate(); ​
122 delete m_wdgPaletteDock; ​
123} ​
124 143​
125void PaletteDockerDock::setViewManager(KisViewManager* kisview) 144​void PaletteDockerDock::setViewManager(KisViewManager* kisview)
126{ 145​{
146​ m_view = kisview;
127 m_resourceProvider = kisview->resourceProvider(); 147​ m_resourceProvider = kisview->resourceProvider();
128 connect(m_resourceProvider, SIGNAL(sigSavingWorkspace(KisWorkspaceResource*)), SLOT(saveToWorkspace(KisWorkspaceResource*))); 148​ connect(m_resourceProvider, SIGNAL(sigSavingWorkspace(KisWorkspaceResource*)),
129 connect(m_resourceProvider, SIGNAL(sigLoadingWorkspace(KisWorkspaceResource*)), SLOT(loadFromWorkspace(KisWorkspaceResource*))); 149​ SLOT(saveToWorkspace(KisWorkspaceResource*)));
130 connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)),m_wdgPaletteDock->paletteView, SLOT(trySelectClosestColor(KoColor))); 150​ connect(m_resourceProvider, SIGNAL(sigLoadingWorkspace(KisWorkspaceResource*)),
151​ SLOT(loadFromWorkspace(KisWorkspaceResource*)));
152​ connect(m_resourceProvider, SIGNAL(sigFGColorChanged(KoColor)),
153​ m_ui->paletteView, SLOT(slotFGColorChanged(KoColor)));
131 154​
132 kisview->nodeManager()->disconnect(m_model); 155​ kisview->nodeManager()->disconnect(m_model);
133 ​
134 ​
135} 156​}
136 157​
137void PaletteDockerDock::setCanvas(KoCanvasBase *canvas) 158​void PaletteDockerDock::slotContextMenu(const QModelIndex &)
138{ 159​{
139 setEnabled(canvas != 0); 160​ if (QApplication::mouseButtons() == Qt::RightButton) {
140 if (canvas) { 161​ m_viewContextMenu.exec(QCursor::pos());
141 KisCanvas2 *cv = qobject_cast<KisCanvas2*>(canvas); ​
142 m_model->setDisplayRenderer(cv->displayColorConverter()->displayRendererInterface()); ​
143 } 162​ }
144 m_canvas = static_cast<KisCanvas2*>(canvas); ​
145} 163​}
146 164​
147 165​void PaletteDockerDock::slotAddPalette()
148void PaletteDockerDock::unsetCanvas() ​
149{ 166​{
150 setEnabled(false); 167​ m_paletteEditor->addPalette();
151 m_model->setDisplayRenderer(0); ​
152 m_canvas = 0; ​
153} 168​}
154 169​
155void PaletteDockerDock::unsetResourceServer() 170​void PaletteDockerDock::slotRemovePalette(KoColorSet *cs)
156{ 171​{
157 KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer(); 172​ m_paletteEditor->removePalette(cs);
158 rServer->removeObserver(this); ​
159} 173​}
160 174​
161void PaletteDockerDock::removingResource(KoColorSet *resource) 175​void PaletteDockerDock::slotImportPalette()
162{ 176​{
163 if (resource == m_currentColorSet) { 177​ m_paletteEditor->importPalette();
164 setColorSet(0); ​
165 } ​
166} 178​}
167 179​
168void PaletteDockerDock::resourceChanged(KoColorSet *resource) 180​void PaletteDockerDock::slotExportPalette(KoColorSet *palette)
169{ 181​{
170 setColorSet(resource); 182​ KoFileDialog dialog(this, KoFileDialog::SaveFile, "Save Palette");
183​ dialog.setDefaultDir(palette->filename());
184​ dialog.setMimeTypeFilters(QStringList() << "krita/x-colorset");
185​ QString newPath;
186​ bool isStandAlone = palette->isGlobal();
187​ QString oriPath = palette->filename();
188​ if ((newPath = dialog.filename()).isEmpty()) { return; }
189​ palette->setFilename(newPath);
190​ palette->setIsGlobal(true);
191​ palette->save();
192​ palette->setFilename(oriPath);
193​ palette->setIsGlobal(isStandAlone);
171} 194​}
172 195​
173 196​void PaletteDockerDock::setCanvas(KoCanvasBase *canvas)
174void PaletteDockerDock::setColorSet(KoColorSet* colorSet) ​
175{ 197​{
176 m_model->setColorSet(colorSet); 198​ setEnabled(canvas != Q_NULLPTR);
177 m_wdgPaletteDock->paletteView->updateView(); 199​ if (canvas) {
178 m_wdgPaletteDock->paletteView->updateRows(); 200​ KisCanvas2 *cv = qobject_cast<KisCanvas2*>(canvas);
179 m_wdgPaletteDock->cmbNameList->clear(); 201​ m_ui->paletteView->setDisplayRenderer(cv->displayColorConverter()->displayRendererInterface());
180 202​ }
181 203​
182 204​ if (m_activeDocument) {
183 if (colorSet && colorSet->nColors()>0) { 205​ for (KoColorSet * &cs : m_activeDocument->paletteList()) {
184 for (quint32 i = 0; i< colorSet->nColors(); i++) { 206​ KoColorSet *tmpAddr = cs;
185 KoColorSetEntry entry = colorSet->getColorGlobal(i); 207​ cs = new KoColorSet(*cs);
186 QPixmap colorSquare = QPixmap(32, 32); 208​ m_rAdapter->removeResource(tmpAddr);
187 if (entry.spotColor()) { ​
188 QImage img = QImage(32, 32, QImage::Format_ARGB32); ​
189 QPainter circlePainter; ​
190 img.fill(Qt::transparent); ​
191 circlePainter.begin(&img); ​
192 QBrush brush = QBrush(Qt::SolidPattern); ​
193 brush.setColor(entry.color().toQColor()); ​
194 circlePainter.setBrush(brush); ​
195 QPen pen = circlePainter.pen(); ​
196 pen.setColor(Qt::transparent); ​
197 pen.setWidth(0); ​
198 circlePainter.setPen(pen); ​
199 circlePainter.drawEllipse(0, 0, 32, 32); ​
200 circlePainter.end(); ​
201 colorSquare = QPixmap::fromImage(img); ​
202 } else { ​
203 colorSquare.fill(entry.color().toQColor()); ​
204 } ​
205 QString name = entry.name(); ​
206 if (!entry.id().isEmpty()){ ​
207 name = entry.id() + " - " + entry.name(); ​
208 } ​
209 m_wdgPaletteDock->cmbNameList->addSqueezedItem(QIcon(colorSquare), name); ​
210 } 209​ }
211 } 210​ }
212 211​
212​ if (m_view && m_view->document()) {
213​ m_activeDocument = m_view->document();
214​ m_paletteEditor->setView(m_view);
213 215​
216​ for (KoColorSet *cs : m_activeDocument->paletteList()) {
217​ m_rAdapter->addResource(cs);
218​ }
219​ }
214 220​
221​ if (!m_currentColorSet) {
222​ slotSetColorSet(Q_NULLPTR);
223​ }
224​}
215 225​
216 QCompleter *completer = new QCompleter(m_wdgPaletteDock->cmbNameList->model()); 226​void PaletteDockerDock::unsetCanvas()
217 completer->setCompletionMode(QCompleter::PopupCompletion); 227​{
218 completer->setCaseSensitivity(Qt::CaseInsensitive); 228​ setEnabled(false);
219 completer->setFilterMode(Qt::MatchContains); 229​ m_ui->paletteView->setDisplayRenderer(Q_NULLPTR);
220 m_wdgPaletteDock->cmbNameList->setCompleter(completer); 230​ m_paletteEditor->setView(Q_NULLPTR);
221 if (colorSet && colorSet->removable()) { 231​
222 m_wdgPaletteDock->bnAdd->setEnabled(true); 232​ for (KoResource *r : m_rServer->resources()) {
223 m_wdgPaletteDock->bnRemove->setEnabled(true); 233​ KoColorSet *g = static_cast<KoColorSet*>(r);
234​ if (!g->isGlobal()) {
235​ m_rAdapter->removeResource(r);
236​ }
237​ }
238​ if (!m_currentColorSet) {
239​ slotSetColorSet(Q_NULLPTR);
240​ }
241​}
242​
243​void PaletteDockerDock::slotSetColorSet(KoColorSet* colorSet)
244​{
245​ if (colorSet && colorSet->isEditable()) {
246​ m_ui->bnAdd->setEnabled(true);
247​ m_ui->bnRename->setEnabled(true);
248​ m_ui->bnRemove->setEnabled(true);
249​ m_ui->bnEditPalette->setEnabled(true);
250​ m_ui->paletteView->setAllowModification(true);
224 } else { 251​ } else {
225 m_wdgPaletteDock->bnAdd->setEnabled(false); 252​ m_ui->bnAdd->setEnabled(false);
226 m_wdgPaletteDock->bnRemove->setEnabled(false); 253​ m_ui->bnRename->setEnabled(false);
254​ m_ui->bnRemove->setEnabled(false);
255​ m_ui->bnEditPalette->setEnabled(false);
256​ m_ui->paletteView->setAllowModification(false);
227 } 257​ }
258​
228 m_currentColorSet = colorSet; 259​ m_currentColorSet = colorSet;
260​ m_model->setPalette(colorSet);
261​ if (colorSet) {
262​ KisConfig cfg(true);
263​ cfg.setDefaultPalette(colorSet->name());
264​ m_ui->bnColorSets->setText(colorSet->name());
265​ } else {
266​ m_ui->bnColorSets->setText("");
267​ }
229} 268​}
230 269​
231void PaletteDockerDock::setColorFromNameList(int index) 270​void PaletteDockerDock::slotEditPalette()
232{ 271​{
233 if (m_model && m_currentColorSet) { 272​ KisDlgPaletteEditor dlg;
234 entrySelected(m_currentColorSet->getColorGlobal(index)); 273​ if (!m_currentColorSet) { return; }
235 m_wdgPaletteDock->paletteView->blockSignals(true); 274​ dlg.setPaletteModel(m_model);
236 m_wdgPaletteDock->cmbNameList->blockSignals(true); 275​ dlg.setView(m_view);
237 m_wdgPaletteDock->cmbNameList->setCurrentIndex(index); 276​ if (dlg.exec() != QDialog::Accepted){ return; }
238 m_wdgPaletteDock->paletteView->selectionModel()->clearSelection(); 277​
239 m_wdgPaletteDock->paletteView->selectionModel()->setCurrentIndex(m_model->indexFromId(index), QItemSelectionModel::Select); 278​ slotSetColorSet(m_currentColorSet); // update GUI
240 m_wdgPaletteDock->paletteView->blockSignals(false); ​
241 m_wdgPaletteDock->cmbNameList->blockSignals(false); ​
242 } ​
243} 279​}
244 280​
245void PaletteDockerDock::addColorForeground() 281​
282​void PaletteDockerDock::slotAddColor()
246{ 283​{
247 if (m_resourceProvider) { 284​ if (m_resourceProvider) {
248 //setup dialog 285​ m_paletteEditor->addEntry(m_resourceProvider->fgColor());
249 m_wdgPaletteDock->paletteView->addEntryWithDialog(m_resourceProvider->fgColor()); ​
250 } 286​ }
251} 287​}
252 288​
253void PaletteDockerDock::removeColor() 289​void PaletteDockerDock::slotRemoveColor()
254{ 290​{
255 QModelIndex index = m_wdgPaletteDock->paletteView->currentIndex(); 291​ QModelIndex index = m_ui->paletteView->currentIndex();
256 if (!index.isValid()) { 292​ if (!index.isValid()) {
257 return; 293​ return;
258 } 294​ }
259 m_wdgPaletteDock->paletteView->removeEntryWithDialog(index); 295​ m_paletteEditor->removeEntry(index);
296​ m_ui->bnRemove->setEnabled(false);
260} 297​}
261 298​
262void PaletteDockerDock::entrySelected(KoColorSetEntry entry) 299​void PaletteDockerDock::setFGColorByPalette(const KisSwatch &entry)
263{ 300​{
264 if (m_wdgPaletteDock->paletteView->currentIndex().isValid()) { ​
265 quint32 index = m_model->idFromIndex(m_wdgPaletteDock->paletteView->currentIndex()); ​
266 m_wdgPaletteDock->cmbNameList->setCurrentIndex(index); ​
267 } ​
268 if (m_resourceProvider) { 301​ if (m_resourceProvider) {
269 m_resourceProvider->setFGColor(entry.color()); 302​ m_resourceProvider->setFGColor(entry.color());
270 } 303​ }
271 if (m_currentColorSet->removable()) { ​
272 m_wdgPaletteDock->bnRemove->setEnabled(true); ​
273 } ​
274} ​
275 ​
276void PaletteDockerDock::entrySelectedBack(KoColorSetEntry entry) ​
277{ ​
278 if (m_wdgPaletteDock->paletteView->currentIndex().isValid()) { ​
279 quint32 index = m_model->idFromIndex(m_wdgPaletteDock->paletteView->currentIndex()); ​
280 m_wdgPaletteDock->cmbNameList->setCurrentIndex(index); ​
281 } ​
282 if (m_resourceProvider) { ​
283 m_resourceProvider->setBGColor(entry.color()); ​
284 } ​
285 if (m_currentColorSet->removable()) { ​
286 m_wdgPaletteDock->bnRemove->setEnabled(true); ​
287 } ​
288} 304​}
289 305​
290void PaletteDockerDock::saveToWorkspace(KisWorkspaceResource* workspace) 306​void PaletteDockerDock::saveToWorkspace(KisWorkspaceResource* workspace)
291{ 307​{
292 if (m_currentColorSet) { 308​ if (!m_currentColorSet.isNull()) {
293 workspace->setProperty("palette", m_currentColorSet->name()); 309​ workspace->setProperty("palette", m_currentColorSet->name());
294 } 310​ }
295} 311​}
Context not available.
300 KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer(); 316​ KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer();
301 KoColorSet* colorSet = rServer->resourceByName(workspace->getString("palette")); 317​ KoColorSet* colorSet = rServer->resourceByName(workspace->getString("palette"));
302 if (colorSet) { 318​ if (colorSet) {
303 setColorSet(colorSet); 319​ slotSetColorSet(colorSet);
304 } 320​ }
305 } 321​ }
306} 322​}
307 323​
324​void PaletteDockerDock::slotPaletteIndexSelected(const QModelIndex &index)
325​{
326​ if ((qvariant_cast<bool>(index.data(KisPaletteModel::CheckSlotRole)))) {
327​ m_ui->bnRemove->setEnabled(true);
328​ KisSwatch entry = m_model->getEntry(index);
329​ setFGColorByPalette(entry);
330​ }
331​}
332​
333​void PaletteDockerDock::slotPaletteIndexClicked(const QModelIndex &index)
334​{
335​ if (!(qvariant_cast<bool>(index.data(KisPaletteModel::CheckSlotRole)))) {
336​ setEntryByForeground(index);
337​ }
338​}
339​
340​void PaletteDockerDock::slotPaletteIndexDoubleClicked(const QModelIndex &index)
341​{
342​ m_paletteEditor->modifyEntry(index);
343​}
308 344​
345​void PaletteDockerDock::setEntryByForeground(const QModelIndex &index)
346​{
347​ m_paletteEditor->setEntry(m_resourceProvider->fgColor(), index);
348​ if (m_currentColorSet->isEditable()) {
349​ m_ui->bnRemove->setEnabled(true);
350​ }
351​}
352​
353​void PaletteDockerDock::slotEditEntry()
354​{
355​ QModelIndex index = m_ui->paletteView->currentIndex();
356​ if (!index.isValid()) {
357​ return;
358​ }
359​ m_paletteEditor->modifyEntry(index);
360​}
361​
362​void PaletteDockerDock::slotNameListSelection(const KoColor &color)
363​{
364​ m_resourceProvider->setFGColor(color);
365​}
Context not available.