Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include <tools/vcompat.hxx>
30 : :
31 : : #include <vcl/graphictools.hxx>
32 : :
33 : 0 : static ::rtl::OString polyToString( const Polygon& rPoly )
34 : : {
35 : 0 : ::rtl::OString aStr;
36 : : sal_uInt16 nVertex;
37 [ # # ][ # # ]: 0 : for(nVertex=0; nVertex<rPoly.GetSize(); ++nVertex)
38 : : {
39 : 0 : aStr += "(";
40 [ # # # ]: 0 : switch( rPoly.GetFlags(nVertex) )
[ # # ]
41 : : {
42 : : case POLY_NORMAL:
43 : : case POLY_SMOOTH:
44 : : case POLY_SYMMTR:
45 : 0 : aStr += "n: ";
46 : 0 : break;
47 : :
48 : : case POLY_CONTROL:
49 : 0 : aStr += "c: ";
50 : 0 : break;
51 : :
52 : : default:
53 : : OSL_FAIL( "SvtGraphicStroke::polyToString invalid flag");
54 : 0 : break;
55 : : }
56 [ # # ]: 0 : aStr += ::rtl::OString::valueOf( static_cast< double >( rPoly[nVertex].getX() ) );
57 : 0 : aStr += ",";
58 [ # # ]: 0 : aStr += ::rtl::OString::valueOf( static_cast< double >( rPoly[nVertex].getY() ) );
59 : 0 : aStr += ") ";
60 : : }
61 : :
62 : 0 : return aStr;
63 : : }
64 : :
65 : 0 : static ::rtl::OString polyPolyToString( const PolyPolygon& rPolyPoly )
66 : : {
67 : 0 : ::rtl::OString aStr;
68 : : sal_uInt16 nPoly;
69 [ # # ][ # # ]: 0 : for(nPoly=0; nPoly<rPolyPoly.Count(); ++nPoly)
70 : : {
71 [ # # ]: 0 : const Polygon& rPoly = rPolyPoly[nPoly];
72 : :
73 : 0 : aStr += "{ ";
74 [ # # ]: 0 : aStr += polyToString( rPoly );
75 : 0 : aStr += "} ";
76 : : }
77 : :
78 : 0 : return aStr;
79 : : }
80 : :
81 : 0 : static ::rtl::OString dashToString( const SvtGraphicStroke::DashArray& rDashArray )
82 : : {
83 : 0 : ::rtl::OString aStr;
84 : :
85 : 0 : aStr += "dash: [ ";
86 : :
87 : 0 : int i, nDashes( rDashArray.size() );
88 [ # # ]: 0 : for(i=0; i<nDashes; ++i)
89 : : {
90 [ # # ]: 0 : aStr += ::rtl::OString::valueOf( rDashArray[i] );
91 : 0 : aStr += " ";
92 : : }
93 : :
94 : 0 : aStr += "] ";
95 : :
96 : 0 : return aStr;
97 : : }
98 : :
99 : : ////////////////////////////////////////////////////////////////////////////
100 : :
101 : 1195 : SvtGraphicFill::Transform::Transform()
102 : : {
103 : 1195 : matrix[0] = 1.0; matrix[1] = 0.0; matrix[2] = 0.0;
104 : 1195 : matrix[3] = 0.0; matrix[4] = 1.0; matrix[5] = 0.0;
105 : 1195 : }
106 : :
107 : : ////////////////////////////////////////////////////////////////////////////
108 : :
109 : 0 : SvtGraphicStroke::SvtGraphicStroke() :
110 : : maPath(),
111 : : maStartArrow(),
112 : : maEndArrow(),
113 : : mfTransparency(),
114 : : mfStrokeWidth(),
115 : : maCapType(),
116 : : maJoinType(),
117 : : mfMiterLimit( 3.0 ),
118 [ # # ][ # # ]: 0 : maDashArray()
[ # # ]
119 : : {
120 : 0 : }
121 : :
122 : 4735 : SvtGraphicStroke::SvtGraphicStroke( const Polygon& rPath,
123 : : const PolyPolygon& rStartArrow,
124 : : const PolyPolygon& rEndArrow,
125 : : double fTransparency,
126 : : double fStrokeWidth,
127 : : CapType aCap,
128 : : JoinType aJoin,
129 : : double fMiterLimit,
130 : : const DashArray& rDashArray ) :
131 : : maPath( rPath ),
132 : : maStartArrow( rStartArrow ),
133 : : maEndArrow( rEndArrow ),
134 : : mfTransparency( fTransparency ),
135 : : mfStrokeWidth( fStrokeWidth ),
136 : : maCapType( aCap ),
137 : : maJoinType( aJoin ),
138 : : mfMiterLimit( fMiterLimit ),
139 [ + - ][ + - ]: 4735 : maDashArray( rDashArray )
[ + - ]
140 : : {
141 : 4735 : }
142 : :
143 : 0 : void SvtGraphicStroke::getPath( Polygon& rPath ) const
144 : : {
145 : 0 : rPath = maPath;
146 : 0 : }
147 : :
148 : 0 : void SvtGraphicStroke::getStartArrow( PolyPolygon& rPath ) const
149 : : {
150 : 0 : rPath = maStartArrow;
151 : 0 : }
152 : :
153 : 0 : void SvtGraphicStroke::getEndArrow( PolyPolygon& rPath ) const
154 : : {
155 : 0 : rPath = maEndArrow;
156 : 0 : }
157 : :
158 : 0 : double SvtGraphicStroke::getTransparency() const
159 : : {
160 : 0 : return mfTransparency;
161 : : }
162 : :
163 : 0 : double SvtGraphicStroke::getStrokeWidth() const
164 : : {
165 : 0 : return mfStrokeWidth;
166 : : }
167 : :
168 : 0 : SvtGraphicStroke::CapType SvtGraphicStroke::getCapType() const
169 : : {
170 : 0 : return maCapType;
171 : : }
172 : :
173 : 0 : SvtGraphicStroke::JoinType SvtGraphicStroke::getJoinType() const
174 : : {
175 : 0 : return maJoinType;
176 : : }
177 : :
178 : 0 : double SvtGraphicStroke::getMiterLimit() const
179 : : {
180 : 0 : return mfMiterLimit;
181 : : }
182 : :
183 : 0 : void SvtGraphicStroke::getDashArray( DashArray& rDashArray ) const
184 : : {
185 : 0 : rDashArray = maDashArray;
186 : 0 : }
187 : :
188 : 0 : ::rtl::OString SvtGraphicStroke::toString() const
189 : : {
190 : 0 : ::rtl::OString aStr;
191 : :
192 [ # # ]: 0 : aStr += polyToString( maPath );
193 : 0 : aStr += "trans: ";
194 [ # # ]: 0 : aStr += ::rtl::OString::valueOf( static_cast< double >(getTransparency()) );
195 : 0 : aStr += " width: ";
196 [ # # ]: 0 : aStr += ::rtl::OString::valueOf( static_cast< double >(getStrokeWidth()) );
197 : 0 : aStr += " cap: ";
198 [ # # # # ]: 0 : switch( getCapType() )
[ # # ]
199 : : {
200 : : case capButt:
201 : 0 : aStr += "butt";
202 : 0 : break;
203 : :
204 : : case capRound:
205 : 0 : aStr += "round";
206 : 0 : break;
207 : :
208 : : case capSquare:
209 : 0 : aStr += "square";
210 : 0 : break;
211 : :
212 : : default:
213 : : OSL_FAIL( "SvtGraphicStroke::toString missing cap type");
214 : 0 : break;
215 : : }
216 : 0 : aStr += " join: ";
217 [ # # # # : 0 : switch( getJoinType() )
# ][ # # ]
218 : : {
219 : : case joinMiter:
220 : 0 : aStr += "miter";
221 : 0 : break;
222 : :
223 : : case joinRound:
224 : 0 : aStr += "round";
225 : 0 : break;
226 : :
227 : : case joinBevel:
228 : 0 : aStr += "bevel";
229 : 0 : break;
230 : :
231 : : case joinNone:
232 : 0 : aStr += "none";
233 : 0 : break;
234 : :
235 : : default:
236 : : OSL_FAIL( "SvtGraphicStroke::toString missing join type");
237 : 0 : break;
238 : : }
239 : 0 : aStr += " ";
240 : :
241 [ # # ][ # # ]: 0 : if( maStartArrow.Count() )
242 : : {
243 : 0 : aStr += "start: ";
244 [ # # ]: 0 : aStr += polyPolyToString( maStartArrow );
245 : 0 : aStr += " ";
246 : : }
247 : :
248 [ # # ][ # # ]: 0 : if( maEndArrow.Count() )
249 : : {
250 : 0 : aStr += "end: ";
251 [ # # ]: 0 : aStr += polyPolyToString( maEndArrow );
252 : 0 : aStr += " ";
253 : : }
254 : :
255 [ # # ]: 0 : aStr += dashToString( maDashArray );
256 : :
257 : 0 : return aStr;
258 : : }
259 : :
260 : 0 : void SvtGraphicStroke::setPath( const Polygon& rPoly )
261 : : {
262 : 0 : maPath = rPoly;
263 : 0 : }
264 : :
265 : 4735 : SvStream& operator<<( SvStream& rOStm, const SvtGraphicStroke& rClass )
266 : : {
267 [ + - ]: 4735 : VersionCompat aCompat( rOStm, STREAM_WRITE, 1 );
268 : :
269 [ + - ]: 4735 : rClass.maPath.Write( rOStm );
270 [ + - ]: 4735 : rClass.maStartArrow.Write( rOStm );
271 [ + - ]: 4735 : rClass.maEndArrow.Write( rOStm );
272 [ + - ]: 4735 : rOStm << rClass.mfTransparency;
273 [ + - ]: 4735 : rOStm << rClass.mfStrokeWidth;
274 : 4735 : sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maCapType );
275 [ + - ]: 4735 : rOStm << nTmp;
276 : 4735 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maJoinType );
277 [ + - ]: 4735 : rOStm << nTmp;
278 [ + - ]: 4735 : rOStm << rClass.mfMiterLimit;
279 : :
280 [ + - ]: 4735 : rOStm << static_cast<sal_uInt32>(rClass.maDashArray.size());
281 : : size_t i;
282 [ + + ]: 4751 : for(i=0; i<rClass.maDashArray.size(); ++i)
283 [ + - ][ + - ]: 16 : rOStm << rClass.maDashArray[i];
284 : :
285 [ + - ]: 4735 : return rOStm;
286 : : }
287 : :
288 : 0 : SvStream& operator>>( SvStream& rIStm, SvtGraphicStroke& rClass )
289 : : {
290 [ # # ]: 0 : VersionCompat aCompat( rIStm, STREAM_READ );
291 : :
292 [ # # ]: 0 : rClass.maPath.Read( rIStm );
293 [ # # ]: 0 : rClass.maStartArrow.Read( rIStm );
294 [ # # ]: 0 : rClass.maEndArrow.Read( rIStm );
295 [ # # ]: 0 : rIStm >> rClass.mfTransparency;
296 [ # # ]: 0 : rIStm >> rClass.mfStrokeWidth;
297 : : sal_uInt16 nTmp;
298 [ # # ]: 0 : rIStm >> nTmp;
299 : 0 : rClass.maCapType = SvtGraphicStroke::CapType(nTmp);
300 [ # # ]: 0 : rIStm >> nTmp;
301 : 0 : rClass.maJoinType = SvtGraphicStroke::JoinType(nTmp);
302 [ # # ]: 0 : rIStm >> rClass.mfMiterLimit;
303 : :
304 : : sal_uInt32 nSize;
305 [ # # ]: 0 : rIStm >> nSize;
306 [ # # ]: 0 : rClass.maDashArray.resize(nSize);
307 : : size_t i;
308 [ # # ]: 0 : for(i=0; i<rClass.maDashArray.size(); ++i)
309 [ # # ][ # # ]: 0 : rIStm >> rClass.maDashArray[i];
310 : :
311 [ # # ]: 0 : return rIStm;
312 : : }
313 : :
314 : :
315 : : /////////////////////////////////////////////////////////////////////////////
316 : :
317 : 0 : SvtGraphicFill::SvtGraphicFill() :
318 : : maPath(),
319 : : maFillColor( COL_BLACK ),
320 : : mfTransparency(),
321 : : maFillRule(),
322 : : maFillType(),
323 : : maFillTransform(),
324 : : maHatchType(),
325 : : maHatchColor( COL_BLACK ),
326 : : maGradientType(),
327 : : maGradient1stColor( COL_BLACK ),
328 : : maGradient2ndColor( COL_BLACK ),
329 : : maGradientStepCount( gradientStepsInfinite ),
330 [ # # ][ # # ]: 0 : maFillGraphic()
331 : : {
332 : 0 : }
333 : :
334 : 1195 : SvtGraphicFill::SvtGraphicFill( const PolyPolygon& rPath,
335 : : Color aFillColor,
336 : : double fTransparency,
337 : : FillRule aFillRule,
338 : : FillType aFillType,
339 : : const Transform& aFillTransform,
340 : : bool bTiling,
341 : : HatchType aHatchType,
342 : : Color aHatchColor,
343 : : GradientType aGradientType,
344 : : Color aGradient1stColor,
345 : : Color aGradient2ndColor,
346 : : sal_Int32 aGradientStepCount,
347 : : const Graphic& aFillGraphic ) :
348 : : maPath( rPath ),
349 : : maFillColor( aFillColor ),
350 : : mfTransparency( fTransparency ),
351 : : maFillRule( aFillRule ),
352 : : maFillType( aFillType ),
353 : : maFillTransform( aFillTransform ),
354 : : mbTiling( bTiling ),
355 : : maHatchType( aHatchType ),
356 : : maHatchColor( aHatchColor ),
357 : : maGradientType( aGradientType ),
358 : : maGradient1stColor( aGradient1stColor ),
359 : : maGradient2ndColor( aGradient2ndColor ),
360 : : maGradientStepCount( aGradientStepCount ),
361 [ + - ]: 1195 : maFillGraphic( aFillGraphic )
362 : : {
363 : 1195 : }
364 : :
365 : 0 : void SvtGraphicFill::getPath( PolyPolygon& rPath ) const
366 : : {
367 : 0 : rPath = maPath;
368 : 0 : }
369 : :
370 : 0 : Color SvtGraphicFill::getFillColor() const
371 : : {
372 : 0 : return maFillColor;
373 : : }
374 : :
375 : 0 : double SvtGraphicFill::getTransparency() const
376 : : {
377 : 0 : return mfTransparency;
378 : : }
379 : :
380 : 0 : SvtGraphicFill::FillRule SvtGraphicFill::getFillRule() const
381 : : {
382 : 0 : return maFillRule;
383 : : }
384 : :
385 : 0 : SvtGraphicFill::FillType SvtGraphicFill::getFillType() const
386 : : {
387 : 0 : return maFillType;
388 : : }
389 : :
390 : 0 : void SvtGraphicFill::getTransform( Transform& rTrans ) const
391 : : {
392 : 0 : rTrans = maFillTransform;
393 : 0 : }
394 : :
395 : 0 : bool SvtGraphicFill::IsTiling() const
396 : : {
397 : 0 : return mbTiling;
398 : : }
399 : :
400 : 0 : bool SvtGraphicFill::isTiling() const
401 : : {
402 : 0 : return mbTiling;
403 : : }
404 : :
405 : 0 : SvtGraphicFill::GradientType SvtGraphicFill::getGradientType() const
406 : : {
407 : 0 : return maGradientType;
408 : : }
409 : :
410 : 0 : void SvtGraphicFill::getGraphic( Graphic& rGraphic ) const
411 : : {
412 : 0 : rGraphic = maFillGraphic;
413 : 0 : }
414 : :
415 : 0 : void SvtGraphicFill::setPath( const PolyPolygon& rPath )
416 : : {
417 : 0 : maPath = rPath;
418 : 0 : }
419 : :
420 : 1195 : SvStream& operator<<( SvStream& rOStm, const SvtGraphicFill& rClass )
421 : : {
422 [ + - ]: 1195 : VersionCompat aCompat( rOStm, STREAM_WRITE, 1 );
423 : :
424 [ + - ]: 1195 : rClass.maPath.Write( rOStm );
425 [ + - ]: 1195 : rOStm << rClass.maFillColor;
426 [ + - ]: 1195 : rOStm << rClass.mfTransparency;
427 : 1195 : sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillRule );
428 [ + - ]: 1195 : rOStm << nTmp;
429 : 1195 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillType );
430 [ + - ]: 1195 : rOStm << nTmp;
431 : : int i;
432 [ + + ]: 8365 : for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
433 [ + - ]: 7170 : rOStm << rClass.maFillTransform.matrix[i];
434 : 1195 : nTmp = rClass.mbTiling;
435 [ + - ]: 1195 : rOStm << nTmp;
436 : 1195 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maHatchType );
437 [ + - ]: 1195 : rOStm << nTmp;
438 [ + - ]: 1195 : rOStm << rClass.maHatchColor;
439 : 1195 : nTmp = sal::static_int_cast<sal_uInt16>( rClass.maGradientType );
440 [ + - ]: 1195 : rOStm << nTmp;
441 [ + - ]: 1195 : rOStm << rClass.maGradient1stColor;
442 [ + - ]: 1195 : rOStm << rClass.maGradient2ndColor;
443 [ + - ]: 1195 : rOStm << rClass.maGradientStepCount;
444 [ + - ]: 1195 : rOStm << rClass.maFillGraphic;
445 : :
446 [ + - ]: 1195 : return rOStm;
447 : : }
448 : :
449 : 0 : SvStream& operator>>( SvStream& rIStm, SvtGraphicFill& rClass )
450 : : {
451 [ # # ]: 0 : VersionCompat aCompat( rIStm, STREAM_READ );
452 : :
453 [ # # ]: 0 : rClass.maPath.Read( rIStm );
454 [ # # ]: 0 : rIStm >> rClass.maFillColor;
455 [ # # ]: 0 : rIStm >> rClass.mfTransparency;
456 : : sal_uInt16 nTmp;
457 [ # # ]: 0 : rIStm >> nTmp;
458 : 0 : rClass.maFillRule = SvtGraphicFill::FillRule( nTmp );
459 [ # # ]: 0 : rIStm >> nTmp;
460 : 0 : rClass.maFillType = SvtGraphicFill::FillType( nTmp );
461 : : int i;
462 [ # # ]: 0 : for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
463 [ # # ]: 0 : rIStm >> rClass.maFillTransform.matrix[i];
464 [ # # ]: 0 : rIStm >> nTmp;
465 : 0 : rClass.mbTiling = nTmp;
466 [ # # ]: 0 : rIStm >> nTmp;
467 : 0 : rClass.maHatchType = SvtGraphicFill::HatchType( nTmp );
468 [ # # ]: 0 : rIStm >> rClass.maHatchColor;
469 [ # # ]: 0 : rIStm >> nTmp;
470 : 0 : rClass.maGradientType = SvtGraphicFill::GradientType( nTmp );
471 [ # # ]: 0 : rIStm >> rClass.maGradient1stColor;
472 [ # # ]: 0 : rIStm >> rClass.maGradient2ndColor;
473 [ # # ]: 0 : rIStm >> rClass.maGradientStepCount;
474 [ # # ]: 0 : rIStm >> rClass.maFillGraphic;
475 : :
476 [ # # ]: 0 : return rIStm;
477 : : }
478 : :
479 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
