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