f4f6ea381eecb8465f82e5712e55e467e013135f
[WebKit-https.git] / WebCore / kcanvas / KCanvasFilters.h
1 /*
2     Copyright (C) 2004, 2005 Nikolas Zimmermann <wildfox@kde.org>
3                   2004, 2005 Rob Buis <buis@kde.org>
4                   2005 Eric Seidel <eric.seidel@kdemail.net>
5
6     This file is part of the KDE project
7
8     This library is free software; you can redistribute it and/or
9     modify it under the terms of the GNU Library General Public
10     License as published by the Free Software Foundation; either
11     version 2 of the License, or (at your option) any later version.
12
13     This library is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16     Library General Public License for more details.
17
18     You should have received a copy of the GNU Library General Public License
19     aint with this library; see the file COPYING.LIB.  If not, write to
20     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21     Boston, MA 02111-1307, USA.
22 */
23
24 #ifndef KCanvasFilters_H
25 #define KCanvasFilters_H
26
27 #include "KCanvasResources.h"
28 #include <QSizeF>
29 // Enumerations
30 typedef enum
31 {
32     FE_DISTANT_LIGHT = 0,
33     FE_POINT_LIGHT = 1,
34     FE_SPOT_LIGHT = 2,
35     FE_BLEND = 3,
36     FE_COLOR_MATRIX = 4,
37     FE_COMPONENT_TRANSFER = 5,
38     FE_COMPOSITE = 6,
39     FE_CONVOLVE_MATRIX = 7,
40     FE_DIFFUSE_LIGHTING = 8,
41     FE_DISPLACEMENT_MAP = 9,
42     FE_FLOOD = 10,
43     FE_GAUSSIAN_BLUR = 11,
44     FE_IMAGE = 12,
45     FE_MERGE = 13,
46     FE_MORPHOLOGY = 14,
47     FE_OFFSET = 15,
48     FE_SPECULAR_LIGHTING = 16,
49     FE_TILE = 17,
50     FE_TURBULENCE = 18
51 } KCFilterEffectType;
52
53 #include <qcolor.h>
54 #include <qstringlist.h>
55
56 class KCanvasPoint3F {
57 public:
58     KCanvasPoint3F() : m_x(0), m_y(0), m_z(0) { }
59     KCanvasPoint3F(float x, float y, float z) : m_x(x), m_y(y), m_z(z) { }
60     
61     float x() const { return m_x; }
62     void setX(float x) { m_x = x; }
63     
64     float y() const { return m_y; }
65     void setY(float y) { m_y = y; }
66     
67     float z() const { return m_z; }
68     void setZ(float z) { m_z = z; }
69     
70     void normalize();
71     
72 private:
73     float m_x;
74     float m_y;
75     float m_z;
76 };
77
78 class KCanvasFilterEffect;
79 class KRenderingDevice;
80
81 class KCanvasFilter : public KCanvasResource
82 {
83 public:
84     KCanvasFilter() { };
85     virtual ~KCanvasFilter() { };
86     
87     virtual bool isFilter() const { return true; }
88     
89     bool filterBoundingBoxMode() const { return m_filterBBoxMode; }
90     void setFilterBoundingBoxMode(bool bboxMode) { m_filterBBoxMode = bboxMode; }
91     
92     bool effectBoundingBoxMode() const { return m_effectBBoxMode; }
93     void setEffectBoundingBoxMode(bool bboxMode) { m_effectBBoxMode = bboxMode; }    
94
95     QRectF filterRect() const { return m_filterRect; }
96     void setFilterRect(const QRectF &rect) { m_filterRect = rect; }
97
98     void addFilterEffect(KCanvasFilterEffect *effect);
99
100     virtual void prepareFilter(KRenderingDevice *device, const QRectF &bbox) = 0;
101     virtual void applyFilter(KRenderingDevice *device, const QRectF &bbox) = 0;
102
103     QTextStream &externalRepresentation(QTextStream &) const;
104
105 protected:
106     QRectF m_filterRect;
107     Q3ValueList<KCanvasFilterEffect *> m_effects;
108     bool m_filterBBoxMode;
109     bool m_effectBBoxMode;
110 };
111
112 KCanvasFilter *getFilterById(KDOM::DocumentImpl *document, const KDOM::DOMString &id);
113
114 #ifdef APPLE_CHANGES
115 // FIXME: this strikes me as a total hack...
116 #ifdef __OBJC__
117 @class CIFilter;
118 #else
119 class CIFilter;
120 #endif
121 class KCanvasFilterQuartz;
122 #endif
123
124 class KCanvasFilterEffect
125 {
126 public:
127     // this default constructor is only needed for gcc 3.3
128     KCanvasFilterEffect() { }
129     virtual ~KCanvasFilterEffect() { };
130
131     virtual KCFilterEffectType effectType() const { return FE_TURBULENCE; }
132
133     QRectF subRegion() const;
134     void setSubRegion(const QRectF &subregion);
135
136     QString in() const;
137     void setIn(const QString &in);
138
139     QString result() const;
140     void setResult(const QString &result);
141     
142 #ifdef APPLE_CHANGES
143     virtual CIFilter *getCIFilter(KCanvasFilterQuartz *quartzFilter) const = 0;
144 #endif
145
146     virtual QTextStream &externalRepresentation(QTextStream &) const;
147
148 private:
149     QRectF m_subregion;
150     QString m_in;
151     QString m_result;
152 };
153
154 QTextStream &operator<<(QTextStream &, const KCanvasFilterEffect &);
155
156 typedef enum {
157     BM_NORMAL = 0,
158     BM_MULTIPLY = 1,
159     BM_SCREEN = 2,
160     BM_DARKEN = 3,
161     BM_LIGHTEN = 4
162 } KCBlendModeType;
163
164 class KCanvasFEBlend : public KCanvasFilterEffect
165 {
166 public:
167     QString in2() const { return m_in2; }
168     void setIn2(const QString &in2) { m_in2 = in2; }
169     
170     KCBlendModeType blendMode() const { return m_mode; }
171     void setBlendMode(KCBlendModeType mode) { m_mode = mode; }
172
173     QTextStream &externalRepresentation(QTextStream &) const;
174
175 private:
176     KCBlendModeType m_mode;
177     QString m_in2;
178 };
179
180 typedef enum {
181     CMT_MATRIX = 0,
182     CMT_SATURATE = 1,
183     CMT_HUE_ROTATE = 2,
184     CMT_LUMINANCE_TO_ALPHA = 3
185 } KCColorMatrixType;
186
187 class KCanvasFEColorMatrix : public KCanvasFilterEffect
188 {
189 public:
190     KCColorMatrixType type() const { return m_type; }
191     void setType(KCColorMatrixType type) { m_type = type; }
192
193     Q3ValueList<float> values() const { return m_values; }
194     void setValues(const Q3ValueList<float> &values) { m_values = values; };
195
196     QTextStream &externalRepresentation(QTextStream &) const;
197
198 private:
199     KCColorMatrixType m_type;
200     Q3ValueList<float> m_values;
201 };
202
203 typedef enum {
204     CT_IDENTITY = 0,
205     CT_TABLE = 1,
206     CT_DISCRETE = 2,
207     CT_LINEAR = 3,
208     CT_GAMMA = 4
209 } KCComponentTransferType;
210
211 struct KCComponentTransferFunction
212 {
213     KCComponentTransferType type;
214     Q3ValueList<float> tableValues;
215     float slope;
216     float intercept;
217     float amplitude;
218     float exponent;
219     float offset;
220 };
221
222 class KCanvasFEComponentTransfer : public KCanvasFilterEffect
223 {
224 public:    
225     KCComponentTransferFunction redFunction() const { return m_redFunc; }
226     void setRedFunction(const KCComponentTransferFunction& func) { m_redFunc = func; }
227     
228     KCComponentTransferFunction greenFunction() const { return m_greenFunc; }
229     void setGreenFunction(const KCComponentTransferFunction& func) { m_greenFunc = func; }
230     
231     KCComponentTransferFunction blueFunction() const { return m_blueFunc; }
232     void setBlueFunction(const KCComponentTransferFunction& func) { m_blueFunc = func; }
233     
234     KCComponentTransferFunction alphaFunction() const { return m_alphaFunc; }
235     void setAlphaFunction(const KCComponentTransferFunction& func) { m_alphaFunc = func; }
236
237     QTextStream& externalRepresentation(QTextStream&) const;
238
239 private:
240     KCComponentTransferFunction m_redFunc;
241     KCComponentTransferFunction m_greenFunc;
242     KCComponentTransferFunction m_blueFunc;
243     KCComponentTransferFunction m_alphaFunc;
244 };
245
246 typedef enum {
247     CO_OVER = 0,
248     CO_IN = 1,
249     CO_OUT = 2,
250     CO_ATOP = 3,
251     CO_XOR = 4,
252     CO_ARITHMETIC = 5,
253 } KCCompositeOperationType;
254
255 class KCanvasFEComposite : public KCanvasFilterEffect
256 {
257 public:
258     QString in2() const { return m_in2; }
259     void setIn2(const QString &in2) { m_in2 = in2; }
260     
261     KCCompositeOperationType operation() const { return m_operation; }
262     void setOperation(KCCompositeOperationType oper) { m_operation = oper; }
263     
264     float k1() const { return m_k1; }
265     void setK1(float k1) { m_k1 = k1; }
266     float k2() const { return m_k2;}
267     void setK2(float k2) { m_k2 = k2; }
268     float k3() const { return m_k3; }
269     void setK3(float k3) { m_k3 = k3; }
270     float k4() const { return m_k4; }
271     void setK4(float k4) { m_k4 = k4; }
272
273     QTextStream &externalRepresentation(QTextStream &) const;
274
275 private:
276     QString m_in2;
277     KCCompositeOperationType m_operation;
278     float m_k1;
279     float m_k2;
280     float m_k3;
281     float m_k4;
282 };
283
284 typedef enum {
285     EM_DUPLICATE = 0,
286     EM_WRAP = 1,
287     EM_NONE = 2
288 } KCEdgeModeType;
289
290 class KCanvasFEConvolveMatrix : public KCanvasFilterEffect
291 {
292 public:
293     KCanvasFEConvolveMatrix() { };
294
295     QSizeF kernelSize() const { return m_kernelSize; }
296     void setKernelSize(QSizeF kernelSize) { m_kernelSize = kernelSize; }
297     
298     Q3ValueList<float> kernel() const { return m_kernelMatrix; }
299     void setKernel(Q3ValueList<float> kernel) { m_kernelMatrix = kernel; }
300     
301     float divisor() const { return m_divisor; }
302     void setDivisor(float divisor) { m_divisor = divisor; }
303     
304     float bias() const { return m_bias; }
305     void setBias(float bias) { m_bias = bias; }
306     
307     QSizeF targetOffset() const { return m_targetOffset; }
308     void setTargetOffset(QSizeF targetOffset) { m_targetOffset = targetOffset; }
309     
310     KCEdgeModeType edgeMode() const { return m_edgeMode; }
311     void setEdgeMode(KCEdgeModeType edgeMode) { m_edgeMode = edgeMode; }
312     
313     QPointF kernelUnitLength() const {return m_kernelUnitLength; }
314     void setKernelUnitLength(QPointF kernelUnitLength) { m_kernelUnitLength = kernelUnitLength; }
315     
316     bool preserveAlpha() const { return m_preserveAlpha; }
317     void setPreserveAlpha(bool preserveAlpha) { m_preserveAlpha = preserveAlpha; }
318
319     QTextStream &externalRepresentation(QTextStream &) const;
320
321 private:
322     QSizeF m_kernelSize;
323     Q3ValueList<float> m_kernelMatrix; // maybe should be a real matrix?
324     float m_divisor;
325     float m_bias;
326     QSizeF m_targetOffset;
327     KCEdgeModeType m_edgeMode;
328     QPointF m_kernelUnitLength;
329     bool m_preserveAlpha;
330 };
331
332 typedef enum{
333     LS_DISTANT,
334     LS_POINT,
335     LS_SPOT
336 } KCLightType;
337
338 //The light source for Diffuse/SpecularLighting
339 class KCLightSource
340 {
341 public:
342     KCLightSource(KCLightType a_type) : m_type(a_type) { }
343     
344     virtual ~KCLightSource() { }
345     
346     KCLightType type() const { return m_type; }
347     
348     virtual QTextStream &externalRepresentation(QTextStream &) const = 0;
349     
350 private:
351     KCLightType m_type;
352 };
353
354 class KCDistantLightSource : public KCLightSource
355 {
356 public:
357     KCDistantLightSource(float azimuth, float elevation) :
358         KCLightSource(LS_DISTANT), m_azimuth(azimuth), m_elevation(elevation) { }
359     
360     float azimuth() const{ return m_azimuth; }
361     float elevation() const{ return m_elevation; }
362     
363     virtual QTextStream &externalRepresentation(QTextStream &) const;
364     
365 private:
366     float m_azimuth;
367     float m_elevation;
368 };
369
370 class KCPointLightSource : public KCLightSource
371 {
372 public:
373     KCPointLightSource(KCanvasPoint3F& position) : KCLightSource(LS_POINT), m_position(position) { }
374     
375     const KCanvasPoint3F& position() const { return m_position; }
376     
377     virtual QTextStream &externalRepresentation(QTextStream &) const;
378
379 private:
380     KCanvasPoint3F m_position;
381 };
382
383 class KCSpotLightSource : public KCLightSource
384 {
385 public:
386     KCSpotLightSource(KCanvasPoint3F& position, KCanvasPoint3F& direction, 
387         float specularExponent, float limitingConeAngle) : KCLightSource(LS_SPOT), 
388         m_position(position), m_direction(direction), m_specularExponent(specularExponent), m_limitingConeAngle(limitingConeAngle) { }
389     
390     const KCanvasPoint3F& position() const { return m_position; }
391     const KCanvasPoint3F& direction() const { return m_direction; }
392     float specularExponent() const { return m_specularExponent; }
393     float limitingConeAngle() const { return m_limitingConeAngle; }
394     
395     virtual QTextStream &externalRepresentation(QTextStream &) const;
396 private:
397     KCanvasPoint3F m_position;
398     KCanvasPoint3F m_direction;
399     float          m_specularExponent;
400     float          m_limitingConeAngle;
401 };
402
403 class KCanvasFEDiffuseLighting : public KCanvasFilterEffect
404 {
405 public:
406     KCanvasFEDiffuseLighting() : m_lightSource(0) { }
407     ~KCanvasFEDiffuseLighting() { delete m_lightSource; }
408
409     QColor lightingColor() const { return m_lightingColor; }
410     void setLightingColor(const QColor &lightingColor) { m_lightingColor = lightingColor; }
411
412     float surfaceScale() const { return m_surfaceScale; }
413     void setSurfaceScale(float surfaceScale) { m_surfaceScale = surfaceScale; }
414     
415     float diffuseConstant() const { return m_diffuseConstant; }
416     void setDiffuseConstant(float diffuseConstant) { m_diffuseConstant = diffuseConstant; }
417     
418     float kernelUnitLengthX() const { return m_kernelUnitLengthX; }
419     void setKernelUnitLengthX(float kernelUnitLengthX) { m_kernelUnitLengthX = kernelUnitLengthX; }
420     
421     float kernelUnitLengthY() const { return m_kernelUnitLengthY; }
422     void setKernelUnitLengthY(float kernelUnitLengthY) { m_kernelUnitLengthY = kernelUnitLengthY; }
423
424     const KCLightSource *lightSource() const { return m_lightSource; }
425     void setLightSource(KCLightSource *lightSource);
426     
427     QTextStream &externalRepresentation(QTextStream &) const;
428
429 private:
430     QColor m_lightingColor;
431     float m_surfaceScale;
432     float m_diffuseConstant;
433     float m_kernelUnitLengthX;
434     float m_kernelUnitLengthY;
435     KCLightSource *m_lightSource;
436 };
437
438 typedef enum {
439     CS_RED = 0,
440     CS_GREEN = 1,
441     CS_BLUE = 2,
442     CS_ALPHA = 3
443 } KCChannelSelectorType;
444
445 class KCanvasFEDisplacementMap : public KCanvasFilterEffect
446 {
447 public:
448     QString in2() const { return m_in2; }
449     void setIn2(const QString &in2) { m_in2 = in2; }
450
451     QTextStream &externalRepresentation(QTextStream &) const;
452     
453 private:
454     float m_scale;
455     KCChannelSelectorType m_XChannelSelector;
456     KCChannelSelectorType m_YChannelSelector;
457     QString m_in2;
458 };
459
460 class KCanvasFEFlood : public KCanvasFilterEffect
461 {
462 public:
463     QColor floodColor() const { return m_floodColor; }
464     void setFloodColor(const QColor &color) { m_floodColor = color; }
465
466     float floodOpacity() const { return m_floodOpacity; }
467     void setFloodOpacity(float floodOpacity) { m_floodOpacity = floodOpacity; }
468
469     QTextStream &externalRepresentation(QTextStream &) const;
470
471 private:
472     QColor m_floodColor;
473     float m_floodOpacity;
474 };
475
476 class KCanvasFEGaussianBlur : public KCanvasFilterEffect
477 {
478 public:
479     float stdDeviationX() const;
480     void setStdDeviationX(float x);
481
482     float stdDeviationY() const;
483     void setStdDeviationY(float y);
484
485     QTextStream &externalRepresentation(QTextStream &) const;
486
487 private:
488     float m_x;
489     float m_y;
490 };
491
492 class KCanvasFEImage : public KCanvasFilterEffect
493 {
494 public:
495     KCanvasFEImage() { }
496     virtual ~KCanvasFEImage() { };
497     
498     // FIXME: Eventually we need to support <svg> (RenderObject *) as well as pixmap data.
499     
500     QPixmap pixmap() const { return m_pixmap; }
501     void setPixmap(const QPixmap& pixmap) { m_pixmap = pixmap; }
502
503     QTextStream &externalRepresentation(QTextStream &) const;
504     
505 private:
506     khtml::RenderObject *m_renderObject;
507     QPixmap m_pixmap;
508 };
509
510 class KCanvasFEMerge : public KCanvasFilterEffect
511 {
512 public:
513     QStringList mergeInputs() const { return m_mergeInputs; }
514     void setMergeInputs(const QStringList &mergeInputs) { m_mergeInputs = mergeInputs; }
515
516     QTextStream &externalRepresentation(QTextStream &) const;
517     
518 private:
519     QStringList m_mergeInputs;
520 };
521
522 typedef enum {
523     MO_ERODE = 0,
524     MO_DIALATE = 1
525 } KCMorphologyOperatorType;
526
527 class KCanvasFEMorphology : public KCanvasFilterEffect
528 {
529 public:
530     KCMorphologyOperatorType morphologyOperator() const { return m_operator; }
531     void setMorphologyOperator(KCMorphologyOperatorType _operator) { m_operator = _operator; }
532
533     float radiusX() const { return m_radiusX; }
534     void setRadiusX(float radiusX) { m_radiusX = radiusX; }
535
536     float radiusY() const { return m_radiusY; }
537     void setRadiusY(float radiusY) { m_radiusY = radiusY; }
538     
539     QTextStream &externalRepresentation(QTextStream &) const;
540     
541 private:
542     KCMorphologyOperatorType m_operator;
543     float m_radiusX;
544     float m_radiusY;
545 };
546
547 class KCanvasFEOffset : public KCanvasFilterEffect
548 {
549 public:
550     float dx() const { return m_dx; }
551     void setDx(float dx) { m_dx = dx; }
552
553     float dy() const { return m_dy; }
554     void setDy(float dy) { m_dy = dy; }
555     
556     QTextStream &externalRepresentation(QTextStream &) const;
557     
558 private:
559     float m_dx;
560     float m_dy;
561 };
562
563 class KCanvasFESpecularLighting : public KCanvasFilterEffect
564 {
565 public:
566     KCanvasFESpecularLighting() : m_lightSource(0) { }
567     ~KCanvasFESpecularLighting() { delete m_lightSource; }
568
569     QColor lightingColor() const { return m_lightingColor; }
570     void setLightingColor(const QColor &lightingColor) { m_lightingColor = lightingColor; }
571
572     float surfaceScale() const { return m_surfaceScale; }
573     void setSurfaceScale(float surfaceScale) { m_surfaceScale = surfaceScale; }
574     
575     float specularConstant() const { return m_specularConstant; }
576     void setSpecularConstant(float specularConstant) { m_specularConstant = specularConstant; }
577     
578     float specularExponent() const { return m_specularExponent; }
579     void setSpecularExponent(float specularExponent) { m_specularExponent = specularExponent; }
580     
581     float kernelUnitLengthX() const { return m_kernelUnitLengthX; }
582     void setKernelUnitLengthX(float kernelUnitLengthX) { m_kernelUnitLengthX = kernelUnitLengthX; }
583     
584     float kernelUnitLengthY() const { return m_kernelUnitLengthY; }
585     void setKernelUnitLengthY(float kernelUnitLengthY) { m_kernelUnitLengthY = kernelUnitLengthY; }
586     
587     const KCLightSource *lightSource() const { return m_lightSource; }
588     void setLightSource(KCLightSource *lightSource);
589     
590     QTextStream &externalRepresentation(QTextStream &) const;
591     
592 private:
593     QColor m_lightingColor;
594     float m_surfaceScale;
595     float m_specularConstant;
596     float m_specularExponent;
597     float m_kernelUnitLengthX;
598     float m_kernelUnitLengthY;
599     KCLightSource *m_lightSource;
600 };
601
602 class KCanvasFETile : public KCanvasFilterEffect { };
603
604 typedef enum {
605     TT_TURBULANCE = 0,
606     TT_NOISE = 1
607 } KCTurbulanceType;
608
609 class KCanvasFETurbulence : public KCanvasFilterEffect
610 {
611 public:
612     KCTurbulanceType type() const { return m_type; }
613     void setType(KCTurbulanceType type) { m_type = type; }
614
615     float baseFrequencyY() const { return m_baseFrequencyY; }
616     void setBaseFrequencyY(float baseFrequencyY) { m_baseFrequencyY = baseFrequencyY; }
617
618     float baseFrequencyX() const { return m_baseFrequencyX; }
619     void setBaseFrequencyX(float baseFrequencyX) { m_baseFrequencyX = baseFrequencyX; }
620
621     float seed() const { return m_seed; }
622     void setSeed(float seed) { m_seed = seed; }
623
624     int numOctaves() const { return m_numOctaves; }
625     void setNumOctaves(bool numOctaves) { m_numOctaves = numOctaves; }
626
627     bool stitchTiles() const { return m_stitchTiles; }
628     void setStitchTiles(bool stitch) { m_stitchTiles = stitch; }
629
630     QTextStream &externalRepresentation(QTextStream &) const;
631     
632 private:
633     float m_baseFrequencyX;
634     float m_baseFrequencyY;
635     int m_numOctaves;
636     float m_seed;
637     bool m_stitchTiles;
638     KCTurbulanceType m_type;
639 };
640
641 #endif