KRenderingPaintServerGradient.cpp [plain text]
#include "config.h"
#if SVG_SUPPORT
#include "IntPoint.h"
#include "KRenderingPaintServerGradient.h"
#include "KCanvasMatrix.h"
#include "TextStream.h"
#include "KCanvasTreeDebug.h"
namespace WebCore {
TextStream &operator<<(TextStream &ts, KCGradientSpreadMethod m)
{
switch (m)
{
case SPREADMETHOD_PAD:
ts << "PAD"; break;
case SPREADMETHOD_REPEAT:
ts << "REPEAT"; break;
case SPREADMETHOD_REFLECT:
ts << "REFLECT"; break;
}
return ts;
}
TextStream &operator<<(TextStream &ts, const Vector<KCGradientStop>& l)
{
ts << "[";
for (Vector<KCGradientStop>::const_iterator it = l.begin(); it != l.end(); ++it) {
ts << "(" << it->first << "," << it->second << ")";
if (it + 1 != l.end())
ts << ", ";
}
ts << "]";
return ts;
}
class KRenderingPaintServerGradient::Private
{
public:
Private() { boundingBoxMode = true; spreadMethod = SPREADMETHOD_PAD; listener = 0; }
~Private() { }
Vector<KCGradientStop> stops;
KCGradientSpreadMethod spreadMethod;
bool boundingBoxMode;
KCanvasMatrix gradientTransform;
KCanvasResourceListener *listener;
};
KRenderingPaintServerGradient::KRenderingPaintServerGradient() : KRenderingPaintServer(), d(new Private())
{
}
KRenderingPaintServerGradient::~KRenderingPaintServerGradient()
{
delete d;
}
const Vector<KCGradientStop>& KRenderingPaintServerGradient::gradientStops() const
{
return d->stops;
}
static inline bool compareStopOffset(const KCGradientStop& first, const KCGradientStop& second)
{
return first.first < second.first;
}
void KRenderingPaintServerGradient::setGradientStops(const Vector<KCGradientStop>& stops)
{
d->stops = stops;
std::sort(d->stops.begin(), d->stops.end(), compareStopOffset);
}
void KRenderingPaintServerGradient::setGradientStops(KRenderingPaintServerGradient* server)
{
d->stops = server->gradientStops();
}
KCGradientSpreadMethod KRenderingPaintServerGradient::spreadMethod() const
{
return d->spreadMethod;
}
void KRenderingPaintServerGradient::setGradientSpreadMethod(const KCGradientSpreadMethod &method)
{
d->spreadMethod = method;
}
bool KRenderingPaintServerGradient::boundingBoxMode() const
{
return d->boundingBoxMode;
}
void KRenderingPaintServerGradient::setBoundingBoxMode(bool mode)
{
d->boundingBoxMode = mode;
}
KCanvasMatrix KRenderingPaintServerGradient::gradientTransform() const
{
return d->gradientTransform;
}
void KRenderingPaintServerGradient::setGradientTransform(const KCanvasMatrix &mat)
{
d->gradientTransform = mat;
}
TextStream &KRenderingPaintServerGradient::externalRepresentation(TextStream &ts) const
{
ts << "[stops=" << gradientStops() << "]";
if (spreadMethod() != SPREADMETHOD_PAD)
ts << "[method=" << spreadMethod() << "]";
if (!boundingBoxMode())
ts << " [bounding box mode=" << boundingBoxMode() << "]";
if (!gradientTransform().matrix().isIdentity())
ts << " [transform=" << gradientTransform().matrix() << "]";
return ts;
}
class KRenderingPaintServerLinearGradient::Private
{
public:
Private() { }
~Private() { }
FloatPoint start, end;
};
KRenderingPaintServerLinearGradient::KRenderingPaintServerLinearGradient() : KRenderingPaintServerGradient(), d(new Private())
{
}
KRenderingPaintServerLinearGradient::~KRenderingPaintServerLinearGradient()
{
delete d;
}
FloatPoint KRenderingPaintServerLinearGradient::gradientStart() const
{
return d->start;
}
void KRenderingPaintServerLinearGradient::setGradientStart(const FloatPoint &start)
{
d->start = start;
}
FloatPoint KRenderingPaintServerLinearGradient::gradientEnd() const
{
return d->end;
}
void KRenderingPaintServerLinearGradient::setGradientEnd(const FloatPoint &end)
{
d->end = end;
}
KCPaintServerType KRenderingPaintServerLinearGradient::type() const
{
return PS_LINEAR_GRADIENT;
}
TextStream &KRenderingPaintServerLinearGradient::externalRepresentation(TextStream &ts) const
{
ts << "[type=LINEAR-GRADIENT] ";
KRenderingPaintServerGradient::externalRepresentation(ts);
ts << " [start=" << gradientStart() << "]"
<< " [end=" << gradientEnd() << "]";
return ts;
}
class KRenderingPaintServerRadialGradient::Private
{
public:
Private() { }
~Private() { }
float radius;
FloatPoint center, focal;
};
KRenderingPaintServerRadialGradient::KRenderingPaintServerRadialGradient() : KRenderingPaintServerGradient(), d(new Private())
{
}
KRenderingPaintServerRadialGradient::~KRenderingPaintServerRadialGradient()
{
delete d;
}
FloatPoint KRenderingPaintServerRadialGradient::gradientCenter() const
{
return d->center;
}
void KRenderingPaintServerRadialGradient::setGradientCenter(const FloatPoint ¢er)
{
d->center = center;
}
FloatPoint KRenderingPaintServerRadialGradient::gradientFocal() const
{
return d->focal;
}
void KRenderingPaintServerRadialGradient::setGradientFocal(const FloatPoint &focal)
{
d->focal = focal;
}
float KRenderingPaintServerRadialGradient::gradientRadius() const
{
return d->radius;
}
void KRenderingPaintServerRadialGradient::setGradientRadius(float radius)
{
d->radius = radius;
}
KCPaintServerType KRenderingPaintServerRadialGradient::type() const
{
return PS_RADIAL_GRADIENT;
}
KCanvasResourceListener *KRenderingPaintServerGradient::listener() const
{
return d->listener;
}
void KRenderingPaintServerGradient::setListener(KCanvasResourceListener *listener)
{
d->listener = listener;
}
TextStream &KRenderingPaintServerRadialGradient::externalRepresentation(TextStream &ts) const
{
ts << "[type=RADIAL-GRADIENT] ";
KRenderingPaintServerGradient::externalRepresentation(ts);
ts << " [center=" << gradientCenter() << "]"
<< " [focal=" << gradientFocal() << "]"
<< " [radius=" << gradientRadius() << "]";
return ts;
}
}
#endif // SVG_SUPPORT