Resolve CSS Exclusions shapeInside, shapeOutside properties to Length based WrapShape...
[WebKit-https.git] / Source / WebCore / css / CSSWrapShapes.h
1 /*
2  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above
9  *    copyright notice, this list of conditions and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above
12  *    copyright notice, this list of conditions and the following
13  *    disclaimer in the documentation and/or other materials
14  *    provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29
30 #ifndef CSSWrapShapes_h
31 #define CSSWrapShapes_h
32
33 #include "CSSPrimitiveValue.h"
34 #include "PlatformString.h"
35 #include "WindRule.h"
36 #include <wtf/RefPtr.h>
37 #include <wtf/Vector.h>
38
39 namespace WebCore {
40
41 class CSSWrapShape : public RefCounted<CSSWrapShape> {
42 public:
43     enum Type {
44         CSS_WRAP_SHAPE_RECTANGLE = 1,
45         CSS_WRAP_SHAPE_CIRCLE = 2,
46         CSS_WRAP_SHAPE_ELLIPSE = 3,
47         CSS_WRAP_SHAPE_POLYGON = 4
48     };
49
50     virtual Type type() const = 0;
51     virtual String cssText() const = 0;
52
53 public:
54     virtual ~CSSWrapShape() { }
55
56 protected:
57     CSSWrapShape() { }
58 };
59
60 class CSSWrapShapeRectangle : public CSSWrapShape {
61 public:
62     static PassRefPtr<CSSWrapShapeRectangle> create() { return adoptRef(new CSSWrapShapeRectangle); }
63
64     CSSPrimitiveValue* left() const { return m_left.get(); }
65     CSSPrimitiveValue* top() const { return m_top.get(); }
66     CSSPrimitiveValue* width() const { return m_width.get(); }
67     CSSPrimitiveValue* height() const { return m_height.get(); }
68     CSSPrimitiveValue* radiusX() const { return m_radiusX.get(); }
69     CSSPrimitiveValue* radiusY() const { return m_radiusY.get(); }
70
71     void setLeft(PassRefPtr<CSSPrimitiveValue> left) { m_left = left; }
72     void setTop(PassRefPtr<CSSPrimitiveValue> top) { m_top = top; }
73     void setWidth(PassRefPtr<CSSPrimitiveValue> width) { m_width = width; }
74     void setHeight(PassRefPtr<CSSPrimitiveValue> height) { m_height = height; }
75     void setRadiusX(PassRefPtr<CSSPrimitiveValue> radiusX) { m_radiusX = radiusX; }
76     void setRadiusY(PassRefPtr<CSSPrimitiveValue> radiusY) { m_radiusY = radiusY; }
77
78     virtual Type type() const { return CSS_WRAP_SHAPE_RECTANGLE; }
79     virtual String cssText() const;
80
81 private:
82     CSSWrapShapeRectangle() { }
83
84     RefPtr<CSSPrimitiveValue> m_top;
85     RefPtr<CSSPrimitiveValue> m_left;
86     RefPtr<CSSPrimitiveValue> m_width;
87     RefPtr<CSSPrimitiveValue> m_height;
88     RefPtr<CSSPrimitiveValue> m_radiusX;
89     RefPtr<CSSPrimitiveValue> m_radiusY;
90 };
91
92 class CSSWrapShapeCircle : public CSSWrapShape {
93 public:
94     static PassRefPtr<CSSWrapShapeCircle> create() { return adoptRef(new CSSWrapShapeCircle); }
95
96     CSSPrimitiveValue* left() const { return m_left.get(); }
97     CSSPrimitiveValue* top() const { return m_top.get(); }
98     CSSPrimitiveValue* radius() const { return m_radius.get(); }
99
100     void setLeft(PassRefPtr<CSSPrimitiveValue> left) { m_left = left; }
101     void setTop(PassRefPtr<CSSPrimitiveValue> top) { m_top = top; }
102     void setRadius(PassRefPtr<CSSPrimitiveValue> radius) { m_radius = radius; }
103
104     virtual Type type() const { return CSS_WRAP_SHAPE_CIRCLE; }
105     virtual String cssText() const;
106
107 private:
108     CSSWrapShapeCircle() { }
109
110     RefPtr<CSSPrimitiveValue> m_top;
111     RefPtr<CSSPrimitiveValue> m_left;
112     RefPtr<CSSPrimitiveValue> m_radius;
113 };
114
115 class CSSWrapShapeEllipse : public CSSWrapShape {
116 public:
117     static PassRefPtr<CSSWrapShapeEllipse> create() { return adoptRef(new CSSWrapShapeEllipse); }
118
119     CSSPrimitiveValue* left() const { return m_left.get(); }
120     CSSPrimitiveValue* top() const { return m_top.get(); }
121     CSSPrimitiveValue* radiusX() const { return m_radiusX.get(); }
122     CSSPrimitiveValue* radiusY() const { return m_radiusY.get(); }
123
124     void setLeft(PassRefPtr<CSSPrimitiveValue> left) { m_left = left; }
125     void setTop(PassRefPtr<CSSPrimitiveValue> top) { m_top = top; }
126     void setRadiusX(PassRefPtr<CSSPrimitiveValue> radiusX) { m_radiusX = radiusX; }
127     void setRadiusY(PassRefPtr<CSSPrimitiveValue> radiusY) { m_radiusY = radiusY; }
128
129     virtual Type type() const { return CSS_WRAP_SHAPE_ELLIPSE; }
130     virtual String cssText() const;
131
132 private:
133     CSSWrapShapeEllipse() { }
134
135     RefPtr<CSSPrimitiveValue> m_top;
136     RefPtr<CSSPrimitiveValue> m_left;
137     RefPtr<CSSPrimitiveValue> m_radiusX;
138     RefPtr<CSSPrimitiveValue> m_radiusY;
139 };
140
141 class CSSWrapShapePolygon : public CSSWrapShape {
142 public:
143     static PassRefPtr<CSSWrapShapePolygon> create() { return adoptRef(new CSSWrapShapePolygon); }
144
145     void appendPoint(PassRefPtr<CSSPrimitiveValue> x, PassRefPtr<CSSPrimitiveValue> y)
146     {
147         m_values.append(x);
148         m_values.append(y);
149     }
150
151     PassRefPtr<CSSPrimitiveValue> getXAt(unsigned i) const { return m_values.at(i * 2); }
152     PassRefPtr<CSSPrimitiveValue> getYAt(unsigned i) const { return m_values.at(i * 2 + 1); }
153     const Vector<RefPtr<CSSPrimitiveValue> >& values() const { return m_values; }
154
155     void setWindRule(WindRule w) { m_windRule = w; }
156     WindRule windRule() const { return m_windRule; }
157
158     virtual Type type() const { return CSS_WRAP_SHAPE_POLYGON; }
159     virtual String cssText() const;
160
161 private:
162     CSSWrapShapePolygon()
163         : m_windRule(RULE_NONZERO)
164     {
165     }
166
167     Vector<RefPtr<CSSPrimitiveValue> > m_values;
168     WindRule m_windRule;
169 };
170
171 } // namespace WebCore
172
173 #endif // CSSWrapShapes_h