1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #ifndef INCLUDED_DRAWINGLAYER_PRIMITIVE2D_POLYGONPRIMITIVE2D_HXX
25 #define INCLUDED_DRAWINGLAYER_PRIMITIVE2D_POLYGONPRIMITIVE2D_HXX
26 
27 #include <drawinglayer/drawinglayerdllapi.h>
28 #include <drawinglayer/primitive2d/baseprimitive2d.hxx>
29 #include <drawinglayer/attribute/lineattribute.hxx>
30 #include <drawinglayer/attribute/strokeattribute.hxx>
31 #include <drawinglayer/attribute/linestartendattribute.hxx>
32 #include <basegfx/matrix/b2dhommatrix.hxx>
33 #include <basegfx/polygon/b2dpolygon.hxx>
34 #include <basegfx/color/bcolor.hxx>
35 
36 //////////////////////////////////////////////////////////////////////////////
37 // PolygonHairlinePrimitive2D class
38 
39 namespace drawinglayer
40 {
41 	namespace primitive2d
42 	{
43         /** PolygonHairlinePrimitive2D class
44 
45             This primitive defines a Hairline. Since hairlines are view-dependent,
46             this primitive is view-dependent, too.
47 
48             This is one of the non-decomposable primitives, so a renderer
49             should proccess it.
50          */
51 		class DRAWINGLAYER_DLLPUBLIC PolygonHairlinePrimitive2D : public BasePrimitive2D
52 		{
53 		private:
54             /// the hairline geometry
55 			basegfx::B2DPolygon						maPolygon;
56 
57             /// the hairline color
58 			basegfx::BColor							maBColor;
59 
60 		public:
61             /// constructor
62 			PolygonHairlinePrimitive2D(
63                 const basegfx::B2DPolygon& rPolygon,
64                 const basegfx::BColor& rBColor);
65 
66 			/// data read access
67 			const basegfx::B2DPolygon& getB2DPolygon() const { return maPolygon; }
68 			const basegfx::BColor& getBColor() const { return maBColor; }
69 
70 			/// compare operator
71 			virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
72 
73 			/// get range
74 			virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
75 
76 			/// provide unique ID
77 			DeclPrimitrive2DIDBlock()
78 		};
79 	} // end of namespace primitive2d
80 } // end of namespace drawinglayer
81 
82 //////////////////////////////////////////////////////////////////////////////
83 // PolygonMarkerPrimitive2D class
84 
85 namespace drawinglayer
86 {
87 	namespace primitive2d
88 	{
89         /** PolygonMarkerPrimitive2D class
90 
91             This primitive defines a two-colored marker hairline which is
92             dashed with the given dash length. Since hairlines are view-dependent,
93             this primitive is view-dependent, too.
94 
95             It will be decomposed to the needed PolygonHairlinePrimitive2D if
96             not handled directly by a renderer.
97          */
98 		class DRAWINGLAYER_DLLPUBLIC PolygonMarkerPrimitive2D : public BufferedDecompositionPrimitive2D
99 		{
100 		private:
101             /// the marker hairline geometry
102 			basegfx::B2DPolygon						maPolygon;
103 
104             /// the two colors
105 			basegfx::BColor							maRGBColorA;
106 			basegfx::BColor							maRGBColorB;
107 
108             /// the dash distance in 'pixels'
109 			double									mfDiscreteDashLength;
110 
111 			/// decomposition is view-dependent, remember last InverseObjectToViewTransformation
112 			basegfx::B2DHomMatrix					maLastInverseObjectToViewTransformation;
113 
114 		protected:
115 			/// local decomposition.
116 			virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
117 
118 		public:
119             /// constructor
120 			PolygonMarkerPrimitive2D(
121 				const basegfx::B2DPolygon& rPolygon,
122 				const basegfx::BColor& rRGBColorA,
123 				const basegfx::BColor& rRGBColorB,
124 				double fDiscreteDashLength);
125 
126 			/// data read access
127 			const basegfx::B2DPolygon& getB2DPolygon() const { return maPolygon; }
128 			const basegfx::BColor& getRGBColorA() const { return maRGBColorA; }
129 			const basegfx::BColor& getRGBColorB() const { return maRGBColorB; }
130 			double getDiscreteDashLength() const { return mfDiscreteDashLength; }
131 
132 			/// compare operator
133 			virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
134 
135 			/// get range
136 			virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
137 
138 			/// get local decomposition. Overloaded since this decomposition is view-dependent
139 			virtual Primitive2DSequence get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
140 
141 			/// provide unique ID
142 			DeclPrimitrive2DIDBlock()
143 		};
144 	} // end of namespace primitive2d
145 } // end of namespace drawinglayer
146 
147 //////////////////////////////////////////////////////////////////////////////
148 // PolygonStrokePrimitive2D class
149 
150 namespace drawinglayer
151 {
152 	namespace primitive2d
153 	{
154         /** PolygonStrokePrimitive2D class
155 
156             This primitive defines a line with line width, line join, line color
157             and stroke attributes. It will be decomposed dependent on the definition
158             to the needed primitives, e.g. filled PolyPolygons for fat lines.
159          */
160 		class DRAWINGLAYER_DLLPUBLIC PolygonStrokePrimitive2D : public BufferedDecompositionPrimitive2D
161 		{
162 		private:
163             /// the line geometry
164 			basegfx::B2DPolygon						maPolygon;
165 
166             /// the line attributes like width, join and color
167 			attribute::LineAttribute				maLineAttribute;
168 
169             /// the line stroking (if used)
170 			attribute::StrokeAttribute				maStrokeAttribute;
171 
172 		protected:
173 			/// local decomposition.
174 			virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
175 
176 		public:
177             /// constructor
178 			PolygonStrokePrimitive2D(
179 				const basegfx::B2DPolygon& rPolygon,
180                 const attribute::LineAttribute& rLineAttribute,
181 				const attribute::StrokeAttribute& rStrokeAttribute);
182 
183             /// constructor without stroking
184 			PolygonStrokePrimitive2D(
185 				const basegfx::B2DPolygon& rPolygon,
186                 const attribute::LineAttribute& rLineAttribute);
187 
188 			/// data read access
189 			const basegfx::B2DPolygon& getB2DPolygon() const { return maPolygon; }
190 			const attribute::LineAttribute& getLineAttribute() const { return maLineAttribute; }
191 			const attribute::StrokeAttribute& getStrokeAttribute() const { return maStrokeAttribute; }
192 
193 			/// compare operator
194 			virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
195 
196 			/// get range
197 			virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
198 
199 			/// provide unique ID
200 			DeclPrimitrive2DIDBlock()
201 		};
202 	} // end of namespace primitive2d
203 } // end of namespace drawinglayer
204 
205 //////////////////////////////////////////////////////////////////////////////
206 // PolygonWavePrimitive2D class
207 
208 namespace drawinglayer
209 {
210 	namespace primitive2d
211 	{
212         /** PolygonWavePrimitive2D class
213 
214             This primitive defines a waveline based on a PolygonStrokePrimitive2D
215             where the wave is defined by wave width and wave length.
216          */
217 		class DRAWINGLAYER_DLLPUBLIC PolygonWavePrimitive2D : public PolygonStrokePrimitive2D
218 		{
219 		private:
220             /// wave definition
221 			double									mfWaveWidth;
222 			double									mfWaveHeight;
223 
224 		protected:
225 			/// local decomposition.
226 			virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
227 
228 		public:
229             /// constructor
230 			PolygonWavePrimitive2D(
231 				const basegfx::B2DPolygon& rPolygon,
232                 const attribute::LineAttribute& rLineAttribute,
233 				const attribute::StrokeAttribute& rStrokeAttribute,
234 				double fWaveWidth,
235 				double fWaveHeight);
236 
237             /// constructor without stroking
238 			PolygonWavePrimitive2D(
239 				const basegfx::B2DPolygon& rPolygon,
240                 const attribute::LineAttribute& rLineAttribute,
241 				double fWaveWidth,
242 				double fWaveHeight);
243 
244 			/// data read access
245 			double getWaveWidth() const { return mfWaveWidth; }
246 			double getWaveHeight() const { return mfWaveHeight; }
247 
248 			/// compare operator
249 			virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
250 
251 			/// get range
252 			virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
253 
254 			/// provide unique ID
255 			DeclPrimitrive2DIDBlock()
256 		};
257 	} // end of namespace primitive2d
258 } // end of namespace drawinglayer
259 
260 //////////////////////////////////////////////////////////////////////////////
261 // PolygonStrokeArrowPrimitive2D class
262 
263 namespace drawinglayer
264 {
265 	namespace primitive2d
266 	{
267         /** PolygonStrokeArrowPrimitive2D class
268 
269             This primitive defines a PolygonStrokePrimitive2D which is extended
270             eventually by start and end definitions which are normally used for
271             arrows.
272          */
273 		class DRAWINGLAYER_DLLPUBLIC PolygonStrokeArrowPrimitive2D : public PolygonStrokePrimitive2D
274 		{
275 		private:
276             /// geometric definitions for line start and end
277 			attribute::LineStartEndAttribute				maStart;
278 			attribute::LineStartEndAttribute				maEnd;
279 
280 		protected:
281 			/// local decomposition.
282 			virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
283 
284 		public:
285             /// constructor
286 			PolygonStrokeArrowPrimitive2D(
287 				const basegfx::B2DPolygon& rPolygon,
288                 const attribute::LineAttribute& rLineAttribute,
289 				const attribute::StrokeAttribute& rStrokeAttribute,
290 				const attribute::LineStartEndAttribute& rStart,
291 				const attribute::LineStartEndAttribute& rEnd);
292 
293             /// constructor without stroking
294 			PolygonStrokeArrowPrimitive2D(
295 				const basegfx::B2DPolygon& rPolygon,
296                 const attribute::LineAttribute& rLineAttribute,
297 				const attribute::LineStartEndAttribute& rStart,
298 				const attribute::LineStartEndAttribute& rEnd);
299 
300 			/// data read access
301 			const attribute::LineStartEndAttribute& getStart() const { return maStart; }
302 			const attribute::LineStartEndAttribute& getEnd() const { return maEnd; }
303 
304 			/// compare operator
305 			virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
306 
307 			/// get range
308 			virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
309 
310 			/// provide unique ID
311 			DeclPrimitrive2DIDBlock()
312 		};
313 	} // end of namespace primitive2d
314 } // end of namespace drawinglayer
315 
316 //////////////////////////////////////////////////////////////////////////////
317 
318 #endif //INCLUDED_DRAWINGLAYER_PRIMITIVE2D_POLYGONPRIMITIVE2D_HXX
319 
320 //////////////////////////////////////////////////////////////////////////////
321 // eof
322