You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
640 lines
18 KiB
640 lines
18 KiB
/*
|
|
* kis_gradient.cpp - part of Krayon
|
|
*
|
|
* Copyright (c) 2000 Matthias Elter <elter@kde.org>
|
|
* 2001 John Califf
|
|
* 2004 Boudewijn Rempt <boud@valdyas.org>
|
|
* 2004 Adrian Page <adrian@pagenet.plus.com>
|
|
* 2004 Sven Langkamp <longamp@reallygood.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <cfloat>
|
|
#include <cmath>
|
|
|
|
#include <tqimage.h>
|
|
#include <tqtextstream.h>
|
|
#include <tqfile.h>
|
|
|
|
#include <koColor.h>
|
|
#include <kogradientmanager.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <tdelocale.h>
|
|
|
|
#include "kis_gradient.h"
|
|
|
|
#define PREVIEW_WIDTH 64
|
|
#define PREVIEW_HEIGHT 64
|
|
|
|
KisGradientSegment::RGBColorInterpolationStrategy *KisGradientSegment::RGBColorInterpolationStrategy::m_instance = 0;
|
|
KisGradientSegment::HSVCWColorInterpolationStrategy *KisGradientSegment::HSVCWColorInterpolationStrategy::m_instance = 0;
|
|
KisGradientSegment::HSVCCWColorInterpolationStrategy *KisGradientSegment::HSVCCWColorInterpolationStrategy::m_instance = 0;
|
|
|
|
KisGradientSegment::LinearInterpolationStrategy *KisGradientSegment::LinearInterpolationStrategy::m_instance = 0;
|
|
KisGradientSegment::CurvedInterpolationStrategy *KisGradientSegment::CurvedInterpolationStrategy::m_instance = 0;
|
|
KisGradientSegment::SineInterpolationStrategy *KisGradientSegment::SineInterpolationStrategy::m_instance = 0;
|
|
KisGradientSegment::SphereIncreasingInterpolationStrategy *KisGradientSegment::SphereIncreasingInterpolationStrategy::m_instance = 0;
|
|
KisGradientSegment::SphereDecreasingInterpolationStrategy *KisGradientSegment::SphereDecreasingInterpolationStrategy::m_instance = 0;
|
|
|
|
KisGradient::KisGradient(const TQString& file) : super(file)
|
|
{
|
|
}
|
|
|
|
KisGradient::~KisGradient()
|
|
{
|
|
for (uint i = 0; i < m_segments.count(); i++) {
|
|
delete m_segments[i];
|
|
m_segments[i] = 0;
|
|
}
|
|
}
|
|
|
|
bool KisGradient::load()
|
|
{
|
|
return init();
|
|
}
|
|
|
|
bool KisGradient::save()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
TQImage KisGradient::img()
|
|
{
|
|
return m_img;
|
|
}
|
|
|
|
bool KisGradient::init()
|
|
{
|
|
KoGradientManager gradLoader;
|
|
KoGradient* grad = gradLoader.loadGradient(filename());
|
|
|
|
if( !grad )
|
|
return false;
|
|
|
|
m_segments.clear();
|
|
|
|
if( grad->colorStops.count() > 1 ) {
|
|
KoColorStop *colstop;
|
|
for(colstop = grad->colorStops.first(); colstop; colstop = grad->colorStops.next()) {
|
|
KoColorStop *colstopNext = grad->colorStops.next();
|
|
|
|
if(colstopNext) {
|
|
KoColor leftRgb((int)(colstop->color1 * 255 + 0.5), (int)(colstop->color2 * 255 + 0.5), (int)(colstop->color3 * 255 + 0.5));
|
|
KoColor rightRgb((int)(colstopNext->color1 * 255 + 0.5), (int)(colstopNext->color2 * 255 + 0.5), (int)(colstopNext->color3 * 255 + 0.5));
|
|
|
|
double midp = colstop->midpoint;
|
|
midp = colstop->offset + ((colstopNext->offset - colstop->offset) * midp);
|
|
|
|
Color leftColor(leftRgb.color(), colstop->opacity);
|
|
Color rightColor(rightRgb.color(), colstopNext->opacity);
|
|
|
|
KisGradientSegment *segment = new KisGradientSegment(colstop->interpolation, colstop->colorType, colstop->offset, midp, colstopNext->offset, leftColor, rightColor);
|
|
TQ_CHECK_PTR(segment);
|
|
|
|
if ( !segment->isValid() ) {
|
|
delete segment;
|
|
return false;
|
|
}
|
|
|
|
m_segments.push_back(segment);
|
|
grad->colorStops.prev();
|
|
}
|
|
else {
|
|
grad->colorStops.prev();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return false;
|
|
|
|
if (!m_segments.isEmpty()) {
|
|
m_img = generatePreview(PREVIEW_WIDTH, PREVIEW_HEIGHT);
|
|
setValid(true);
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void KisGradient::setImage(const TQImage& img)
|
|
{
|
|
m_img = img;
|
|
m_img.detach();
|
|
|
|
setValid(true);
|
|
}
|
|
|
|
KisGradientSegment *KisGradient::segmentAt(double t) const
|
|
{
|
|
Q_ASSERT(t >= 0 || t <= 1);
|
|
Q_ASSERT(!m_segments.empty());
|
|
|
|
for(TQValueVector<KisGradientSegment *>::const_iterator it = m_segments.begin(); it!= m_segments.end(); ++it)
|
|
{
|
|
if (t > (*it)->startOffset() - DBL_EPSILON && t < (*it)->endOffset() + DBL_EPSILON) {
|
|
return *it;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void KisGradient::colorAt(double t, TQColor *color, TQ_UINT8 *opacity) const
|
|
{
|
|
const KisGradientSegment *segment = segmentAt(t);
|
|
Q_ASSERT(segment != 0);
|
|
|
|
if (segment) {
|
|
Color col = segment->colorAt(t);
|
|
*color = col.color();
|
|
*opacity = static_cast<TQ_UINT8>(col.alpha() * OPACITY_OPAQUE + 0.5);
|
|
}
|
|
}
|
|
|
|
TQImage KisGradient::generatePreview(int width, int height) const
|
|
{
|
|
TQImage img(width, height, 32);
|
|
|
|
for (int y = 0; y < img.height(); y++) {
|
|
for (int x = 0; x < img.width(); x++) {
|
|
|
|
int backgroundRed = 128 + 63 * ((x / 4 + y / 4) % 2);
|
|
int backgroundGreen = backgroundRed;
|
|
int backgroundBlue = backgroundRed;
|
|
|
|
TQColor color;
|
|
TQ_UINT8 opacity;
|
|
double t = static_cast<double>(x) / (img.width() - 1);
|
|
|
|
colorAt(t, &color, &opacity);
|
|
|
|
double alpha = static_cast<double>(opacity) / OPACITY_OPAQUE;
|
|
|
|
int red = static_cast<int>((1 - alpha) * backgroundRed + alpha * color.red() + 0.5);
|
|
int green = static_cast<int>((1 - alpha) * backgroundGreen + alpha * color.green() + 0.5);
|
|
int blue = static_cast<int>((1 - alpha) * backgroundBlue + alpha * color.blue() + 0.5);
|
|
|
|
img.setPixel(x, y, tqRgb(red, green, blue));
|
|
}
|
|
}
|
|
|
|
return img;
|
|
}
|
|
|
|
KisGradientSegment::KisGradientSegment(int interpolationType, int colorInterpolationType, double startOffset, double middleOffset, double endOffset, const Color& startColor, const Color& endColor)
|
|
{
|
|
m_interpolator = 0;
|
|
|
|
switch (interpolationType) {
|
|
case INTERP_LINEAR:
|
|
m_interpolator = LinearInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_CURVED:
|
|
m_interpolator = CurvedInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_SINE:
|
|
m_interpolator = SineInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_SPHERE_INCREASING:
|
|
m_interpolator = SphereIncreasingInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_SPHERE_DECREASING:
|
|
m_interpolator = SphereDecreasingInterpolationStrategy::instance();
|
|
break;
|
|
}
|
|
|
|
m_colorInterpolator = 0;
|
|
|
|
switch (colorInterpolationType) {
|
|
case COLOR_INTERP_RGB:
|
|
m_colorInterpolator = RGBColorInterpolationStrategy::instance();
|
|
break;
|
|
case COLOR_INTERP_HSV_CCW:
|
|
m_colorInterpolator = HSVCCWColorInterpolationStrategy::instance();
|
|
break;
|
|
case COLOR_INTERP_HSV_CW:
|
|
m_colorInterpolator = HSVCWColorInterpolationStrategy::instance();
|
|
break;
|
|
}
|
|
|
|
if (startOffset < DBL_EPSILON) {
|
|
m_startOffset = 0;
|
|
}
|
|
else
|
|
if (startOffset > 1 - DBL_EPSILON) {
|
|
m_startOffset = 1;
|
|
}
|
|
else {
|
|
m_startOffset = startOffset;
|
|
}
|
|
|
|
if (middleOffset < m_startOffset + DBL_EPSILON) {
|
|
m_middleOffset = m_startOffset;
|
|
}
|
|
else
|
|
if (middleOffset > 1 - DBL_EPSILON) {
|
|
m_middleOffset = 1;
|
|
}
|
|
else {
|
|
m_middleOffset = middleOffset;
|
|
}
|
|
|
|
if (endOffset < m_middleOffset + DBL_EPSILON) {
|
|
m_endOffset = m_middleOffset;
|
|
}
|
|
else
|
|
if (endOffset > 1 - DBL_EPSILON) {
|
|
m_endOffset = 1;
|
|
}
|
|
else {
|
|
m_endOffset = endOffset;
|
|
}
|
|
|
|
m_length = m_endOffset - m_startOffset;
|
|
|
|
if (m_length < DBL_EPSILON) {
|
|
m_middleT = 0.5;
|
|
}
|
|
else {
|
|
m_middleT = (m_middleOffset - m_startOffset) / m_length;
|
|
}
|
|
|
|
m_startColor = startColor;
|
|
m_endColor = endColor;
|
|
}
|
|
|
|
const Color& KisGradientSegment::startColor() const
|
|
{
|
|
return m_startColor;
|
|
}
|
|
|
|
const Color& KisGradientSegment::endColor() const
|
|
{
|
|
return m_endColor;
|
|
}
|
|
|
|
double KisGradientSegment::startOffset() const
|
|
{
|
|
return m_startOffset;
|
|
}
|
|
|
|
double KisGradientSegment::middleOffset() const
|
|
{
|
|
return m_middleOffset;
|
|
}
|
|
|
|
double KisGradientSegment::endOffset() const
|
|
{
|
|
return m_endOffset;
|
|
}
|
|
|
|
void KisGradientSegment::setStartOffset(double t)
|
|
{
|
|
m_startOffset = t;
|
|
m_length = m_endOffset - m_startOffset;
|
|
|
|
if (m_length < DBL_EPSILON) {
|
|
m_middleT = 0.5;
|
|
}
|
|
else {
|
|
m_middleT = (m_middleOffset - m_startOffset) / m_length;
|
|
}
|
|
}
|
|
void KisGradientSegment::setMiddleOffset(double t)
|
|
{
|
|
m_middleOffset = t;
|
|
|
|
if (m_length < DBL_EPSILON) {
|
|
m_middleT = 0.5;
|
|
}
|
|
else {
|
|
m_middleT = (m_middleOffset - m_startOffset) / m_length;
|
|
}
|
|
}
|
|
|
|
void KisGradientSegment::setEndOffset(double t)
|
|
{
|
|
m_endOffset = t;
|
|
m_length = m_endOffset - m_startOffset;
|
|
|
|
if (m_length < DBL_EPSILON) {
|
|
m_middleT = 0.5;
|
|
}
|
|
else {
|
|
m_middleT = (m_middleOffset - m_startOffset) / m_length;
|
|
}
|
|
}
|
|
|
|
int KisGradientSegment::interpolation() const
|
|
{
|
|
return m_interpolator->type();
|
|
}
|
|
|
|
void KisGradientSegment::setInterpolation(int interpolationType)
|
|
{
|
|
switch (interpolationType) {
|
|
case INTERP_LINEAR:
|
|
m_interpolator = LinearInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_CURVED:
|
|
m_interpolator = CurvedInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_SINE:
|
|
m_interpolator = SineInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_SPHERE_INCREASING:
|
|
m_interpolator = SphereIncreasingInterpolationStrategy::instance();
|
|
break;
|
|
case INTERP_SPHERE_DECREASING:
|
|
m_interpolator = SphereDecreasingInterpolationStrategy::instance();
|
|
break;
|
|
}
|
|
}
|
|
|
|
int KisGradientSegment::colorInterpolation() const
|
|
{
|
|
return m_colorInterpolator->type();
|
|
}
|
|
|
|
void KisGradientSegment::setColorInterpolation(int colorInterpolationType)
|
|
{
|
|
switch (colorInterpolationType) {
|
|
case COLOR_INTERP_RGB:
|
|
m_colorInterpolator = RGBColorInterpolationStrategy::instance();
|
|
break;
|
|
case COLOR_INTERP_HSV_CCW:
|
|
m_colorInterpolator = HSVCCWColorInterpolationStrategy::instance();
|
|
break;
|
|
case COLOR_INTERP_HSV_CW:
|
|
m_colorInterpolator = HSVCWColorInterpolationStrategy::instance();
|
|
break;
|
|
}
|
|
}
|
|
|
|
Color KisGradientSegment::colorAt(double t) const
|
|
{
|
|
Q_ASSERT(t > m_startOffset - DBL_EPSILON && t < m_endOffset + DBL_EPSILON);
|
|
|
|
double segmentT;
|
|
|
|
if (m_length < DBL_EPSILON) {
|
|
segmentT = 0.5;
|
|
}
|
|
else {
|
|
segmentT = (t - m_startOffset) / m_length;
|
|
}
|
|
|
|
double colorT = m_interpolator->valueAt(segmentT, m_middleT);
|
|
|
|
Color color = m_colorInterpolator->colorAt(colorT, m_startColor, m_endColor);
|
|
|
|
return color;
|
|
}
|
|
|
|
bool KisGradientSegment::isValid() const
|
|
{
|
|
if (m_interpolator == 0 || m_colorInterpolator ==0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
KisGradientSegment::RGBColorInterpolationStrategy *KisGradientSegment::RGBColorInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new RGBColorInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
Color KisGradientSegment::RGBColorInterpolationStrategy::colorAt(double t, Color start, Color end) const
|
|
{
|
|
int startRed = start.color().red();
|
|
int startGreen = start.color().green();
|
|
int startBlue = start.color().blue();
|
|
double startAlpha = start.alpha();
|
|
int red = static_cast<int>(startRed + t * (end.color().red() - startRed) + 0.5);
|
|
int green = static_cast<int>(startGreen + t * (end.color().green() - startGreen) + 0.5);
|
|
int blue = static_cast<int>(startBlue + t * (end.color().blue() - startBlue) + 0.5);
|
|
double alpha = startAlpha + t * (end.alpha() - startAlpha);
|
|
|
|
return Color(TQColor(red, green, blue), alpha);
|
|
}
|
|
|
|
KisGradientSegment::HSVCWColorInterpolationStrategy *KisGradientSegment::HSVCWColorInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new HSVCWColorInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
Color KisGradientSegment::HSVCWColorInterpolationStrategy::colorAt(double t, Color start, Color end) const
|
|
{
|
|
KoColor sc = KoColor(start.color());
|
|
KoColor ec = KoColor(end.color());
|
|
|
|
int s = static_cast<int>(sc.S() + t * (ec.S() - sc.S()) + 0.5);
|
|
int v = static_cast<int>(sc.V() + t * (ec.V() - sc.V()) + 0.5);
|
|
int h;
|
|
|
|
if (ec.H() < sc.H()) {
|
|
h = static_cast<int>(ec.H() + (1 - t) * (sc.H() - ec.H()) + 0.5);
|
|
}
|
|
else {
|
|
h = static_cast<int>(ec.H() + (1 - t) * (360 - ec.H() + sc.H()) + 0.5);
|
|
|
|
if (h > 359) {
|
|
h -= 360;
|
|
}
|
|
}
|
|
|
|
double alpha = start.alpha() + t * (end.alpha() - start.alpha());
|
|
|
|
return Color(KoColor(h, s, v, KoColor::csHSV).color(), alpha);
|
|
}
|
|
|
|
KisGradientSegment::HSVCCWColorInterpolationStrategy *KisGradientSegment::HSVCCWColorInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new HSVCCWColorInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
Color KisGradientSegment::HSVCCWColorInterpolationStrategy::colorAt(double t, Color start, Color end) const
|
|
{
|
|
KoColor sc = KoColor(start.color());
|
|
KoColor se = KoColor(end.color());
|
|
|
|
int s = static_cast<int>(sc.S() + t * (se.S() - sc.S()) + 0.5);
|
|
int v = static_cast<int>(sc.V() + t * (se.V() - sc.V()) + 0.5);
|
|
int h;
|
|
|
|
if (sc.H() < se.H()) {
|
|
h = static_cast<int>(sc.H() + t * (se.H() - sc.H()) + 0.5);
|
|
}
|
|
else {
|
|
h = static_cast<int>(sc.H() + t * (360 - sc.H() + se.H()) + 0.5);
|
|
|
|
if (h > 359) {
|
|
h -= 360;
|
|
}
|
|
}
|
|
|
|
double alpha = start.alpha() + t * (end.alpha() - start.alpha());
|
|
|
|
return Color(KoColor(h, s, v, KoColor::csHSV).color(), alpha);
|
|
}
|
|
|
|
KisGradientSegment::LinearInterpolationStrategy *KisGradientSegment::LinearInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new LinearInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
double KisGradientSegment::LinearInterpolationStrategy::calcValueAt(double t, double middle)
|
|
{
|
|
Q_ASSERT(t > -DBL_EPSILON && t < 1 + DBL_EPSILON);
|
|
Q_ASSERT(middle > -DBL_EPSILON && middle < 1 + DBL_EPSILON);
|
|
|
|
double value = 0;
|
|
|
|
if (t <= middle) {
|
|
if (middle < DBL_EPSILON) {
|
|
value = 0;
|
|
}
|
|
else {
|
|
value = (t / middle) * 0.5;
|
|
}
|
|
}
|
|
else {
|
|
if (middle > 1 - DBL_EPSILON) {
|
|
value = 1;
|
|
}
|
|
else {
|
|
value = ((t - middle) / (1 - middle)) * 0.5 + 0.5;
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
double KisGradientSegment::LinearInterpolationStrategy::valueAt(double t, double middle) const
|
|
{
|
|
return calcValueAt(t, middle);
|
|
}
|
|
|
|
KisGradientSegment::CurvedInterpolationStrategy::CurvedInterpolationStrategy()
|
|
{
|
|
m_logHalf = log(0.5);
|
|
}
|
|
|
|
KisGradientSegment::CurvedInterpolationStrategy *KisGradientSegment::CurvedInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new CurvedInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
double KisGradientSegment::CurvedInterpolationStrategy::valueAt(double t, double middle) const
|
|
{
|
|
Q_ASSERT(t > -DBL_EPSILON && t < 1 + DBL_EPSILON);
|
|
Q_ASSERT(middle > -DBL_EPSILON && middle < 1 + DBL_EPSILON);
|
|
|
|
double value = 0;
|
|
|
|
if (middle < DBL_EPSILON) {
|
|
middle = DBL_EPSILON;
|
|
}
|
|
|
|
value = pow(t, m_logHalf / log(middle));
|
|
|
|
return value;
|
|
}
|
|
|
|
KisGradientSegment::SineInterpolationStrategy *KisGradientSegment::SineInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new SineInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
double KisGradientSegment::SineInterpolationStrategy::valueAt(double t, double middle) const
|
|
{
|
|
double lt = LinearInterpolationStrategy::calcValueAt(t, middle);
|
|
double value = (sin(-M_PI_2 + M_PI * lt) + 1.0) / 2.0;
|
|
|
|
return value;
|
|
}
|
|
|
|
KisGradientSegment::SphereIncreasingInterpolationStrategy *KisGradientSegment::SphereIncreasingInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new SphereIncreasingInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
double KisGradientSegment::SphereIncreasingInterpolationStrategy::valueAt(double t, double middle) const
|
|
{
|
|
double lt = LinearInterpolationStrategy::calcValueAt(t, middle) - 1;
|
|
double value = sqrt(1 - lt * lt);
|
|
|
|
return value;
|
|
}
|
|
|
|
KisGradientSegment::SphereDecreasingInterpolationStrategy *KisGradientSegment::SphereDecreasingInterpolationStrategy::instance()
|
|
{
|
|
if (m_instance == 0) {
|
|
m_instance = new SphereDecreasingInterpolationStrategy();
|
|
TQ_CHECK_PTR(m_instance);
|
|
}
|
|
|
|
return m_instance;
|
|
}
|
|
|
|
double KisGradientSegment::SphereDecreasingInterpolationStrategy::valueAt(double t, double middle) const
|
|
{
|
|
double lt = LinearInterpolationStrategy::calcValueAt(t, middle);
|
|
double value = 1 - sqrt(1 - lt * lt);
|
|
|
|
return value;
|
|
}
|
|
|
|
#include "kis_gradient.moc"
|
|
|