?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / filter / source / svg / svgwriter.cxx
blobf97cc2162954f403f25674bbfbd616cd20f4b75e
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: svgwriter.cxx,v $
10 * $Revision: 1.10 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_filter.hxx"
33
34 #include "svgfontexport.hxx"
35 #include "svgwriter.hxx"
36
37 // -----------
38 // - statics -
39 // -----------
40
41 static const char aXMLElemG[] = "g";
42 static const char aXMLElemDefs[] = "defs";
43 static const char aXMLElemClipPath[] = "clipPath";
44 static const char aXMLElemLine[] = "line";
45 static const char aXMLElemRect[] = "rect";
46 static const char aXMLElemEllipse[] = "ellipse";
47 static const char aXMLElemPath[] = "path";
48 static const char aXMLElemPolygon[] = "polygon";
49 static const char aXMLElemPolyLine[] = "polyline";
50 static const char aXMLElemText[] = "text";
51 static const char aXMLElemTSpan[] = "tspan";
52 static const char aXMLElemImage[] = "image";
53
54 static const char aXMLAttrTransform[] = "transform";
55 static const char aXMLAttrStyle[] = "style";
56 static const char aXMLAttrId[] = "id";
57 static const char aXMLAttrD[] = "d";
58 static const char aXMLAttrX[] = "x";
59 static const char aXMLAttrY[] = "y";
60 static const char aXMLAttrX1[] = "x1";
61 static const char aXMLAttrY1[] = "y1";
62 static const char aXMLAttrX2[] = "x2";
63 static const char aXMLAttrY2[] = "y2";
64 static const char aXMLAttrCX[] = "cx";
65 static const char aXMLAttrCY[] = "cy";
66 static const char aXMLAttrRX[] = "rx";
67 static const char aXMLAttrRY[] = "ry";
68 static const char aXMLAttrWidth[] = "width";
69 static const char aXMLAttrHeight[] = "height";
70 static const char aXMLAttrPoints[] = "points";
71 static const char aXMLAttrXLinkHRef[] = "xlink:href";
72
73 static const sal_Unicode pBase64[] =
74 {
75 //0 1 2 3 4 5 6 7
76 'A','B','C','D','E','F','G','H', // 0
77 'I','J','K','L','M','N','O','P', // 1
78 'Q','R','S','T','U','V','W','X', // 2
79 'Y','Z','a','b','c','d','e','f', // 3
80 'g','h','i','j','k','l','m','n', // 4
81 'o','p','q','r','s','t','u','v', // 5
82 'w','x','y','z','0','1','2','3', // 6
83 '4','5','6','7','8','9','+','/' // 7
84 };
85
86 // --------------
87 // - FastString -
88 // --------------
89
90 FastString::FastString( sal_uInt32 nInitLen, sal_uInt32 nIncrement ) :
91 mnBufLen( nInitLen ),
92 mnCurLen( 0 ),
93 mnBufInc( nIncrement ),
94 mpBuffer( new sal_Unicode[ nInitLen * sizeof( sal_Unicode ) ] ),
95 mnPartPos( 0 )
96 {
97 DBG_ASSERT( nInitLen, "invalid initial length" );
98 DBG_ASSERT( nIncrement, "invalid increment" );
99 }
100
101 // -----------------------------------------------------------------------------
102
103 FastString::FastString( sal_Char* pBufferForBase64Encoding, sal_uInt32 nBufLen ) :
104 mnBufInc( 2048 ),
105 mnPartPos( 0 )
106 {
107 DBG_ASSERT( pBufferForBase64Encoding && nBufLen, "invalid arguments" );
108
109 const sal_uInt32 nQuadCount = nBufLen / 3;
110 const sal_uInt32 nRest = nBufLen % 3;
111
112 if( nQuadCount || nRest )
113 {
114 mnBufLen = mnCurLen = ( ( nQuadCount + ( nRest ? 1 : 0 ) ) << 2 );
115 mpBuffer = new sal_Unicode[ mnBufLen * sizeof( sal_Unicode ) ];
116
117 sal_Char* pTmpSrc = pBufferForBase64Encoding;
118 sal_Unicode* pTmpDst = mpBuffer;
119
120 for( sal_uInt32 i = 0; i < nQuadCount; i++ )
121 {
122 const sal_Int32 nA = *pTmpSrc++;
123 const sal_Int32 nB = *pTmpSrc++;
124 const sal_Int32 nC = *pTmpSrc++;
125
126 *pTmpDst++ = pBase64[ ( nA >> 2 ) & 0x3f ];
127 *pTmpDst++ = pBase64[ ( ( nA << 4 ) & 0x30 ) + ( ( nB >> 4 ) & 0xf ) ];
128 *pTmpDst++ = pBase64[ ( ( nB << 2 ) & 0x3c ) + ( ( nC >> 6 ) & 0x3 ) ];
129 *pTmpDst++ = pBase64[ nC & 0x3f ];
130 }
131
132 if( 1 == nRest )
133 {
134 const sal_Int32 nA = *pTmpSrc;
135
136 *pTmpDst++ = pBase64[ ( nA >> 2 ) & 0x3f ];
137 *pTmpDst++ = pBase64[ ( nA << 4 ) & 0x30 ];
138 *pTmpDst++ = '=';
139 *pTmpDst = '=';
140 }
141 else if( 2 == nRest )
142 {
143 const sal_Int32 nA = *pTmpSrc++;
144 const sal_Int32 nB = *pTmpSrc;
145
146 *pTmpDst++ = pBase64[ ( nA >> 2 ) & 0x3f ];
147 *pTmpDst++ = pBase64[ ( ( nA << 4 ) & 0x30 ) + ( ( nB >> 4 ) & 0xf ) ];
148 *pTmpDst++ = pBase64[ ( nB << 2 ) & 0x3c ];
149 *pTmpDst = '=';
150 }
151 }
152 else
153 {
154 mpBuffer = new sal_Unicode[ ( mnBufLen = 1 ) * sizeof( sal_Unicode ) ];
155 mnCurLen = 0;
156 }
157 }
158
159 // -----------------------------------------------------------------------------
160
161 FastString::~FastString()
162 {
163 delete[] mpBuffer;
164 }
165
166 // -----------------------------------------------------------------------------
167
168 FastString& FastString::operator+=( const NMSP_RTL::OUString& rStr )
169 {
170 if( rStr.getLength() )
171 {
172 if( ( mnCurLen + rStr.getLength() ) > mnBufLen )
173 {
174 const sal_uInt32 nNewBufLen = ( mnBufLen + ( ( ( mnCurLen + rStr.getLength() ) - mnBufLen ) / mnBufInc + 1 ) * mnBufInc );
175 sal_Unicode* pNewBuffer = new sal_Unicode[ nNewBufLen * sizeof( sal_Unicode ) ];
176
177 memcpy( pNewBuffer, mpBuffer, mnBufLen * sizeof( sal_Unicode ) );
178 delete[] mpBuffer;
179 mpBuffer = pNewBuffer;
180 mnBufLen = nNewBufLen;
181 }
182
183 memcpy( mpBuffer + mnCurLen, rStr.getStr(), rStr.getLength() * sizeof( sal_Unicode ) );
184 mnCurLen += rStr.getLength();
185
186 if( maString.getLength() )
187 maString = NMSP_RTL::OUString();
188 }
189
190 return *this;
191 }
192
193 // -----------------------------------------------------------------------------
194
195 const NMSP_RTL::OUString& FastString::GetString() const
196 {
197 if( !maString.getLength() && mnCurLen )
198 ( (FastString*) this )->maString = NMSP_RTL::OUString( mpBuffer, mnCurLen );
199
200 return maString;
201 }
202
203 // -----------------------------------------------------------------------------
204
205 sal_Bool FastString::GetFirstPartString( const sal_uInt32 nPartLen, NMSP_RTL::OUString& rPartString )
206 {
207 const sal_uInt32 nLength = Min( mnCurLen, nPartLen );
208
209 mnPartPos = 0;
210
211 if( nLength )
212 {
213 rPartString = NMSP_RTL::OUString( mpBuffer, nLength );
214 mnPartPos = nLength;
215 }
216
217 return( rPartString.getLength() > 0 );
218 }
219
220 // -----------------------------------------------------------------------------
221
222 sal_Bool FastString::GetNextPartString( const sal_uInt32 nPartLen, NMSP_RTL::OUString& rPartString )
223 {
224 if( mnPartPos < mnCurLen )
225 {
226 const sal_uInt32 nLength = Min( mnCurLen - mnPartPos, nPartLen );
227 rPartString = NMSP_RTL::OUString( mpBuffer + mnPartPos, nLength );
228 mnPartPos += nLength;
229 }
230 else
231 rPartString = NMSP_RTL::OUString();
232
233 return( rPartString.getLength() > 0 );
234 }
235
236 // ----------------------
237 // - SVGAttributeWriter -
238 // ----------------------
239
240 SVGAttributeWriter::SVGAttributeWriter( SvXMLExport& rExport, SVGFontExport& rFontExport ) :
241 mrExport( rExport ),
242 mrFontExport( rFontExport ),
243 mpElemFont( NULL ),
244 mpElemPaint( NULL )
245 {
246 }
247
248 // -----------------------------------------------------------------------------
249
250 SVGAttributeWriter::~SVGAttributeWriter()
251 {
252 delete mpElemPaint;
253 delete mpElemFont;
254 }
255
256 // -----------------------------------------------------------------------------
257
258 NMSP_RTL::OUString SVGAttributeWriter::GetFontStyle( const Font& rFont )
259 {
260 FastString aStyle;
261
262 // font family
263 aStyle += B2UCONST( "font-family:" );
264 aStyle += mrFontExport.GetMappedFontName( rFont.GetName() );
265
266 // font size
267 aStyle += B2UCONST( ";" );
268 aStyle += B2UCONST( "font-size:" );
269 aStyle += SVGActionWriter::GetValueString( rFont.GetHeight() );
270
271 // font style
272 /*
273 if( rFont.GetItalic() != ITALIC_NONE )
274 {
275 aStyle += B2UCONST( ";" );
276 aStyle += B2UCONST( "font-style:" );
277
278 if( rFont.GetItalic() == ITALIC_OBLIQUE )
279 aStyle += B2UCONST( "oblique" );
280 else
281 aStyle += B2UCONST( "italic" );
282 }
283 */
284
285 // font weight
286 sal_Int32 nFontWeight;
287
288 switch( rFont.GetWeight() )
289 {
290 case WEIGHT_THIN: nFontWeight = 100; break;
291 case WEIGHT_ULTRALIGHT: nFontWeight = 200; break;
292 case WEIGHT_LIGHT: nFontWeight = 300; break;
293 case WEIGHT_SEMILIGHT: nFontWeight = 400; break;
294 case WEIGHT_NORMAL: nFontWeight = 400; break;
295 case WEIGHT_MEDIUM: nFontWeight = 500; break;
296 case WEIGHT_SEMIBOLD: nFontWeight = 600; break;
297 case WEIGHT_BOLD: nFontWeight = 700; break;
298 case WEIGHT_ULTRABOLD: nFontWeight = 800; break;
299 case WEIGHT_BLACK: nFontWeight = 900; break;
300 default: nFontWeight = 400; break;
301 }
302
303 aStyle += B2UCONST( ";" );
304 aStyle += B2UCONST( "font-weight:" );
305 aStyle += NMSP_RTL::OUString::valueOf( nFontWeight );
306
307 // !!!
308 // font-variant
309 // font-stretch
310 // font-size-adjust
311
312 #ifdef _SVG_USE_NATIVE_TEXTDECORATION
313
314 if( rFont.GetUnderline() != UNDERLINE_NONE || rFont.GetStrikeout() != STRIKEOUT_NONE )
315 {
316 aStyle += B2UCONST( ";" );
317 aStyle += B2UCONST( "text-decoration:" );
318
319 if( rFont.GetUnderline() != UNDERLINE_NONE )
320 aStyle += B2UCONST( " underline" );
321
322 if( rFont.GetStrikeout() != STRIKEOUT_NONE )
323 aStyle += B2UCONST( " line-through" );
324 }
325
326 #endif // _SVG_USE_NATIVE_TEXTDECORATION
327
328 return aStyle.GetString();
329 }
330
331 // -----------------------------------------------------------------------------
332
333 NMSP_RTL::OUString SVGAttributeWriter::GetPaintStyle( const Color& rLineColor, const Color& rFillColor )
334 {
335 FastString aStyle;
336
337 // line color
338 aStyle += B2UCONST( "stroke:" );
339
340 if( rLineColor.GetTransparency() == 255 )
341 aStyle += B2UCONST( "none" );
342 else
343 {
344 // line color value in rgb
345 aStyle += B2UCONST( "rgb(" );
346 aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rLineColor.GetRed() );
347 aStyle += B2UCONST( "," );
348 aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rLineColor.GetGreen() );
349 aStyle += B2UCONST( "," );
350 aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rLineColor.GetBlue() );
351 aStyle += B2UCONST( ")" );
352
353 // line color opacity in percent if neccessary
354 if( rLineColor.GetTransparency() )
355 {
356 aStyle += B2UCONST( ";" );
357 aStyle += B2UCONST( "stroke-opacity:" );
358 aStyle += NMSP_RTL::OUString::valueOf( ( 255 - (double) rLineColor.GetTransparency() ) / 255.0 );
359 }
360 }
361
362 // fill color
363 aStyle += B2UCONST( ";" );
364 aStyle += B2UCONST( "fill:" );
365
366 if( rFillColor.GetTransparency() == 255 )
367 aStyle += B2UCONST( "none" );
368 else
369 {
370 // fill color value in rgb
371 aStyle += B2UCONST( "rgb(" );
372 aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rFillColor.GetRed() );
373 aStyle += B2UCONST( "," );
374 aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rFillColor.GetGreen() );
375 aStyle += B2UCONST( "," );
376 aStyle += NMSP_RTL::OUString::valueOf( (sal_Int32) rFillColor.GetBlue() );
377 aStyle += B2UCONST( ")" );
378
379 // fill color opacity in percent if neccessary
380 if( rFillColor.GetTransparency() )
381 {
382 aStyle += B2UCONST( ";" );
383 aStyle += B2UCONST( "fill-opacity:" );
384 aStyle += NMSP_RTL::OUString::valueOf( ( 255 - (double) rFillColor.GetTransparency() ) / 255.0 );
385 }
386 }
387
388 return aStyle.GetString();
389 }
390
391 // -----------------------------------------------------------------------------
392
393 void SVGAttributeWriter::SetFontAttr( const Font& rFont )
394 {
395 if( !mpElemFont || ( rFont != maCurFont ) )
396 {
397 delete mpElemPaint, mpElemPaint = NULL;
398 delete mpElemFont;
399 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, GetFontStyle( maCurFont = rFont ) );
400 mpElemFont = new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
401 }
402 }
403
404 // -----------------------------------------------------------------------------
405
406 void SVGAttributeWriter::SetPaintAttr( const Color& rLineColor, const Color& rFillColor )
407 {
408 if( !mpElemPaint || ( rLineColor != maCurLineColor ) || ( rFillColor != maCurFillColor ) )
409 {
410 delete mpElemPaint;
411 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, GetPaintStyle( maCurLineColor = rLineColor, maCurFillColor = rFillColor ) );
412 mpElemPaint = new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
413 }
414 }
415
416 // -------------------
417 // - SVGActionWriter -
418 // -------------------
419
420 SVGActionWriter::SVGActionWriter( SvXMLExport& rExport, SVGFontExport& rFontExport ) :
421 mrExport( rExport ),
422 mrFontExport( rFontExport ),
423 mpContext( NULL ),
424 mbClipAttrChanged( sal_False ),
425 mnCurClipId( 1 )
426 {
427 mpVDev = new VirtualDevice;
428 mpVDev->EnableOutput( sal_False );
429 maTargetMapMode = MAP_100TH_MM;
430 }
431
432 // -----------------------------------------------------------------------------
433
434 SVGActionWriter::~SVGActionWriter()
435 {
436 DBG_ASSERT( !mpContext, "Not all contexts are closed" );
437 delete mpVDev;
438 }
439
440 // -----------------------------------------------------------------------------
441
442 long SVGActionWriter::ImplMap( sal_Int32 nVal ) const
443 {
444 return ImplMap( Size( nVal, nVal ) ).Width();
445 }
446
447 // -----------------------------------------------------------------------------
448
449 Point SVGActionWriter::ImplMap( const Point& rPt ) const
450 {
451 return mpVDev->LogicToLogic( rPt, mpVDev->GetMapMode(), maTargetMapMode );
452 }
453
454 // -----------------------------------------------------------------------------
455
456 Size SVGActionWriter::ImplMap( const Size& rSz ) const
457 {
458 return mpVDev->LogicToLogic( rSz, mpVDev->GetMapMode(), maTargetMapMode );
459 }
460
461 // -----------------------------------------------------------------------------
462
463 NMSP_RTL::OUString SVGActionWriter::GetValueString( sal_Int32 nVal )
464 {
465 return ::rtl::OUString::valueOf( nVal );
466 }
467
468 // -----------------------------------------------------------------------------
469
470 NMSP_RTL::OUString SVGActionWriter::GetPathString( const PolyPolygon& rPolyPoly, sal_Bool bLine )
471 {
472 FastString aPathData;
473 const NMSP_RTL::OUString aBlank( B2UCONST( " " ) );
474 const NMSP_RTL::OUString aComma( B2UCONST( "," ) );
475 Point aPolyPoint;
476
477 for( long i = 0, nCount = rPolyPoly.Count(); i < nCount; i++ )
478 {
479 const Polygon& rPoly = rPolyPoly[ (USHORT) i ];
480 USHORT n = 1, nSize = rPoly.GetSize();
481
482 if( nSize > 1 )
483 {
484 aPathData += B2UCONST( "M " );
485 aPathData += GetValueString( ( aPolyPoint = rPoly[ 0 ] ).X() );
486 aPathData += aComma;
487 aPathData += GetValueString( aPolyPoint.Y() );
488 sal_Char nCurrentMode = 0;
489
490 while( n < nSize )
491 {
492 aPathData += aBlank;
493 if ( ( rPoly.GetFlags( n ) == POLY_CONTROL ) && ( ( n + 2 ) < nSize ) )
494 {
495 if ( nCurrentMode != 'C' )
496 {
497 nCurrentMode = 'C';
498 aPathData += B2UCONST( "C " );
499 }
500 for ( int j = 0; j < 3; j++ )
501 {
502 if ( j )
503 aPathData += aBlank;
504 aPathData += GetValueString( ( aPolyPoint = rPoly[ n++ ] ).X() );
505 aPathData += aComma;
506 aPathData += GetValueString( aPolyPoint.Y() );
507 }
508 }
509 else
510 {
511 if ( nCurrentMode != 'L' )
512 {
513 nCurrentMode = 'L';
514 aPathData += B2UCONST( "L " );
515 }
516 aPathData += GetValueString( ( aPolyPoint = rPoly[ n++ ] ).X() );
517 aPathData += aComma;
518 aPathData += GetValueString( aPolyPoint.Y() );
519 }
520 }
521
522 if( !bLine )
523 aPathData += B2UCONST( " Z" );
524
525 if( i < ( nCount - 1 ) )
526 aPathData += aBlank;
527 }
528 }
529
530 return aPathData.GetString();
531 }
532
533 // -----------------------------------------------------------------------------
534
535 void SVGActionWriter::ImplWriteLine( const Point& rPt1, const Point& rPt2, const Color* pLineColor,
536 const NMSP_RTL::OUString* pStyle )
537 {
538 const Point aPt1( ImplMap( rPt1 ) );
539 const Point aPt2( ImplMap( rPt2 ) );
540
541 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX1, GetValueString( aPt1.X() ) );
542 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY1, GetValueString( aPt1.Y() ) );
543 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX2, GetValueString( aPt2.X() ) );
544 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY2, GetValueString( aPt2.Y() ) );
545
546 // add additional style if requested
547 if( pStyle )
548 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
549
550 if( pLineColor )
551 {
552 // !!! mrExport.AddAttribute( XML_NAMESPACE_NONE, ... )
553 DBG_ERROR( "SVGActionWriter::ImplWriteLine: Line color not implemented" );
554 }
555
556 {
557 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemLine, TRUE, TRUE );
558 }
559 }
560
561 // -----------------------------------------------------------------------------
562
563 void SVGActionWriter::ImplWriteRect( const Rectangle& rRect, long nRadX, long nRadY,
564 const NMSP_RTL::OUString* pStyle )
565 {
566 const Rectangle aRect( ImplMap( rRect ) );
567
568 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, GetValueString( aRect.Left() ) );
569 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, GetValueString( aRect.Top() ) );
570 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrWidth, GetValueString( aRect.GetWidth() ) );
571 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrHeight, GetValueString( aRect.GetHeight() ) );
572
573 if( nRadX )
574 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRX, GetValueString( ImplMap( nRadX ) ) );
575
576 if( nRadY )
577 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRY, GetValueString( ImplMap( nRadY ) ) );
578
579 // add additional style if requested
580 if( pStyle )
581 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
582
583 {
584 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemRect, TRUE, TRUE );
585 }
586 }
587
588 // -----------------------------------------------------------------------------
589
590 void SVGActionWriter::ImplWriteEllipse( const Point& rCenter, long nRadX, long nRadY,
591 const NMSP_RTL::OUString* pStyle )
592 {
593 const Point aCenter( ImplMap( rCenter ) );
594
595 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCX, GetValueString( aCenter.X() ) );
596 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrCY, GetValueString( aCenter.Y() ) );
597 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRX, GetValueString( ImplMap( nRadX ) ) );
598 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrRY, GetValueString( ImplMap( nRadY ) ) );
599
600 // add additional style if requested
601 if( pStyle )
602 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
603
604 {
605 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemEllipse, TRUE, TRUE );
606 }
607 }
608
609 // -----------------------------------------------------------------------------
610
611 void SVGActionWriter::ImplWritePolyPolygon( const PolyPolygon& rPolyPoly, sal_Bool bLineOnly,
612 const NMSP_RTL::OUString* pStyle )
613 {
614 if( rPolyPoly.Count() )
615 {
616 PolyPolygon aMappedPolyPoly;
617 FastString aStyle;
618
619 for( USHORT i = 0, nCount = rPolyPoly.Count(); i < nCount; i++ )
620 {
621 const Polygon& rPoly = rPolyPoly[ i ];
622 const USHORT nSize = rPoly.GetSize();
623 Polygon aMappedPoly( nSize );
624
625 for( USHORT n = 0; n < nSize; n++ )
626 aMappedPoly[ n ] = ImplMap( rPoly[ n ] );
627
628 aMappedPolyPoly.Insert( aMappedPoly );
629 }
630
631 if( bLineOnly )
632 {
633 aStyle += B2UCONST( "fill:none" );
634 if( pStyle )
635 aStyle += B2UCONST( ";" );
636 }
637 if( pStyle )
638 aStyle += *pStyle;
639
640 // add style attribute
641 if( aStyle.GetLength() )
642 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, aStyle.GetString() );
643
644 // add path data attribute
645 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrD, GetPathString( aMappedPolyPoly, bLineOnly ) );
646 {
647 // write polyline/polygon element
648 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemPath, TRUE, TRUE );
649 }
650 }
651 }
652
653 // -----------------------------------------------------------------------------
654
655 void SVGActionWriter::ImplWriteGradientEx( const PolyPolygon& rPolyPoly, const Gradient& rGradient,
656 const NMSP_RTL::OUString* pStyle, sal_uInt32 nWriteFlags )
657 {
658 if( rPolyPoly.Count() )
659 {
660 SvXMLElementExport aElemG( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
661 FastString aClipId;
662 FastString aClipStyle;
663
664 aClipId += B2UCONST( "clip" );
665 aClipId += NMSP_RTL::OUString::valueOf( ImplGetNextClipId() );
666
667 {
668 SvXMLElementExport aElemDefs( mrExport, XML_NAMESPACE_NONE, aXMLElemDefs, TRUE, TRUE );
669
670 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrId, aClipId.GetString() );
671
672 {
673 SvXMLElementExport aElemClipPath( mrExport, XML_NAMESPACE_NONE, aXMLElemClipPath, TRUE, TRUE );
674 ImplWritePolyPolygon( rPolyPoly, sal_False );
675 }
676 }
677
678 // create new context with clippath set
679 aClipStyle += B2UCONST( "clip-path:URL(#" );
680 aClipStyle += aClipId.GetString();
681 aClipStyle += B2UCONST( ")" );
682
683 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, aClipStyle.GetString() );
684
685 {
686 GDIMetaFile aTmpMtf;
687 SvXMLElementExport aElemG2( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
688
689 mpVDev->AddGradientActions( rPolyPoly.GetBoundRect(), rGradient, aTmpMtf );
690 ImplWriteActions( aTmpMtf, pStyle, nWriteFlags );
691 }
692 }
693 }
694
695 // -----------------------------------------------------------------------------
696
697 void SVGActionWriter::ImplWriteText( const Point& rPos, const String& rText,
698 const sal_Int32* pDXArray, long nWidth,
699 const NMSP_RTL::OUString* pStyle )
700 {
701 long nLen = rText.Len(), i;
702
703 if( nLen )
704 {
705 Size aNormSize;
706 sal_Int32* pOwnArray;
707 sal_Int32* pDX;
708
709 // get text sizes
710 if( pDXArray )
711 {
712 pOwnArray = NULL;
713 aNormSize = Size( mpVDev->GetTextWidth( rText ), 0 );
714 pDX = (sal_Int32*) pDXArray;
715 }
716 else
717 {
718 pOwnArray = new sal_Int32[ nLen ];
719 aNormSize = Size( mpVDev->GetTextArray( rText, pOwnArray ), 0 );
720 pDX = pOwnArray;
721 }
722
723 if( nLen > 1 )
724 {
725 aNormSize.Width() = pDX[ nLen - 2 ] + mpVDev->GetTextWidth( rText.GetChar( sal::static_int_cast<USHORT>( nLen - 1 ) ) );
726
727 if( nWidth && aNormSize.Width() && ( nWidth != aNormSize.Width() ) )
728 {
729 const double fFactor = (double) nWidth / aNormSize.Width();
730
731 for( i = 0; i < ( nLen - 1 ); i++ )
732 pDX[ i ] = FRound( pDX[ i ] * fFactor );
733 }
734 }
735
736 FastString aStyle;
737 const Font& rFont = mpVDev->GetFont();
738 const FontMetric aMetric( mpVDev->GetFontMetric() );
739 Point aBaseLinePos( rPos );
740 SvXMLElementExport* pTransform = NULL;
741
742 // always adjust text position to match baseline alignment
743 switch( rFont.GetAlign() )
744 {
745 case( ALIGN_TOP ):
746 aBaseLinePos.Y() += aMetric.GetAscent();
747 break;
748
749 case( ALIGN_BOTTOM ):
750 aBaseLinePos.Y() -= aMetric.GetDescent();
751 break;
752
753 default:
754 break;
755 }
756
757 // get mapped text position
758 const Point aPt( ImplMap( aBaseLinePos ) );
759
760 // if text is italic, set transform at new g element
761 if( ( rFont.GetItalic() != ITALIC_NONE ) || rFont.GetOrientation() )
762 {
763 String aTransform;
764
765 aTransform = NMSP_RTL::OUString::createFromAscii( "translate" );
766 aTransform += '(';
767 aTransform += String( GetValueString( aPt.X() ) );
768 aTransform += ',';
769 aTransform += String( GetValueString( aPt.Y() ) );
770 aTransform += ')';
771
772 if( rFont.GetOrientation() )
773 {
774 aTransform += String( NMSP_RTL::OUString::createFromAscii( " rotate" ) );
775 aTransform += '(';
776 aTransform += String( NMSP_RTL::OUString::valueOf( rFont.GetOrientation() * -0.1 ) );
777 aTransform += ')';
778 }
779
780 if( rFont.GetItalic() != ITALIC_NONE )
781 {
782 aTransform += String( NMSP_RTL::OUString::createFromAscii( " skewX" ) );
783 aTransform += '(';
784 aTransform += String( NMSP_RTL::OUString::valueOf( (sal_Int32) -10 ) );
785 aTransform += ')';
786 }
787
788 aTransform += String( NMSP_RTL::OUString::createFromAscii( " translate" ) );
789 aTransform += '(';
790 aTransform += String( GetValueString( -aPt.X() ) );
791 aTransform += ',';
792 aTransform += String( GetValueString( -aPt.Y() ) );
793 aTransform += ')';
794
795 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrTransform, aTransform );
796 pTransform = new SvXMLElementExport( mrExport, XML_NAMESPACE_NONE, aXMLElemG, TRUE, TRUE );
797 }
798
799 // add additional style if requested
800 if( pStyle && pStyle->getLength() )
801 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStyle, *pStyle );
802
803 // write text element
804 {
805 #ifdef _SVG_USE_TSPANS
806 SvXMLElementExport aElem( mrExport, XML_NAMESPACE_NONE, aXMLElemText, TRUE, TRUE );
807 FastString aTSpanX;
808 const NMSP_RTL::OUString aSpace( ' ' );
809 String aOutputText( rText );
810 long nCurPos = 0;
811 bool bIgnoreWhitespace = true;
812
813 for( long j = 0, nX = aPt.X(); j < nLen; ++j )
814 {
815 const sal_Unicode cCode = rText.GetChar( sal::static_int_cast<USHORT>( j ) );
816
817 // don't take more than one whitespace into account
818 if( !bIgnoreWhitespace || ( ' ' != cCode ) )
819 {
820 aOutputText.SetChar( sal::static_int_cast<USHORT>( nCurPos++ ), cCode );
821 ( aTSpanX += GetValueString( nX + ( ( j > 0 ) ? pDX[ j - 1 ] : 0 ) ) ) += aSpace;
822 bIgnoreWhitespace = ( ' ' == cCode );
823 }
824 }
825
826 if( nCurPos < nLen )
827 aOutputText.Erase( sal::static_int_cast<USHORT>( nCurPos ) );
828
829 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, aTSpanX.GetString() );
830 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, GetValueString( aPt.Y() ) );
831
832 {
833 SvXMLElementExport aElem2( mrExport, XML_NAMESPACE_NONE, aXMLElemTSpan, TRUE, TRUE );
834 mrExport.GetDocHandler()->characters( aOutputText );
835 }
836 #else
837 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrX, GetValueString( aPt.X() ) );
838 mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrY, GetValueString( aPt.Y() ) );
839
840 {
841 SvXMLElementExport aElem2( mrExport, XML_NAMESPACE_NONE, aXMLElemText, TRUE, TRUE );
842 mrExport.GetDocHandler()->characters( rText );
843 }
844 #endif
845 }
846
847 #ifndef _SVG_USE_NATIVE_TEXTDECORATION
848 // write strikeout if neccessary
849 if( rFont.GetStrikeout() || rFont.GetUnderline() )
850 {
851 Polygon aPoly( 4 );
852 const long nLineHeight = Max( (long) FRound( aMetric.GetLineHeight() * 0.05 ), (long) 1 );
853
854 if( rFont.GetStrikeout() )
855 {
856 const long nYLinePos = aBaseLinePos.Y() - FRound( aMetric.GetAscent() * 0.26 );
857
858 aPoly[ 0 ].X() = aBaseLinePos.X(); aPoly[ 0 ].Y() = nYLinePos - ( nLineHeight >> 1 );
859 aPoly[ 1 ].X() = aBaseLinePos.X() + aNormSize.Width() - 1; aPoly[ 1 ].Y() = aPoly[ 0 ].Y();
860 aPoly[ 2 ].X() = aPoly[ 1 ].X(); aPoly[ 2 ].Y() = aPoly[ 0 ].Y() + nLineHeight - 1;
861 aPoly[ 3 ].X() = aPoly[ 0 ].X(); aPoly[ 3 ].Y() = aPoly[ 2 ].Y();
862
863 ImplWritePolyPolygon( aPoly, sal_False );
864 }
865
866 if( rFont.GetUnderline() )
867 {
868 const long nYLinePos = aBaseLinePos.Y() + ( nLineHeight << 1 );
869
870 aPoly[ 0 ].X() = aBaseLinePos.X(); aPoly[ 0 ].Y() = nYLinePos - ( nLineHeight >> 1 );
871 aPoly[ 1 ].X() = aBaseLinePos.X() + aNormSize.Width() - 1; aPoly[ 1 ].Y() = aPoly[ 0 ].Y();
872 aPoly[ 2 ].X() = aPoly[ 1 ].X(); aPoly[ 2 ].Y() = aPoly[ 0 ].Y() + nLineHeight - 1;
873 aPoly[ 3 ].X() = aPoly[ 0 ].X(); aPoly[ 3 ].Y() = aPoly[ 2 ].Y();
874
875 ImplWritePolyPolygon( aPoly, sal_False );
876 }
877 }
878 #endif // _SVG_USE_NATIVE_TEXTDECORATION
879
880 delete[] pOwnArray;
881 delete pTransform;
882 }
883 }
884
885 // -----------------------------------------------------------------------------
886
887 void SVGActionWriter::ImplWriteBmp( const BitmapEx& rBmpEx,
888 const Point& rPt, const Size& rSz,
889 const Point& rSrcPt, const Size& rSrcSz,
890 const NMSP_RTL::OUString* /* pStyle */ )
891 {
892 if( !!rBmpEx )
893 {
894 BitmapEx aBmpEx( rBmpEx );
895 Point aPoint = Point();
896 const Rectangle aBmpRect( aPoint, rBmpEx.GetSizePixel() );
897 const Rectangle aSrcRect( rSrcPt, rSrcSz );
898
899 if( aSrcRect != aBmpRect )
900 aBmpEx.Crop( aSrcRect );
901
902 if( !!aBmpEx )
903 {
904 SvMemoryStream aOStm( 65535, 65535 );
905
906 if( GraphicConverter::Export( aOStm, rBmpEx, CVT_PNG ) == ERRCODE_NONE )
907 {
908 const Point aPt( ImplMap( rPt ) );
909 const Size aSz( ImplMap( rSz ) );
910 FastString aImageData( (sal_Char*) aOStm.GetData(), aOStm.Tell() );
911 REF( NMSP_SAX::XExtendedDocumentHandler ) xExtDocHandler( mrExport.GetDocHandler(), NMSP_UNO::UNO_QUERY );
912
913 if( xExtDocHandler.is() )
914 {
915 static const sal_uInt32 nPartLen = 64;
916 const NMSP_RTL::OUString aSpace( ' ' );
917 const NMSP_RTL::OUString aLineFeed( NMSP_RTL::OUString::valueOf( (sal_Unicode) 0x0a ) );
918 NMSP_RTL::OUString aString;
919 NMSP_RTL::OUString aImageString;
920
921 aString = aLineFeed;
922 aString += B2UCONST( "<" );
923 aString += NMSP_RTL::OUString::createFromAscii( aXMLElemImage );
924 aString += aSpace;
925
926 aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrX );
927 aString += B2UCONST( "=\"" );
928 aString += GetValueString( aPt.X() );
929 aString += B2UCONST( "\" " );
930
931 aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrY );
932 aString += B2UCONST( "=\"" );
933 aString += GetValueString( aPt.Y() );
934 aString += B2UCONST( "\" " );
935
936 aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrWidth );
937 aString += B2UCONST( "=\"" );
938 aString += GetValueString( aSz.Width() );
939 aString += B2UCONST( "\" " );
940
941 aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrHeight );
942 aString += B2UCONST( "=\"" );
943 aString += GetValueString( aSz.Height() );
944 aString += B2UCONST( "\" " );
945
946 aString += NMSP_RTL::OUString::createFromAscii( aXMLAttrXLinkHRef );
947 aString += B2UCONST( "=\"data:image/png;base64," );
948
949 if( aImageData.GetFirstPartString( nPartLen, aImageString ) )
950 {
951 xExtDocHandler->unknown( aString += aImageString );
952
953 while( aImageData.GetNextPartString( nPartLen, aImageString ) )
954 {
955 xExtDocHandler->unknown( aLineFeed );
956 xExtDocHandler->unknown( aImageString );
957 }
958 }
959
960 xExtDocHandler->unknown( B2UCONST( "\"/>" ) );
961 }
962 }
963 }
964 }
965 }
966
967 // -----------------------------------------------------------------------------
968
969 void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
970 const NMSP_RTL::OUString* pStyle,
971 sal_uInt32 nWriteFlags )
972 {
973 ImplAcquireContext();
974
975 for( ULONG i = 0, nCount = rMtf.GetActionCount(); i < nCount; i++ )
976 {
977 const MetaAction* pAction = rMtf.GetAction( i );
978 const USHORT nType = pAction->GetType();
979
980 switch( nType )
981 {
982 case( META_PIXEL_ACTION ):
983 {
984 if( nWriteFlags & SVGWRITER_WRITE_FILL )
985 {
986 const MetaPixelAction* pA = (const MetaPixelAction*) pAction;
987
988 mpContext->SetPaintAttr( pA->GetColor(), pA->GetColor() );
989 ImplWriteLine( pA->GetPoint(), pA->GetPoint(), &pA->GetColor(), pStyle );
990 }
991 }
992 break;
993
994 case( META_POINT_ACTION ):
995 {
996 if( nWriteFlags & SVGWRITER_WRITE_FILL )
997 {
998 const MetaPointAction* pA = (const MetaPointAction*) pAction;
999
1000 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetLineColor() );
1001 ImplWriteLine( pA->GetPoint(), pA->GetPoint(), NULL, pStyle );
1002 }
1003 }
1004 break;
1005
1006 case( META_LINE_ACTION ):
1007 {
1008 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1009 {
1010 const MetaLineAction* pA = (const MetaLineAction*) pAction;
1011
1012 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetLineColor() );
1013 ImplWriteLine( pA->GetStartPoint(), pA->GetEndPoint(), NULL, pStyle );
1014 }
1015 }
1016 break;
1017
1018 case( META_RECT_ACTION ):
1019 {
1020 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1021 {
1022 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1023 ImplWriteRect( ( (const MetaRectAction*) pAction )->GetRect(), 0, 0, pStyle );
1024 }
1025 }
1026 break;
1027
1028 case( META_ROUNDRECT_ACTION ):
1029 {
1030 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1031 {
1032 const MetaRoundRectAction* pA = (const MetaRoundRectAction*) pAction;
1033
1034 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1035 ImplWriteRect( pA->GetRect(), pA->GetHorzRound(), pA->GetVertRound(), pStyle );
1036 }
1037 }
1038 break;
1039
1040 case( META_ELLIPSE_ACTION ):
1041 {
1042 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1043 {
1044 const MetaEllipseAction* pA = (const MetaEllipseAction*) pAction;
1045 const Rectangle& rRect = pA->GetRect();
1046
1047 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1048 ImplWriteEllipse( rRect.Center(), rRect.GetWidth() >> 1, rRect.GetHeight() >> 1, pStyle );
1049 }
1050 }
1051 break;
1052
1053 case( META_ARC_ACTION ):
1054 case( META_PIE_ACTION ):
1055 case( META_CHORD_ACTION ):
1056 case( META_POLYGON_ACTION ):
1057 {
1058 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1059 {
1060 Polygon aPoly;
1061
1062 switch( nType )
1063 {
1064 case( META_ARC_ACTION ):
1065 {
1066 const MetaArcAction* pA = (const MetaArcAction*) pAction;
1067 aPoly = Polygon( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_ARC );
1068 }
1069 break;
1070
1071 case( META_PIE_ACTION ):
1072 {
1073 const MetaPieAction* pA = (const MetaPieAction*) pAction;
1074 aPoly = Polygon( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_PIE );
1075 }
1076 break;
1077
1078 case( META_CHORD_ACTION ):
1079 {
1080 const MetaChordAction* pA = (const MetaChordAction*) pAction;
1081 aPoly = Polygon( pA->GetRect(), pA->GetStartPoint(), pA->GetEndPoint(), POLY_CHORD );
1082 }
1083 break;
1084
1085 case( META_POLYGON_ACTION ):
1086 aPoly = ( (const MetaPolygonAction*) pAction )->GetPolygon();
1087 break;
1088 }
1089
1090 if( aPoly.GetSize() )
1091 {
1092 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1093 ImplWritePolyPolygon( aPoly, sal_False, pStyle );
1094 }
1095 }
1096 }
1097 break;
1098
1099 case( META_POLYLINE_ACTION ):
1100 {
1101 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1102 {
1103 const MetaPolyLineAction* pA = (const MetaPolyLineAction*) pAction;
1104 const Polygon& rPoly = pA->GetPolygon();
1105
1106 if( rPoly.GetSize() )
1107 {
1108 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1109 ImplWritePolyPolygon( rPoly, sal_True, pStyle );
1110 }
1111 }
1112 }
1113 break;
1114
1115 case( META_POLYPOLYGON_ACTION ):
1116 {
1117 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1118 {
1119 const MetaPolyPolygonAction* pA = (const MetaPolyPolygonAction*) pAction;
1120 const PolyPolygon& rPolyPoly = pA->GetPolyPolygon();
1121
1122 if( rPolyPoly.Count() )
1123 {
1124 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1125 ImplWritePolyPolygon( rPolyPoly, sal_False, pStyle );
1126 }
1127 }
1128 }
1129 break;
1130
1131 case( META_GRADIENT_ACTION ):
1132 {
1133 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1134 {
1135 const MetaGradientAction* pA = (const MetaGradientAction*) pAction;
1136 const Polygon aRectPoly( pA->GetRect() );
1137 const PolyPolygon aRectPolyPoly( aRectPoly );
1138
1139 ImplWriteGradientEx( aRectPolyPoly, pA->GetGradient(), pStyle, nWriteFlags );
1140 }
1141 }
1142 break;
1143
1144 case( META_GRADIENTEX_ACTION ):
1145 {
1146 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1147 {
1148 const MetaGradientExAction* pA = (const MetaGradientExAction*) pAction;
1149 ImplWriteGradientEx( pA->GetPolyPolygon(), pA->GetGradient(), pStyle, nWriteFlags );
1150 }
1151 }
1152 break;
1153
1154 case META_HATCH_ACTION:
1155 {
1156 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1157 {
1158 const MetaHatchAction* pA = (const MetaHatchAction*) pAction;
1159 GDIMetaFile aTmpMtf;
1160
1161 mpVDev->AddHatchActions( pA->GetPolyPolygon(), pA->GetHatch(), aTmpMtf );
1162 ImplWriteActions( aTmpMtf, pStyle, nWriteFlags );
1163 }
1164 }
1165 break;
1166
1167 case( META_TRANSPARENT_ACTION ):
1168 {
1169 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1170 {
1171 const MetaTransparentAction* pA = (const MetaTransparentAction*) pAction;
1172 const PolyPolygon& rPolyPoly = pA->GetPolyPolygon();
1173
1174 if( rPolyPoly.Count() )
1175 {
1176 const Color aOldLineColor( mpVDev->GetLineColor() ), aOldFillColor( mpVDev->GetFillColor() );
1177 Color aNewLineColor( aOldLineColor ), aNewFillColor( aOldFillColor );
1178
1179 aNewLineColor.SetTransparency( sal::static_int_cast<UINT8>( FRound( pA->GetTransparence() * 2.55 ) ) );
1180 aNewFillColor.SetTransparency( sal::static_int_cast<UINT8>( FRound( pA->GetTransparence() * 2.55 ) ) );
1181
1182 mpContext->SetPaintAttr( aNewLineColor, aNewFillColor );
1183 ImplWritePolyPolygon( rPolyPoly, sal_False, pStyle );
1184 mpContext->SetPaintAttr( aOldLineColor, aOldFillColor );
1185 }
1186 }
1187 }
1188 break;
1189
1190 case( META_FLOATTRANSPARENT_ACTION ):
1191 {
1192 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1193 {
1194 const MetaFloatTransparentAction* pA = (const MetaFloatTransparentAction*) pAction;
1195 GDIMetaFile aTmpMtf( pA->GetGDIMetaFile() );
1196 Point aSrcPt( aTmpMtf.GetPrefMapMode().GetOrigin() );
1197 const Size aSrcSize( aTmpMtf.GetPrefSize() );
1198 const Point aDestPt( pA->GetPoint() );
1199 const Size aDestSize( pA->GetSize() );
1200 const double fScaleX = aSrcSize.Width() ? (double) aDestSize.Width() / aSrcSize.Width() : 1.0;
1201 const double fScaleY = aSrcSize.Height() ? (double) aDestSize.Height() / aSrcSize.Height() : 1.0;
1202 long nMoveX, nMoveY;
1203
1204 if( fScaleX != 1.0 || fScaleY != 1.0 )
1205 {
1206 aTmpMtf.Scale( fScaleX, fScaleY );
1207 aSrcPt.X() = FRound( aSrcPt.X() * fScaleX ), aSrcPt.Y() = FRound( aSrcPt.Y() * fScaleY );
1208 }
1209
1210 nMoveX = aDestPt.X() - aSrcPt.X(), nMoveY = aDestPt.Y() - aSrcPt.Y();
1211
1212 if( nMoveX || nMoveY )
1213 aTmpMtf.Move( nMoveX, nMoveY );
1214
1215 mpVDev->Push();
1216 ImplWriteActions( aTmpMtf, pStyle, nWriteFlags );
1217 mpVDev->Pop();
1218 }
1219 }
1220 break;
1221
1222 case( META_EPS_ACTION ):
1223 {
1224 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1225 {
1226 const MetaEPSAction* pA = (const MetaEPSAction*) pAction;
1227 const GDIMetaFile aGDIMetaFile( pA->GetSubstitute() );
1228 sal_Bool bFound = sal_False;
1229
1230 for( ULONG j = 0, nC = aGDIMetaFile.GetActionCount(); ( j < nC ) && !bFound; j++ )
1231 {
1232 const MetaAction* pSubstAct = aGDIMetaFile.GetAction( j );
1233
1234 if( pSubstAct->GetType() == META_BMPSCALE_ACTION )
1235 {
1236 bFound = sal_True;
1237 const MetaBmpScaleAction* pBmpScaleAction = (const MetaBmpScaleAction*) pSubstAct;
1238 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1239 ImplWriteBmp( pBmpScaleAction->GetBitmap(),
1240 pA->GetPoint(), pA->GetSize(),
1241 Point(), pBmpScaleAction->GetBitmap().GetSizePixel(), pStyle );
1242 }
1243 }
1244 }
1245 }
1246 break;
1247
1248 case( META_COMMENT_ACTION ):
1249 {
1250 const MetaCommentAction* pA = (const MetaCommentAction*) pAction;
1251 String aSkipComment;
1252
1253 if( ( pA->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_BEGIN" ) == COMPARE_EQUAL ) &&
1254 ( nWriteFlags & SVGWRITER_WRITE_FILL ) )
1255 {
1256 const MetaGradientExAction* pGradAction = NULL;
1257 sal_Bool bDone = sal_False;
1258
1259 while( !bDone && ( ++i < nCount ) )
1260 {
1261 pAction = rMtf.GetAction( i );
1262
1263 if( pAction->GetType() == META_GRADIENTEX_ACTION )
1264 pGradAction = (const MetaGradientExAction*) pAction;
1265 else if( ( pAction->GetType() == META_COMMENT_ACTION ) &&
1266 ( ( (const MetaCommentAction*) pAction )->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_END" ) == COMPARE_EQUAL ) )
1267 {
1268 bDone = sal_True;
1269 }
1270 }
1271
1272 if( pGradAction )
1273 ImplWriteGradientEx( pGradAction->GetPolyPolygon(), pGradAction->GetGradient(), pStyle, nWriteFlags );
1274 }
1275 }
1276 break;
1277
1278 case( META_BMP_ACTION ):
1279 {
1280 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1281 {
1282 const MetaBmpAction* pA = (const MetaBmpAction*) pAction;
1283
1284 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1285 ImplWriteBmp( pA->GetBitmap(),
1286 pA->GetPoint(), mpVDev->PixelToLogic( pA->GetBitmap().GetSizePixel() ),
1287 Point(), pA->GetBitmap().GetSizePixel(), pStyle );
1288 }
1289 }
1290 break;
1291
1292 case( META_BMPSCALE_ACTION ):
1293 {
1294 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1295 {
1296 const MetaBmpScaleAction* pA = (const MetaBmpScaleAction*) pAction;
1297
1298 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1299 ImplWriteBmp( pA->GetBitmap(),
1300 pA->GetPoint(), pA->GetSize(),
1301 Point(), pA->GetBitmap().GetSizePixel(), pStyle );
1302 }
1303 }
1304 break;
1305
1306 case( META_BMPSCALEPART_ACTION ):
1307 {
1308 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1309 {
1310 const MetaBmpScalePartAction* pA = (const MetaBmpScalePartAction*) pAction;
1311
1312 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1313 ImplWriteBmp( pA->GetBitmap(),
1314 pA->GetDestPoint(), pA->GetDestSize(),
1315 pA->GetSrcPoint(), pA->GetSrcSize(), pStyle );
1316 }
1317 }
1318 break;
1319
1320 case( META_BMPEX_ACTION ):
1321 {
1322 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1323 {
1324 const MetaBmpExAction* pA = (const MetaBmpExAction*) pAction;
1325
1326 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1327 ImplWriteBmp( pA->GetBitmapEx(),
1328 pA->GetPoint(), mpVDev->PixelToLogic( pA->GetBitmapEx().GetSizePixel() ),
1329 Point(), pA->GetBitmapEx().GetSizePixel(), pStyle );
1330 }
1331 }
1332 break;
1333
1334 case( META_BMPEXSCALE_ACTION ):
1335 {
1336 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1337 {
1338 const MetaBmpExScaleAction* pA = (const MetaBmpExScaleAction*) pAction;
1339
1340 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1341 ImplWriteBmp( pA->GetBitmapEx(),
1342 pA->GetPoint(), pA->GetSize(),
1343 Point(), pA->GetBitmapEx().GetSizePixel(), pStyle );
1344 }
1345 }
1346 break;
1347
1348 case( META_BMPEXSCALEPART_ACTION ):
1349 {
1350 if( nWriteFlags & SVGWRITER_WRITE_FILL )
1351 {
1352 const MetaBmpExScalePartAction* pA = (const MetaBmpExScalePartAction*) pAction;
1353
1354 mpContext->SetPaintAttr( mpVDev->GetLineColor(), mpVDev->GetFillColor() );
1355 ImplWriteBmp( pA->GetBitmapEx(),
1356 pA->GetDestPoint(), pA->GetDestSize(),
1357 pA->GetSrcPoint(), pA->GetSrcSize(), pStyle );
1358 }
1359 }
1360 break;
1361
1362 case( META_TEXT_ACTION ):
1363 {
1364 if( nWriteFlags & SVGWRITER_WRITE_TEXT )
1365 {
1366 const MetaTextAction* pA = (const MetaTextAction*) pAction;
1367 Font aFont( mpVDev->GetFont() );
1368
1369 aFont.SetHeight( ImplMap( Size( 0, aFont.GetHeight() ) ).Height() );
1370 mpContext->SetFontAttr( aFont );
1371 mpContext->SetPaintAttr( COL_TRANSPARENT, aFont.GetColor() );
1372 ImplWriteText( pA->GetPoint(), String( pA->GetText(), pA->GetIndex(), pA->GetLen() ), NULL, 0, pStyle );
1373 }
1374 }
1375 break;
1376
1377 case( META_TEXTRECT_ACTION ):
1378 {
1379 if( nWriteFlags & SVGWRITER_WRITE_TEXT )
1380 {
1381 const MetaTextRectAction* pA = (const MetaTextRectAction*) pAction;
1382 Font aFont( mpVDev->GetFont() );
1383
1384 aFont.SetHeight( ImplMap( Size( 0, aFont.GetHeight() ) ).Height() );
1385 mpContext->SetFontAttr( aFont );
1386 mpContext->SetPaintAttr( COL_TRANSPARENT, aFont.GetColor() );
1387 ImplWriteText( pA->GetRect().TopLeft(), pA->GetText(), NULL, 0, pStyle );
1388 }
1389 }
1390 break;
1391
1392 case( META_TEXTARRAY_ACTION ):
1393 {
1394 if( nWriteFlags & SVGWRITER_WRITE_TEXT )
1395 {
1396 const MetaTextArrayAction* pA = (const MetaTextArrayAction*) pAction;
1397 const Point aPos( ImplMap( pA->GetPoint() ) );
1398 Font aFont( mpVDev->GetFont() );
1399
1400 aFont.SetHeight( ImplMap( Size( 0, aFont.GetHeight() ) ).Height() );
1401 mpContext->SetFontAttr( aFont );
1402 mpContext->SetPaintAttr( COL_TRANSPARENT, aFont.GetColor() );
1403 ImplWriteText( pA->GetPoint(), String( pA->GetText(), pA->GetIndex(), pA->GetLen() ), pA->GetDXArray(), 0, pStyle );
1404 }
1405 }
1406 break;
1407
1408 case( META_STRETCHTEXT_ACTION ):
1409 {
1410 if( nWriteFlags & SVGWRITER_WRITE_TEXT )
1411 {
1412 const MetaStretchTextAction* pA = (const MetaStretchTextAction*) pAction;
1413 Font aFont( mpVDev->GetFont() );
1414
1415 aFont.SetHeight( ImplMap( Size( 0, aFont.GetHeight() ) ).Height() );
1416 mpContext->SetFontAttr( aFont );
1417 mpContext->SetPaintAttr( COL_TRANSPARENT, aFont.GetColor() );
1418 ImplWriteText( pA->GetPoint(), String( pA->GetText(), pA->GetIndex(), pA->GetLen() ), NULL, pA->GetWidth(), pStyle );
1419 }
1420 }
1421 break;
1422
1423 case( META_CLIPREGION_ACTION ):
1424 case( META_ISECTRECTCLIPREGION_ACTION ):
1425 case( META_ISECTREGIONCLIPREGION_ACTION ):
1426 case( META_MOVECLIPREGION_ACTION ):
1427 {
1428 ( (MetaAction*) pAction )->Execute( mpVDev );
1429 mbClipAttrChanged = sal_True;
1430 }
1431 break;
1432
1433 case( META_REFPOINT_ACTION ):
1434 case( META_MAPMODE_ACTION ):
1435 case( META_LINECOLOR_ACTION ):
1436 case( META_FILLCOLOR_ACTION ):
1437 case( META_TEXTLINECOLOR_ACTION ):
1438 case( META_TEXTFILLCOLOR_ACTION ):
1439 case( META_TEXTCOLOR_ACTION ):
1440 case( META_TEXTALIGN_ACTION ):
1441 case( META_FONT_ACTION ):
1442 case( META_PUSH_ACTION ):
1443 case( META_POP_ACTION ):
1444 case( META_LAYOUTMODE_ACTION ):
1445 {
1446 ( (MetaAction*) pAction )->Execute( mpVDev );
1447 }
1448 break;
1449
1450 case( META_RASTEROP_ACTION ):
1451 case( META_MASK_ACTION ):
1452 case( META_MASKSCALE_ACTION ):
1453 case( META_MASKSCALEPART_ACTION ):
1454 case( META_WALLPAPER_ACTION ):
1455 case( META_TEXTLINE_ACTION ):
1456 {
1457 // !!! >>> we don't want to support these actions
1458 }
1459 break;
1460
1461 default:
1462 DBG_ERROR( "SVGActionWriter::ImplWriteActions: unsupported MetaAction #" );
1463 break;
1464 }
1465 }
1466
1467 ImplReleaseContext();
1468 }
1469
1470 // -----------------------------------------------------------------------------
1471
1472 void SVGActionWriter::WriteMetaFile( const Point& rPos100thmm,
1473 const Size& rSize100thmm,
1474 const GDIMetaFile& rMtf,
1475 sal_uInt32 nWriteFlags )
1476 {
1477 MapMode aMapMode( rMtf.GetPrefMapMode() );
1478 Size aPrefSize( rMtf.GetPrefSize() );
1479 Fraction aFractionX( aMapMode.GetScaleX() );
1480 Fraction aFractionY( aMapMode.GetScaleY() );
1481
1482 mpVDev->Push();
1483
1484 Size aSize( OutputDevice::LogicToLogic( rSize100thmm, MAP_100TH_MM, aMapMode ) );
1485 aMapMode.SetScaleX( aFractionX *= Fraction( aSize.Width(), aPrefSize.Width() ) );
1486 aMapMode.SetScaleY( aFractionY *= Fraction( aSize.Height(), aPrefSize.Height() ) );
1487
1488 Point aOffset( OutputDevice::LogicToLogic( rPos100thmm, MAP_100TH_MM, aMapMode ) );
1489 aMapMode.SetOrigin( aOffset += aMapMode.GetOrigin() );
1490
1491 mpVDev->SetMapMode( aMapMode );
1492
1493 ImplWriteActions( rMtf, NULL, nWriteFlags );
1494
1495 mpVDev->Pop();
1496 }
vba interoperability for OOo