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