Differential D16833 Diff 48766 plugins/tools/basictools/kis_tool_colorpicker.cc

Changeset View

Standalone View

View Options

plugins/tools/basictools/kis_tool_colorpicker.cc

Context not available.
34#include "kis_wrapped_rect.h" 34​#include "kis_wrapped_rect.h"
35#include "kis_tool_utils.h" 35​#include "kis_tool_utils.h"
36 36​
37namespace ​
38{ ​
39// GUI ComboBox index constants ​
40const int SAMPLE_MERGED = 0; ​
41} ​
42 ​
43KisToolColorPicker::KisToolColorPicker(KoCanvasBase *canvas) 37​KisToolColorPicker::KisToolColorPicker(KoCanvasBase *canvas)
44 : KisTool(canvas, KisCursor::pickerCursor()), 38​ : KisTool(canvas, KisCursor::pickerCursor()),
45 m_config(new KisToolUtils::ColorPickerConfig) 39​ m_config(new KisPickerUtils::ColorPickerConfig)
46{ 40​{
47 setObjectName("tool_colorpicker"); 41​ setObjectName("tool_colorpicker");
48 m_isActivated = false; 42​ m_isActivated = false;
49 m_optionsWidget = 0; 43​ m_optionsWidget = 0;
50 m_pickedColor = KoColor(); 44​ m_pickedColor = KoColor();
45​ m_resampleDelayTimer.setSingleShot(true);
51} 46​}
52 47​
53KisToolColorPicker::~KisToolColorPicker() 48​KisToolColorPicker::~KisToolColorPicker()
Context not available.
57 } 52​ }
58} 53​}
59 54​
55​QWidget* KisToolColorPicker::createOptionWidget()
56​{
57​ m_optionsWidget = new ColorPickerOptionsWidget(0);
58​ m_optionsWidget->setObjectName(toolId() + " Options Widget");
59​ m_optionsWidget->tableColorData->setSortingEnabled(false);
60​
61​ { // See https://bugs.kde.org/show_bug.cgi?id=316896
62​ QWidget *specialSpacer = new QWidget(m_optionsWidget);
63​ specialSpacer->setObjectName("SpecialSpacer");
64​ specialSpacer->setFixedSize(0, 0);
65​ m_optionsWidget->layout()->addWidget(specialSpacer);
66​ }
67​
68​ // Initialize mix KisSliderSpinBox.
69​ m_optionsWidget->mix->setRange(1,100);
70​ m_optionsWidget->mix->setSuffix("%");
71​
72​ { // Initialize palette selector.
73​ KoResourceServer<KoColorSet> *srv = KoResourceServerProvider::instance()->paletteServer();
74​
75​ if (!srv) {
76​ return m_optionsWidget;
77​ }
78​
79​ QList<KoColorSet*> palettes = srv->resources();
80​ Q_FOREACH (KoColorSet *palette, palettes) {
81​ if (palette) {
82​ m_optionsWidget->cmbPalettes->addSqueezedItem(palette->name());
83​ m_palettes.append(palette);
84​ }
85​ }
86​ }
87​
88​ connect(m_optionsWidget->cbUpdate, SIGNAL(toggled(bool)), SLOT(slotSetUpdate(bool)));
89​ connect(m_optionsWidget->cmbSamplingSources, SIGNAL(currentIndexChanged(int)), SLOT(slotSetSamplingSource(int)));
90​ connect(m_optionsWidget->radius, SIGNAL(valueChanged(int)), SLOT(slotChangeRadius(int)));
91​ connect(m_optionsWidget->mix, SIGNAL(valueChanged(int)), SLOT(slotChangeMix(int)));
92​ connect(m_optionsWidget->cbNormaliseValues, SIGNAL(toggled(bool)), SLOT(slotNormalizeColorData(bool)));
93​
94​ updateOptionsWidget();
95​ return m_optionsWidget;
96​}
97​
98​void KisToolColorPicker::updateOptionsWidget()
99​{
emmetoneillAuthorUnsubmitted
Not Done

Any idea why this might not be working?

I've tried scattering calls to this function across various places (constructor, activation, gui change signal, etc.).
Printing debug lines shows me that the code is being run, but useCursor seems to be having no effect.
It's probably something simple, but I figured I'd just ask about it.

emmetoneill: Any idea why this might not be working? I've tried scattering calls to this function across…
100​ if (!m_optionsWidget) return;
101​
102​ m_optionsWidget->cbUpdate->setChecked(m_config->update);
103​ m_optionsWidget->cmbSamplingSources->setCurrentIndex(m_config->source);
104​ m_optionsWidget->radius->setValue(m_config->radius);
105​ m_optionsWidget->mix->setValue(m_config->mix);
106​ m_optionsWidget->cbNormaliseValues->setChecked(m_config->normalizeColorData);
107​}
108​
60void KisToolColorPicker::paint(QPainter &gc, const KoViewConverter &converter) 109​void KisToolColorPicker::paint(QPainter &gc, const KoViewConverter &converter)
61{ 110​{
62 Q_UNUSED(gc); 111​ Q_UNUSED(gc); Q_UNUSED(converter);
63 Q_UNUSED(converter); ​
64} 112​}
65 113​
66void KisToolColorPicker::activate(ToolActivation activation, const QSet<KoShape*> &shapes) 114​void KisToolColorPicker::activate(ToolActivation activation, const QSet<KoShape*> &shapes)
Context not available.
68 m_isActivated = true; 116​ m_isActivated = true;
69 m_toolActivationSource = activation; 117​ m_toolActivationSource = activation;
70 m_config->load(m_toolActivationSource == KisTool::DefaultActivation); 118​ m_config->load(m_toolActivationSource == KisTool::DefaultActivation);
71 updateOptionWidget(); ​
72 ​
73 KisTool::activate(activation, shapes); 119​ KisTool::activate(activation, shapes);
120​
121​ updateOptionsWidget();
74} 122​}
75 123​
76void KisToolColorPicker::deactivate() 124​void KisToolColorPicker::deactivate()
Context not available.
80 KisTool::deactivate(); 128​ KisTool::deactivate();
81} 129​}
82 130​
83bool KisToolColorPicker::pickColor(const QPointF &pos) 131​void KisToolColorPicker::beginPrimaryAction(KoPointerEvent *event) //Mouse down.
84{ 132​{
85 // Timer check. 133​ bool sampleMerged = m_optionsWidget->cmbSamplingSources->currentIndex() == KisPickerUtils::MERGED_VISIBLE;
86 if (m_colorPickerDelayTimer.isActive()) { 134​ if (!sampleMerged) {
87 return false; 135​ if (!currentNode()) {
88 } 136​ QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as no layer is active."));
89 else { 137​ event->ignore();
90 m_colorPickerDelayTimer.setSingleShot(true); 138​ return;
91 m_colorPickerDelayTimer.start(100); 139​ }
140​ if (!currentNode()->visible()) {
141​ QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as the active layer is not visible."));
142​ event->ignore();
143​ return;
144​ }
92 } 145​ }
93 146​
94 QScopedPointer<boost::lock_guard<KisImage>> imageLocker; 147​ setMode(KisTool::PAINT_MODE);
95 148​
96 m_pickedColor.setOpacity(0.0); 149​ QPoint pos = convertToImagePixelCoordFloored(event);
97 150​
98 // Pick from reference images. 151​ bool picked = pickColor(pos);
99 if (m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED) { 152​ if (!picked) { // Color picking has to start in the visible part of the layer
100 auto *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas()); 153​ event->ignore();
101 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(kisCanvas, false); 154​ return;
102 KisSharedPtr<KisReferenceImagesLayer> referenceImageLayer = ​
103 kisCanvas->imageView()->document()->referenceImagesLayer(); ​
104 ​
105 if (referenceImageLayer && kisCanvas->referenceImagesDecoration()->visible()) { ​
106 QColor color = referenceImageLayer->getPixel(pos); ​
107 if (color.isValid()) { ​
108 m_pickedColor.fromQColor(color); ​
109 } ​
110 } ​
111 } 155​ }
112 156​
113 if (m_pickedColor.opacityU8() == OPACITY_TRANSPARENT_U8) { 157​ displayPickedColor();
114 if (!currentImage()->bounds().contains(pos.toPoint()) && ​
115 !currentImage()->wrapAroundModePermitted()) { ​
116 return false; ​
117 } ​
118 ​
119 KisPaintDeviceSP dev; ​
120 158​
121 if (m_optionsWidget->cmbSources->currentIndex() != SAMPLE_MERGED && 159​ m_resampleDelayTimer.start(m_config->resampleRateMS);
122 currentNode() && currentNode()->colorPickSourceDevice()) { 160​}
123 dev = currentNode()->colorPickSourceDevice(); ​
124 } ​
125 else { ​
126 imageLocker.reset(new boost::lock_guard<KisImage>(*currentImage())); ​
127 dev = currentImage()->projection(); ​
128 } ​
129 161​
130 KoColor previousColor = canvas()->resourceManager()->foregroundColor(); 162​void KisToolColorPicker::continuePrimaryAction(KoPointerEvent *event) //Mouse drag.
163​{
164​ CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
131 165​
132 KisToolUtils::pickColor(m_pickedColor, dev, pos.toPoint(), &previousColor, m_config->radius, m_config->blend); 166​ if (m_resampleDelayTimer.isActive()) {
167​ return;
168​ }
169​ else {
170​ m_resampleDelayTimer.start(m_config->resampleRateMS);
133 } 171​ }
134 172​
135 if (m_config->updateColor && 173​ QPoint pos = convertToImagePixelCoordFloored(event);
136 m_pickedColor.opacityU8() != OPACITY_TRANSPARENT_U8) { ​
137 174​
138 KoColor publicColor = m_pickedColor; 175​ pickColor(pos);
139 publicColor.setOpacity(OPACITY_OPAQUE_U8); // Alpha is unwanted for FG and BG colors. 176​ displayPickedColor();
177​}
140 178​
141 if (m_config->toForegroundColor) { 179​void KisToolColorPicker::endPrimaryAction(KoPointerEvent *event) //Mouse up.
142 canvas()->resourceManager()->setResource(KoCanvasResourceProvider::ForegroundColor, publicColor); 180​{
143 } 181​ Q_UNUSED(event);
144 else { 182​ CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
145 canvas()->resourceManager()->setResource(KoCanvasResourceProvider::BackgroundColor, publicColor); ​
146 } ​
147 } ​
148 183​
149 return true; 184​ // Add picked colors to selected palette.
185​ if (m_optionsWidget->cbAddToPalette->isChecked()) {
186​ KisSwatch entry;
187​ entry.setColor(m_pickedColor);
188​ entry.setName("Picked"); // Placeholder - better than nothing!
189​
190​ KoColorSet *palette = m_palettes.at(m_optionsWidget->cmbPalettes->currentIndex());
191​ palette->add(entry);
192​ }
150} 193​}
151 194​
152void KisToolColorPicker::beginPrimaryAction(KoPointerEvent *event) 195​void KisToolColorPicker::beginAlternateAction(KoPointerEvent *event, AlternateAction action) {
153{ 196​ // ***WARNING: Modified copy-paste from 'beginPrimaryAction'; it'd be nice to unify these later.***
154 bool sampleMerged = m_optionsWidget->cmbSources->currentIndex() == SAMPLE_MERGED; 197​ bool sampleMerged = m_optionsWidget->cmbSamplingSources->currentIndex() == KisPickerUtils::MERGED_VISIBLE;
155 if (!sampleMerged) { 198​ if (!sampleMerged) {
156 if (!currentNode()) { 199​ if (!currentNode()) {
157 QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as no layer is active.")); 200​ QMessageBox::information(0, i18nc("@title:window", "Krita"), i18n("Cannot pick a color as no layer is active."));
Context not available.
165 } 208​ }
166 } 209​ }
167 210​
168 QPoint pos = convertToImagePixelCoordFloored(event); ​
169 ​
170 setMode(KisTool::PAINT_MODE); 211​ setMode(KisTool::PAINT_MODE);
171 212​
172 bool picked = pickColor(pos); 213​ QPoint pos = convertToImagePixelCoordFloored(event);
173 if (!picked) { 214​ bool pure = action == ChangeSize ? true : false; // Pure on "ChangeSize" (shift + leftclick).
174 // Color picking has to start in the visible part of the layer 215​
216​ bool picked = pickColor(pos, pure);
217​ if (!picked) { // Color picking has to start in the visible part of the layer
175 event->ignore(); 218​ event->ignore();
176 return; 219​ return;
177 } 220​ }
178 221​
179 displayPickedColor(); 222​ displayPickedColor();
180} ​
181 ​
182void KisToolColorPicker::continuePrimaryAction(KoPointerEvent *event) ​
183{ ​
184 CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE); ​
185 223​
186 QPoint pos = convertToImagePixelCoordFloored(event); 224​ m_resampleDelayTimer.start(m_config->resampleRateMS);
187 pickColor(pos); ​
188 displayPickedColor(); ​
189} 225​}
190 226​
191void KisToolColorPicker::endPrimaryAction(KoPointerEvent *event) 227​bool KisToolColorPicker::pickColor(const QPointF &pos, bool pure)
192{ 228​{
193 Q_UNUSED(event); 229​ QScopedPointer<boost::lock_guard<KisImage>> imageLocker;
194 CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE); ​
195 230​
196 if (m_config->addPalette) { 231​ m_pickedColor.setOpacity(0.0);
197 KisSwatch ent; ​
198 ent.setColor(m_pickedColor); ​
199 // We don't ask for a name, too intrusive here ​
200 232​
201 KoColorSet *palette = m_palettes.at(m_optionsWidget->cmbPalette->currentIndex()); 233​ auto *canv = dynamic_cast<KisCanvas2*>(canvas());
202 palette->add(ent); 234​ KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canv, false);
235​
236​ if (m_pickedColor.opacityU8() == OPACITY_TRANSPARENT_U8) {
237​ KisPaintDeviceSP activeDevice;
203 238​
204 if (!palette->save()) { 239​ if (m_config->source != KisPickerUtils::MERGED_VISIBLE
205 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Cannot write to palette file %1. Maybe it is read-only.", palette->filename())); 240​ && currentNode() && currentNode()->colorPickSourceDevice()) {
241​ activeDevice = currentNode()->colorPickSourceDevice();
206 } 242​ }
243​ else {
244​ imageLocker.reset(new boost::lock_guard<KisImage>(*currentImage()));
245​ activeDevice = currentImage()->projection();
246​ }
247​
248​ KoColor previousColor = canvas()->resourceManager()->foregroundColor();
249​
250​ KisPickerUtils::pickColor(m_pickedColor, activeDevice, canv, pos.toPoint(), &previousColor, m_config->radius, m_config->mix, pure);
207 } 251​ }
208} ​
209 252​
210struct PickedChannel { 253​ if (m_config->update && m_pickedColor.opacityU8() != OPACITY_TRANSPARENT_U8) {
211 QString name; 254​ KisPickerUtils::UpdateTarget target = KisPickerUtils::FOREGROUND;
212 QString valueText; 255​ KisPickerUtils::submitColor(*canvas()->resourceManager(), target, m_pickedColor);
213}; 256​ }
257​
258​ return true;
259​}
214 260​
215void KisToolColorPicker::displayPickedColor() 261​void KisToolColorPicker::displayPickedColor()
216{ 262​{
263​ struct PickedChannel {
264​ QString name;
265​ QString valueText;
266​ };
267​
217 if (m_pickedColor.data() && m_optionsWidget) { 268​ if (m_pickedColor.data() && m_optionsWidget) {
218 269​
219 QList<KoChannelInfo *> channels = m_pickedColor.colorSpace()->channels(); 270​ QList<KoChannelInfo *> channels = m_pickedColor.colorSpace()->channels();
220 m_optionsWidget->listViewChannels->clear(); 271​ m_optionsWidget->tableColorData->clear();
221 272​
222 QVector<PickedChannel> pickedChannels; 273​ QVector<PickedChannel> pickedChannels;
223 for (int i = 0; i < channels.count(); ++i) { 274​ for (int i = 0; i < channels.count(); ++i) {
Context not available.
229 PickedChannel pc; 280​ PickedChannel pc;
230 pc.name = channels[i]->name(); 281​ pc.name = channels[i]->name();
231 282​
232 if (m_config->normaliseValues) { 283​ if (m_config->normalizeColorData) {
233 pc.valueText = m_pickedColor.colorSpace()->normalisedChannelValueText(m_pickedColor.data(), i); 284​ pc.valueText = m_pickedColor.colorSpace()->normalisedChannelValueText(m_pickedColor.data(), i);
234 } else { 285​ } else {
235 pc.valueText = m_pickedColor.colorSpace()->channelValueText(m_pickedColor.data(), i); 286​ pc.valueText = m_pickedColor.colorSpace()->channelValueText(m_pickedColor.data(), i);
Context not available.
240 } 291​ }
241 292​
242 Q_FOREACH (const PickedChannel &pc, pickedChannels) { 293​ Q_FOREACH (const PickedChannel &pc, pickedChannels) {
243 QTreeWidgetItem *item = new QTreeWidgetItem(m_optionsWidget->listViewChannels); 294​ QTreeWidgetItem *item = new QTreeWidgetItem(m_optionsWidget->tableColorData);
244 item->setText(0, pc.name); 295​ item->setText(0, pc.name);
245 item->setText(1, pc.valueText); 296​ item->setText(1, pc.valueText);
246 } 297​ }
247 } 298​ }
248} 299​}
249 300​
250QWidget* KisToolColorPicker::createOptionWidget() 301​void KisToolColorPicker::slotSetSamplingSource(int source)
251{ ​
252 m_optionsWidget = new ColorPickerOptionsWidget(0); ​
253 m_optionsWidget->setObjectName(toolId() + " option widget"); ​
254 m_optionsWidget->listViewChannels->setSortingEnabled(false); ​
255 ​
256 // See https://bugs.kde.org/show_bug.cgi?id=316896 ​
257 QWidget *specialSpacer = new QWidget(m_optionsWidget); ​
258 specialSpacer->setObjectName("SpecialSpacer"); ​
259 specialSpacer->setFixedSize(0, 0); ​
260 m_optionsWidget->layout()->addWidget(specialSpacer); ​
261 ​
262 // Initialize blend KisSliderSpinBox ​
263 m_optionsWidget->blend->setRange(0,100); ​
264 m_optionsWidget->blend->setSuffix("%"); ​
265 ​
266 updateOptionWidget(); ​
267 ​
268 connect(m_optionsWidget->cbUpdateCurrentColor, SIGNAL(toggled(bool)), SLOT(slotSetUpdateColor(bool))); ​
269 connect(m_optionsWidget->cbNormaliseValues, SIGNAL(toggled(bool)), SLOT(slotSetNormaliseValues(bool))); ​
270 connect(m_optionsWidget->cbPalette, SIGNAL(toggled(bool)), ​
271 SLOT(slotSetAddPalette(bool))); ​
272 connect(m_optionsWidget->radius, SIGNAL(valueChanged(int)), ​
273 SLOT(slotChangeRadius(int))); ​
274 connect(m_optionsWidget->blend, SIGNAL(valueChanged(int)), ​
275 SLOT(slotChangeBlend(int))); ​
276 connect(m_optionsWidget->cmbSources, SIGNAL(currentIndexChanged(int)), ​
277 SLOT(slotSetColorSource(int))); ​
278 ​
279 KoResourceServer<KoColorSet> *srv = KoResourceServerProvider::instance()->paletteServer(); ​
280 ​
281 if (!srv) { ​
282 return m_optionsWidget; ​
283 } ​
284 ​
285 QList<KoColorSet*> palettes = srv->resources(); ​
286 ​
287 Q_FOREACH (KoColorSet *palette, palettes) { ​
288 if (palette) { ​
289 m_optionsWidget->cmbPalette->addSqueezedItem(palette->name()); ​
290 m_palettes.append(palette); ​
291 } ​
292 } ​
293 ​
294 return m_optionsWidget; ​
295} ​
296 ​
297void KisToolColorPicker::updateOptionWidget() ​
298{ 302​{
299 if (!m_optionsWidget) return; 303​ auto src = static_cast<KisPickerUtils::SamplingSource>(source);
300 304​ m_config->source = src;
301 m_optionsWidget->cbNormaliseValues->setChecked(m_config->normaliseValues); ​
302 m_optionsWidget->cbUpdateCurrentColor->setChecked(m_config->updateColor); ​
303 m_optionsWidget->cmbSources->setCurrentIndex(SAMPLE_MERGED + !m_config->sampleMerged); ​
304 m_optionsWidget->cbPalette->setChecked(m_config->addPalette); ​
305 m_optionsWidget->radius->setValue(m_config->radius); ​
306 m_optionsWidget->blend->setValue(m_config->blend); ​
307} ​
308 ​
309void KisToolColorPicker::setToForeground(bool newValue) ​
310{ ​
311 m_config->toForegroundColor = newValue; ​
312 emit toForegroundChanged(); ​
313} 305​}
314 306​
315bool KisToolColorPicker::toForeground() const 307​void KisToolColorPicker::slotSetUpdate(bool state)
316{ 308​{
317 return m_config->toForegroundColor; 309​ m_config->update = state;
318} 310​}
319 311​
320void KisToolColorPicker::slotSetUpdateColor(bool state) 312​void KisToolColorPicker::slotNormalizeColorData(bool state)
321{ 313​{
322 m_config->updateColor = state; 314​ m_config->normalizeColorData = state;
323} ​
324 ​
325void KisToolColorPicker::slotSetNormaliseValues(bool state) ​
326{ ​
327 m_config->normaliseValues = state; ​
328 displayPickedColor(); 315​ displayPickedColor();
329} 316​}
330 317​
331void KisToolColorPicker::slotSetAddPalette(bool state) ​
332{ ​
333 m_config->addPalette = state; ​
334} ​
335 ​
336void KisToolColorPicker::slotChangeRadius(int value) 318​void KisToolColorPicker::slotChangeRadius(int value)
337{ 319​{
338 m_config->radius = value; 320​ m_config->radius = value;
339} 321​}
340 322​
341void KisToolColorPicker::slotChangeBlend(int value) 323​void KisToolColorPicker::slotChangeMix(int value)
342{ ​
343 m_config->blend = value; ​
344} ​
345 ​
346void KisToolColorPicker::slotSetColorSource(int value) ​
347{ 324​{
348 m_config->sampleMerged = value == SAMPLE_MERGED; 325​ m_config->mix = value;
349} ​
350 ​
351void KisToolColorPicker::slotAddPalette(KoResource *resource) ​
352{ ​
353 KoColorSet *palette = dynamic_cast<KoColorSet*>(resource); ​
354 if (palette) { ​
355 m_optionsWidget->cmbPalette->addSqueezedItem(palette->name()); ​
356 m_palettes.append(palette); ​
357 } ​
358} 326​}
Context not available.