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 <functional>
21 : #include <algorithm>
22 : #include <utility>
23 : #include <list>
24 : #include <vector>
25 :
26 : #include <basegfx/polygon/b2dpolygon.hxx>
27 : #include <basegfx/polygon/b2dpolygontools.hxx>
28 :
29 : #include <tools/debug.hxx>
30 :
31 : #include <vcl/virdev.hxx>
32 : #include <vcl/metaact.hxx>
33 : #include <vcl/gdimtf.hxx>
34 : #include <vcl/print.hxx>
35 : #include <vcl/svapp.hxx>
36 : #include <vcl/bmpacc.hxx>
37 :
38 : #include <print.h>
39 :
40 : #include "pdfwriter_impl.hxx"
41 :
42 : #define MAX_TILE_WIDTH 1024
43 : #define MAX_TILE_HEIGHT 1024
44 :
45 : typedef ::std::pair< MetaAction*, int > Component; // MetaAction plus index in metafile
46 :
47 : typedef ::std::list< Component > ComponentList;
48 :
49 : // List of (intersecting) actions, plus overall bounds
50 0 : struct ConnectedComponents
51 : {
52 0 : ConnectedComponents() :
53 : aComponentList(),
54 : aBounds(),
55 : aBgColor(COL_WHITE),
56 : bIsSpecial(false),
57 0 : bIsFullyTransparent(false)
58 0 : {}
59 :
60 : ComponentList aComponentList;
61 : Rectangle aBounds;
62 : Color aBgColor;
63 : bool bIsSpecial;
64 : bool bIsFullyTransparent;
65 : };
66 :
67 : typedef ::std::list< ConnectedComponents > ConnectedComponentsList;
68 :
69 : namespace {
70 :
71 : /** \#i10613# Extracted from Printer::GetPreparedMetaFile. Returns true
72 : if given action requires special transparency handling
73 : */
74 0 : bool IsTransparentAction( const MetaAction& rAct )
75 : {
76 0 : switch( rAct.GetType() )
77 : {
78 : case MetaActionType::Transparent:
79 0 : return true;
80 :
81 : case MetaActionType::FLOATTRANSPARENT:
82 0 : return true;
83 :
84 : case MetaActionType::BMPEX:
85 0 : return static_cast<const MetaBmpExAction&>(rAct).GetBitmapEx().IsTransparent();
86 :
87 : case MetaActionType::BMPEXSCALE:
88 0 : return static_cast<const MetaBmpExScaleAction&>(rAct).GetBitmapEx().IsTransparent();
89 :
90 : case MetaActionType::BMPEXSCALEPART:
91 0 : return static_cast<const MetaBmpExScalePartAction&>(rAct).GetBitmapEx().IsTransparent();
92 :
93 : default:
94 0 : return false;
95 : }
96 : }
97 :
98 :
99 : /** Determines whether the action can handle transparency correctly
100 : (i.e. when painted on white background, does the action still look
101 : correct)?
102 : */
103 0 : bool DoesActionHandleTransparency( const MetaAction& rAct )
104 : {
105 : // MetaActionType::FLOATTRANSPARENT can contain a whole metafile,
106 : // which is to be rendered with the given transparent gradient. We
107 : // currently cannot emulate transparent painting on a white
108 : // background reliably.
109 :
110 : // the remainder can handle printing itself correctly on a uniform
111 : // white background.
112 0 : switch( rAct.GetType() )
113 : {
114 : case MetaActionType::Transparent:
115 : case MetaActionType::BMPEX:
116 : case MetaActionType::BMPEXSCALE:
117 : case MetaActionType::BMPEXSCALEPART:
118 0 : return true;
119 :
120 : default:
121 0 : return false;
122 : }
123 : }
124 :
125 : /** Check whether rCurrRect rectangle fully covers io_rPrevRect - if
126 : yes, return true and update o_rBgColor
127 : */
128 0 : bool checkRect( Rectangle& io_rPrevRect,
129 : Color& o_rBgColor,
130 : const Rectangle& rCurrRect,
131 : OutputDevice& rMapModeVDev )
132 : {
133 : // shape needs to fully cover previous content, and have uniform
134 : // color
135 : const bool bRet(
136 0 : rMapModeVDev.LogicToPixel(rCurrRect).IsInside(io_rPrevRect) &&
137 0 : rMapModeVDev.IsFillColor() );
138 :
139 0 : if( bRet )
140 : {
141 0 : io_rPrevRect = rCurrRect;
142 0 : o_rBgColor = rMapModeVDev.GetFillColor();
143 : }
144 :
145 0 : return bRet;
146 : }
147 :
148 : /** #107169# Convert BitmapEx to Bitmap with appropriately blended
149 : color. Convert MetaTransparentAction to plain polygon,
150 : appropriately colored
151 :
152 : @param o_rMtf
153 : Add converted actions to this metafile
154 : */
155 0 : void ImplConvertTransparentAction( GDIMetaFile& o_rMtf,
156 : const MetaAction& rAct,
157 : const OutputDevice& rStateOutDev,
158 : Color aBgColor )
159 : {
160 0 : if( rAct.GetType() == MetaActionType::Transparent )
161 : {
162 0 : const MetaTransparentAction* pTransAct = static_cast<const MetaTransparentAction*>(&rAct);
163 0 : sal_uInt16 nTransparency( pTransAct->GetTransparence() );
164 :
165 : // #i10613# Respect transparency for draw color
166 0 : if( nTransparency )
167 : {
168 0 : o_rMtf.AddAction( new MetaPushAction( PushFlags::LINECOLOR|PushFlags::FILLCOLOR ) );
169 :
170 : // assume white background for alpha blending
171 0 : Color aLineColor( rStateOutDev.GetLineColor() );
172 0 : aLineColor.SetRed( static_cast<sal_uInt8>( (255L*nTransparency + (100L - nTransparency)*aLineColor.GetRed()) / 100L ) );
173 0 : aLineColor.SetGreen( static_cast<sal_uInt8>( (255L*nTransparency + (100L - nTransparency)*aLineColor.GetGreen()) / 100L ) );
174 0 : aLineColor.SetBlue( static_cast<sal_uInt8>( (255L*nTransparency + (100L - nTransparency)*aLineColor.GetBlue()) / 100L ) );
175 0 : o_rMtf.AddAction( new MetaLineColorAction(aLineColor, true) );
176 :
177 0 : Color aFillColor( rStateOutDev.GetFillColor() );
178 0 : aFillColor.SetRed( static_cast<sal_uInt8>( (255L*nTransparency + (100L - nTransparency)*aFillColor.GetRed()) / 100L ) );
179 0 : aFillColor.SetGreen( static_cast<sal_uInt8>( (255L*nTransparency + (100L - nTransparency)*aFillColor.GetGreen()) / 100L ) );
180 0 : aFillColor.SetBlue( static_cast<sal_uInt8>( (255L*nTransparency + (100L - nTransparency)*aFillColor.GetBlue()) / 100L ) );
181 0 : o_rMtf.AddAction( new MetaFillColorAction(aFillColor, true) );
182 : }
183 :
184 0 : o_rMtf.AddAction( new MetaPolyPolygonAction(pTransAct->GetPolyPolygon()) );
185 :
186 0 : if( nTransparency )
187 0 : o_rMtf.AddAction( new MetaPopAction() );
188 : }
189 : else
190 : {
191 0 : BitmapEx aBmpEx;
192 :
193 0 : switch( rAct.GetType() )
194 : {
195 : case MetaActionType::BMPEX:
196 0 : aBmpEx = static_cast<const MetaBmpExAction&>(rAct).GetBitmapEx();
197 0 : break;
198 :
199 : case MetaActionType::BMPEXSCALE:
200 0 : aBmpEx = static_cast<const MetaBmpExScaleAction&>(rAct).GetBitmapEx();
201 0 : break;
202 :
203 : case MetaActionType::BMPEXSCALEPART:
204 0 : aBmpEx = static_cast<const MetaBmpExScaleAction&>(rAct).GetBitmapEx();
205 0 : break;
206 :
207 : case MetaActionType::Transparent:
208 :
209 : default:
210 : OSL_FAIL("Printer::GetPreparedMetafile impossible state reached");
211 0 : break;
212 : }
213 :
214 0 : Bitmap aBmp( aBmpEx.GetBitmap() );
215 0 : if( !aBmpEx.IsAlpha() )
216 : {
217 : // blend with mask
218 0 : BitmapReadAccess* pRA = aBmp.AcquireReadAccess();
219 :
220 0 : if( !pRA )
221 0 : return; // what else should I do?
222 :
223 0 : Color aActualColor( aBgColor );
224 :
225 0 : if( pRA->HasPalette() )
226 0 : aActualColor = pRA->GetBestPaletteColor( aBgColor ).operator Color();
227 :
228 0 : Bitmap::ReleaseAccess(pRA);
229 :
230 : // did we get true white?
231 0 : if( aActualColor.GetColorError( aBgColor ) )
232 : {
233 : // no, create truecolor bitmap, then
234 0 : aBmp.Convert( BMP_CONVERSION_24BIT );
235 :
236 : // fill masked out areas white
237 0 : aBmp.Replace( aBmpEx.GetMask(), aBgColor );
238 : }
239 : else
240 : {
241 : // fill masked out areas white
242 0 : aBmp.Replace( aBmpEx.GetMask(), aActualColor );
243 : }
244 : }
245 : else
246 : {
247 : // blend with alpha channel
248 0 : aBmp.Convert( BMP_CONVERSION_24BIT );
249 0 : aBmp.Blend(aBmpEx.GetAlpha(),aBgColor);
250 : }
251 :
252 : // add corresponding action
253 0 : switch( rAct.GetType() )
254 : {
255 : case MetaActionType::BMPEX:
256 : o_rMtf.AddAction( new MetaBmpAction(
257 : static_cast<const MetaBmpExAction&>(rAct).GetPoint(),
258 0 : aBmp ));
259 0 : break;
260 : case MetaActionType::BMPEXSCALE:
261 : o_rMtf.AddAction( new MetaBmpScaleAction(
262 : static_cast<const MetaBmpExScaleAction&>(rAct).GetPoint(),
263 : static_cast<const MetaBmpExScaleAction&>(rAct).GetSize(),
264 0 : aBmp ));
265 0 : break;
266 : case MetaActionType::BMPEXSCALEPART:
267 : o_rMtf.AddAction( new MetaBmpScalePartAction(
268 : static_cast<const MetaBmpExScalePartAction&>(rAct).GetDestPoint(),
269 : static_cast<const MetaBmpExScalePartAction&>(rAct).GetDestSize(),
270 : static_cast<const MetaBmpExScalePartAction&>(rAct).GetSrcPoint(),
271 : static_cast<const MetaBmpExScalePartAction&>(rAct).GetSrcSize(),
272 0 : aBmp ));
273 0 : break;
274 : default:
275 : OSL_FAIL("Unexpected case");
276 0 : break;
277 0 : }
278 : }
279 : }
280 :
281 : // #i10613# Extracted from ImplCheckRect::ImplCreate
282 : // Returns true, if given action creates visible (i.e. non-transparent) output
283 0 : bool ImplIsNotTransparent( const MetaAction& rAct, const OutputDevice& rOut )
284 : {
285 0 : const bool bLineTransparency( !rOut.IsLineColor() || rOut.GetLineColor().GetTransparency() == 255 );
286 0 : const bool bFillTransparency( !rOut.IsFillColor() || rOut.GetFillColor().GetTransparency() == 255 );
287 0 : bool bRet( false );
288 :
289 0 : switch( rAct.GetType() )
290 : {
291 : case MetaActionType::POINT:
292 0 : if( !bLineTransparency )
293 0 : bRet = true;
294 0 : break;
295 :
296 : case MetaActionType::LINE:
297 0 : if( !bLineTransparency )
298 0 : bRet = true;
299 0 : break;
300 :
301 : case MetaActionType::RECT:
302 0 : if( !bLineTransparency || !bFillTransparency )
303 0 : bRet = true;
304 0 : break;
305 :
306 : case MetaActionType::ROUNDRECT:
307 0 : if( !bLineTransparency || !bFillTransparency )
308 0 : bRet = true;
309 0 : break;
310 :
311 : case MetaActionType::ELLIPSE:
312 0 : if( !bLineTransparency || !bFillTransparency )
313 0 : bRet = true;
314 0 : break;
315 :
316 : case MetaActionType::ARC:
317 0 : if( !bLineTransparency || !bFillTransparency )
318 0 : bRet = true;
319 0 : break;
320 :
321 : case MetaActionType::PIE:
322 0 : if( !bLineTransparency || !bFillTransparency )
323 0 : bRet = true;
324 0 : break;
325 :
326 : case MetaActionType::CHORD:
327 0 : if( !bLineTransparency || !bFillTransparency )
328 0 : bRet = true;
329 0 : break;
330 :
331 : case MetaActionType::POLYLINE:
332 0 : if( !bLineTransparency )
333 0 : bRet = true;
334 0 : break;
335 :
336 : case MetaActionType::POLYGON:
337 0 : if( !bLineTransparency || !bFillTransparency )
338 0 : bRet = true;
339 0 : break;
340 :
341 : case MetaActionType::POLYPOLYGON:
342 0 : if( !bLineTransparency || !bFillTransparency )
343 0 : bRet = true;
344 0 : break;
345 :
346 : case MetaActionType::TEXT:
347 : {
348 0 : const MetaTextAction& rTextAct = static_cast<const MetaTextAction&>(rAct);
349 0 : const OUString aString( rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()) );
350 0 : if (!aString.isEmpty())
351 0 : bRet = true;
352 : }
353 0 : break;
354 :
355 : case MetaActionType::TEXTARRAY:
356 : {
357 0 : const MetaTextArrayAction& rTextAct = static_cast<const MetaTextArrayAction&>(rAct);
358 0 : const OUString aString( rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()) );
359 0 : if (!aString.isEmpty())
360 0 : bRet = true;
361 : }
362 0 : break;
363 :
364 : case MetaActionType::PIXEL:
365 : case MetaActionType::BMP:
366 : case MetaActionType::BMPSCALE:
367 : case MetaActionType::BMPSCALEPART:
368 : case MetaActionType::BMPEX:
369 : case MetaActionType::BMPEXSCALE:
370 : case MetaActionType::BMPEXSCALEPART:
371 : case MetaActionType::MASK:
372 : case MetaActionType::MASKSCALE:
373 : case MetaActionType::MASKSCALEPART:
374 : case MetaActionType::GRADIENT:
375 : case MetaActionType::GRADIENTEX:
376 : case MetaActionType::HATCH:
377 : case MetaActionType::WALLPAPER:
378 : case MetaActionType::Transparent:
379 : case MetaActionType::FLOATTRANSPARENT:
380 : case MetaActionType::EPS:
381 : case MetaActionType::TEXTRECT:
382 : case MetaActionType::STRETCHTEXT:
383 : case MetaActionType::TEXTLINE:
384 : // all other actions: generate non-transparent output
385 0 : bRet = true;
386 0 : break;
387 :
388 : default:
389 0 : break;
390 : }
391 :
392 0 : return bRet;
393 : }
394 :
395 : // #i10613# Extracted from ImplCheckRect::ImplCreate
396 0 : Rectangle ImplCalcActionBounds( const MetaAction& rAct, const OutputDevice& rOut )
397 : {
398 0 : Rectangle aActionBounds;
399 :
400 0 : switch( rAct.GetType() )
401 : {
402 : case MetaActionType::PIXEL:
403 0 : aActionBounds = Rectangle( static_cast<const MetaPixelAction&>(rAct).GetPoint(), Size( 1, 1 ) );
404 0 : break;
405 :
406 : case MetaActionType::POINT:
407 0 : aActionBounds = Rectangle( static_cast<const MetaPointAction&>(rAct).GetPoint(), Size( 1, 1 ) );
408 0 : break;
409 :
410 : case MetaActionType::LINE:
411 : {
412 0 : const MetaLineAction& rMetaLineAction = static_cast<const MetaLineAction&>(rAct);
413 0 : aActionBounds = Rectangle( rMetaLineAction.GetStartPoint(), rMetaLineAction.GetEndPoint() );
414 0 : aActionBounds.Justify();
415 0 : const long nLineWidth(rMetaLineAction.GetLineInfo().GetWidth());
416 0 : if(nLineWidth)
417 : {
418 0 : const long nHalfLineWidth((nLineWidth + 1) / 2);
419 0 : aActionBounds.Left() -= nHalfLineWidth;
420 0 : aActionBounds.Top() -= nHalfLineWidth;
421 0 : aActionBounds.Right() += nHalfLineWidth;
422 0 : aActionBounds.Bottom() += nHalfLineWidth;
423 : }
424 0 : break;
425 : }
426 :
427 : case MetaActionType::RECT:
428 0 : aActionBounds = static_cast<const MetaRectAction&>(rAct).GetRect();
429 0 : break;
430 :
431 : case MetaActionType::ROUNDRECT:
432 0 : aActionBounds = Polygon( static_cast<const MetaRoundRectAction&>(rAct).GetRect(),
433 0 : static_cast<const MetaRoundRectAction&>(rAct).GetHorzRound(),
434 0 : static_cast<const MetaRoundRectAction&>(rAct).GetVertRound() ).GetBoundRect();
435 0 : break;
436 :
437 : case MetaActionType::ELLIPSE:
438 : {
439 0 : const Rectangle& rRect = static_cast<const MetaEllipseAction&>(rAct).GetRect();
440 : aActionBounds = Polygon( rRect.Center(),
441 0 : rRect.GetWidth() >> 1,
442 0 : rRect.GetHeight() >> 1 ).GetBoundRect();
443 0 : break;
444 : }
445 :
446 : case MetaActionType::ARC:
447 0 : aActionBounds = Polygon( static_cast<const MetaArcAction&>(rAct).GetRect(),
448 0 : static_cast<const MetaArcAction&>(rAct).GetStartPoint(),
449 0 : static_cast<const MetaArcAction&>(rAct).GetEndPoint(), POLY_ARC ).GetBoundRect();
450 0 : break;
451 :
452 : case MetaActionType::PIE:
453 0 : aActionBounds = Polygon( static_cast<const MetaPieAction&>(rAct).GetRect(),
454 0 : static_cast<const MetaPieAction&>(rAct).GetStartPoint(),
455 0 : static_cast<const MetaPieAction&>(rAct).GetEndPoint(), POLY_PIE ).GetBoundRect();
456 0 : break;
457 :
458 : case MetaActionType::CHORD:
459 0 : aActionBounds = Polygon( static_cast<const MetaChordAction&>(rAct).GetRect(),
460 0 : static_cast<const MetaChordAction&>(rAct).GetStartPoint(),
461 0 : static_cast<const MetaChordAction&>(rAct).GetEndPoint(), POLY_CHORD ).GetBoundRect();
462 0 : break;
463 :
464 : case MetaActionType::POLYLINE:
465 : {
466 0 : const MetaPolyLineAction& rMetaPolyLineAction = static_cast<const MetaPolyLineAction&>(rAct);
467 0 : aActionBounds = rMetaPolyLineAction.GetPolygon().GetBoundRect();
468 0 : const long nLineWidth(rMetaPolyLineAction.GetLineInfo().GetWidth());
469 0 : if(nLineWidth)
470 : {
471 0 : const long nHalfLineWidth((nLineWidth + 1) / 2);
472 0 : aActionBounds.Left() -= nHalfLineWidth;
473 0 : aActionBounds.Top() -= nHalfLineWidth;
474 0 : aActionBounds.Right() += nHalfLineWidth;
475 0 : aActionBounds.Bottom() += nHalfLineWidth;
476 : }
477 0 : break;
478 : }
479 :
480 : case MetaActionType::POLYGON:
481 0 : aActionBounds = static_cast<const MetaPolygonAction&>(rAct).GetPolygon().GetBoundRect();
482 0 : break;
483 :
484 : case MetaActionType::POLYPOLYGON:
485 0 : aActionBounds = static_cast<const MetaPolyPolygonAction&>(rAct).GetPolyPolygon().GetBoundRect();
486 0 : break;
487 :
488 : case MetaActionType::BMP:
489 0 : aActionBounds = Rectangle( static_cast<const MetaBmpAction&>(rAct).GetPoint(),
490 0 : rOut.PixelToLogic( static_cast<const MetaBmpAction&>(rAct).GetBitmap().GetSizePixel() ) );
491 0 : break;
492 :
493 : case MetaActionType::BMPSCALE:
494 0 : aActionBounds = Rectangle( static_cast<const MetaBmpScaleAction&>(rAct).GetPoint(),
495 0 : static_cast<const MetaBmpScaleAction&>(rAct).GetSize() );
496 0 : break;
497 :
498 : case MetaActionType::BMPSCALEPART:
499 0 : aActionBounds = Rectangle( static_cast<const MetaBmpScalePartAction&>(rAct).GetDestPoint(),
500 0 : static_cast<const MetaBmpScalePartAction&>(rAct).GetDestSize() );
501 0 : break;
502 :
503 : case MetaActionType::BMPEX:
504 0 : aActionBounds = Rectangle( static_cast<const MetaBmpExAction&>(rAct).GetPoint(),
505 0 : rOut.PixelToLogic( static_cast<const MetaBmpExAction&>(rAct).GetBitmapEx().GetSizePixel() ) );
506 0 : break;
507 :
508 : case MetaActionType::BMPEXSCALE:
509 0 : aActionBounds = Rectangle( static_cast<const MetaBmpExScaleAction&>(rAct).GetPoint(),
510 0 : static_cast<const MetaBmpExScaleAction&>(rAct).GetSize() );
511 0 : break;
512 :
513 : case MetaActionType::BMPEXSCALEPART:
514 0 : aActionBounds = Rectangle( static_cast<const MetaBmpExScalePartAction&>(rAct).GetDestPoint(),
515 0 : static_cast<const MetaBmpExScalePartAction&>(rAct).GetDestSize() );
516 0 : break;
517 :
518 : case MetaActionType::MASK:
519 0 : aActionBounds = Rectangle( static_cast<const MetaMaskAction&>(rAct).GetPoint(),
520 0 : rOut.PixelToLogic( static_cast<const MetaMaskAction&>(rAct).GetBitmap().GetSizePixel() ) );
521 0 : break;
522 :
523 : case MetaActionType::MASKSCALE:
524 0 : aActionBounds = Rectangle( static_cast<const MetaMaskScaleAction&>(rAct).GetPoint(),
525 0 : static_cast<const MetaMaskScaleAction&>(rAct).GetSize() );
526 0 : break;
527 :
528 : case MetaActionType::MASKSCALEPART:
529 0 : aActionBounds = Rectangle( static_cast<const MetaMaskScalePartAction&>(rAct).GetDestPoint(),
530 0 : static_cast<const MetaMaskScalePartAction&>(rAct).GetDestSize() );
531 0 : break;
532 :
533 : case MetaActionType::GRADIENT:
534 0 : aActionBounds = static_cast<const MetaGradientAction&>(rAct).GetRect();
535 0 : break;
536 :
537 : case MetaActionType::GRADIENTEX:
538 0 : aActionBounds = static_cast<const MetaGradientExAction&>(rAct).GetPolyPolygon().GetBoundRect();
539 0 : break;
540 :
541 : case MetaActionType::HATCH:
542 0 : aActionBounds = static_cast<const MetaHatchAction&>(rAct).GetPolyPolygon().GetBoundRect();
543 0 : break;
544 :
545 : case MetaActionType::WALLPAPER:
546 0 : aActionBounds = static_cast<const MetaWallpaperAction&>(rAct).GetRect();
547 0 : break;
548 :
549 : case MetaActionType::Transparent:
550 0 : aActionBounds = static_cast<const MetaTransparentAction&>(rAct).GetPolyPolygon().GetBoundRect();
551 0 : break;
552 :
553 : case MetaActionType::FLOATTRANSPARENT:
554 0 : aActionBounds = Rectangle( static_cast<const MetaFloatTransparentAction&>(rAct).GetPoint(),
555 0 : static_cast<const MetaFloatTransparentAction&>(rAct).GetSize() );
556 0 : break;
557 :
558 : case MetaActionType::EPS:
559 0 : aActionBounds = Rectangle( static_cast<const MetaEPSAction&>(rAct).GetPoint(),
560 0 : static_cast<const MetaEPSAction&>(rAct).GetSize() );
561 0 : break;
562 :
563 : case MetaActionType::TEXT:
564 : {
565 0 : const MetaTextAction& rTextAct = static_cast<const MetaTextAction&>(rAct);
566 0 : const OUString aString( rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()) );
567 :
568 0 : if (!aString.isEmpty())
569 : {
570 0 : const Point aPtLog( rTextAct.GetPoint() );
571 :
572 : // #105987# Use API method instead of Impl* methods
573 : // #107490# Set base parameter equal to index parameter
574 0 : rOut.GetTextBoundRect( aActionBounds, rTextAct.GetText(), rTextAct.GetIndex(),
575 0 : rTextAct.GetIndex(), rTextAct.GetLen() );
576 0 : aActionBounds.Move( aPtLog.X(), aPtLog.Y() );
577 0 : }
578 : }
579 0 : break;
580 :
581 : case MetaActionType::TEXTARRAY:
582 : {
583 0 : const MetaTextArrayAction& rTextAct = static_cast<const MetaTextArrayAction&>(rAct);
584 0 : const OUString aString( rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()) );
585 :
586 0 : if( !aString.isEmpty() )
587 : {
588 : // #105987# ImplLayout takes everything in logical coordinates
589 0 : SalLayout* pSalLayout = rOut.ImplLayout( rTextAct.GetText(), rTextAct.GetIndex(),
590 0 : rTextAct.GetLen(), rTextAct.GetPoint(),
591 0 : 0, rTextAct.GetDXArray() );
592 0 : if( pSalLayout )
593 : {
594 0 : Rectangle aBoundRect( const_cast<OutputDevice&>(rOut).ImplGetTextBoundRect( *pSalLayout ) );
595 0 : aActionBounds = rOut.PixelToLogic( aBoundRect );
596 0 : pSalLayout->Release();
597 : }
598 0 : }
599 : }
600 0 : break;
601 :
602 : case MetaActionType::TEXTRECT:
603 0 : aActionBounds = static_cast<const MetaTextRectAction&>(rAct).GetRect();
604 0 : break;
605 :
606 : case MetaActionType::STRETCHTEXT:
607 : {
608 0 : const MetaStretchTextAction& rTextAct = static_cast<const MetaStretchTextAction&>(rAct);
609 0 : const OUString aString( rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()) );
610 :
611 : // #i16195# Literate copy from TextArray action, the
612 : // semantics for the ImplLayout call are copied from the
613 : // OutDev::DrawStretchText() code. Unfortunately, also in
614 : // this case, public outdev methods such as GetTextWidth()
615 : // don't provide enough info.
616 0 : if( !aString.isEmpty() )
617 : {
618 : // #105987# ImplLayout takes everything in logical coordinates
619 0 : SalLayout* pSalLayout = rOut.ImplLayout( rTextAct.GetText(), rTextAct.GetIndex(),
620 0 : rTextAct.GetLen(), rTextAct.GetPoint(),
621 0 : rTextAct.GetWidth() );
622 0 : if( pSalLayout )
623 : {
624 0 : Rectangle aBoundRect( const_cast<OutputDevice&>(rOut).ImplGetTextBoundRect( *pSalLayout ) );
625 0 : aActionBounds = rOut.PixelToLogic( aBoundRect );
626 0 : pSalLayout->Release();
627 : }
628 0 : }
629 : }
630 0 : break;
631 :
632 : case MetaActionType::TEXTLINE:
633 : OSL_FAIL("MetaActionType::TEXTLINE not supported");
634 0 : break;
635 :
636 : default:
637 0 : break;
638 : }
639 :
640 0 : if( !aActionBounds.IsEmpty() )
641 : {
642 : // fdo#40421 limit current action's output to clipped area
643 0 : if( rOut.IsClipRegion() )
644 : return rOut.LogicToPixel(
645 0 : rOut.GetClipRegion().GetBoundRect().Intersection( aActionBounds ) );
646 : else
647 0 : return rOut.LogicToPixel( aActionBounds );
648 : }
649 : else
650 0 : return Rectangle();
651 : }
652 :
653 : } // end anon namespace
654 :
655 0 : bool OutputDevice::RemoveTransparenciesFromMetaFile( const GDIMetaFile& rInMtf, GDIMetaFile& rOutMtf,
656 : long nMaxBmpDPIX, long nMaxBmpDPIY,
657 : bool bReduceTransparency, bool bTransparencyAutoMode,
658 : bool bDownsampleBitmaps,
659 : const Color& rBackground
660 : )
661 : {
662 : MetaAction* pCurrAct;
663 0 : bool bTransparent( false );
664 :
665 0 : rOutMtf.Clear();
666 :
667 0 : if( ! bReduceTransparency || bTransparencyAutoMode )
668 : {
669 : // watch for transparent drawing actions
670 0 : for( pCurrAct = ( (GDIMetaFile&) rInMtf ).FirstAction();
671 0 : pCurrAct && !bTransparent;
672 0 : pCurrAct = ( (GDIMetaFile&) rInMtf ).NextAction() )
673 : {
674 : // #i10613# determine if the action is transparency capable
675 :
676 : // #107169# Also examine metafiles with masked bitmaps in
677 : // detail. Further down, this is optimized in such a way
678 : // that there's no unnecessary painting of masked bitmaps
679 : // (which are _always_ subdivided into rectangular regions
680 : // of uniform opacity): if a masked bitmap is printed over
681 : // empty background, we convert to a plain bitmap with
682 : // white background.
683 0 : if( IsTransparentAction( *pCurrAct ) )
684 : {
685 0 : bTransparent = true;
686 : }
687 : }
688 : }
689 :
690 : // #i10613# Determine set of connected components containing transparent objects. These are
691 : // then processed as bitmaps, the original actions are removed from the metafile.
692 0 : if( !bTransparent )
693 : {
694 : // nothing transparent -> just copy
695 0 : rOutMtf = rInMtf;
696 : }
697 : else
698 : {
699 : // #i10613#
700 : // This works as follows: we want a number of distinct sets of
701 : // connected components, where each set contains metafile
702 : // actions that are intersecting (note: there are possibly
703 : // more actions contained as are directly intersecting,
704 : // because we can only produce rectangular bitmaps later
705 : // on. Thus, each set of connected components is the smallest
706 : // enclosing, axis-aligned rectangle that completely bounds a
707 : // number of intersecting metafile actions, plus any action
708 : // that would otherwise be cut in two). Therefore, we
709 : // iteratively add metafile actions from the original metafile
710 : // to this connected components list (aCCList), by checking
711 : // each element's bounding box against intersection with the
712 : // metaaction at hand.
713 : // All those intersecting elements are removed from aCCList
714 : // and collected in a temporary list (aCCMergeList). After all
715 : // elements have been checked, the aCCMergeList elements are
716 : // merged with the metaaction at hand into one resulting
717 : // connected component, with one big bounding box, and
718 : // inserted into aCCList again.
719 : // The time complexity of this algorithm is O(n^3), where n is
720 : // the number of metafile actions, and it finds all distinct
721 : // regions of rectangle-bounded connected components. This
722 : // algorithm was designed by AF.
723 :
724 : // STAGE 1: Detect background
725 :
726 : // Receives uniform background content, and is _not_ merged
727 : // nor checked for intersection against other aCCList elements
728 0 : ConnectedComponents aBackgroundComponent;
729 :
730 : // create an OutputDevice to record mapmode changes and the like
731 0 : ScopedVclPtrInstance< VirtualDevice > aMapModeVDev;
732 0 : aMapModeVDev->mnDPIX = mnDPIX;
733 0 : aMapModeVDev->mnDPIY = mnDPIY;
734 0 : aMapModeVDev->EnableOutput(false);
735 :
736 : int nLastBgAction, nActionNum;
737 :
738 : // weed out page-filling background objects (if they are
739 : // uniformly coloured). Keeping them outside the other
740 : // connected components often prevents whole-page bitmap
741 : // generation.
742 0 : bool bStillBackground=true; // true until first non-bg action
743 0 : nActionNum=0; nLastBgAction=-1;
744 0 : pCurrAct=const_cast<GDIMetaFile&>(rInMtf).FirstAction();
745 0 : if( rBackground != Color( COL_TRANSPARENT ) )
746 : {
747 0 : aBackgroundComponent.aBgColor = rBackground;
748 0 : if( meOutDevType == OUTDEV_PRINTER )
749 : {
750 0 : Printer* pThis = dynamic_cast<Printer*>(this);
751 0 : Point aPageOffset = pThis->GetPageOffsetPixel();
752 0 : aPageOffset = Point( 0, 0 ) - aPageOffset;
753 0 : Size aSize = pThis->GetPaperSizePixel();
754 0 : aBackgroundComponent.aBounds = Rectangle( aPageOffset, aSize );
755 : }
756 : else
757 0 : aBackgroundComponent.aBounds = Rectangle( Point( 0, 0 ), GetOutputSizePixel() );
758 : }
759 0 : while( pCurrAct && bStillBackground )
760 : {
761 0 : switch( pCurrAct->GetType() )
762 : {
763 : case MetaActionType::RECT:
764 : {
765 0 : if( !checkRect(
766 : aBackgroundComponent.aBounds,
767 : aBackgroundComponent.aBgColor,
768 0 : static_cast<const MetaRectAction*>(pCurrAct)->GetRect(),
769 0 : *aMapModeVDev.get()) )
770 0 : bStillBackground=false; // incomplete occlusion of background
771 : else
772 0 : nLastBgAction=nActionNum; // this _is_ background
773 0 : break;
774 : }
775 : case MetaActionType::POLYGON:
776 : {
777 : const Polygon aPoly(
778 0 : static_cast<const MetaPolygonAction*>(pCurrAct)->GetPolygon());
779 0 : if( !basegfx::tools::isRectangle(
780 0 : aPoly.getB2DPolygon()) ||
781 : !checkRect(
782 : aBackgroundComponent.aBounds,
783 : aBackgroundComponent.aBgColor,
784 : aPoly.GetBoundRect(),
785 0 : *aMapModeVDev.get()) )
786 0 : bStillBackground=false; // incomplete occlusion of background
787 : else
788 0 : nLastBgAction=nActionNum; // this _is_ background
789 0 : break;
790 : }
791 : case MetaActionType::POLYPOLYGON:
792 : {
793 : const tools::PolyPolygon aPoly(
794 0 : static_cast<const MetaPolyPolygonAction*>(pCurrAct)->GetPolyPolygon());
795 0 : if( aPoly.Count() != 1 ||
796 : !basegfx::tools::isRectangle(
797 0 : aPoly[0].getB2DPolygon()) ||
798 : !checkRect(
799 : aBackgroundComponent.aBounds,
800 : aBackgroundComponent.aBgColor,
801 : aPoly.GetBoundRect(),
802 0 : *aMapModeVDev.get()) )
803 0 : bStillBackground=false; // incomplete occlusion of background
804 : else
805 0 : nLastBgAction=nActionNum; // this _is_ background
806 0 : break;
807 : }
808 : case MetaActionType::WALLPAPER:
809 : {
810 0 : if( !checkRect(
811 : aBackgroundComponent.aBounds,
812 : aBackgroundComponent.aBgColor,
813 0 : static_cast<const MetaWallpaperAction*>(pCurrAct)->GetRect(),
814 0 : *aMapModeVDev.get()) )
815 0 : bStillBackground=false; // incomplete occlusion of background
816 : else
817 0 : nLastBgAction=nActionNum; // this _is_ background
818 0 : break;
819 : }
820 : default:
821 : {
822 0 : if( ImplIsNotTransparent( *pCurrAct,
823 0 : *aMapModeVDev.get() ) )
824 0 : bStillBackground=false; // non-transparent action, possibly
825 : // not uniform
826 : else
827 : // extend current bounds (next uniform action
828 : // needs to fully cover this area)
829 : aBackgroundComponent.aBounds.Union(
830 0 : ImplCalcActionBounds(*pCurrAct, *aMapModeVDev.get()) );
831 0 : break;
832 : }
833 : }
834 :
835 : // execute action to get correct MapModes etc.
836 0 : pCurrAct->Execute( aMapModeVDev.get() );
837 :
838 0 : pCurrAct=const_cast<GDIMetaFile&>(rInMtf).NextAction();
839 0 : ++nActionNum;
840 : }
841 :
842 : // clean up aMapModeVDev
843 0 : sal_uInt32 nCount = aMapModeVDev->GetGCStackDepth();
844 0 : while( nCount-- )
845 0 : aMapModeVDev->Pop();
846 :
847 0 : ConnectedComponentsList aCCList; // list containing distinct sets of connected components as elements.
848 :
849 : // fast-forward until one after the last background action
850 : // (need to reconstruct map mode vdev state)
851 0 : nActionNum=0;
852 0 : pCurrAct=const_cast<GDIMetaFile&>(rInMtf).FirstAction();
853 0 : while( pCurrAct && nActionNum<=nLastBgAction )
854 : {
855 : // up to and including last ink-generating background
856 : // action go to background component
857 : aBackgroundComponent.aComponentList.push_back(
858 : ::std::make_pair(
859 0 : pCurrAct, nActionNum) );
860 :
861 : // execute action to get correct MapModes etc.
862 0 : pCurrAct->Execute( aMapModeVDev.get() );
863 0 : pCurrAct=const_cast<GDIMetaFile&>(rInMtf).NextAction();
864 0 : ++nActionNum;
865 : }
866 :
867 : // STAGE 2: Generate connected components list
868 :
869 : // iterate over all actions (start where background action
870 : // search left off)
871 0 : for( ;
872 : pCurrAct;
873 0 : pCurrAct=const_cast<GDIMetaFile&>(rInMtf).NextAction(), ++nActionNum )
874 : {
875 : // execute action to get correct MapModes etc.
876 0 : pCurrAct->Execute( aMapModeVDev.get() );
877 :
878 : // cache bounds of current action
879 0 : const Rectangle aBBCurrAct( ImplCalcActionBounds(*pCurrAct, *aMapModeVDev.get()) );
880 :
881 : // accumulate collected bounds here, initialize with current action
882 0 : Rectangle aTotalBounds( aBBCurrAct ); // thus,
883 : // aTotalComponents.aBounds
884 : // is
885 : // empty
886 : // for
887 : // non-output-generating
888 : // actions
889 0 : bool bTreatSpecial( false );
890 0 : ConnectedComponents aTotalComponents;
891 :
892 : // STAGE 2.1: Search for intersecting cc entries
893 :
894 : // if aBBCurrAct is empty, it will intersect with no
895 : // aCCList member. Thus, we can save the check.
896 : // Furthermore, this ensures that non-output-generating
897 : // actions get their own aCCList entry, which is necessary
898 : // when copying them to the output metafile (see stage 4
899 : // below).
900 :
901 : // #107169# Wholly transparent objects need
902 : // not be considered for connected components,
903 : // too. Just put each of them into a separate
904 : // component.
905 0 : aTotalComponents.bIsFullyTransparent = !ImplIsNotTransparent(*pCurrAct, *aMapModeVDev.get());
906 :
907 0 : if( !aBBCurrAct.IsEmpty() &&
908 0 : !aTotalComponents.bIsFullyTransparent )
909 : {
910 0 : if( !aBackgroundComponent.aComponentList.empty() &&
911 0 : !aBackgroundComponent.aBounds.IsInside(aTotalBounds) )
912 : {
913 : // it seems the background is not large enough. to
914 : // be on the safe side, combine with this component.
915 0 : aTotalBounds.Union( aBackgroundComponent.aBounds );
916 :
917 : // extract all aCurr actions to aTotalComponents
918 : aTotalComponents.aComponentList.splice( aTotalComponents.aComponentList.end(),
919 0 : aBackgroundComponent.aComponentList );
920 :
921 0 : if( aBackgroundComponent.bIsSpecial )
922 0 : bTreatSpecial = true;
923 : }
924 :
925 0 : ConnectedComponentsList::iterator aCurrCC;
926 0 : const ConnectedComponentsList::iterator aLastCC( aCCList.end() );
927 : bool bSomeComponentsChanged;
928 :
929 : // now, this is unfortunate: since changing anyone of
930 : // the aCCList elements (e.g. by merging or addition
931 : // of an action) might generate new intersection with
932 : // other aCCList elements, have to repeat the whole
933 : // element scanning, until nothing changes anymore.
934 : // Thus, this loop here makes us O(n^3) in the worst
935 : // case.
936 0 : do
937 : {
938 : // only loop here if 'intersects' branch below was hit
939 0 : bSomeComponentsChanged = false;
940 :
941 : // iterate over all current members of aCCList
942 0 : for( aCurrCC=aCCList.begin(); aCurrCC != aLastCC; )
943 : {
944 : // first check if current element's bounds are
945 : // empty. This ensures that empty actions are not
946 : // merged into one component, as a matter of fact,
947 : // they have no position.
948 :
949 : // #107169# Wholly transparent objects need
950 : // not be considered for connected components,
951 : // too. Just put each of them into a separate
952 : // component.
953 0 : if( !aCurrCC->aBounds.IsEmpty() &&
954 0 : !aCurrCC->bIsFullyTransparent &&
955 0 : aCurrCC->aBounds.IsOver( aTotalBounds ) )
956 : {
957 : // union the intersecting aCCList element into aTotalComponents
958 :
959 : // calc union bounding box
960 0 : aTotalBounds.Union( aCurrCC->aBounds );
961 :
962 : // extract all aCurr actions to aTotalComponents
963 : aTotalComponents.aComponentList.splice( aTotalComponents.aComponentList.end(),
964 0 : aCurrCC->aComponentList );
965 :
966 0 : if( aCurrCC->bIsSpecial )
967 0 : bTreatSpecial = true;
968 :
969 : // remove and delete aCurrCC element from list (we've now merged its content)
970 0 : aCurrCC = aCCList.erase( aCurrCC );
971 :
972 : // at least one component changed, need to rescan everything
973 0 : bSomeComponentsChanged = true;
974 : }
975 : else
976 : {
977 0 : ++aCurrCC;
978 : }
979 : }
980 : }
981 : while( bSomeComponentsChanged );
982 : }
983 :
984 : // STAGE 2.2: Determine special state for cc element
985 :
986 : // now test whether the whole connected component must be
987 : // treated specially (i.e. rendered as a bitmap): if the
988 : // added action is the very first action, or all actions
989 : // before it are completely transparent, the connected
990 : // component need not be treated specially, not even if
991 : // the added action contains transparency. This is because
992 : // painting of transparent objects on _white background_
993 : // works without alpha compositing (you just calculate the
994 : // color). Note that for the test "all objects before me
995 : // are transparent" no sorting is necessary, since the
996 : // added metaaction pCurrAct is always in the order the
997 : // metafile is painted. Generally, the order of the
998 : // metaactions in the ConnectedComponents are not
999 : // guaranteed to be the same as in the metafile.
1000 0 : if( bTreatSpecial )
1001 : {
1002 : // prev component(s) special -> this one, too
1003 0 : aTotalComponents.bIsSpecial = true;
1004 : }
1005 0 : else if( !IsTransparentAction( *pCurrAct ) )
1006 : {
1007 : // added action and none of prev components special ->
1008 : // this one normal, too
1009 0 : aTotalComponents.bIsSpecial = false;
1010 : }
1011 : else
1012 : {
1013 : // added action is special and none of prev components
1014 : // special -> do the detailed tests
1015 :
1016 : // can the action handle transparency correctly
1017 : // (i.e. when painted on white background, does the
1018 : // action still look correct)?
1019 0 : if( !DoesActionHandleTransparency( *pCurrAct ) )
1020 : {
1021 : // no, action cannot handle its transparency on
1022 : // a printer device, render to bitmap
1023 0 : aTotalComponents.bIsSpecial = true;
1024 : }
1025 : else
1026 : {
1027 : // yes, action can handle its transparency, so
1028 : // check whether we're on white background
1029 0 : if( aTotalComponents.aComponentList.empty() )
1030 : {
1031 : // nothing between pCurrAct and page
1032 : // background -> don't be special
1033 0 : aTotalComponents.bIsSpecial = false;
1034 : }
1035 : else
1036 : {
1037 : // #107169# Fixes abnove now ensure that _no_
1038 : // object in the list is fully transparent. Thus,
1039 : // if the component list is not empty above, we
1040 : // must assume that we have to treat this
1041 : // component special.
1042 :
1043 : // there are non-transparent objects between
1044 : // pCurrAct and the empty sheet of paper -> be
1045 : // special, then
1046 0 : aTotalComponents.bIsSpecial = true;
1047 : }
1048 : }
1049 : }
1050 :
1051 : // STAGE 2.3: Add newly generated CC list element
1052 :
1053 : // set new bounds and add action to list
1054 0 : aTotalComponents.aBounds = aTotalBounds;
1055 : aTotalComponents.aComponentList.push_back(
1056 : ::std::make_pair(
1057 0 : pCurrAct, nActionNum) );
1058 :
1059 : // add aTotalComponents as a new entry to aCCList
1060 0 : aCCList.push_back( aTotalComponents );
1061 :
1062 : DBG_ASSERT( !aTotalComponents.aComponentList.empty(),
1063 : "Printer::GetPreparedMetaFile empty component" );
1064 : DBG_ASSERT( !aTotalComponents.aBounds.IsEmpty() ||
1065 : (aTotalComponents.aBounds.IsEmpty() && aTotalComponents.aComponentList.size() == 1),
1066 : "Printer::GetPreparedMetaFile non-output generating actions must be solitary");
1067 : DBG_ASSERT( !aTotalComponents.bIsFullyTransparent ||
1068 : (aTotalComponents.bIsFullyTransparent && aTotalComponents.aComponentList.size() == 1),
1069 : "Printer::GetPreparedMetaFile fully transparent actions must be solitary");
1070 0 : }
1071 :
1072 : // well now, we've got the list of disjunct connected
1073 : // components. Now we've got to create a map, which contains
1074 : // the corresponding aCCList element for every
1075 : // metaaction. Later on, we always process the complete
1076 : // metafile for each bitmap to be generated, but switch on
1077 : // output only for actions contained in the then current
1078 : // aCCList element. This ensures correct mapmode and attribute
1079 : // settings for all cases.
1080 :
1081 : // maps mtf actions to CC list entries
1082 0 : ::std::vector< const ConnectedComponents* > aCCList_MemberMap( rInMtf.GetActionSize() );
1083 :
1084 : // iterate over all aCCList members and their contained metaactions
1085 0 : ConnectedComponentsList::iterator aCurr( aCCList.begin() );
1086 0 : const ConnectedComponentsList::iterator aLast( aCCList.end() );
1087 0 : for( ; aCurr != aLast; ++aCurr )
1088 : {
1089 0 : ComponentList::iterator aCurrentAction( aCurr->aComponentList.begin() );
1090 0 : const ComponentList::iterator aLastAction( aCurr->aComponentList.end() );
1091 0 : for( ; aCurrentAction != aLastAction; ++aCurrentAction )
1092 : {
1093 : // set pointer to aCCList element for corresponding index
1094 0 : aCCList_MemberMap[ aCurrentAction->second ] = &(*aCurr);
1095 : }
1096 : }
1097 :
1098 : // STAGE 3.1: Output background mtf actions (if there are any)
1099 :
1100 0 : ComponentList::iterator aCurrAct( aBackgroundComponent.aComponentList.begin() );
1101 0 : const ComponentList::iterator aLastAct( aBackgroundComponent.aComponentList.end() );
1102 0 : for( ; aCurrAct != aLastAct; ++aCurrAct )
1103 : {
1104 : // simply add this action (above, we inserted the actions
1105 : // starting at index 0 up to and including nLastBgAction)
1106 0 : rOutMtf.AddAction( ( aCurrAct->first->Duplicate(), aCurrAct->first ) );
1107 : }
1108 :
1109 : // STAGE 3.2: Generate banded bitmaps for special regions
1110 :
1111 0 : Point aPageOffset;
1112 0 : Size aTmpSize( GetOutputSizePixel() );
1113 0 : if( mpPDFWriter )
1114 : {
1115 0 : aTmpSize = mpPDFWriter->getCurPageSize();
1116 0 : aTmpSize = LogicToPixel( aTmpSize, MapMode( MAP_POINT ) );
1117 :
1118 : // also add error code to PDFWriter
1119 0 : mpPDFWriter->insertError( vcl::PDFWriter::Warning_Transparency_Converted );
1120 : }
1121 0 : else if( meOutDevType == OUTDEV_PRINTER )
1122 : {
1123 0 : Printer* pThis = dynamic_cast<Printer*>(this);
1124 0 : aPageOffset = pThis->GetPageOffsetPixel();
1125 0 : aPageOffset = Point( 0, 0 ) - aPageOffset;
1126 0 : aTmpSize = pThis->GetPaperSizePixel();
1127 : }
1128 0 : const Rectangle aOutputRect( aPageOffset, aTmpSize );
1129 0 : bool bTiling = dynamic_cast<Printer*>(this) != NULL;
1130 :
1131 : // iterate over all aCCList members and generate bitmaps for the special ones
1132 0 : for( aCurr = aCCList.begin(); aCurr != aLast; ++aCurr )
1133 : {
1134 0 : if( aCurr->bIsSpecial )
1135 : {
1136 0 : Rectangle aBoundRect( aCurr->aBounds );
1137 0 : aBoundRect.Intersection( aOutputRect );
1138 :
1139 0 : const double fBmpArea( (double) aBoundRect.GetWidth() * aBoundRect.GetHeight() );
1140 0 : const double fOutArea( (double) aOutputRect.GetWidth() * aOutputRect.GetHeight() );
1141 :
1142 : // check if output doesn't exceed given size
1143 0 : if( bReduceTransparency && bTransparencyAutoMode && ( fBmpArea > ( 0.25 * fOutArea ) ) )
1144 : {
1145 : // output normally. Therefore, we simply clear the
1146 : // special attribute, as everything non-special is
1147 : // copied to rOutMtf further below.
1148 0 : aCurr->bIsSpecial = false;
1149 : }
1150 : else
1151 : {
1152 : // create new bitmap action first
1153 0 : if( aBoundRect.GetWidth() && aBoundRect.GetHeight() )
1154 : {
1155 0 : Point aDstPtPix( aBoundRect.TopLeft() );
1156 0 : Size aDstSzPix;
1157 :
1158 0 : ScopedVclPtrInstance<VirtualDevice> aMapVDev; // here, we record only mapmode information
1159 0 : aMapVDev->EnableOutput(false);
1160 :
1161 0 : ScopedVclPtrInstance<VirtualDevice> aPaintVDev; // into this one, we render.
1162 0 : aPaintVDev->SetBackground( aBackgroundComponent.aBgColor );
1163 :
1164 0 : rOutMtf.AddAction( new MetaPushAction( PushFlags::MAPMODE ) );
1165 0 : rOutMtf.AddAction( new MetaMapModeAction() );
1166 :
1167 0 : aPaintVDev->SetDrawMode( GetDrawMode() );
1168 :
1169 0 : while( aDstPtPix.Y() <= aBoundRect.Bottom() )
1170 : {
1171 0 : aDstPtPix.X() = aBoundRect.Left();
1172 0 : aDstSzPix = bTiling ? Size( MAX_TILE_WIDTH, MAX_TILE_HEIGHT ) : aBoundRect.GetSize();
1173 :
1174 0 : if( ( aDstPtPix.Y() + aDstSzPix.Height() - 1L ) > aBoundRect.Bottom() )
1175 0 : aDstSzPix.Height() = aBoundRect.Bottom() - aDstPtPix.Y() + 1L;
1176 :
1177 0 : while( aDstPtPix.X() <= aBoundRect.Right() )
1178 : {
1179 0 : if( ( aDstPtPix.X() + aDstSzPix.Width() - 1L ) > aBoundRect.Right() )
1180 0 : aDstSzPix.Width() = aBoundRect.Right() - aDstPtPix.X() + 1L;
1181 :
1182 0 : if( !Rectangle( aDstPtPix, aDstSzPix ).Intersection( aBoundRect ).IsEmpty() &&
1183 0 : aPaintVDev->SetOutputSizePixel( aDstSzPix ) )
1184 : {
1185 0 : aPaintVDev->Push();
1186 0 : aMapVDev->Push();
1187 :
1188 0 : aMapVDev->mnDPIX = aPaintVDev->mnDPIX = mnDPIX;
1189 0 : aMapVDev->mnDPIY = aPaintVDev->mnDPIY = mnDPIY;
1190 :
1191 0 : aPaintVDev->EnableOutput(false);
1192 :
1193 : // iterate over all actions
1194 0 : for( pCurrAct=const_cast<GDIMetaFile&>(rInMtf).FirstAction(), nActionNum=0;
1195 : pCurrAct;
1196 0 : pCurrAct=const_cast<GDIMetaFile&>(rInMtf).NextAction(), ++nActionNum )
1197 : {
1198 : // enable output only for
1199 : // actions that are members of
1200 : // the current aCCList element
1201 : // (aCurr)
1202 0 : if( aCCList_MemberMap[nActionNum] == &(*aCurr) )
1203 0 : aPaintVDev->EnableOutput(true);
1204 :
1205 : // but process every action
1206 0 : const MetaActionType nType( pCurrAct->GetType() );
1207 :
1208 0 : if( MetaActionType::MAPMODE == nType )
1209 : {
1210 0 : pCurrAct->Execute( aMapVDev.get() );
1211 :
1212 0 : MapMode aMtfMap( aMapVDev->GetMapMode() );
1213 0 : const Point aNewOrg( aMapVDev->PixelToLogic( aDstPtPix ) );
1214 :
1215 0 : aMtfMap.SetOrigin( Point( -aNewOrg.X(), -aNewOrg.Y() ) );
1216 0 : aPaintVDev->SetMapMode( aMtfMap );
1217 : }
1218 0 : else if( ( MetaActionType::PUSH == nType ) || ( MetaActionType::POP ) == nType )
1219 : {
1220 0 : pCurrAct->Execute( aMapVDev.get() );
1221 0 : pCurrAct->Execute( aPaintVDev.get() );
1222 : }
1223 0 : else if( MetaActionType::GRADIENT == nType )
1224 : {
1225 0 : MetaGradientAction* pGradientAction = static_cast<MetaGradientAction*>(pCurrAct);
1226 0 : Printer* pPrinter = dynamic_cast< Printer* >(this);
1227 0 : if( pPrinter )
1228 0 : pPrinter->DrawGradientEx( aPaintVDev.get(), pGradientAction->GetRect(), pGradientAction->GetGradient() );
1229 : else
1230 0 : DrawGradient( pGradientAction->GetRect(), pGradientAction->GetGradient() );
1231 : }
1232 : else
1233 : {
1234 0 : pCurrAct->Execute( aPaintVDev.get() );
1235 : }
1236 :
1237 0 : if( !( nActionNum % 8 ) )
1238 0 : Application::Reschedule();
1239 : }
1240 :
1241 0 : const bool bOldMap = mbMap;
1242 0 : mbMap = aPaintVDev->mbMap = false;
1243 :
1244 0 : Bitmap aBandBmp( aPaintVDev->GetBitmap( Point(), aDstSzPix ) );
1245 :
1246 : // scale down bitmap, if requested
1247 0 : if( bDownsampleBitmaps )
1248 : {
1249 0 : aBandBmp = GetDownsampledBitmap( aDstSzPix,
1250 : Point(), aBandBmp.GetSizePixel(),
1251 0 : aBandBmp, nMaxBmpDPIX, nMaxBmpDPIY );
1252 : }
1253 :
1254 0 : rOutMtf.AddAction( new MetaCommentAction( "PRNSPOOL_TRANSPARENTBITMAP_BEGIN" ) );
1255 0 : rOutMtf.AddAction( new MetaBmpScaleAction( aDstPtPix, aDstSzPix, aBandBmp ) );
1256 0 : rOutMtf.AddAction( new MetaCommentAction( "PRNSPOOL_TRANSPARENTBITMAP_END" ) );
1257 :
1258 0 : aPaintVDev->mbMap = true;
1259 0 : mbMap = bOldMap;
1260 0 : aMapVDev->Pop();
1261 0 : aPaintVDev->Pop();
1262 : }
1263 :
1264 : // overlapping bands to avoid missing lines (e.g. PostScript)
1265 0 : aDstPtPix.X() += aDstSzPix.Width();
1266 : }
1267 :
1268 : // overlapping bands to avoid missing lines (e.g. PostScript)
1269 0 : aDstPtPix.Y() += aDstSzPix.Height();
1270 : }
1271 :
1272 0 : rOutMtf.AddAction( new MetaPopAction() );
1273 : }
1274 : }
1275 : }
1276 : }
1277 :
1278 : // clean up aMapModeVDev
1279 0 : nCount = aMapModeVDev->GetGCStackDepth();
1280 0 : while( nCount-- )
1281 0 : aMapModeVDev->Pop();
1282 :
1283 : // STAGE 4: Copy actions to output metafile
1284 :
1285 : // iterate over all actions and duplicate the ones not in a
1286 : // special aCCList member into rOutMtf
1287 0 : for( pCurrAct=const_cast<GDIMetaFile&>(rInMtf).FirstAction(), nActionNum=0;
1288 : pCurrAct;
1289 0 : pCurrAct=const_cast<GDIMetaFile&>(rInMtf).NextAction(), ++nActionNum )
1290 : {
1291 0 : const ConnectedComponents* pCurrAssociatedComponent = aCCList_MemberMap[nActionNum];
1292 :
1293 : // NOTE: This relies on the fact that map-mode or draw
1294 : // mode changing actions are solitary aCCList elements and
1295 : // have empty bounding boxes, see comment on stage 2.1
1296 : // above
1297 0 : if( pCurrAssociatedComponent &&
1298 0 : (pCurrAssociatedComponent->aBounds.IsEmpty() ||
1299 0 : !pCurrAssociatedComponent->bIsSpecial) )
1300 : {
1301 : // #107169# Treat transparent bitmaps special, if they
1302 : // are the first (or sole) action in their bounds
1303 : // list. Note that we previously ensured that no
1304 : // fully-transparent objects are before us here.
1305 0 : if( DoesActionHandleTransparency( *pCurrAct ) &&
1306 0 : pCurrAssociatedComponent->aComponentList.begin()->first == pCurrAct )
1307 : {
1308 : // convert actions, where masked-out parts are of
1309 : // given background color
1310 : ImplConvertTransparentAction(rOutMtf,
1311 : *pCurrAct,
1312 0 : *aMapModeVDev.get(),
1313 0 : aBackgroundComponent.aBgColor);
1314 : }
1315 : else
1316 : {
1317 : // simply add this action
1318 0 : rOutMtf.AddAction( ( pCurrAct->Duplicate(), pCurrAct ) );
1319 : }
1320 :
1321 0 : pCurrAct->Execute(aMapModeVDev.get());
1322 : }
1323 : }
1324 :
1325 0 : rOutMtf.SetPrefMapMode( rInMtf.GetPrefMapMode() );
1326 0 : rOutMtf.SetPrefSize( rInMtf.GetPrefSize() );
1327 :
1328 : #if OSL_DEBUG_LEVEL > 1
1329 : // iterate over all aCCList members and generate rectangles for the bounding boxes
1330 : rOutMtf.AddAction( new MetaFillColorAction( COL_WHITE, false ) );
1331 : for( aCurr = aCCList.begin(); aCurr != aLast; ++aCurr )
1332 : {
1333 : if( aCurr->bIsSpecial )
1334 : rOutMtf.AddAction( new MetaLineColorAction( COL_RED, true) );
1335 : else
1336 : rOutMtf.AddAction( new MetaLineColorAction( COL_BLUE, true) );
1337 :
1338 : rOutMtf.AddAction( new MetaRectAction( aMapModeVDev->PixelToLogic( aCurr->aBounds ) ) );
1339 : }
1340 : #endif
1341 : }
1342 0 : return bTransparent;
1343 : }
1344 :
1345 0 : void Printer::DrawGradientEx( OutputDevice* pOut, const Rectangle& rRect, const Gradient& rGradient )
1346 : {
1347 0 : const PrinterOptions& rPrinterOptions = GetPrinterOptions();
1348 :
1349 0 : if( rPrinterOptions.IsReduceGradients() )
1350 : {
1351 0 : if( PRINTER_GRADIENT_STRIPES == rPrinterOptions.GetReducedGradientMode() )
1352 : {
1353 0 : if( !rGradient.GetSteps() || ( rGradient.GetSteps() > rPrinterOptions.GetReducedGradientStepCount() ) )
1354 : {
1355 0 : Gradient aNewGradient( rGradient );
1356 :
1357 0 : aNewGradient.SetSteps( rPrinterOptions.GetReducedGradientStepCount() );
1358 0 : pOut->DrawGradient( rRect, aNewGradient );
1359 : }
1360 : else
1361 0 : pOut->DrawGradient( rRect, rGradient );
1362 : }
1363 : else
1364 : {
1365 0 : const Color& rStartColor = rGradient.GetStartColor();
1366 0 : const Color& rEndColor = rGradient.GetEndColor();
1367 0 : const long nR = ( ( (long) rStartColor.GetRed() * rGradient.GetStartIntensity() ) / 100L +
1368 0 : ( (long) rEndColor.GetRed() * rGradient.GetEndIntensity() ) / 100L ) >> 1;
1369 0 : const long nG = ( ( (long) rStartColor.GetGreen() * rGradient.GetStartIntensity() ) / 100L +
1370 0 : ( (long) rEndColor.GetGreen() * rGradient.GetEndIntensity() ) / 100L ) >> 1;
1371 0 : const long nB = ( ( (long) rStartColor.GetBlue() * rGradient.GetStartIntensity() ) / 100L +
1372 0 : ( (long) rEndColor.GetBlue() * rGradient.GetEndIntensity() ) / 100L ) >> 1;
1373 0 : const Color aColor( (sal_uInt8) nR, (sal_uInt8) nG, (sal_uInt8) nB );
1374 :
1375 0 : pOut->Push( PushFlags::LINECOLOR | PushFlags::FILLCOLOR );
1376 0 : pOut->SetLineColor( aColor );
1377 0 : pOut->SetFillColor( aColor );
1378 0 : pOut->DrawRect( rRect );
1379 0 : pOut->Pop();
1380 : }
1381 : }
1382 : else
1383 0 : pOut->DrawGradient( rRect, rGradient );
1384 801 : }
1385 :
1386 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
