• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • krita API Reference
  • KDE Home
  • Contact Us
 

plugins/paintops/libpaintop

  • sources
  • kfour-appscomplete
  • krita
  • plugins
  • paintops
  • libpaintop
kis_texture_option.cpp
Go to the documentation of this file.
1 /* This file is part of the KDE project
2  * SPDX-FileCopyrightText: 2012 Boudewijn Rempt <[email protected]>
3  * SPDX-FileCopyrightText: 2014 Mohit Goyal <[email protected]>
4  *
5  * SPDX-License-Identifier: LGPL-2.0-or-later
6  */
7 #include "kis_texture_option.h"
8 
9 #include <QWidget>
10 #include <QString>
11 #include <QByteArray>
12 #include <QCheckBox>
13 #include <QBuffer>
14 #include <QFormLayout>
15 #include <QLabel>
16 #include <QComboBox>
17 #include <QTransform>
18 #include <QPainter>
19 #include <QBoxLayout>
20 
21 #include <klocalizedstring.h>
22 
23 #include <kis_pattern_chooser.h>
24 #include <kis_slider_spin_box.h>
25 #include <kis_multipliers_double_slider_spinbox.h>
26 #include <KoPattern.h>
27 #include <KoAbstractGradient.h>
28 #include <KoResource.h>
29 #include <KoResourceServerProvider.h>
30 #include <kis_paint_device.h>
31 #include <kis_fill_painter.h>
32 #include <kis_painter.h>
33 #include <kis_iterator_ng.h>
34 #include <kis_fixed_paint_device.h>
35 #include <KisGradientSlider.h>
36 #include "kis_embedded_pattern_manager.h"
37 #include <brushengine/kis_paintop_lod_limitations.h>
38 #include "kis_texture_chooser.h"
39 #include "KoMixColorsOp.h"
40 #include <time.h>
41 #include "kis_signals_blocker.h"
42 #include <KisGlobalResourcesInterface.h>
43 
44 #include <KoCanvasResourcesIds.h>
45 #include <KoCanvasResourcesInterface.h>
46 
47 
48 KisTextureOption::KisTextureOption()
49  : KisPaintOpOption(KisPaintOpOption::TEXTURE, true)
50  , m_textureOptions(new KisTextureChooser())
51 {
52  setObjectName("KisTextureOption");
53  setConfigurationPage(m_textureOptions);
54 
55  connect(m_textureOptions->textureSelectorWidget, SIGNAL(resourceSelected(KoResourceSP )), SLOT(resetGUI(KoResourceSP )));
56  connect(m_textureOptions->textureSelectorWidget, SIGNAL(resourceSelected(KoResourceSP )), SLOT(emitSettingChanged()));
57  connect(m_textureOptions->scaleSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
58  connect(m_textureOptions->brightnessSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
59  connect(m_textureOptions->contrastSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
60  connect(m_textureOptions->neutralPointSlider, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
61  connect(m_textureOptions->offsetSliderX, SIGNAL(valueChanged(int)), SLOT(emitSettingChanged()));
62  connect(m_textureOptions->randomOffsetX, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
63  connect(m_textureOptions->randomOffsetY, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
64  connect(m_textureOptions->offsetSliderY, SIGNAL(valueChanged(int)), SLOT(emitSettingChanged()));
65  connect(m_textureOptions->cmbTexturingMode, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
66  connect(m_textureOptions->cmbCutoffPolicy, SIGNAL(currentIndexChanged(int)), SLOT(emitSettingChanged()));
67  connect(m_textureOptions->cutoffSlider, SIGNAL(sigModifiedBlack(int)), SLOT(emitSettingChanged()));
68  connect(m_textureOptions->cutoffSlider, SIGNAL(sigModifiedWhite(int)), SLOT(emitSettingChanged()));
69  connect(m_textureOptions->chkInvert, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
70  resetGUI(m_textureOptions->textureSelectorWidget->currentResource());
71 
72 }
73 
74 KisTextureOption::~KisTextureOption()
75 {
76  delete m_textureOptions;
77 }
78 
79 void KisTextureOption::writeOptionSetting(KisPropertiesConfigurationSP setting) const
80 {
81  KoPatternSP pattern;
82 
83  {
84  KisSignalsBlocker b(m_textureOptions->textureSelectorWidget);
85  KoResourceSP resource = m_textureOptions->textureSelectorWidget->currentResource();
86  if (!resource) return;
87 
88  pattern = resource.staticCast<KoPattern>();
89  if (!pattern) return;
90  }
91 
92  setting->setProperty("Texture/Pattern/Enabled", isChecked());
93  if (!isChecked()) {
94  return;
95  }
96 
97  qreal scale = m_textureOptions->scaleSlider->value();
98 
99  qreal brightness = m_textureOptions->brightnessSlider->value();
100 
101  qreal contrast = m_textureOptions->contrastSlider->value();
102 
103  qreal neutralPoint = m_textureOptions->neutralPointSlider->value();
104 
105  int offsetX = m_textureOptions->offsetSliderX->value();
106  if (m_textureOptions ->randomOffsetX->isChecked()) {
107 
108  m_textureOptions->offsetSliderX ->setEnabled(false);
109  m_textureOptions->offsetSliderX ->blockSignals(true);
110  m_textureOptions->offsetSliderX ->setValue(offsetX);
111  m_textureOptions->offsetSliderX ->blockSignals(false);
112  }
113  else {
114  m_textureOptions->offsetSliderX ->setEnabled(true);
115  }
116 
117  int offsetY = m_textureOptions->offsetSliderY->value();
118  if (m_textureOptions ->randomOffsetY->isChecked()) {
119 
120  m_textureOptions->offsetSliderY ->setEnabled(false);
121  m_textureOptions->offsetSliderY ->blockSignals(true);
122  m_textureOptions->offsetSliderY ->setValue(offsetY);
123  m_textureOptions->offsetSliderY ->blockSignals(false);
124  }
125  else {
126  m_textureOptions->offsetSliderY ->setEnabled(true);
127  }
128 
129  int texturingMode = m_textureOptions->cmbTexturingMode->currentIndex();
130  bool invert = (m_textureOptions->chkInvert->checkState() == Qt::Checked);
131 
132  setting->setProperty("Texture/Pattern/Scale", scale);
133  setting->setProperty("Texture/Pattern/Brightness", brightness);
134  setting->setProperty("Texture/Pattern/Contrast", contrast);
135  setting->setProperty("Texture/Pattern/NeutralPoint", neutralPoint);
136  setting->setProperty("Texture/Pattern/OffsetX", offsetX);
137  setting->setProperty("Texture/Pattern/OffsetY", offsetY);
138  setting->setProperty("Texture/Pattern/TexturingMode", texturingMode);
139  setting->setProperty("Texture/Pattern/CutoffLeft", m_textureOptions->cutoffSlider->black());
140  setting->setProperty("Texture/Pattern/CutoffRight", m_textureOptions->cutoffSlider->white());
141  setting->setProperty("Texture/Pattern/CutoffPolicy", m_textureOptions->cmbCutoffPolicy->currentIndex());
142  setting->setProperty("Texture/Pattern/Invert", invert);
143 
144  setting->setProperty("Texture/Pattern/MaximumOffsetX",m_textureOptions->offsetSliderX ->maximum());
145  setting->setProperty("Texture/Pattern/MaximumOffsetY",m_textureOptions->offsetSliderY ->maximum());
146  setting->setProperty("Texture/Pattern/isRandomOffsetX",m_textureOptions ->randomOffsetX ->isChecked());
147  setting->setProperty("Texture/Pattern/isRandomOffsetY",m_textureOptions ->randomOffsetY ->isChecked());
148 
149  KisEmbeddedPatternManager::saveEmbeddedPattern(setting, pattern);
150 }
151 
152 void KisTextureOption::readOptionSetting(const KisPropertiesConfigurationSP setting)
153 {
154 
155  setChecked(setting->getBool("Texture/Pattern/Enabled"));
156  if (!isChecked()) {
157  return;
158  }
159  KoPatternSP pattern = KisEmbeddedPatternManager::loadEmbeddedPattern(setting, resourcesInterface());
160 
161  if (!pattern) {
162  pattern =m_textureOptions->textureSelectorWidget->currentResource().staticCast<KoPattern>();
163  }
164 
165  m_textureOptions->textureSelectorWidget->setCurrentPattern(pattern);
166 
167  m_textureOptions->scaleSlider->setValue(setting->getDouble("Texture/Pattern/Scale", 1.0));
168  m_textureOptions->brightnessSlider->setValue(setting->getDouble("Texture/Pattern/Brightness"));
169  m_textureOptions->contrastSlider->setValue(setting->getDouble("Texture/Pattern/Contrast", 1.0));
170  m_textureOptions->neutralPointSlider->setValue(setting->getDouble("Texture/Pattern/NeutralPoint", 0.5));
171  m_textureOptions->offsetSliderX->setValue(setting->getInt("Texture/Pattern/OffsetX"));
172  m_textureOptions->offsetSliderY->setValue(setting->getInt("Texture/Pattern/OffsetY"));
173  m_textureOptions->randomOffsetX->setChecked(setting->getBool("Texture/Pattern/isRandomOffsetX"));
174  m_textureOptions->randomOffsetY->setChecked(setting->getBool("Texture/Pattern/isRandomOffsetY"));
175  m_textureOptions->cmbTexturingMode->setCurrentIndex(setting->getInt("Texture/Pattern/TexturingMode", KisTextureProperties::MULTIPLY));
176  m_textureOptions->cmbCutoffPolicy->setCurrentIndex(setting->getInt("Texture/Pattern/CutoffPolicy"));
177  m_textureOptions->cutoffSlider->slotModifyBlack(setting->getInt("Texture/Pattern/CutoffLeft", 0));
178  m_textureOptions->cutoffSlider->slotModifyWhite(setting->getInt("Texture/Pattern/CutoffRight", 255));
179  m_textureOptions->chkInvert->setChecked(setting->getBool("Texture/Pattern/Invert"));
180 
181 }
182 
183 void KisTextureOption::lodLimitations(KisPaintopLodLimitations *l) const
184 {
185  l->limitations << KoID("texture-pattern", i18nc("PaintOp instant preview limitation", "Texture->Pattern (low quality preview)"));
186 }
187 
188 
189 void KisTextureOption::resetGUI(KoResourceSP res)
190 {
191  KoPatternSP pattern = res.staticCast<KoPattern>();
192  if (!pattern) return;
193 
194  m_textureOptions->offsetSliderX->setRange(0, pattern->pattern().width() / 2);
195  m_textureOptions->offsetSliderY->setRange(0, pattern->pattern().height() / 2);
196 }
197 
198 /**********************************************************************/
199 /* KisTextureProperties */
200 /**********************************************************************/
201 
202 
203 KisTextureProperties::KisTextureProperties(int levelOfDetail)
204  : m_gradient(0)
205  , m_levelOfDetail(levelOfDetail)
206 {
207 }
208 
209 void KisTextureProperties::fillProperties(const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface, KoCanvasResourcesInterfaceSP canvasResourcesInterface)
210 {
211  if (!setting->hasProperty("Texture/Pattern/PatternMD5")) {
212  m_enabled = false;
213  return;
214  }
215 
216  m_texturingMode = (TexturingMode)setting->getInt("Texture/Pattern/TexturingMode", MULTIPLY);
217  bool preserveAlpha = m_texturingMode == LIGHTNESS || m_texturingMode == GRADIENT;
218 
219  m_maskInfo = toQShared(new KisTextureMaskInfo(m_levelOfDetail, preserveAlpha));
220  if (!m_maskInfo->fillProperties(setting, resourcesInterface)) {
221  warnKrita << "WARNING: Couldn't load the pattern for a stroke";
222  m_enabled = false;
223  return;
224  }
225 
226  m_maskInfo = KisTextureMaskInfoCache::instance()->fetchCachedTextureInfo(m_maskInfo);
227 
228  m_enabled = setting->getBool("Texture/Pattern/Enabled", false);
229  m_offsetX = setting->getInt("Texture/Pattern/OffsetX");
230  m_offsetY = setting->getInt("Texture/Pattern/OffsetY");
231 
232  if (m_texturingMode == GRADIENT && canvasResourcesInterface) {
233  KoAbstractGradientSP gradient = canvasResourcesInterface->resource(KoCanvasResource::CurrentGradient).value<KoAbstractGradientSP>();
234  if (gradient) {
235  m_gradient = gradient;
236  m_cachedGradient.setGradient(gradient, 256);
237  }
238  }
239 
240  m_strengthOption.readOptionSetting(setting);
241  m_strengthOption.resetAllSensors();
242 }
243 
244 QList<KoResourceSP> KisTextureProperties::prepareEmbeddedResources(const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface)
245 {
246  QList<KoResourceSP> resources;
247 
248  KoPatternSP pattern = KisEmbeddedPatternManager::loadEmbeddedPattern(setting, resourcesInterface);
249  if (pattern) {
250  resources << pattern;
251  }
252 
253  return resources;
254 }
255 
256 bool KisTextureProperties::applyingGradient() const
257 {
258  return m_texturingMode == GRADIENT;
259 }
260 
261 bool KisTextureProperties::applyingGradient(const KisPropertiesConfiguration *settings)
262 {
263  return (TexturingMode) settings->getInt("Texture/Pattern/TexturingMode", MULTIPLY) == GRADIENT;
264 }
265 
266 void KisTextureProperties::applyLightness(KisFixedPaintDeviceSP dab, const QPoint& offset, const KisPaintInformation& info) {
267  if (!m_enabled) return;
268 
269  KisPaintDeviceSP mask = m_maskInfo->mask();
270  const QRect maskBounds = m_maskInfo->maskBounds();
271 
272  KisPaintDeviceSP fillMaskDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
273  const QRect rect = dab->bounds();
274 
275  KIS_SAFE_ASSERT_RECOVER_RETURN(mask);
276 
277  int x = offset.x() % maskBounds.width() - m_offsetX;
278  int y = offset.y() % maskBounds.height() - m_offsetY;
279 
280  KisFillPainter fillMaskPainter(fillMaskDevice);
281  fillMaskPainter.fillRect(x - 1, y - 1, rect.width() + 2, rect.height() + 2, mask, maskBounds);
282  fillMaskPainter.end();
283 
284  qreal pressure = m_strengthOption.apply(info);
285  quint8* dabData = dab->data();
286 
287  KisSequentialConstIterator it(fillMaskDevice, QRect(x, y, rect.width(), rect.height()));
288  while (it.nextPixel()) {
289  const QRgb *maskQRgb = reinterpret_cast<const QRgb*>(it.oldRawData());
290  dab->colorSpace()->fillGrayBrushWithColorAndLightnessWithStrength(dabData, maskQRgb, dabData, pressure, 1);
291  dabData += dab->pixelSize();
292  }
293 }
294 
295 void KisTextureProperties::applyGradient(KisFixedPaintDeviceSP dab, const QPoint& offset, const KisPaintInformation& info) {
296  if (!m_enabled) return;
297 
298  KIS_SAFE_ASSERT_RECOVER_RETURN(m_gradient && m_gradient->valid());
299 
300  KisPaintDeviceSP fillDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8());
301  QRect rect = dab->bounds();
302 
303  KisPaintDeviceSP mask = m_maskInfo->mask();
304  const QRect maskBounds = m_maskInfo->maskBounds();
305 
306  KIS_SAFE_ASSERT_RECOVER_RETURN(mask);
307 
308  int x = offset.x() % maskBounds.width() - m_offsetX;
309  int y = offset.y() % maskBounds.height() - m_offsetY;
310 
311 
312  KisFillPainter fillPainter(fillDevice);
313  fillPainter.fillRect(x - 1, y - 1, rect.width() + 2, rect.height() + 2, mask, maskBounds);
314  fillPainter.end();
315 
316  qreal pressure = m_strengthOption.apply(info);
317  quint8* dabData = dab->data();
318 
319  //for gradient textures...
320  KoMixColorsOp* colorMix = dab->colorSpace()->mixColorsOp();
321  qint16 colorWeights[2];
322  colorWeights[0] = qRound(pressure * 255);
323  colorWeights[1] = 255 - colorWeights[0];
324  quint8* colors[2];
325  m_cachedGradient.setColorSpace(dab->colorSpace()); //Change colorspace here so we don't have to convert each pixel drawn
326 
327  KisHLineIteratorSP iter = fillDevice->createHLineIteratorNG(x, y, rect.width());
328  for (int row = 0; row < rect.height(); ++row) {
329  for (int col = 0; col < rect.width(); ++col) {
330 
331  const QRgb* maskQRgb = reinterpret_cast<const QRgb*>(iter->oldRawData());
332  qreal gradientvalue = qreal(qGray(*maskQRgb))/255.0;//qreal(*iter->oldRawData()) / 255.0;
333  KoColor paintcolor;
334  paintcolor.setColor(m_cachedGradient.cachedAt(gradientvalue), dab->colorSpace());
335  qreal paintOpacity = paintcolor.opacityF() * (qreal(qAlpha(*maskQRgb)) / 255.0);
336  paintcolor.setOpacity(qMin(paintOpacity, dab->colorSpace()->opacityF(dabData)));
337  colors[0] = paintcolor.data();
338  KoColor dabColor(dabData, dab->colorSpace());
339  colors[1] = dabColor.data();
340  colorMix->mixColors(colors, colorWeights, 2, dabData);
341 
342  iter->nextPixel();
343  dabData += dab->pixelSize();
344  }
345  iter->nextRow();
346  }
347 }
348 
349 void KisTextureProperties::apply(KisFixedPaintDeviceSP dab, const QPoint &offset, const KisPaintInformation & info)
350 {
351  if (!m_enabled) return;
352 
353  if (m_texturingMode == LIGHTNESS) {
354  applyLightness(dab, offset, info);
355  return;
356  }
357  else if (m_texturingMode == GRADIENT && m_gradient) {
358  applyGradient(dab, offset, info);
359  return;
360  }
361 
362  KisPaintDeviceSP fillDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->alpha8());
363  QRect rect = dab->bounds();
364 
365  KisPaintDeviceSP mask = m_maskInfo->mask();
366  const QRect maskBounds = m_maskInfo->maskBounds();
367 
368  KIS_SAFE_ASSERT_RECOVER_RETURN(mask);
369 
370  int x = offset.x() % maskBounds.width() - m_offsetX;
371  int y = offset.y() % maskBounds.height() - m_offsetY;
372 
373 
374  KisFillPainter fillPainter(fillDevice);
375  fillPainter.fillRect(x - 1, y - 1, rect.width() + 2, rect.height() + 2, mask, maskBounds);
376  fillPainter.end();
377 
378  qreal pressure = m_strengthOption.apply(info);
379  quint8* dabData = dab->data();
380 
381  KisHLineIteratorSP iter = fillDevice->createHLineIteratorNG(x, y, rect.width());
382  for (int row = 0; row < rect.height(); ++row) {
383  for (int col = 0; col < rect.width(); ++col) {
384  if (m_texturingMode == MULTIPLY) {
385  dab->colorSpace()->multiplyAlpha(dabData, quint8(*iter->oldRawData() * pressure), 1);
386  }
387  else {
388  int pressureOffset = (1.0 - pressure) * 255;
389 
390  qint16 maskA = *iter->oldRawData() + pressureOffset;
391  quint8 dabA = dab->colorSpace()->opacityU8(dabData);
392 
393  dabA = qMax(0, (qint16)dabA - maskA);
394  dab->colorSpace()->setOpacity(dabData, dabA, 1);
395  }
396 
397  iter->nextPixel();
398  dabData += dab->pixelSize();
399  }
400  iter->nextRow();
401  }
402 }
KisTextureMaskInfoCache::instance
static KisTextureMaskInfoCache * instance()
Definition: KisTextureMaskInfo.cpp:248
KisTextureOption::writeOptionSetting
void writeOptionSetting(KisPropertiesConfigurationSP setting) const override
Definition: kis_texture_option.cpp:79
KisTextureMaskInfo::mask
KisPaintDeviceSP mask()
Definition: KisTextureMaskInfo.cpp:96
KisPressureTextureStrengthOption::apply
double apply(const KisPaintInformation &info) const
Definition: kis_pressure_texture_strength_option.cpp:16
kis_texture_chooser.h
KisCurveOption::resetAllSensors
void resetAllSensors()
Definition: kis_curve_option.cpp:104
QRect
KisTextureMaskInfo::maskBounds
QRect maskBounds() const
Definition: KisTextureMaskInfo.cpp:100
KisTextureProperties::LIGHTNESS
Definition: kis_texture_option.h:63
QRect::width
int width() const
KisTextureProperties::applyingGradient
bool applyingGradient() const
Definition: kis_texture_option.cpp:256
KisTextureOption::lodLimitations
void lodLimitations(KisPaintopLodLimitations *l) const override
Definition: kis_texture_option.cpp:183
KisTextureProperties::GRADIENT
Definition: kis_texture_option.h:64
QPoint::x
int x() const
QPoint::y
int y() const
QSharedPointer
Definition: KisDabCacheUtils.h:110
QList
KisEmbeddedPatternManager::loadEmbeddedPattern
static KoPatternSP loadEmbeddedPattern(const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface)
Definition: kis_embedded_pattern_manager.cpp:89
KisTextureOption::KisTextureOption
KisTextureOption()
Definition: kis_texture_option.cpp:48
KisTextureProperties::m_enabled
bool m_enabled
Definition: kis_texture_option.h:67
QObject::blockSignals
bool blockSignals(bool block)
KisTextureProperties::fillProperties
void fillProperties(const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface, KoCanvasResourcesInterfaceSP canvasResourcesInterface)
Definition: kis_texture_option.cpp:209
KisTextureProperties::TexturingMode
TexturingMode
Definition: kis_texture_option.h:60
KisCurveOption::readOptionSetting
virtual void readOptionSetting(KisPropertiesConfigurationSP setting)
Definition: kis_curve_option.cpp:143
KisTextureMaskInfoCache::fetchCachedTextureInfo
KisTextureMaskInfoSP fetchCachedTextureInfo(KisTextureMaskInfoSP info)
Definition: KisTextureMaskInfo.cpp:253
kis_embedded_pattern_manager.h
KisTextureOption::~KisTextureOption
~KisTextureOption() override
Definition: kis_texture_option.cpp:74
QWidget::setEnabled
void setEnabled(bool)
KisTextureProperties::KisTextureProperties
KisTextureProperties(int levelOfDetail)
Definition: kis_texture_option.cpp:203
KisTextureMaskInfo
Definition: KisTextureMaskInfo.h:23
QObject::setProperty
bool setProperty(const char *name, const QVariant &value)
QRect::height
int height() const
KisTextureProperties::prepareEmbeddedResources
QList< KoResourceSP > prepareEmbeddedResources(const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface)
Definition: kis_texture_option.cpp:244
KisTextureProperties::MULTIPLY
Definition: kis_texture_option.h:61
KisEmbeddedPatternManager::saveEmbeddedPattern
static void saveEmbeddedPattern(KisPropertiesConfigurationSP setting, const KoPatternSP pattern)
Definition: kis_embedded_pattern_manager.cpp:43
kis_texture_option.h
KisTextureMaskInfo::fillProperties
bool fillProperties(const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface)
Definition: KisTextureMaskInfo.cpp:104
KisTextureProperties::apply
void apply(KisFixedPaintDeviceSP dab, const QPoint &offset, const KisPaintInformation &info)
apply combine the texture map with the dab
Definition: kis_texture_option.cpp:349
KisPaintOpOption
KisTextureChooser
Definition: kis_texture_chooser.h:12
KisTextureOption::readOptionSetting
void readOptionSetting(const KisPropertiesConfigurationSP setting) override
Definition: kis_texture_option.cpp:152
QPoint
This file is part of the KDE documentation.
Documentation copyright © 1996-2021 The KDE developers.
Generated on Sat Apr 10 2021 23:38:28 by doxygen 1.8.16 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

plugins/paintops/libpaintop

Skip menu "plugins/paintops/libpaintop"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members

krita API Reference

Skip menu "krita API Reference"
  • libs
  •   KritaBasicFlakes
  •   brush
  •   KritaUndo2
  •   KritaFlake
  •   image
  •   KritaPlugin
  •   Krita
  •   KritaPigment
  •   KritaResources
  •   KritaStore
  •   ui
  •   KritaWidgets
  •   KritaWidgetUtils
  • plugins
  •   Assitants
  •   Extensions
  •   Filters
  •   Generators
  •   Formats
  •           src
  •   PaintOps
  •     libpaintop

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal