Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <tools/vcompat.hxx>
21 :
22 : #include <vcl/graphictools.hxx>
23 :
24 : ////////////////////////////////////////////////////////////////////////////
25 :
26 19 : SvtGraphicFill::Transform::Transform()
27 : {
28 19 : matrix[0] = 1.0; matrix[1] = 0.0; matrix[2] = 0.0;
29 19 : matrix[3] = 0.0; matrix[4] = 1.0; matrix[5] = 0.0;
30 19 : }
31 :
32 : ////////////////////////////////////////////////////////////////////////////
33 :
34 0 : SvtGraphicStroke::SvtGraphicStroke() :
35 : maPath(),
36 : maStartArrow(),
37 : maEndArrow(),
38 : mfTransparency(),
39 : mfStrokeWidth(),
40 : maCapType(),
41 : maJoinType(),
42 : mfMiterLimit( 3.0 ),
43 0 : maDashArray()
44 : {
45 0 : }
46 :
47 6 : SvtGraphicStroke::SvtGraphicStroke( const Polygon& rPath,
48 : const PolyPolygon& rStartArrow,
49 : const PolyPolygon& rEndArrow,
50 : double fTransparency,
51 : double fStrokeWidth,
52 : CapType aCap,
53 : JoinType aJoin,
54 : double fMiterLimit,
55 : const DashArray& rDashArray ) :
56 : maPath( rPath ),
57 : maStartArrow( rStartArrow ),
58 : maEndArrow( rEndArrow ),
59 : mfTransparency( fTransparency ),
60 : mfStrokeWidth( fStrokeWidth ),
61 : maCapType( aCap ),
62 : maJoinType( aJoin ),
63 : mfMiterLimit( fMiterLimit ),
64 6 : maDashArray( rDashArray )
65 : {
66 6 : }
67 :
68 0 : void SvtGraphicStroke::getPath( Polygon& rPath ) const
69 : {
70 0 : rPath = maPath;
71 0 : }
72 :
73 0 : void SvtGraphicStroke::getStartArrow( PolyPolygon& rPath ) const
74 : {
75 0 : rPath = maStartArrow;
76 0 : }
77 :
78 0 : void SvtGraphicStroke::getEndArrow( PolyPolygon& rPath ) const
79 : {
80 0 : rPath = maEndArrow;
81 0 : }
82 :
83 0 : double SvtGraphicStroke::getTransparency() const
84 : {
85 0 : return mfTransparency;
86 : }
87 :
88 0 : double SvtGraphicStroke::getStrokeWidth() const
89 : {
90 0 : return mfStrokeWidth;
91 : }
92 :
93 0 : SvtGraphicStroke::CapType SvtGraphicStroke::getCapType() const
94 : {
95 0 : return maCapType;
96 : }
97 :
98 0 : SvtGraphicStroke::JoinType SvtGraphicStroke::getJoinType() const
99 : {
100 0 : return maJoinType;
101 : }
102 :
103 0 : double SvtGraphicStroke::getMiterLimit() const
104 : {
105 0 : return mfMiterLimit;
106 : }
107 :
108 0 : void SvtGraphicStroke::getDashArray( DashArray& rDashArray ) const
109 : {
110 0 : rDashArray = maDashArray;
111 0 : }
112 :
113 0 : void SvtGraphicStroke::setPath( const Polygon& rPoly )
114 : {
115 0 : maPath = rPoly;
116 0 : }
117 :
118 6 : SvStream& operator<<( SvStream& rOStm, const SvtGraphicStroke& rClass )
119 : {
120 6 : VersionCompat aCompat( rOStm, STREAM_WRITE, 1 );
121 :
122 6 : rClass.maPath.Write( rOStm );
123 6 : rClass.maStartArrow.Write( rOStm );
124 6 : rClass.maEndArrow.Write( rOStm );
125 6 : rOStm << rClass.mfTransparency;
126 6 : rOStm << rClass.mfStrokeWidth;
127 6 : sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maCapType );
128 6 : rOStm << nTmp;
129 6 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maJoinType );
130 6 : rOStm << nTmp;
131 6 : rOStm << rClass.mfMiterLimit;
132 :
133 6 : rOStm << static_cast<sal_uInt32>(rClass.maDashArray.size());
134 : size_t i;
135 6 : for(i=0; i<rClass.maDashArray.size(); ++i)
136 0 : rOStm << rClass.maDashArray[i];
137 :
138 6 : return rOStm;
139 : }
140 :
141 0 : SvStream& operator>>( SvStream& rIStm, SvtGraphicStroke& rClass )
142 : {
143 0 : VersionCompat aCompat( rIStm, STREAM_READ );
144 :
145 0 : rClass.maPath.Read( rIStm );
146 0 : rClass.maStartArrow.Read( rIStm );
147 0 : rClass.maEndArrow.Read( rIStm );
148 0 : rIStm >> rClass.mfTransparency;
149 0 : rIStm >> rClass.mfStrokeWidth;
150 : sal_uInt16 nTmp;
151 0 : rIStm >> nTmp;
152 0 : rClass.maCapType = SvtGraphicStroke::CapType(nTmp);
153 0 : rIStm >> nTmp;
154 0 : rClass.maJoinType = SvtGraphicStroke::JoinType(nTmp);
155 0 : rIStm >> rClass.mfMiterLimit;
156 :
157 : sal_uInt32 nSize;
158 0 : rIStm >> nSize;
159 0 : rClass.maDashArray.resize(nSize);
160 : size_t i;
161 0 : for(i=0; i<rClass.maDashArray.size(); ++i)
162 0 : rIStm >> rClass.maDashArray[i];
163 :
164 0 : return rIStm;
165 : }
166 :
167 :
168 : /////////////////////////////////////////////////////////////////////////////
169 :
170 0 : SvtGraphicFill::SvtGraphicFill() :
171 : maPath(),
172 : maFillColor( COL_BLACK ),
173 : mfTransparency(),
174 : maFillRule(),
175 : maFillType(),
176 : maFillTransform(),
177 : maHatchType(),
178 : maHatchColor( COL_BLACK ),
179 : maGradientType(),
180 : maGradient1stColor( COL_BLACK ),
181 : maGradient2ndColor( COL_BLACK ),
182 : maGradientStepCount( gradientStepsInfinite ),
183 0 : maFillGraphic()
184 : {
185 0 : }
186 :
187 19 : SvtGraphicFill::SvtGraphicFill( const PolyPolygon& rPath,
188 : Color aFillColor,
189 : double fTransparency,
190 : FillRule aFillRule,
191 : FillType aFillType,
192 : const Transform& aFillTransform,
193 : bool bTiling,
194 : HatchType aHatchType,
195 : Color aHatchColor,
196 : GradientType aGradientType,
197 : Color aGradient1stColor,
198 : Color aGradient2ndColor,
199 : sal_Int32 aGradientStepCount,
200 : const Graphic& aFillGraphic ) :
201 : maPath( rPath ),
202 : maFillColor( aFillColor ),
203 : mfTransparency( fTransparency ),
204 : maFillRule( aFillRule ),
205 : maFillType( aFillType ),
206 : maFillTransform( aFillTransform ),
207 : mbTiling( bTiling ),
208 : maHatchType( aHatchType ),
209 : maHatchColor( aHatchColor ),
210 : maGradientType( aGradientType ),
211 : maGradient1stColor( aGradient1stColor ),
212 : maGradient2ndColor( aGradient2ndColor ),
213 : maGradientStepCount( aGradientStepCount ),
214 19 : maFillGraphic( aFillGraphic )
215 : {
216 19 : }
217 :
218 0 : void SvtGraphicFill::getPath( PolyPolygon& rPath ) const
219 : {
220 0 : rPath = maPath;
221 0 : }
222 :
223 0 : Color SvtGraphicFill::getFillColor() const
224 : {
225 0 : return maFillColor;
226 : }
227 :
228 0 : double SvtGraphicFill::getTransparency() const
229 : {
230 0 : return mfTransparency;
231 : }
232 :
233 0 : SvtGraphicFill::FillRule SvtGraphicFill::getFillRule() const
234 : {
235 0 : return maFillRule;
236 : }
237 :
238 0 : SvtGraphicFill::FillType SvtGraphicFill::getFillType() const
239 : {
240 0 : return maFillType;
241 : }
242 :
243 0 : void SvtGraphicFill::getTransform( Transform& rTrans ) const
244 : {
245 0 : rTrans = maFillTransform;
246 0 : }
247 :
248 0 : bool SvtGraphicFill::IsTiling() const
249 : {
250 0 : return mbTiling;
251 : }
252 :
253 0 : bool SvtGraphicFill::isTiling() const
254 : {
255 0 : return mbTiling;
256 : }
257 :
258 0 : SvtGraphicFill::GradientType SvtGraphicFill::getGradientType() const
259 : {
260 0 : return maGradientType;
261 : }
262 :
263 0 : void SvtGraphicFill::getGraphic( Graphic& rGraphic ) const
264 : {
265 0 : rGraphic = maFillGraphic;
266 0 : }
267 :
268 0 : void SvtGraphicFill::setPath( const PolyPolygon& rPath )
269 : {
270 0 : maPath = rPath;
271 0 : }
272 :
273 19 : SvStream& operator<<( SvStream& rOStm, const SvtGraphicFill& rClass )
274 : {
275 19 : VersionCompat aCompat( rOStm, STREAM_WRITE, 1 );
276 :
277 19 : rClass.maPath.Write( rOStm );
278 19 : rOStm << rClass.maFillColor;
279 19 : rOStm << rClass.mfTransparency;
280 19 : sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillRule );
281 19 : rOStm << nTmp;
282 19 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillType );
283 19 : rOStm << nTmp;
284 : int i;
285 133 : for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
286 114 : rOStm << rClass.maFillTransform.matrix[i];
287 19 : nTmp = rClass.mbTiling;
288 19 : rOStm << nTmp;
289 19 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maHatchType );
290 19 : rOStm << nTmp;
291 19 : rOStm << rClass.maHatchColor;
292 19 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maGradientType );
293 19 : rOStm << nTmp;
294 19 : rOStm << rClass.maGradient1stColor;
295 19 : rOStm << rClass.maGradient2ndColor;
296 19 : rOStm << rClass.maGradientStepCount;
297 19 : rOStm << rClass.maFillGraphic;
298 :
299 19 : return rOStm;
300 : }
301 :
302 0 : SvStream& operator>>( SvStream& rIStm, SvtGraphicFill& rClass )
303 : {
304 0 : VersionCompat aCompat( rIStm, STREAM_READ );
305 :
306 0 : rClass.maPath.Read( rIStm );
307 0 : rIStm >> rClass.maFillColor;
308 0 : rIStm >> rClass.mfTransparency;
309 : sal_uInt16 nTmp;
310 0 : rIStm >> nTmp;
311 0 : rClass.maFillRule = SvtGraphicFill::FillRule( nTmp );
312 0 : rIStm >> nTmp;
313 0 : rClass.maFillType = SvtGraphicFill::FillType( nTmp );
314 : int i;
315 0 : for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
316 0 : rIStm >> rClass.maFillTransform.matrix[i];
317 0 : rIStm >> nTmp;
318 0 : rClass.mbTiling = nTmp;
319 0 : rIStm >> nTmp;
320 0 : rClass.maHatchType = SvtGraphicFill::HatchType( nTmp );
321 0 : rIStm >> rClass.maHatchColor;
322 0 : rIStm >> nTmp;
323 0 : rClass.maGradientType = SvtGraphicFill::GradientType( nTmp );
324 0 : rIStm >> rClass.maGradient1stColor;
325 0 : rIStm >> rClass.maGradient2ndColor;
326 0 : rIStm >> rClass.maGradientStepCount;
327 0 : rIStm >> rClass.maFillGraphic;
328 :
329 0 : return rIStm;
330 : }
331 :
332 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
