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 <tools/debug.hxx>
28*b1cdbd2cSJim Jagielski #include <tools/line.hxx>
29*b1cdbd2cSJim Jagielski #include <tools/poly.hxx>
30*b1cdbd2cSJim Jagielski
31*b1cdbd2cSJim Jagielski #include <vcl/gradient.hxx>
32*b1cdbd2cSJim Jagielski #include <vcl/metaact.hxx>
33*b1cdbd2cSJim Jagielski #include <vcl/gdimtf.hxx>
34*b1cdbd2cSJim Jagielski #include <vcl/salbtype.hxx>
35*b1cdbd2cSJim Jagielski #include <vcl/hatch.hxx>
36*b1cdbd2cSJim Jagielski #include <vcl/window.hxx>
37*b1cdbd2cSJim Jagielski #include <vcl/virdev.hxx>
38*b1cdbd2cSJim Jagielski #include <vcl/outdev.hxx>
39*b1cdbd2cSJim Jagielski
40*b1cdbd2cSJim Jagielski #include "pdfwriter_impl.hxx"
41*b1cdbd2cSJim Jagielski
42*b1cdbd2cSJim Jagielski #include "window.h"
43*b1cdbd2cSJim Jagielski #include "salframe.hxx"
44*b1cdbd2cSJim Jagielski #include "salgdi.hxx"
45*b1cdbd2cSJim Jagielski #include "svdata.hxx"
46*b1cdbd2cSJim Jagielski #include "outdata.hxx"
47*b1cdbd2cSJim Jagielski
48*b1cdbd2cSJim Jagielski #include <basegfx/polygon/b2dpolygon.hxx>
49*b1cdbd2cSJim Jagielski #include <basegfx/polygon/b2dpolypolygon.hxx>
50*b1cdbd2cSJim Jagielski #include <basegfx/matrix/b2dhommatrix.hxx>
51*b1cdbd2cSJim Jagielski
52*b1cdbd2cSJim Jagielski // -----------
53*b1cdbd2cSJim Jagielski // - Defines -
54*b1cdbd2cSJim Jagielski // -----------
55*b1cdbd2cSJim Jagielski
56*b1cdbd2cSJim Jagielski #define HATCH_MAXPOINTS 1024
57*b1cdbd2cSJim Jagielski #define GRADIENT_DEFAULT_STEPCOUNT 0
58*b1cdbd2cSJim Jagielski
59*b1cdbd2cSJim Jagielski // ----------------
60*b1cdbd2cSJim Jagielski // - Cmp-Function -
61*b1cdbd2cSJim Jagielski // ----------------
62*b1cdbd2cSJim Jagielski
ImplHatchCmpFnc(const void * p1,const void * p2)63*b1cdbd2cSJim Jagielski extern "C" int __LOADONCALLAPI ImplHatchCmpFnc( const void* p1, const void* p2 )
64*b1cdbd2cSJim Jagielski {
65*b1cdbd2cSJim Jagielski const long nX1 = ( (Point*) p1 )->X();
66*b1cdbd2cSJim Jagielski const long nX2 = ( (Point*) p2 )->X();
67*b1cdbd2cSJim Jagielski const long nY1 = ( (Point*) p1 )->Y();
68*b1cdbd2cSJim Jagielski const long nY2 = ( (Point*) p2 )->Y();
69*b1cdbd2cSJim Jagielski
70*b1cdbd2cSJim Jagielski return ( nX1 > nX2 ? 1 : nX1 == nX2 ? nY1 > nY2 ? 1: nY1 == nY2 ? 0 : -1 : -1 );
71*b1cdbd2cSJim Jagielski }
72*b1cdbd2cSJim Jagielski
73*b1cdbd2cSJim Jagielski // =======================================================================
74*b1cdbd2cSJim Jagielski
75*b1cdbd2cSJim Jagielski DBG_NAMEEX( OutputDevice )
DBG_NAMEEX(Gradient)76*b1cdbd2cSJim Jagielski DBG_NAMEEX( Gradient )
77*b1cdbd2cSJim Jagielski
78*b1cdbd2cSJim Jagielski // =======================================================================
79*b1cdbd2cSJim Jagielski
80*b1cdbd2cSJim Jagielski void OutputDevice::ImplDrawPolygon( const Polygon& rPoly, const PolyPolygon* pClipPolyPoly )
81*b1cdbd2cSJim Jagielski {
82*b1cdbd2cSJim Jagielski if( pClipPolyPoly )
83*b1cdbd2cSJim Jagielski ImplDrawPolyPolygon( rPoly, pClipPolyPoly );
84*b1cdbd2cSJim Jagielski else
85*b1cdbd2cSJim Jagielski {
86*b1cdbd2cSJim Jagielski sal_uInt16 nPoints = rPoly.GetSize();
87*b1cdbd2cSJim Jagielski
88*b1cdbd2cSJim Jagielski if ( nPoints < 2 )
89*b1cdbd2cSJim Jagielski return;
90*b1cdbd2cSJim Jagielski
91*b1cdbd2cSJim Jagielski const SalPoint* pPtAry = (const SalPoint*)rPoly.GetConstPointAry();
92*b1cdbd2cSJim Jagielski mpGraphics->DrawPolygon( nPoints, pPtAry, this );
93*b1cdbd2cSJim Jagielski }
94*b1cdbd2cSJim Jagielski }
95*b1cdbd2cSJim Jagielski
96*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
97*b1cdbd2cSJim Jagielski
ImplDrawPolyPolygon(const PolyPolygon & rPolyPoly,const PolyPolygon * pClipPolyPoly)98*b1cdbd2cSJim Jagielski void OutputDevice::ImplDrawPolyPolygon( const PolyPolygon& rPolyPoly, const PolyPolygon* pClipPolyPoly )
99*b1cdbd2cSJim Jagielski {
100*b1cdbd2cSJim Jagielski PolyPolygon* pPolyPoly;
101*b1cdbd2cSJim Jagielski
102*b1cdbd2cSJim Jagielski if( pClipPolyPoly )
103*b1cdbd2cSJim Jagielski {
104*b1cdbd2cSJim Jagielski pPolyPoly = new PolyPolygon;
105*b1cdbd2cSJim Jagielski rPolyPoly.GetIntersection( *pClipPolyPoly, *pPolyPoly );
106*b1cdbd2cSJim Jagielski }
107*b1cdbd2cSJim Jagielski else
108*b1cdbd2cSJim Jagielski pPolyPoly = (PolyPolygon*) &rPolyPoly;
109*b1cdbd2cSJim Jagielski
110*b1cdbd2cSJim Jagielski if( pPolyPoly->Count() == 1 )
111*b1cdbd2cSJim Jagielski {
112*b1cdbd2cSJim Jagielski const Polygon rPoly = pPolyPoly->GetObject( 0 );
113*b1cdbd2cSJim Jagielski sal_uInt16 nSize = rPoly.GetSize();
114*b1cdbd2cSJim Jagielski
115*b1cdbd2cSJim Jagielski if( nSize >= 2 )
116*b1cdbd2cSJim Jagielski {
117*b1cdbd2cSJim Jagielski const SalPoint* pPtAry = (const SalPoint*)rPoly.GetConstPointAry();
118*b1cdbd2cSJim Jagielski mpGraphics->DrawPolygon( nSize, pPtAry, this );
119*b1cdbd2cSJim Jagielski }
120*b1cdbd2cSJim Jagielski }
121*b1cdbd2cSJim Jagielski else if( pPolyPoly->Count() )
122*b1cdbd2cSJim Jagielski {
123*b1cdbd2cSJim Jagielski sal_uInt16 nCount = pPolyPoly->Count();
124*b1cdbd2cSJim Jagielski sal_uInt32* pPointAry = new sal_uInt32[nCount];
125*b1cdbd2cSJim Jagielski PCONSTSALPOINT* pPointAryAry = new PCONSTSALPOINT[nCount];
126*b1cdbd2cSJim Jagielski sal_uInt16 i = 0;
127*b1cdbd2cSJim Jagielski do
128*b1cdbd2cSJim Jagielski {
129*b1cdbd2cSJim Jagielski const Polygon& rPoly = pPolyPoly->GetObject( i );
130*b1cdbd2cSJim Jagielski sal_uInt16 nSize = rPoly.GetSize();
131*b1cdbd2cSJim Jagielski if ( nSize )
132*b1cdbd2cSJim Jagielski {
133*b1cdbd2cSJim Jagielski pPointAry[i] = nSize;
134*b1cdbd2cSJim Jagielski pPointAryAry[i] = (PCONSTSALPOINT)rPoly.GetConstPointAry();
135*b1cdbd2cSJim Jagielski i++;
136*b1cdbd2cSJim Jagielski }
137*b1cdbd2cSJim Jagielski else
138*b1cdbd2cSJim Jagielski nCount--;
139*b1cdbd2cSJim Jagielski }
140*b1cdbd2cSJim Jagielski while( i < nCount );
141*b1cdbd2cSJim Jagielski
142*b1cdbd2cSJim Jagielski if( nCount == 1 )
143*b1cdbd2cSJim Jagielski mpGraphics->DrawPolygon( *pPointAry, *pPointAryAry, this );
144*b1cdbd2cSJim Jagielski else
145*b1cdbd2cSJim Jagielski mpGraphics->DrawPolyPolygon( nCount, pPointAry, pPointAryAry, this );
146*b1cdbd2cSJim Jagielski
147*b1cdbd2cSJim Jagielski delete[] pPointAry;
148*b1cdbd2cSJim Jagielski delete[] pPointAryAry;
149*b1cdbd2cSJim Jagielski }
150*b1cdbd2cSJim Jagielski
151*b1cdbd2cSJim Jagielski if( pClipPolyPoly )
152*b1cdbd2cSJim Jagielski delete pPolyPoly;
153*b1cdbd2cSJim Jagielski }
154*b1cdbd2cSJim Jagielski
155*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
156*b1cdbd2cSJim Jagielski
ImplGetGradientColorValue(long nValue)157*b1cdbd2cSJim Jagielski inline sal_uInt8 ImplGetGradientColorValue( long nValue )
158*b1cdbd2cSJim Jagielski {
159*b1cdbd2cSJim Jagielski if ( nValue < 0 )
160*b1cdbd2cSJim Jagielski return 0;
161*b1cdbd2cSJim Jagielski else if ( nValue > 0xFF )
162*b1cdbd2cSJim Jagielski return 0xFF;
163*b1cdbd2cSJim Jagielski else
164*b1cdbd2cSJim Jagielski return (sal_uInt8)nValue;
165*b1cdbd2cSJim Jagielski }
166*b1cdbd2cSJim Jagielski
167*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
168*b1cdbd2cSJim Jagielski
ImplDrawLinearGradient(const Rectangle & rRect,const Gradient & rGradient,sal_Bool bMtf,const PolyPolygon * pClipPolyPoly)169*b1cdbd2cSJim Jagielski void OutputDevice::ImplDrawLinearGradient( const Rectangle& rRect,
170*b1cdbd2cSJim Jagielski const Gradient& rGradient,
171*b1cdbd2cSJim Jagielski sal_Bool bMtf, const PolyPolygon* pClipPolyPoly )
172*b1cdbd2cSJim Jagielski {
173*b1cdbd2cSJim Jagielski // get BoundRect of rotated rectangle
174*b1cdbd2cSJim Jagielski Rectangle aRect = rRect;
175*b1cdbd2cSJim Jagielski sal_uInt16 nAngle = rGradient.GetAngle() % 3600;
176*b1cdbd2cSJim Jagielski double fAngle = nAngle * F_PI1800;
177*b1cdbd2cSJim Jagielski double fWidth = aRect.GetWidth();
178*b1cdbd2cSJim Jagielski double fHeight = aRect.GetHeight();
179*b1cdbd2cSJim Jagielski double fDX = fWidth * fabs( cos( fAngle ) ) +
180*b1cdbd2cSJim Jagielski fHeight * fabs( sin( fAngle ) );
181*b1cdbd2cSJim Jagielski double fDY = fHeight * fabs( cos( fAngle ) ) +
182*b1cdbd2cSJim Jagielski fWidth * fabs( sin( fAngle ) );
183*b1cdbd2cSJim Jagielski fDX = (fDX - fWidth) * 0.5 + 0.5;
184*b1cdbd2cSJim Jagielski fDY = (fDY - fHeight) * 0.5 + 0.5;
185*b1cdbd2cSJim Jagielski aRect.Left() -= (long)fDX;
186*b1cdbd2cSJim Jagielski aRect.Right() += (long)fDX;
187*b1cdbd2cSJim Jagielski aRect.Top() -= (long)fDY;
188*b1cdbd2cSJim Jagielski aRect.Bottom() += (long)fDY;
189*b1cdbd2cSJim Jagielski
190*b1cdbd2cSJim Jagielski sal_Bool bLinear = ( rGradient.GetStyle() == GRADIENT_LINEAR );
191*b1cdbd2cSJim Jagielski double fBorder = rGradient.GetBorder() * aRect.GetHeight() / 100.0;
192*b1cdbd2cSJim Jagielski Point aCenter = rRect.Center();
193*b1cdbd2cSJim Jagielski if ( !bLinear )
194*b1cdbd2cSJim Jagielski {
195*b1cdbd2cSJim Jagielski fBorder /= 2.0;
196*b1cdbd2cSJim Jagielski }
197*b1cdbd2cSJim Jagielski Rectangle aMirrorRect = aRect; // used in style axial
198*b1cdbd2cSJim Jagielski aMirrorRect.Top() = ( aRect.Top() + aRect.Bottom() ) / 2;
199*b1cdbd2cSJim Jagielski if ( !bLinear )
200*b1cdbd2cSJim Jagielski {
201*b1cdbd2cSJim Jagielski aRect.Bottom() = aMirrorRect.Top();
202*b1cdbd2cSJim Jagielski }
203*b1cdbd2cSJim Jagielski
204*b1cdbd2cSJim Jagielski // Intensitaeten von Start- und Endfarbe ggf. aendern
205*b1cdbd2cSJim Jagielski long nFactor;
206*b1cdbd2cSJim Jagielski Color aStartCol = rGradient.GetStartColor();
207*b1cdbd2cSJim Jagielski Color aEndCol = rGradient.GetEndColor();
208*b1cdbd2cSJim Jagielski long nStartRed = aStartCol.GetRed();
209*b1cdbd2cSJim Jagielski long nStartGreen = aStartCol.GetGreen();
210*b1cdbd2cSJim Jagielski long nStartBlue = aStartCol.GetBlue();
211*b1cdbd2cSJim Jagielski long nEndRed = aEndCol.GetRed();
212*b1cdbd2cSJim Jagielski long nEndGreen = aEndCol.GetGreen();
213*b1cdbd2cSJim Jagielski long nEndBlue = aEndCol.GetBlue();
214*b1cdbd2cSJim Jagielski nFactor = rGradient.GetStartIntensity();
215*b1cdbd2cSJim Jagielski nStartRed = (nStartRed * nFactor) / 100;
216*b1cdbd2cSJim Jagielski nStartGreen = (nStartGreen * nFactor) / 100;
217*b1cdbd2cSJim Jagielski nStartBlue = (nStartBlue * nFactor) / 100;
218*b1cdbd2cSJim Jagielski nFactor = rGradient.GetEndIntensity();
219*b1cdbd2cSJim Jagielski nEndRed = (nEndRed * nFactor) / 100;
220*b1cdbd2cSJim Jagielski nEndGreen = (nEndGreen * nFactor) / 100;
221*b1cdbd2cSJim Jagielski nEndBlue = (nEndBlue * nFactor) / 100;
222*b1cdbd2cSJim Jagielski
223*b1cdbd2cSJim Jagielski // gradient style axial has exchanged start and end colors
224*b1cdbd2cSJim Jagielski if ( !bLinear)
225*b1cdbd2cSJim Jagielski {
226*b1cdbd2cSJim Jagielski long nTempColor = nStartRed;
227*b1cdbd2cSJim Jagielski nStartRed = nEndRed;
228*b1cdbd2cSJim Jagielski nEndRed = nTempColor;
229*b1cdbd2cSJim Jagielski nTempColor = nStartGreen;
230*b1cdbd2cSJim Jagielski nStartGreen = nEndGreen;
231*b1cdbd2cSJim Jagielski nEndGreen = nTempColor;
232*b1cdbd2cSJim Jagielski nTempColor = nStartBlue;
233*b1cdbd2cSJim Jagielski nStartBlue = nEndBlue;
234*b1cdbd2cSJim Jagielski nEndBlue = nTempColor;
235*b1cdbd2cSJim Jagielski }
236*b1cdbd2cSJim Jagielski
237*b1cdbd2cSJim Jagielski sal_uInt8 nRed;
238*b1cdbd2cSJim Jagielski sal_uInt8 nGreen;
239*b1cdbd2cSJim Jagielski sal_uInt8 nBlue;
240*b1cdbd2cSJim Jagielski
241*b1cdbd2cSJim Jagielski // Create border
242*b1cdbd2cSJim Jagielski Rectangle aBorderRect = aRect;
243*b1cdbd2cSJim Jagielski Polygon aPoly( 4 );
244*b1cdbd2cSJim Jagielski if (fBorder > 0.0)
245*b1cdbd2cSJim Jagielski {
246*b1cdbd2cSJim Jagielski nRed = (sal_uInt8)nStartRed;
247*b1cdbd2cSJim Jagielski nGreen = (sal_uInt8)nStartGreen;
248*b1cdbd2cSJim Jagielski nBlue = (sal_uInt8)nStartBlue;
249*b1cdbd2cSJim Jagielski if ( bMtf )
250*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaFillColorAction( Color( nRed, nGreen, nBlue ), sal_True ) );
251*b1cdbd2cSJim Jagielski else
252*b1cdbd2cSJim Jagielski mpGraphics->SetFillColor( MAKE_SALCOLOR( nRed, nGreen, nBlue ) );
253*b1cdbd2cSJim Jagielski
254*b1cdbd2cSJim Jagielski aBorderRect.Bottom() = (long)( aBorderRect.Top() + fBorder );
255*b1cdbd2cSJim Jagielski aRect.Top() = aBorderRect.Bottom();
256*b1cdbd2cSJim Jagielski aPoly[0] = aBorderRect.TopLeft();
257*b1cdbd2cSJim Jagielski aPoly[1] = aBorderRect.TopRight();
258*b1cdbd2cSJim Jagielski aPoly[2] = aBorderRect.BottomRight();
259*b1cdbd2cSJim Jagielski aPoly[3] = aBorderRect.BottomLeft();
260*b1cdbd2cSJim Jagielski aPoly.Rotate( aCenter, nAngle );
261*b1cdbd2cSJim Jagielski if ( bMtf )
262*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPolygonAction( aPoly ) );
263*b1cdbd2cSJim Jagielski else
264*b1cdbd2cSJim Jagielski ImplDrawPolygon( aPoly, pClipPolyPoly );
265*b1cdbd2cSJim Jagielski if ( !bLinear)
266*b1cdbd2cSJim Jagielski {
267*b1cdbd2cSJim Jagielski aBorderRect = aMirrorRect;
268*b1cdbd2cSJim Jagielski aBorderRect.Top() = (long) ( aBorderRect.Bottom() - fBorder );
269*b1cdbd2cSJim Jagielski aMirrorRect.Bottom() = aBorderRect.Top();
270*b1cdbd2cSJim Jagielski aPoly[0] = aBorderRect.TopLeft();
271*b1cdbd2cSJim Jagielski aPoly[1] = aBorderRect.TopRight();
272*b1cdbd2cSJim Jagielski aPoly[2] = aBorderRect.BottomRight();
273*b1cdbd2cSJim Jagielski aPoly[3] = aBorderRect.BottomLeft();
274*b1cdbd2cSJim Jagielski aPoly.Rotate( aCenter, nAngle );
275*b1cdbd2cSJim Jagielski if ( bMtf )
276*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPolygonAction( aPoly ) );
277*b1cdbd2cSJim Jagielski else
278*b1cdbd2cSJim Jagielski ImplDrawPolygon( aPoly, pClipPolyPoly );
279*b1cdbd2cSJim Jagielski }
280*b1cdbd2cSJim Jagielski }
281*b1cdbd2cSJim Jagielski
282*b1cdbd2cSJim Jagielski // calculate step count
283*b1cdbd2cSJim Jagielski long nStepCount = rGradient.GetSteps();
284*b1cdbd2cSJim Jagielski // generate nStepCount, if not passed
285*b1cdbd2cSJim Jagielski long nMinRect = aRect.GetHeight();
286*b1cdbd2cSJim Jagielski if ( !nStepCount )
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski long nInc = 1;
289*b1cdbd2cSJim Jagielski if ( meOutDevType != OUTDEV_PRINTER && !bMtf )
290*b1cdbd2cSJim Jagielski {
291*b1cdbd2cSJim Jagielski nInc = (nMinRect < 50) ? 2 : 4;
292*b1cdbd2cSJim Jagielski }
293*b1cdbd2cSJim Jagielski else
294*b1cdbd2cSJim Jagielski {
295*b1cdbd2cSJim Jagielski // Use display-equivalent step size calculation
296*b1cdbd2cSJim Jagielski nInc = (nMinRect < 800) ? 10 : 20;
297*b1cdbd2cSJim Jagielski }
298*b1cdbd2cSJim Jagielski nStepCount = nMinRect / nInc;
299*b1cdbd2cSJim Jagielski }
300*b1cdbd2cSJim Jagielski
301*b1cdbd2cSJim Jagielski // minimal three steps and maximal as max color steps
302*b1cdbd2cSJim Jagielski long nAbsRedSteps = Abs( nEndRed - nStartRed );
303*b1cdbd2cSJim Jagielski long nAbsGreenSteps = Abs( nEndGreen - nStartGreen );
304*b1cdbd2cSJim Jagielski long nAbsBlueSteps = Abs( nEndBlue - nStartBlue );
305*b1cdbd2cSJim Jagielski long nMaxColorSteps = Max( nAbsRedSteps , nAbsGreenSteps );
306*b1cdbd2cSJim Jagielski nMaxColorSteps = Max( nMaxColorSteps, nAbsBlueSteps );
307*b1cdbd2cSJim Jagielski long nSteps = Min( nStepCount, nMaxColorSteps );
308*b1cdbd2cSJim Jagielski if ( nSteps < 3)
309*b1cdbd2cSJim Jagielski {
310*b1cdbd2cSJim Jagielski nSteps = 3;
311*b1cdbd2cSJim Jagielski }
312*b1cdbd2cSJim Jagielski
313*b1cdbd2cSJim Jagielski double fScanInc = ((double)aRect.GetHeight()) / (double) nSteps;
314*b1cdbd2cSJim Jagielski double fGradientLine = (double)aRect.Top();
315*b1cdbd2cSJim Jagielski double fMirrorGradientLine = (double) aMirrorRect.Bottom();
316*b1cdbd2cSJim Jagielski
317*b1cdbd2cSJim Jagielski double fAlpha = 0.0;
318*b1cdbd2cSJim Jagielski const double fStepsMinus1 = ((double)nSteps) - 1.0;
319*b1cdbd2cSJim Jagielski double fTempColor;
320*b1cdbd2cSJim Jagielski if ( !bLinear)
321*b1cdbd2cSJim Jagielski {
322*b1cdbd2cSJim Jagielski nSteps -= 1; // draw middle polygons as one polygon after loop to avoid gap
323*b1cdbd2cSJim Jagielski }
324*b1cdbd2cSJim Jagielski for ( long i = 0; i < nSteps; i++ )
325*b1cdbd2cSJim Jagielski {
326*b1cdbd2cSJim Jagielski // linear interpolation of color
327*b1cdbd2cSJim Jagielski fAlpha = ((double)i) / fStepsMinus1;
328*b1cdbd2cSJim Jagielski fTempColor = ((double)nStartRed) * (1.0-fAlpha) + ((double)nEndRed) * fAlpha;
329*b1cdbd2cSJim Jagielski nRed = ImplGetGradientColorValue((long)fTempColor);
330*b1cdbd2cSJim Jagielski fTempColor = ((double)nStartGreen) * (1.0-fAlpha) + ((double)nEndGreen) * fAlpha;
331*b1cdbd2cSJim Jagielski nGreen = ImplGetGradientColorValue((long)fTempColor);
332*b1cdbd2cSJim Jagielski fTempColor = ((double)nStartBlue) * (1.0-fAlpha) + ((double)nEndBlue) * fAlpha;
333*b1cdbd2cSJim Jagielski nBlue = ImplGetGradientColorValue((long)fTempColor);
334*b1cdbd2cSJim Jagielski if ( bMtf )
335*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaFillColorAction( Color( nRed, nGreen, nBlue ), sal_True ) );
336*b1cdbd2cSJim Jagielski else
337*b1cdbd2cSJim Jagielski mpGraphics->SetFillColor( MAKE_SALCOLOR( nRed, nGreen, nBlue ) );
338*b1cdbd2cSJim Jagielski
339*b1cdbd2cSJim Jagielski // Polygon for this color step
340*b1cdbd2cSJim Jagielski aRect.Top() = (long)( fGradientLine + ((double) i) * fScanInc );
341*b1cdbd2cSJim Jagielski aRect.Bottom() = (long)( fGradientLine + ( ((double) i) + 1.0 ) * fScanInc );
342*b1cdbd2cSJim Jagielski aPoly[0] = aRect.TopLeft();
343*b1cdbd2cSJim Jagielski aPoly[1] = aRect.TopRight();
344*b1cdbd2cSJim Jagielski aPoly[2] = aRect.BottomRight();
345*b1cdbd2cSJim Jagielski aPoly[3] = aRect.BottomLeft();
346*b1cdbd2cSJim Jagielski aPoly.Rotate( aCenter, nAngle );
347*b1cdbd2cSJim Jagielski if ( bMtf )
348*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPolygonAction( aPoly ) );
349*b1cdbd2cSJim Jagielski else
350*b1cdbd2cSJim Jagielski ImplDrawPolygon( aPoly, pClipPolyPoly );
351*b1cdbd2cSJim Jagielski if ( !bLinear )
352*b1cdbd2cSJim Jagielski {
353*b1cdbd2cSJim Jagielski aMirrorRect.Bottom() = (long)( fMirrorGradientLine - ((double) i) * fScanInc );
354*b1cdbd2cSJim Jagielski aMirrorRect.Top() = (long)( fMirrorGradientLine - (((double) i) + 1.0)* fScanInc );
355*b1cdbd2cSJim Jagielski aPoly[0] = aMirrorRect.TopLeft();
356*b1cdbd2cSJim Jagielski aPoly[1] = aMirrorRect.TopRight();
357*b1cdbd2cSJim Jagielski aPoly[2] = aMirrorRect.BottomRight();
358*b1cdbd2cSJim Jagielski aPoly[3] = aMirrorRect.BottomLeft();
359*b1cdbd2cSJim Jagielski aPoly.Rotate( aCenter, nAngle );
360*b1cdbd2cSJim Jagielski if ( bMtf )
361*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPolygonAction( aPoly ) );
362*b1cdbd2cSJim Jagielski else
363*b1cdbd2cSJim Jagielski ImplDrawPolygon( aPoly, pClipPolyPoly );
364*b1cdbd2cSJim Jagielski }
365*b1cdbd2cSJim Jagielski }
366*b1cdbd2cSJim Jagielski if ( !bLinear)
367*b1cdbd2cSJim Jagielski {
368*b1cdbd2cSJim Jagielski // draw middle polygon with end color
369*b1cdbd2cSJim Jagielski nRed = ImplGetGradientColorValue(nEndRed);
370*b1cdbd2cSJim Jagielski nGreen = ImplGetGradientColorValue(nEndGreen);
371*b1cdbd2cSJim Jagielski nBlue = ImplGetGradientColorValue(nEndBlue);
372*b1cdbd2cSJim Jagielski if ( bMtf )
373*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaFillColorAction( Color( nRed, nGreen, nBlue ), sal_True ) );
374*b1cdbd2cSJim Jagielski else
375*b1cdbd2cSJim Jagielski mpGraphics->SetFillColor( MAKE_SALCOLOR( nRed, nGreen, nBlue ) );
376*b1cdbd2cSJim Jagielski
377*b1cdbd2cSJim Jagielski aRect.Top() = (long)( fGradientLine + ((double)nSteps) * fScanInc );
378*b1cdbd2cSJim Jagielski aRect.Bottom() = (long)( fMirrorGradientLine - ((double) nSteps) * fScanInc );
379*b1cdbd2cSJim Jagielski aPoly[0] = aRect.TopLeft();
380*b1cdbd2cSJim Jagielski aPoly[1] = aRect.TopRight();
381*b1cdbd2cSJim Jagielski aPoly[2] = aRect.BottomRight();
382*b1cdbd2cSJim Jagielski aPoly[3] = aRect.BottomLeft();
383*b1cdbd2cSJim Jagielski aPoly.Rotate( aCenter, nAngle );
384*b1cdbd2cSJim Jagielski if ( bMtf )
385*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPolygonAction( aPoly ) );
386*b1cdbd2cSJim Jagielski else
387*b1cdbd2cSJim Jagielski ImplDrawPolygon( aPoly, pClipPolyPoly );
388*b1cdbd2cSJim Jagielski }
389*b1cdbd2cSJim Jagielski }
390*b1cdbd2cSJim Jagielski
391*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
392*b1cdbd2cSJim Jagielski
ImplDrawComplexGradient(const Rectangle & rRect,const Gradient & rGradient,sal_Bool bMtf,const PolyPolygon * pClipPolyPoly)393*b1cdbd2cSJim Jagielski void OutputDevice::ImplDrawComplexGradient( const Rectangle& rRect,
394*b1cdbd2cSJim Jagielski const Gradient& rGradient,
395*b1cdbd2cSJim Jagielski sal_Bool bMtf, const PolyPolygon* pClipPolyPoly )
396*b1cdbd2cSJim Jagielski {
397*b1cdbd2cSJim Jagielski // Feststellen ob Ausgabe ueber Polygon oder PolyPolygon
398*b1cdbd2cSJim Jagielski // Bei Rasteroperationen ungleich Overpaint immer PolyPolygone,
399*b1cdbd2cSJim Jagielski // da es zu falschen Ergebnissen kommt, wenn man mehrfach uebereinander
400*b1cdbd2cSJim Jagielski // ausgibt
401*b1cdbd2cSJim Jagielski // Bei Druckern auch immer PolyPolygone, da nicht alle Drucker
402*b1cdbd2cSJim Jagielski // das Uebereinanderdrucken von Polygonen koennen
403*b1cdbd2cSJim Jagielski // Virtuelle Device werden auch ausgeklammert, da einige Treiber
404*b1cdbd2cSJim Jagielski // ansonsten zu langsam sind
405*b1cdbd2cSJim Jagielski PolyPolygon* pPolyPoly;
406*b1cdbd2cSJim Jagielski Rectangle aRect( rRect );
407*b1cdbd2cSJim Jagielski Color aStartCol( rGradient.GetStartColor() );
408*b1cdbd2cSJim Jagielski Color aEndCol( rGradient.GetEndColor() );
409*b1cdbd2cSJim Jagielski long nStartRed = ( (long) aStartCol.GetRed() * rGradient.GetStartIntensity() ) / 100;
410*b1cdbd2cSJim Jagielski long nStartGreen = ( (long) aStartCol.GetGreen() * rGradient.GetStartIntensity() ) / 100;
411*b1cdbd2cSJim Jagielski long nStartBlue = ( (long) aStartCol.GetBlue() * rGradient.GetStartIntensity() ) / 100;
412*b1cdbd2cSJim Jagielski long nEndRed = ( (long) aEndCol.GetRed() * rGradient.GetEndIntensity() ) / 100;
413*b1cdbd2cSJim Jagielski long nEndGreen = ( (long) aEndCol.GetGreen() * rGradient.GetEndIntensity() ) / 100;
414*b1cdbd2cSJim Jagielski long nEndBlue = ( (long) aEndCol.GetBlue() * rGradient.GetEndIntensity() ) / 100;
415*b1cdbd2cSJim Jagielski long nRedSteps = nEndRed - nStartRed;
416*b1cdbd2cSJim Jagielski long nGreenSteps = nEndGreen - nStartGreen;
417*b1cdbd2cSJim Jagielski long nBlueSteps = nEndBlue - nStartBlue;
418*b1cdbd2cSJim Jagielski long nStepCount = rGradient.GetSteps();
419*b1cdbd2cSJim Jagielski sal_uInt16 nAngle = rGradient.GetAngle() % 3600;
420*b1cdbd2cSJim Jagielski
421*b1cdbd2cSJim Jagielski if( (meRasterOp != ROP_OVERPAINT) || (meOutDevType != OUTDEV_WINDOW) || bMtf )
422*b1cdbd2cSJim Jagielski pPolyPoly = new PolyPolygon( 2 );
423*b1cdbd2cSJim Jagielski else
424*b1cdbd2cSJim Jagielski pPolyPoly = NULL;
425*b1cdbd2cSJim Jagielski
426*b1cdbd2cSJim Jagielski if( rGradient.GetStyle() == GRADIENT_SQUARE || rGradient.GetStyle() == GRADIENT_RECT )
427*b1cdbd2cSJim Jagielski {
428*b1cdbd2cSJim Jagielski const double fAngle = nAngle * F_PI1800;
429*b1cdbd2cSJim Jagielski const double fWidth = aRect.GetWidth();
430*b1cdbd2cSJim Jagielski const double fHeight = aRect.GetHeight();
431*b1cdbd2cSJim Jagielski double fDX = fWidth * fabs( cos( fAngle ) ) + fHeight * fabs( sin( fAngle ) );
432*b1cdbd2cSJim Jagielski double fDY = fHeight * fabs( cos( fAngle ) ) + fWidth * fabs( sin( fAngle ) );
433*b1cdbd2cSJim Jagielski
434*b1cdbd2cSJim Jagielski fDX = ( fDX - fWidth ) * 0.5 + 0.5;
435*b1cdbd2cSJim Jagielski fDY = ( fDY - fHeight ) * 0.5 + 0.5;
436*b1cdbd2cSJim Jagielski
437*b1cdbd2cSJim Jagielski aRect.Left() -= (long) fDX;
438*b1cdbd2cSJim Jagielski aRect.Right() += (long) fDX;
439*b1cdbd2cSJim Jagielski aRect.Top() -= (long) fDY;
440*b1cdbd2cSJim Jagielski aRect.Bottom() += (long) fDY;
441*b1cdbd2cSJim Jagielski }
442*b1cdbd2cSJim Jagielski
443*b1cdbd2cSJim Jagielski Size aSize( aRect.GetSize() );
444*b1cdbd2cSJim Jagielski
445*b1cdbd2cSJim Jagielski if( rGradient.GetStyle() == GRADIENT_RADIAL )
446*b1cdbd2cSJim Jagielski {
447*b1cdbd2cSJim Jagielski // Radien-Berechnung fuer Kreis
448*b1cdbd2cSJim Jagielski aSize.Width() = (long)(0.5 + sqrt((double)aSize.Width()*(double)aSize.Width() + (double)aSize.Height()*(double)aSize.Height()));
449*b1cdbd2cSJim Jagielski aSize.Height() = aSize.Width();
450*b1cdbd2cSJim Jagielski }
451*b1cdbd2cSJim Jagielski else if( rGradient.GetStyle() == GRADIENT_ELLIPTICAL )
452*b1cdbd2cSJim Jagielski {
453*b1cdbd2cSJim Jagielski // Radien-Berechnung fuer Ellipse
454*b1cdbd2cSJim Jagielski aSize.Width() = (long)( 0.5 + (double) aSize.Width() * 1.4142 );
455*b1cdbd2cSJim Jagielski aSize.Height() = (long)( 0.5 + (double) aSize.Height() * 1.4142 );
456*b1cdbd2cSJim Jagielski }
457*b1cdbd2cSJim Jagielski else if( rGradient.GetStyle() == GRADIENT_SQUARE )
458*b1cdbd2cSJim Jagielski {
459*b1cdbd2cSJim Jagielski if ( aSize.Width() > aSize.Height() )
460*b1cdbd2cSJim Jagielski aSize.Height() = aSize.Width();
461*b1cdbd2cSJim Jagielski else
462*b1cdbd2cSJim Jagielski aSize.Width() = aSize.Height();
463*b1cdbd2cSJim Jagielski }
464*b1cdbd2cSJim Jagielski
465*b1cdbd2cSJim Jagielski // neue Mittelpunkte berechnen
466*b1cdbd2cSJim Jagielski long nZWidth = aRect.GetWidth() * (long) rGradient.GetOfsX() / 100;
467*b1cdbd2cSJim Jagielski long nZHeight = aRect.GetHeight() * (long) rGradient.GetOfsY() / 100;
468*b1cdbd2cSJim Jagielski long nBorderX = (long) rGradient.GetBorder() * aSize.Width() / 100;
469*b1cdbd2cSJim Jagielski long nBorderY = (long) rGradient.GetBorder() * aSize.Height() / 100;
470*b1cdbd2cSJim Jagielski Point aCenter( aRect.Left() + nZWidth, aRect.Top() + nZHeight );
471*b1cdbd2cSJim Jagielski
472*b1cdbd2cSJim Jagielski // Rand beruecksichtigen
473*b1cdbd2cSJim Jagielski aSize.Width() -= nBorderX;
474*b1cdbd2cSJim Jagielski aSize.Height() -= nBorderY;
475*b1cdbd2cSJim Jagielski
476*b1cdbd2cSJim Jagielski // Ausgaberechteck neu setzen
477*b1cdbd2cSJim Jagielski aRect.Left() = aCenter.X() - ( aSize.Width() >> 1 );
478*b1cdbd2cSJim Jagielski aRect.Top() = aCenter.Y() - ( aSize.Height() >> 1 );
479*b1cdbd2cSJim Jagielski
480*b1cdbd2cSJim Jagielski aRect.SetSize( aSize );
481*b1cdbd2cSJim Jagielski long nMinRect = Min( aRect.GetWidth(), aRect.GetHeight() );
482*b1cdbd2cSJim Jagielski
483*b1cdbd2cSJim Jagielski // Anzahl der Schritte berechnen, falls nichts uebergeben wurde
484*b1cdbd2cSJim Jagielski if( !nStepCount )
485*b1cdbd2cSJim Jagielski {
486*b1cdbd2cSJim Jagielski long nInc;
487*b1cdbd2cSJim Jagielski
488*b1cdbd2cSJim Jagielski if ( meOutDevType != OUTDEV_PRINTER && !bMtf )
489*b1cdbd2cSJim Jagielski {
490*b1cdbd2cSJim Jagielski nInc = ( nMinRect < 50 ) ? 2 : 4;
491*b1cdbd2cSJim Jagielski }
492*b1cdbd2cSJim Jagielski else
493*b1cdbd2cSJim Jagielski {
494*b1cdbd2cSJim Jagielski // #105998# Use display-equivalent step size calculation
495*b1cdbd2cSJim Jagielski nInc = (nMinRect < 800) ? 10 : 20;
496*b1cdbd2cSJim Jagielski }
497*b1cdbd2cSJim Jagielski
498*b1cdbd2cSJim Jagielski if( !nInc )
499*b1cdbd2cSJim Jagielski nInc = 1;
500*b1cdbd2cSJim Jagielski
501*b1cdbd2cSJim Jagielski nStepCount = nMinRect / nInc;
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski
504*b1cdbd2cSJim Jagielski // minimal drei Schritte und maximal die Anzahl der Farbunterschiede
505*b1cdbd2cSJim Jagielski long nSteps = Max( nStepCount, 2L );
506*b1cdbd2cSJim Jagielski long nCalcSteps = Abs( nRedSteps );
507*b1cdbd2cSJim Jagielski long nTempSteps = Abs( nGreenSteps );
508*b1cdbd2cSJim Jagielski if ( nTempSteps > nCalcSteps )
509*b1cdbd2cSJim Jagielski nCalcSteps = nTempSteps;
510*b1cdbd2cSJim Jagielski nTempSteps = Abs( nBlueSteps );
511*b1cdbd2cSJim Jagielski if ( nTempSteps > nCalcSteps )
512*b1cdbd2cSJim Jagielski nCalcSteps = nTempSteps;
513*b1cdbd2cSJim Jagielski if ( nCalcSteps < nSteps )
514*b1cdbd2cSJim Jagielski nSteps = nCalcSteps;
515*b1cdbd2cSJim Jagielski if ( !nSteps )
516*b1cdbd2cSJim Jagielski nSteps = 1;
517*b1cdbd2cSJim Jagielski
518*b1cdbd2cSJim Jagielski // Ausgabebegrenzungen und Schrittweite fuer jede Richtung festlegen
519*b1cdbd2cSJim Jagielski Polygon aPoly;
520*b1cdbd2cSJim Jagielski double fScanLeft = aRect.Left();
521*b1cdbd2cSJim Jagielski double fScanTop = aRect.Top();
522*b1cdbd2cSJim Jagielski double fScanRight = aRect.Right();
523*b1cdbd2cSJim Jagielski double fScanBottom = aRect.Bottom();
524*b1cdbd2cSJim Jagielski double fScanInc = (double) nMinRect / (double) nSteps * 0.5;
525*b1cdbd2cSJim Jagielski sal_uInt8 nRed = (sal_uInt8) nStartRed, nGreen = (sal_uInt8) nStartGreen, nBlue = (sal_uInt8) nStartBlue;
526*b1cdbd2cSJim Jagielski bool bPaintLastPolygon( false ); // #107349# Paint last polygon only if loop has generated any output
527*b1cdbd2cSJim Jagielski
528*b1cdbd2cSJim Jagielski if( bMtf )
529*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaFillColorAction( Color( nRed, nGreen, nBlue ), sal_True ) );
530*b1cdbd2cSJim Jagielski else
531*b1cdbd2cSJim Jagielski mpGraphics->SetFillColor( MAKE_SALCOLOR( nRed, nGreen, nBlue ) );
532*b1cdbd2cSJim Jagielski
533*b1cdbd2cSJim Jagielski if( pPolyPoly )
534*b1cdbd2cSJim Jagielski {
535*b1cdbd2cSJim Jagielski pPolyPoly->Insert( aPoly = rRect );
536*b1cdbd2cSJim Jagielski pPolyPoly->Insert( aPoly );
537*b1cdbd2cSJim Jagielski }
538*b1cdbd2cSJim Jagielski else
539*b1cdbd2cSJim Jagielski {
540*b1cdbd2cSJim Jagielski // extend rect, to avoid missing bounding line
541*b1cdbd2cSJim Jagielski Rectangle aExtRect( rRect );
542*b1cdbd2cSJim Jagielski
543*b1cdbd2cSJim Jagielski aExtRect.Left() -= 1;
544*b1cdbd2cSJim Jagielski aExtRect.Top() -= 1;
545*b1cdbd2cSJim Jagielski aExtRect.Right() += 1;
546*b1cdbd2cSJim Jagielski aExtRect.Bottom() += 1;
547*b1cdbd2cSJim Jagielski
548*b1cdbd2cSJim Jagielski ImplDrawPolygon( aPoly = aExtRect, pClipPolyPoly );
549*b1cdbd2cSJim Jagielski }
550*b1cdbd2cSJim Jagielski
551*b1cdbd2cSJim Jagielski // Schleife, um nacheinander die Polygone/PolyPolygone auszugeben
552*b1cdbd2cSJim Jagielski for( long i = 1; i < nSteps; i++ )
553*b1cdbd2cSJim Jagielski {
554*b1cdbd2cSJim Jagielski // neues Polygon berechnen
555*b1cdbd2cSJim Jagielski aRect.Left() = (long)( fScanLeft += fScanInc );
556*b1cdbd2cSJim Jagielski aRect.Top() = (long)( fScanTop += fScanInc );
557*b1cdbd2cSJim Jagielski aRect.Right() = (long)( fScanRight -= fScanInc );
558*b1cdbd2cSJim Jagielski aRect.Bottom() = (long)( fScanBottom -= fScanInc );
559*b1cdbd2cSJim Jagielski
560*b1cdbd2cSJim Jagielski if( ( aRect.GetWidth() < 2 ) || ( aRect.GetHeight() < 2 ) )
561*b1cdbd2cSJim Jagielski break;
562*b1cdbd2cSJim Jagielski
563*b1cdbd2cSJim Jagielski if( rGradient.GetStyle() == GRADIENT_RADIAL || rGradient.GetStyle() == GRADIENT_ELLIPTICAL )
564*b1cdbd2cSJim Jagielski aPoly = Polygon( aRect.Center(), aRect.GetWidth() >> 1, aRect.GetHeight() >> 1 );
565*b1cdbd2cSJim Jagielski else
566*b1cdbd2cSJim Jagielski aPoly = Polygon( aRect );
567*b1cdbd2cSJim Jagielski
568*b1cdbd2cSJim Jagielski aPoly.Rotate( aCenter, nAngle );
569*b1cdbd2cSJim Jagielski
570*b1cdbd2cSJim Jagielski // Farbe entsprechend anpassen
571*b1cdbd2cSJim Jagielski const long nStepIndex = ( ( pPolyPoly != NULL ) ? i : ( i + 1 ) );
572*b1cdbd2cSJim Jagielski nRed = ImplGetGradientColorValue( nStartRed + ( ( nRedSteps * nStepIndex ) / nSteps ) );
573*b1cdbd2cSJim Jagielski nGreen = ImplGetGradientColorValue( nStartGreen + ( ( nGreenSteps * nStepIndex ) / nSteps ) );
574*b1cdbd2cSJim Jagielski nBlue = ImplGetGradientColorValue( nStartBlue + ( ( nBlueSteps * nStepIndex ) / nSteps ) );
575*b1cdbd2cSJim Jagielski
576*b1cdbd2cSJim Jagielski // entweder langsame PolyPolygon-Ausgaben oder schnelles Polygon-Painting
577*b1cdbd2cSJim Jagielski if( pPolyPoly )
578*b1cdbd2cSJim Jagielski {
579*b1cdbd2cSJim Jagielski bPaintLastPolygon = true; // #107349# Paint last polygon only if loop has generated any output
580*b1cdbd2cSJim Jagielski
581*b1cdbd2cSJim Jagielski pPolyPoly->Replace( pPolyPoly->GetObject( 1 ), 0 );
582*b1cdbd2cSJim Jagielski pPolyPoly->Replace( aPoly, 1 );
583*b1cdbd2cSJim Jagielski
584*b1cdbd2cSJim Jagielski if( bMtf )
585*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPolyPolygonAction( *pPolyPoly ) );
586*b1cdbd2cSJim Jagielski else
587*b1cdbd2cSJim Jagielski ImplDrawPolyPolygon( *pPolyPoly, pClipPolyPoly );
588*b1cdbd2cSJim Jagielski
589*b1cdbd2cSJim Jagielski // #107349# Set fill color _after_ geometry painting:
590*b1cdbd2cSJim Jagielski // pPolyPoly's geometry is the band from last iteration's
591*b1cdbd2cSJim Jagielski // aPoly to current iteration's aPoly. The window outdev
592*b1cdbd2cSJim Jagielski // path (see else below), on the other hand, paints the
593*b1cdbd2cSJim Jagielski // full aPoly. Thus, here, we're painting the band before
594*b1cdbd2cSJim Jagielski // the one painted in the window outdev path below. To get
595*b1cdbd2cSJim Jagielski // matching colors, have to delay color setting here.
596*b1cdbd2cSJim Jagielski if( bMtf )
597*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaFillColorAction( Color( nRed, nGreen, nBlue ), sal_True ) );
598*b1cdbd2cSJim Jagielski else
599*b1cdbd2cSJim Jagielski mpGraphics->SetFillColor( MAKE_SALCOLOR( nRed, nGreen, nBlue ) );
600*b1cdbd2cSJim Jagielski }
601*b1cdbd2cSJim Jagielski else
602*b1cdbd2cSJim Jagielski {
603*b1cdbd2cSJim Jagielski // #107349# Set fill color _before_ geometry painting
604*b1cdbd2cSJim Jagielski if( bMtf )
605*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaFillColorAction( Color( nRed, nGreen, nBlue ), sal_True ) );
606*b1cdbd2cSJim Jagielski else
607*b1cdbd2cSJim Jagielski mpGraphics->SetFillColor( MAKE_SALCOLOR( nRed, nGreen, nBlue ) );
608*b1cdbd2cSJim Jagielski
609*b1cdbd2cSJim Jagielski ImplDrawPolygon( aPoly, pClipPolyPoly );
610*b1cdbd2cSJim Jagielski }
611*b1cdbd2cSJim Jagielski }
612*b1cdbd2cSJim Jagielski
613*b1cdbd2cSJim Jagielski // Falls PolyPolygon-Ausgabe, muessen wir noch ein letztes inneres Polygon zeichnen
614*b1cdbd2cSJim Jagielski if( pPolyPoly )
615*b1cdbd2cSJim Jagielski {
616*b1cdbd2cSJim Jagielski const Polygon& rPoly = pPolyPoly->GetObject( 1 );
617*b1cdbd2cSJim Jagielski
618*b1cdbd2cSJim Jagielski if( !rPoly.GetBoundRect().IsEmpty() )
619*b1cdbd2cSJim Jagielski {
620*b1cdbd2cSJim Jagielski // #107349# Paint last polygon with end color only if loop
621*b1cdbd2cSJim Jagielski // has generated output. Otherwise, the current
622*b1cdbd2cSJim Jagielski // (i.e. start) color is taken, to generate _any_ output.
623*b1cdbd2cSJim Jagielski if( bPaintLastPolygon )
624*b1cdbd2cSJim Jagielski {
625*b1cdbd2cSJim Jagielski nRed = ImplGetGradientColorValue( nEndRed );
626*b1cdbd2cSJim Jagielski nGreen = ImplGetGradientColorValue( nEndGreen );
627*b1cdbd2cSJim Jagielski nBlue = ImplGetGradientColorValue( nEndBlue );
628*b1cdbd2cSJim Jagielski }
629*b1cdbd2cSJim Jagielski
630*b1cdbd2cSJim Jagielski if( bMtf )
631*b1cdbd2cSJim Jagielski {
632*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaFillColorAction( Color( nRed, nGreen, nBlue ), sal_True ) );
633*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPolygonAction( rPoly ) );
634*b1cdbd2cSJim Jagielski }
635*b1cdbd2cSJim Jagielski else
636*b1cdbd2cSJim Jagielski {
637*b1cdbd2cSJim Jagielski mpGraphics->SetFillColor( MAKE_SALCOLOR( nRed, nGreen, nBlue ) );
638*b1cdbd2cSJim Jagielski ImplDrawPolygon( rPoly, pClipPolyPoly );
639*b1cdbd2cSJim Jagielski }
640*b1cdbd2cSJim Jagielski }
641*b1cdbd2cSJim Jagielski
642*b1cdbd2cSJim Jagielski delete pPolyPoly;
643*b1cdbd2cSJim Jagielski }
644*b1cdbd2cSJim Jagielski }
645*b1cdbd2cSJim Jagielski
646*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
647*b1cdbd2cSJim Jagielski
DrawGradient(const Rectangle & rRect,const Gradient & rGradient)648*b1cdbd2cSJim Jagielski void OutputDevice::DrawGradient( const Rectangle& rRect,
649*b1cdbd2cSJim Jagielski const Gradient& rGradient )
650*b1cdbd2cSJim Jagielski {
651*b1cdbd2cSJim Jagielski DBG_TRACE( "OutputDevice::DrawGradient()" );
652*b1cdbd2cSJim Jagielski DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
653*b1cdbd2cSJim Jagielski DBG_CHKOBJ( &rGradient, Gradient, NULL );
654*b1cdbd2cSJim Jagielski
655*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_NOGRADIENT )
656*b1cdbd2cSJim Jagielski return;
657*b1cdbd2cSJim Jagielski else if ( mnDrawMode & ( DRAWMODE_BLACKGRADIENT | DRAWMODE_WHITEGRADIENT | DRAWMODE_SETTINGSGRADIENT) )
658*b1cdbd2cSJim Jagielski {
659*b1cdbd2cSJim Jagielski Color aColor;
660*b1cdbd2cSJim Jagielski
661*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_BLACKGRADIENT )
662*b1cdbd2cSJim Jagielski aColor = Color( COL_BLACK );
663*b1cdbd2cSJim Jagielski else if ( mnDrawMode & DRAWMODE_WHITEGRADIENT )
664*b1cdbd2cSJim Jagielski aColor = Color( COL_WHITE );
665*b1cdbd2cSJim Jagielski else if ( mnDrawMode & DRAWMODE_SETTINGSGRADIENT )
666*b1cdbd2cSJim Jagielski aColor = GetSettings().GetStyleSettings().GetWindowColor();
667*b1cdbd2cSJim Jagielski
668*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_GHOSTEDGRADIENT )
669*b1cdbd2cSJim Jagielski {
670*b1cdbd2cSJim Jagielski aColor = Color( ( aColor.GetRed() >> 1 ) | 0x80,
671*b1cdbd2cSJim Jagielski ( aColor.GetGreen() >> 1 ) | 0x80,
672*b1cdbd2cSJim Jagielski ( aColor.GetBlue() >> 1 ) | 0x80 );
673*b1cdbd2cSJim Jagielski }
674*b1cdbd2cSJim Jagielski
675*b1cdbd2cSJim Jagielski Push( PUSH_LINECOLOR | PUSH_FILLCOLOR );
676*b1cdbd2cSJim Jagielski SetLineColor( aColor );
677*b1cdbd2cSJim Jagielski SetFillColor( aColor );
678*b1cdbd2cSJim Jagielski DrawRect( rRect );
679*b1cdbd2cSJim Jagielski Pop();
680*b1cdbd2cSJim Jagielski return;
681*b1cdbd2cSJim Jagielski }
682*b1cdbd2cSJim Jagielski
683*b1cdbd2cSJim Jagielski Gradient aGradient( rGradient );
684*b1cdbd2cSJim Jagielski
685*b1cdbd2cSJim Jagielski if ( mnDrawMode & ( DRAWMODE_GRAYGRADIENT | DRAWMODE_GHOSTEDGRADIENT ) )
686*b1cdbd2cSJim Jagielski {
687*b1cdbd2cSJim Jagielski Color aStartCol( aGradient.GetStartColor() );
688*b1cdbd2cSJim Jagielski Color aEndCol( aGradient.GetEndColor() );
689*b1cdbd2cSJim Jagielski
690*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_GRAYGRADIENT )
691*b1cdbd2cSJim Jagielski {
692*b1cdbd2cSJim Jagielski sal_uInt8 cStartLum = aStartCol.GetLuminance(), cEndLum = aEndCol.GetLuminance();
693*b1cdbd2cSJim Jagielski aStartCol = Color( cStartLum, cStartLum, cStartLum );
694*b1cdbd2cSJim Jagielski aEndCol = Color( cEndLum, cEndLum, cEndLum );
695*b1cdbd2cSJim Jagielski }
696*b1cdbd2cSJim Jagielski
697*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_GHOSTEDGRADIENT )
698*b1cdbd2cSJim Jagielski {
699*b1cdbd2cSJim Jagielski aStartCol = Color( ( aStartCol.GetRed() >> 1 ) | 0x80,
700*b1cdbd2cSJim Jagielski ( aStartCol.GetGreen() >> 1 ) | 0x80,
701*b1cdbd2cSJim Jagielski ( aStartCol.GetBlue() >> 1 ) | 0x80 );
702*b1cdbd2cSJim Jagielski
703*b1cdbd2cSJim Jagielski aEndCol = Color( ( aEndCol.GetRed() >> 1 ) | 0x80,
704*b1cdbd2cSJim Jagielski ( aEndCol.GetGreen() >> 1 ) | 0x80,
705*b1cdbd2cSJim Jagielski ( aEndCol.GetBlue() >> 1 ) | 0x80 );
706*b1cdbd2cSJim Jagielski }
707*b1cdbd2cSJim Jagielski
708*b1cdbd2cSJim Jagielski aGradient.SetStartColor( aStartCol );
709*b1cdbd2cSJim Jagielski aGradient.SetEndColor( aEndCol );
710*b1cdbd2cSJim Jagielski }
711*b1cdbd2cSJim Jagielski
712*b1cdbd2cSJim Jagielski if( mpMetaFile )
713*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaGradientAction( rRect, aGradient ) );
714*b1cdbd2cSJim Jagielski
715*b1cdbd2cSJim Jagielski if( !IsDeviceOutputNecessary() || ImplIsRecordLayout() )
716*b1cdbd2cSJim Jagielski return;
717*b1cdbd2cSJim Jagielski
718*b1cdbd2cSJim Jagielski // Rechteck in Pixel umrechnen
719*b1cdbd2cSJim Jagielski Rectangle aRect( ImplLogicToDevicePixel( rRect ) );
720*b1cdbd2cSJim Jagielski aRect.Justify();
721*b1cdbd2cSJim Jagielski
722*b1cdbd2cSJim Jagielski // Wenn Rechteck leer ist, brauchen wir nichts machen
723*b1cdbd2cSJim Jagielski if ( !aRect.IsEmpty() )
724*b1cdbd2cSJim Jagielski {
725*b1cdbd2cSJim Jagielski // Clip Region sichern
726*b1cdbd2cSJim Jagielski Push( PUSH_CLIPREGION );
727*b1cdbd2cSJim Jagielski IntersectClipRegion( rRect );
728*b1cdbd2cSJim Jagielski
729*b1cdbd2cSJim Jagielski // because we draw with no border line, we have to expand gradient
730*b1cdbd2cSJim Jagielski // rect to avoid missing lines on the right and bottom edge
731*b1cdbd2cSJim Jagielski aRect.Left()--;
732*b1cdbd2cSJim Jagielski aRect.Top()--;
733*b1cdbd2cSJim Jagielski aRect.Right()++;
734*b1cdbd2cSJim Jagielski aRect.Bottom()++;
735*b1cdbd2cSJim Jagielski
736*b1cdbd2cSJim Jagielski // we need a graphics
737*b1cdbd2cSJim Jagielski if ( !mpGraphics )
738*b1cdbd2cSJim Jagielski {
739*b1cdbd2cSJim Jagielski if ( !ImplGetGraphics() )
740*b1cdbd2cSJim Jagielski return;
741*b1cdbd2cSJim Jagielski }
742*b1cdbd2cSJim Jagielski
743*b1cdbd2cSJim Jagielski if ( mbInitClipRegion )
744*b1cdbd2cSJim Jagielski ImplInitClipRegion();
745*b1cdbd2cSJim Jagielski
746*b1cdbd2cSJim Jagielski if ( !mbOutputClipped )
747*b1cdbd2cSJim Jagielski {
748*b1cdbd2cSJim Jagielski // Gradienten werden ohne Umrandung gezeichnet
749*b1cdbd2cSJim Jagielski if ( mbLineColor || mbInitLineColor )
750*b1cdbd2cSJim Jagielski {
751*b1cdbd2cSJim Jagielski mpGraphics->SetLineColor();
752*b1cdbd2cSJim Jagielski mbInitLineColor = sal_True;
753*b1cdbd2cSJim Jagielski }
754*b1cdbd2cSJim Jagielski
755*b1cdbd2cSJim Jagielski mbInitFillColor = sal_True;
756*b1cdbd2cSJim Jagielski
757*b1cdbd2cSJim Jagielski // calculate step count if neccessary
758*b1cdbd2cSJim Jagielski if ( !aGradient.GetSteps() )
759*b1cdbd2cSJim Jagielski aGradient.SetSteps( GRADIENT_DEFAULT_STEPCOUNT );
760*b1cdbd2cSJim Jagielski
761*b1cdbd2cSJim Jagielski if( aGradient.GetStyle() == GRADIENT_LINEAR || aGradient.GetStyle() == GRADIENT_AXIAL )
762*b1cdbd2cSJim Jagielski ImplDrawLinearGradient( aRect, aGradient, sal_False, NULL );
763*b1cdbd2cSJim Jagielski else
764*b1cdbd2cSJim Jagielski ImplDrawComplexGradient( aRect, aGradient, sal_False, NULL );
765*b1cdbd2cSJim Jagielski }
766*b1cdbd2cSJim Jagielski
767*b1cdbd2cSJim Jagielski Pop();
768*b1cdbd2cSJim Jagielski }
769*b1cdbd2cSJim Jagielski
770*b1cdbd2cSJim Jagielski if( mpAlphaVDev )
771*b1cdbd2cSJim Jagielski {
772*b1cdbd2cSJim Jagielski // #i32109#: Make gradient area opaque
773*b1cdbd2cSJim Jagielski mpAlphaVDev->ImplFillOpaqueRectangle( rRect );
774*b1cdbd2cSJim Jagielski }
775*b1cdbd2cSJim Jagielski }
776*b1cdbd2cSJim Jagielski
777*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
778*b1cdbd2cSJim Jagielski
DrawGradient(const PolyPolygon & rPolyPoly,const Gradient & rGradient)779*b1cdbd2cSJim Jagielski void OutputDevice::DrawGradient( const PolyPolygon& rPolyPoly,
780*b1cdbd2cSJim Jagielski const Gradient& rGradient )
781*b1cdbd2cSJim Jagielski {
782*b1cdbd2cSJim Jagielski DBG_TRACE( "OutputDevice::DrawGradient()" );
783*b1cdbd2cSJim Jagielski DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
784*b1cdbd2cSJim Jagielski DBG_CHKOBJ( &rGradient, Gradient, NULL );
785*b1cdbd2cSJim Jagielski
786*b1cdbd2cSJim Jagielski if( mbInitClipRegion )
787*b1cdbd2cSJim Jagielski ImplInitClipRegion();
788*b1cdbd2cSJim Jagielski
789*b1cdbd2cSJim Jagielski if( mbOutputClipped )
790*b1cdbd2cSJim Jagielski return;
791*b1cdbd2cSJim Jagielski
792*b1cdbd2cSJim Jagielski if( !mpGraphics )
793*b1cdbd2cSJim Jagielski if( !ImplGetGraphics() )
794*b1cdbd2cSJim Jagielski return;
795*b1cdbd2cSJim Jagielski
796*b1cdbd2cSJim Jagielski if( rPolyPoly.Count() && rPolyPoly[ 0 ].GetSize() && !( mnDrawMode & DRAWMODE_NOGRADIENT ) )
797*b1cdbd2cSJim Jagielski {
798*b1cdbd2cSJim Jagielski if ( mnDrawMode & ( DRAWMODE_BLACKGRADIENT | DRAWMODE_WHITEGRADIENT | DRAWMODE_SETTINGSGRADIENT) )
799*b1cdbd2cSJim Jagielski {
800*b1cdbd2cSJim Jagielski Color aColor;
801*b1cdbd2cSJim Jagielski
802*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_BLACKGRADIENT )
803*b1cdbd2cSJim Jagielski aColor = Color( COL_BLACK );
804*b1cdbd2cSJim Jagielski else if ( mnDrawMode & DRAWMODE_WHITEGRADIENT )
805*b1cdbd2cSJim Jagielski aColor = Color( COL_WHITE );
806*b1cdbd2cSJim Jagielski else if ( mnDrawMode & DRAWMODE_SETTINGSGRADIENT )
807*b1cdbd2cSJim Jagielski aColor = GetSettings().GetStyleSettings().GetWindowColor();
808*b1cdbd2cSJim Jagielski
809*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_GHOSTEDGRADIENT )
810*b1cdbd2cSJim Jagielski {
811*b1cdbd2cSJim Jagielski aColor = Color( ( aColor.GetRed() >> 1 ) | 0x80,
812*b1cdbd2cSJim Jagielski ( aColor.GetGreen() >> 1 ) | 0x80,
813*b1cdbd2cSJim Jagielski ( aColor.GetBlue() >> 1 ) | 0x80 );
814*b1cdbd2cSJim Jagielski }
815*b1cdbd2cSJim Jagielski
816*b1cdbd2cSJim Jagielski Push( PUSH_LINECOLOR | PUSH_FILLCOLOR );
817*b1cdbd2cSJim Jagielski SetLineColor( aColor );
818*b1cdbd2cSJim Jagielski SetFillColor( aColor );
819*b1cdbd2cSJim Jagielski DrawPolyPolygon( rPolyPoly );
820*b1cdbd2cSJim Jagielski Pop();
821*b1cdbd2cSJim Jagielski return;
822*b1cdbd2cSJim Jagielski }
823*b1cdbd2cSJim Jagielski
824*b1cdbd2cSJim Jagielski if( mpMetaFile )
825*b1cdbd2cSJim Jagielski {
826*b1cdbd2cSJim Jagielski const Rectangle aRect( rPolyPoly.GetBoundRect() );
827*b1cdbd2cSJim Jagielski
828*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaCommentAction( "XGRAD_SEQ_BEGIN" ) );
829*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaGradientExAction( rPolyPoly, rGradient ) );
830*b1cdbd2cSJim Jagielski
831*b1cdbd2cSJim Jagielski if( OUTDEV_PRINTER == meOutDevType )
832*b1cdbd2cSJim Jagielski {
833*b1cdbd2cSJim Jagielski Push( PUSH_CLIPREGION );
834*b1cdbd2cSJim Jagielski IntersectClipRegion( rPolyPoly );
835*b1cdbd2cSJim Jagielski DrawGradient( aRect, rGradient );
836*b1cdbd2cSJim Jagielski Pop();
837*b1cdbd2cSJim Jagielski }
838*b1cdbd2cSJim Jagielski else
839*b1cdbd2cSJim Jagielski {
840*b1cdbd2cSJim Jagielski const sal_Bool bOldOutput = IsOutputEnabled();
841*b1cdbd2cSJim Jagielski
842*b1cdbd2cSJim Jagielski EnableOutput( sal_False );
843*b1cdbd2cSJim Jagielski Push( PUSH_RASTEROP );
844*b1cdbd2cSJim Jagielski SetRasterOp( ROP_XOR );
845*b1cdbd2cSJim Jagielski DrawGradient( aRect, rGradient );
846*b1cdbd2cSJim Jagielski SetFillColor( COL_BLACK );
847*b1cdbd2cSJim Jagielski SetRasterOp( ROP_0 );
848*b1cdbd2cSJim Jagielski DrawPolyPolygon( rPolyPoly );
849*b1cdbd2cSJim Jagielski SetRasterOp( ROP_XOR );
850*b1cdbd2cSJim Jagielski DrawGradient( aRect, rGradient );
851*b1cdbd2cSJim Jagielski Pop();
852*b1cdbd2cSJim Jagielski EnableOutput( bOldOutput );
853*b1cdbd2cSJim Jagielski }
854*b1cdbd2cSJim Jagielski
855*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaCommentAction( "XGRAD_SEQ_END" ) );
856*b1cdbd2cSJim Jagielski }
857*b1cdbd2cSJim Jagielski
858*b1cdbd2cSJim Jagielski if( !IsDeviceOutputNecessary() || ImplIsRecordLayout() )
859*b1cdbd2cSJim Jagielski return;
860*b1cdbd2cSJim Jagielski
861*b1cdbd2cSJim Jagielski Gradient aGradient( rGradient );
862*b1cdbd2cSJim Jagielski
863*b1cdbd2cSJim Jagielski if ( mnDrawMode & ( DRAWMODE_GRAYGRADIENT | DRAWMODE_GHOSTEDGRADIENT ) )
864*b1cdbd2cSJim Jagielski {
865*b1cdbd2cSJim Jagielski Color aStartCol( aGradient.GetStartColor() );
866*b1cdbd2cSJim Jagielski Color aEndCol( aGradient.GetEndColor() );
867*b1cdbd2cSJim Jagielski
868*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_GRAYGRADIENT )
869*b1cdbd2cSJim Jagielski {
870*b1cdbd2cSJim Jagielski sal_uInt8 cStartLum = aStartCol.GetLuminance(), cEndLum = aEndCol.GetLuminance();
871*b1cdbd2cSJim Jagielski aStartCol = Color( cStartLum, cStartLum, cStartLum );
872*b1cdbd2cSJim Jagielski aEndCol = Color( cEndLum, cEndLum, cEndLum );
873*b1cdbd2cSJim Jagielski }
874*b1cdbd2cSJim Jagielski
875*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_GHOSTEDGRADIENT )
876*b1cdbd2cSJim Jagielski {
877*b1cdbd2cSJim Jagielski aStartCol = Color( ( aStartCol.GetRed() >> 1 ) | 0x80,
878*b1cdbd2cSJim Jagielski ( aStartCol.GetGreen() >> 1 ) | 0x80,
879*b1cdbd2cSJim Jagielski ( aStartCol.GetBlue() >> 1 ) | 0x80 );
880*b1cdbd2cSJim Jagielski
881*b1cdbd2cSJim Jagielski aEndCol = Color( ( aEndCol.GetRed() >> 1 ) | 0x80,
882*b1cdbd2cSJim Jagielski ( aEndCol.GetGreen() >> 1 ) | 0x80,
883*b1cdbd2cSJim Jagielski ( aEndCol.GetBlue() >> 1 ) | 0x80 );
884*b1cdbd2cSJim Jagielski }
885*b1cdbd2cSJim Jagielski
886*b1cdbd2cSJim Jagielski aGradient.SetStartColor( aStartCol );
887*b1cdbd2cSJim Jagielski aGradient.SetEndColor( aEndCol );
888*b1cdbd2cSJim Jagielski }
889*b1cdbd2cSJim Jagielski
890*b1cdbd2cSJim Jagielski if( OUTDEV_PRINTER == meOutDevType || ImplGetSVData()->maGDIData.mbNoXORClipping )
891*b1cdbd2cSJim Jagielski {
892*b1cdbd2cSJim Jagielski const Rectangle aBoundRect( rPolyPoly.GetBoundRect() );
893*b1cdbd2cSJim Jagielski
894*b1cdbd2cSJim Jagielski if( !Rectangle( PixelToLogic( Point() ), GetOutputSize() ).IsEmpty() )
895*b1cdbd2cSJim Jagielski {
896*b1cdbd2cSJim Jagielski // Rechteck in Pixel umrechnen
897*b1cdbd2cSJim Jagielski Rectangle aRect( ImplLogicToDevicePixel( aBoundRect ) );
898*b1cdbd2cSJim Jagielski aRect.Justify();
899*b1cdbd2cSJim Jagielski
900*b1cdbd2cSJim Jagielski // Wenn Rechteck leer ist, brauchen wir nichts machen
901*b1cdbd2cSJim Jagielski if ( !aRect.IsEmpty() )
902*b1cdbd2cSJim Jagielski {
903*b1cdbd2cSJim Jagielski if( !mpGraphics && !ImplGetGraphics() )
904*b1cdbd2cSJim Jagielski return;
905*b1cdbd2cSJim Jagielski
906*b1cdbd2cSJim Jagielski if( mbInitClipRegion )
907*b1cdbd2cSJim Jagielski ImplInitClipRegion();
908*b1cdbd2cSJim Jagielski
909*b1cdbd2cSJim Jagielski if( !mbOutputClipped )
910*b1cdbd2cSJim Jagielski {
911*b1cdbd2cSJim Jagielski PolyPolygon aClipPolyPoly( ImplLogicToDevicePixel( rPolyPoly ) );
912*b1cdbd2cSJim Jagielski
913*b1cdbd2cSJim Jagielski // Gradienten werden ohne Umrandung gezeichnet
914*b1cdbd2cSJim Jagielski if( mbLineColor || mbInitLineColor )
915*b1cdbd2cSJim Jagielski {
916*b1cdbd2cSJim Jagielski mpGraphics->SetLineColor();
917*b1cdbd2cSJim Jagielski mbInitLineColor = sal_True;
918*b1cdbd2cSJim Jagielski }
919*b1cdbd2cSJim Jagielski
920*b1cdbd2cSJim Jagielski mbInitFillColor = sal_True;
921*b1cdbd2cSJim Jagielski
922*b1cdbd2cSJim Jagielski // calculate step count if neccessary
923*b1cdbd2cSJim Jagielski if ( !aGradient.GetSteps() )
924*b1cdbd2cSJim Jagielski aGradient.SetSteps( GRADIENT_DEFAULT_STEPCOUNT );
925*b1cdbd2cSJim Jagielski
926*b1cdbd2cSJim Jagielski if( aGradient.GetStyle() == GRADIENT_LINEAR || aGradient.GetStyle() == GRADIENT_AXIAL )
927*b1cdbd2cSJim Jagielski ImplDrawLinearGradient( aRect, aGradient, sal_False, &aClipPolyPoly );
928*b1cdbd2cSJim Jagielski else
929*b1cdbd2cSJim Jagielski ImplDrawComplexGradient( aRect, aGradient, sal_False, &aClipPolyPoly );
930*b1cdbd2cSJim Jagielski }
931*b1cdbd2cSJim Jagielski }
932*b1cdbd2cSJim Jagielski }
933*b1cdbd2cSJim Jagielski }
934*b1cdbd2cSJim Jagielski else
935*b1cdbd2cSJim Jagielski {
936*b1cdbd2cSJim Jagielski const PolyPolygon aPolyPoly( LogicToPixel( rPolyPoly ) );
937*b1cdbd2cSJim Jagielski const Rectangle aBoundRect( aPolyPoly.GetBoundRect() );
938*b1cdbd2cSJim Jagielski Point aPoint;
939*b1cdbd2cSJim Jagielski Rectangle aDstRect( aPoint, GetOutputSizePixel() );
940*b1cdbd2cSJim Jagielski
941*b1cdbd2cSJim Jagielski aDstRect.Intersection( aBoundRect );
942*b1cdbd2cSJim Jagielski
943*b1cdbd2cSJim Jagielski if( OUTDEV_WINDOW == meOutDevType )
944*b1cdbd2cSJim Jagielski {
945*b1cdbd2cSJim Jagielski const Region aPaintRgn( ( (Window*) this )->GetPaintRegion() );
946*b1cdbd2cSJim Jagielski
947*b1cdbd2cSJim Jagielski if( !aPaintRgn.IsNull() )
948*b1cdbd2cSJim Jagielski aDstRect.Intersection( LogicToPixel( aPaintRgn ).GetBoundRect() );
949*b1cdbd2cSJim Jagielski }
950*b1cdbd2cSJim Jagielski
951*b1cdbd2cSJim Jagielski if( !aDstRect.IsEmpty() )
952*b1cdbd2cSJim Jagielski {
953*b1cdbd2cSJim Jagielski VirtualDevice* pVDev;
954*b1cdbd2cSJim Jagielski const Size aDstSize( aDstRect.GetSize() );
955*b1cdbd2cSJim Jagielski
956*b1cdbd2cSJim Jagielski if( HasAlpha() )
957*b1cdbd2cSJim Jagielski {
958*b1cdbd2cSJim Jagielski // #110958# Pay attention to alpha VDevs here, otherwise,
959*b1cdbd2cSJim Jagielski // background will be wrong: Temp VDev has to have alpha, too.
960*b1cdbd2cSJim Jagielski pVDev = new VirtualDevice( *this, 0, GetAlphaBitCount() > 1 ? 0 : 1 );
961*b1cdbd2cSJim Jagielski }
962*b1cdbd2cSJim Jagielski else
963*b1cdbd2cSJim Jagielski {
964*b1cdbd2cSJim Jagielski // nothing special here. Plain VDev
965*b1cdbd2cSJim Jagielski pVDev = new VirtualDevice();
966*b1cdbd2cSJim Jagielski }
967*b1cdbd2cSJim Jagielski
968*b1cdbd2cSJim Jagielski if( pVDev->SetOutputSizePixel( aDstSize) )
969*b1cdbd2cSJim Jagielski {
970*b1cdbd2cSJim Jagielski MapMode aVDevMap;
971*b1cdbd2cSJim Jagielski const sal_Bool bOldMap = mbMap;
972*b1cdbd2cSJim Jagielski
973*b1cdbd2cSJim Jagielski EnableMapMode( sal_False );
974*b1cdbd2cSJim Jagielski
975*b1cdbd2cSJim Jagielski pVDev->DrawOutDev( Point(), aDstSize, aDstRect.TopLeft(), aDstSize, *this );
976*b1cdbd2cSJim Jagielski pVDev->SetRasterOp( ROP_XOR );
977*b1cdbd2cSJim Jagielski aVDevMap.SetOrigin( Point( -aDstRect.Left(), -aDstRect.Top() ) );
978*b1cdbd2cSJim Jagielski pVDev->SetMapMode( aVDevMap );
979*b1cdbd2cSJim Jagielski pVDev->DrawGradient( aBoundRect, aGradient );
980*b1cdbd2cSJim Jagielski pVDev->SetFillColor( COL_BLACK );
981*b1cdbd2cSJim Jagielski pVDev->SetRasterOp( ROP_0 );
982*b1cdbd2cSJim Jagielski pVDev->DrawPolyPolygon( aPolyPoly );
983*b1cdbd2cSJim Jagielski pVDev->SetRasterOp( ROP_XOR );
984*b1cdbd2cSJim Jagielski pVDev->DrawGradient( aBoundRect, aGradient );
985*b1cdbd2cSJim Jagielski aVDevMap.SetOrigin( Point() );
986*b1cdbd2cSJim Jagielski pVDev->SetMapMode( aVDevMap );
987*b1cdbd2cSJim Jagielski DrawOutDev( aDstRect.TopLeft(), aDstSize, Point(), aDstSize, *pVDev );
988*b1cdbd2cSJim Jagielski
989*b1cdbd2cSJim Jagielski EnableMapMode( bOldMap );
990*b1cdbd2cSJim Jagielski }
991*b1cdbd2cSJim Jagielski
992*b1cdbd2cSJim Jagielski delete pVDev;
993*b1cdbd2cSJim Jagielski }
994*b1cdbd2cSJim Jagielski }
995*b1cdbd2cSJim Jagielski }
996*b1cdbd2cSJim Jagielski
997*b1cdbd2cSJim Jagielski if( mpAlphaVDev )
998*b1cdbd2cSJim Jagielski mpAlphaVDev->DrawPolyPolygon( rPolyPoly );
999*b1cdbd2cSJim Jagielski }
1000*b1cdbd2cSJim Jagielski
1001*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
1002*b1cdbd2cSJim Jagielski
AddGradientActions(const Rectangle & rRect,const Gradient & rGradient,GDIMetaFile & rMtf)1003*b1cdbd2cSJim Jagielski void OutputDevice::AddGradientActions( const Rectangle& rRect, const Gradient& rGradient,
1004*b1cdbd2cSJim Jagielski GDIMetaFile& rMtf )
1005*b1cdbd2cSJim Jagielski {
1006*b1cdbd2cSJim Jagielski DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1007*b1cdbd2cSJim Jagielski DBG_CHKOBJ( &rGradient, Gradient, NULL );
1008*b1cdbd2cSJim Jagielski
1009*b1cdbd2cSJim Jagielski Rectangle aRect( rRect );
1010*b1cdbd2cSJim Jagielski
1011*b1cdbd2cSJim Jagielski aRect.Justify();
1012*b1cdbd2cSJim Jagielski
1013*b1cdbd2cSJim Jagielski // Wenn Rechteck leer ist, brauchen wir nichts machen
1014*b1cdbd2cSJim Jagielski if ( !aRect.IsEmpty() )
1015*b1cdbd2cSJim Jagielski {
1016*b1cdbd2cSJim Jagielski Gradient aGradient( rGradient );
1017*b1cdbd2cSJim Jagielski GDIMetaFile* pOldMtf = mpMetaFile;
1018*b1cdbd2cSJim Jagielski
1019*b1cdbd2cSJim Jagielski mpMetaFile = &rMtf;
1020*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPushAction( PUSH_ALL ) );
1021*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaISectRectClipRegionAction( aRect ) );
1022*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaLineColorAction( Color(), sal_False ) );
1023*b1cdbd2cSJim Jagielski
1024*b1cdbd2cSJim Jagielski // because we draw with no border line, we have to expand gradient
1025*b1cdbd2cSJim Jagielski // rect to avoid missing lines on the right and bottom edge
1026*b1cdbd2cSJim Jagielski aRect.Left()--;
1027*b1cdbd2cSJim Jagielski aRect.Top()--;
1028*b1cdbd2cSJim Jagielski aRect.Right()++;
1029*b1cdbd2cSJim Jagielski aRect.Bottom()++;
1030*b1cdbd2cSJim Jagielski
1031*b1cdbd2cSJim Jagielski // calculate step count if neccessary
1032*b1cdbd2cSJim Jagielski if ( !aGradient.GetSteps() )
1033*b1cdbd2cSJim Jagielski aGradient.SetSteps( GRADIENT_DEFAULT_STEPCOUNT );
1034*b1cdbd2cSJim Jagielski
1035*b1cdbd2cSJim Jagielski if( aGradient.GetStyle() == GRADIENT_LINEAR || aGradient.GetStyle() == GRADIENT_AXIAL )
1036*b1cdbd2cSJim Jagielski ImplDrawLinearGradient( aRect, aGradient, sal_True, NULL );
1037*b1cdbd2cSJim Jagielski else
1038*b1cdbd2cSJim Jagielski ImplDrawComplexGradient( aRect, aGradient, sal_True, NULL );
1039*b1cdbd2cSJim Jagielski
1040*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPopAction() );
1041*b1cdbd2cSJim Jagielski mpMetaFile = pOldMtf;
1042*b1cdbd2cSJim Jagielski }
1043*b1cdbd2cSJim Jagielski }
1044*b1cdbd2cSJim Jagielski
1045*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
1046*b1cdbd2cSJim Jagielski
DrawHatch(const PolyPolygon & rPolyPoly,const Hatch & rHatch)1047*b1cdbd2cSJim Jagielski void OutputDevice::DrawHatch( const PolyPolygon& rPolyPoly, const Hatch& rHatch )
1048*b1cdbd2cSJim Jagielski {
1049*b1cdbd2cSJim Jagielski DBG_TRACE( "OutputDevice::DrawHatch()" );
1050*b1cdbd2cSJim Jagielski DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1051*b1cdbd2cSJim Jagielski
1052*b1cdbd2cSJim Jagielski Hatch aHatch( rHatch );
1053*b1cdbd2cSJim Jagielski
1054*b1cdbd2cSJim Jagielski if ( mnDrawMode & ( DRAWMODE_BLACKLINE | DRAWMODE_WHITELINE |
1055*b1cdbd2cSJim Jagielski DRAWMODE_GRAYLINE | DRAWMODE_GHOSTEDLINE |
1056*b1cdbd2cSJim Jagielski DRAWMODE_SETTINGSLINE ) )
1057*b1cdbd2cSJim Jagielski {
1058*b1cdbd2cSJim Jagielski Color aColor( rHatch.GetColor() );
1059*b1cdbd2cSJim Jagielski
1060*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_BLACKLINE )
1061*b1cdbd2cSJim Jagielski aColor = Color( COL_BLACK );
1062*b1cdbd2cSJim Jagielski else if ( mnDrawMode & DRAWMODE_WHITELINE )
1063*b1cdbd2cSJim Jagielski aColor = Color( COL_WHITE );
1064*b1cdbd2cSJim Jagielski else if ( mnDrawMode & DRAWMODE_GRAYLINE )
1065*b1cdbd2cSJim Jagielski {
1066*b1cdbd2cSJim Jagielski const sal_uInt8 cLum = aColor.GetLuminance();
1067*b1cdbd2cSJim Jagielski aColor = Color( cLum, cLum, cLum );
1068*b1cdbd2cSJim Jagielski }
1069*b1cdbd2cSJim Jagielski else if( mnDrawMode & DRAWMODE_SETTINGSLINE )
1070*b1cdbd2cSJim Jagielski {
1071*b1cdbd2cSJim Jagielski aColor = GetSettings().GetStyleSettings().GetFontColor();
1072*b1cdbd2cSJim Jagielski }
1073*b1cdbd2cSJim Jagielski
1074*b1cdbd2cSJim Jagielski if ( mnDrawMode & DRAWMODE_GHOSTEDLINE )
1075*b1cdbd2cSJim Jagielski {
1076*b1cdbd2cSJim Jagielski aColor = Color( ( aColor.GetRed() >> 1 ) | 0x80,
1077*b1cdbd2cSJim Jagielski ( aColor.GetGreen() >> 1 ) | 0x80,
1078*b1cdbd2cSJim Jagielski ( aColor.GetBlue() >> 1 ) | 0x80);
1079*b1cdbd2cSJim Jagielski }
1080*b1cdbd2cSJim Jagielski
1081*b1cdbd2cSJim Jagielski aHatch.SetColor( aColor );
1082*b1cdbd2cSJim Jagielski }
1083*b1cdbd2cSJim Jagielski
1084*b1cdbd2cSJim Jagielski if( mpMetaFile )
1085*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaHatchAction( rPolyPoly, aHatch ) );
1086*b1cdbd2cSJim Jagielski
1087*b1cdbd2cSJim Jagielski if( !IsDeviceOutputNecessary() || ImplIsRecordLayout() )
1088*b1cdbd2cSJim Jagielski return;
1089*b1cdbd2cSJim Jagielski
1090*b1cdbd2cSJim Jagielski if( !mpGraphics && !ImplGetGraphics() )
1091*b1cdbd2cSJim Jagielski return;
1092*b1cdbd2cSJim Jagielski
1093*b1cdbd2cSJim Jagielski if( mbInitClipRegion )
1094*b1cdbd2cSJim Jagielski ImplInitClipRegion();
1095*b1cdbd2cSJim Jagielski
1096*b1cdbd2cSJim Jagielski if( mbOutputClipped )
1097*b1cdbd2cSJim Jagielski return;
1098*b1cdbd2cSJim Jagielski
1099*b1cdbd2cSJim Jagielski if( rPolyPoly.Count() )
1100*b1cdbd2cSJim Jagielski {
1101*b1cdbd2cSJim Jagielski PolyPolygon aPolyPoly( LogicToPixel( rPolyPoly ) );
1102*b1cdbd2cSJim Jagielski GDIMetaFile* pOldMetaFile = mpMetaFile;
1103*b1cdbd2cSJim Jagielski sal_Bool bOldMap = mbMap;
1104*b1cdbd2cSJim Jagielski
1105*b1cdbd2cSJim Jagielski aPolyPoly.Optimize( POLY_OPTIMIZE_NO_SAME );
1106*b1cdbd2cSJim Jagielski aHatch.SetDistance( ImplLogicWidthToDevicePixel( aHatch.GetDistance() ) );
1107*b1cdbd2cSJim Jagielski
1108*b1cdbd2cSJim Jagielski mpMetaFile = NULL;
1109*b1cdbd2cSJim Jagielski EnableMapMode( sal_False );
1110*b1cdbd2cSJim Jagielski Push( PUSH_LINECOLOR );
1111*b1cdbd2cSJim Jagielski SetLineColor( aHatch.GetColor() );
1112*b1cdbd2cSJim Jagielski ImplInitLineColor();
1113*b1cdbd2cSJim Jagielski ImplDrawHatch( aPolyPoly, aHatch, sal_False );
1114*b1cdbd2cSJim Jagielski Pop();
1115*b1cdbd2cSJim Jagielski EnableMapMode( bOldMap );
1116*b1cdbd2cSJim Jagielski mpMetaFile = pOldMetaFile;
1117*b1cdbd2cSJim Jagielski }
1118*b1cdbd2cSJim Jagielski
1119*b1cdbd2cSJim Jagielski if( mpAlphaVDev )
1120*b1cdbd2cSJim Jagielski mpAlphaVDev->DrawHatch( rPolyPoly, rHatch );
1121*b1cdbd2cSJim Jagielski }
1122*b1cdbd2cSJim Jagielski
1123*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
1124*b1cdbd2cSJim Jagielski
AddHatchActions(const PolyPolygon & rPolyPoly,const Hatch & rHatch,GDIMetaFile & rMtf)1125*b1cdbd2cSJim Jagielski void OutputDevice::AddHatchActions( const PolyPolygon& rPolyPoly, const Hatch& rHatch,
1126*b1cdbd2cSJim Jagielski GDIMetaFile& rMtf )
1127*b1cdbd2cSJim Jagielski {
1128*b1cdbd2cSJim Jagielski DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
1129*b1cdbd2cSJim Jagielski
1130*b1cdbd2cSJim Jagielski PolyPolygon aPolyPoly( rPolyPoly );
1131*b1cdbd2cSJim Jagielski aPolyPoly.Optimize( POLY_OPTIMIZE_NO_SAME | POLY_OPTIMIZE_CLOSE );
1132*b1cdbd2cSJim Jagielski
1133*b1cdbd2cSJim Jagielski if( aPolyPoly.Count() )
1134*b1cdbd2cSJim Jagielski {
1135*b1cdbd2cSJim Jagielski GDIMetaFile* pOldMtf = mpMetaFile;
1136*b1cdbd2cSJim Jagielski
1137*b1cdbd2cSJim Jagielski mpMetaFile = &rMtf;
1138*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPushAction( PUSH_ALL ) );
1139*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaLineColorAction( rHatch.GetColor(), sal_True ) );
1140*b1cdbd2cSJim Jagielski ImplDrawHatch( aPolyPoly, rHatch, sal_True );
1141*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaPopAction() );
1142*b1cdbd2cSJim Jagielski mpMetaFile = pOldMtf;
1143*b1cdbd2cSJim Jagielski }
1144*b1cdbd2cSJim Jagielski }
1145*b1cdbd2cSJim Jagielski
1146*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
1147*b1cdbd2cSJim Jagielski
ImplDrawHatch(const PolyPolygon & rPolyPoly,const Hatch & rHatch,sal_Bool bMtf)1148*b1cdbd2cSJim Jagielski void OutputDevice::ImplDrawHatch( const PolyPolygon& rPolyPoly, const Hatch& rHatch, sal_Bool bMtf )
1149*b1cdbd2cSJim Jagielski {
1150*b1cdbd2cSJim Jagielski if(rPolyPoly.Count())
1151*b1cdbd2cSJim Jagielski {
1152*b1cdbd2cSJim Jagielski // #115630# ImplDrawHatch does not work with beziers included in the polypolygon, take care of that
1153*b1cdbd2cSJim Jagielski bool bIsCurve(false);
1154*b1cdbd2cSJim Jagielski
1155*b1cdbd2cSJim Jagielski for(sal_uInt16 a(0); !bIsCurve && a < rPolyPoly.Count(); a++)
1156*b1cdbd2cSJim Jagielski {
1157*b1cdbd2cSJim Jagielski if(rPolyPoly[a].HasFlags())
1158*b1cdbd2cSJim Jagielski {
1159*b1cdbd2cSJim Jagielski bIsCurve = true;
1160*b1cdbd2cSJim Jagielski }
1161*b1cdbd2cSJim Jagielski }
1162*b1cdbd2cSJim Jagielski
1163*b1cdbd2cSJim Jagielski if(bIsCurve)
1164*b1cdbd2cSJim Jagielski {
1165*b1cdbd2cSJim Jagielski OSL_ENSURE(false, "ImplDrawHatch does *not* support curves, falling back to AdaptiveSubdivide()...");
1166*b1cdbd2cSJim Jagielski PolyPolygon aPolyPoly;
1167*b1cdbd2cSJim Jagielski
1168*b1cdbd2cSJim Jagielski rPolyPoly.AdaptiveSubdivide(aPolyPoly);
1169*b1cdbd2cSJim Jagielski ImplDrawHatch(aPolyPoly, rHatch, bMtf);
1170*b1cdbd2cSJim Jagielski }
1171*b1cdbd2cSJim Jagielski else
1172*b1cdbd2cSJim Jagielski {
1173*b1cdbd2cSJim Jagielski Rectangle aRect( rPolyPoly.GetBoundRect() );
1174*b1cdbd2cSJim Jagielski const long nLogPixelWidth = ImplDevicePixelToLogicWidth( 1 );
1175*b1cdbd2cSJim Jagielski const long nWidth = ImplDevicePixelToLogicWidth( Max( ImplLogicWidthToDevicePixel( rHatch.GetDistance() ), 3L ) );
1176*b1cdbd2cSJim Jagielski Point* pPtBuffer = new Point[ HATCH_MAXPOINTS ];
1177*b1cdbd2cSJim Jagielski Point aPt1, aPt2, aEndPt1;
1178*b1cdbd2cSJim Jagielski Size aInc;
1179*b1cdbd2cSJim Jagielski
1180*b1cdbd2cSJim Jagielski // Single hatch
1181*b1cdbd2cSJim Jagielski aRect.Left() -= nLogPixelWidth; aRect.Top() -= nLogPixelWidth; aRect.Right() += nLogPixelWidth; aRect.Bottom() += nLogPixelWidth;
1182*b1cdbd2cSJim Jagielski ImplCalcHatchValues( aRect, nWidth, rHatch.GetAngle(), aPt1, aPt2, aInc, aEndPt1 );
1183*b1cdbd2cSJim Jagielski do
1184*b1cdbd2cSJim Jagielski {
1185*b1cdbd2cSJim Jagielski ImplDrawHatchLine( Line( aPt1, aPt2 ), rPolyPoly, pPtBuffer, bMtf );
1186*b1cdbd2cSJim Jagielski aPt1.X() += aInc.Width(); aPt1.Y() += aInc.Height();
1187*b1cdbd2cSJim Jagielski aPt2.X() += aInc.Width(); aPt2.Y() += aInc.Height();
1188*b1cdbd2cSJim Jagielski }
1189*b1cdbd2cSJim Jagielski while( ( aPt1.X() <= aEndPt1.X() ) && ( aPt1.Y() <= aEndPt1.Y() ) );
1190*b1cdbd2cSJim Jagielski
1191*b1cdbd2cSJim Jagielski if( ( rHatch.GetStyle() == HATCH_DOUBLE ) || ( rHatch.GetStyle() == HATCH_TRIPLE ) )
1192*b1cdbd2cSJim Jagielski {
1193*b1cdbd2cSJim Jagielski // Double hatch
1194*b1cdbd2cSJim Jagielski ImplCalcHatchValues( aRect, nWidth, rHatch.GetAngle() + 900, aPt1, aPt2, aInc, aEndPt1 );
1195*b1cdbd2cSJim Jagielski do
1196*b1cdbd2cSJim Jagielski {
1197*b1cdbd2cSJim Jagielski ImplDrawHatchLine( Line( aPt1, aPt2 ), rPolyPoly, pPtBuffer, bMtf );
1198*b1cdbd2cSJim Jagielski aPt1.X() += aInc.Width(); aPt1.Y() += aInc.Height();
1199*b1cdbd2cSJim Jagielski aPt2.X() += aInc.Width(); aPt2.Y() += aInc.Height();
1200*b1cdbd2cSJim Jagielski }
1201*b1cdbd2cSJim Jagielski while( ( aPt1.X() <= aEndPt1.X() ) && ( aPt1.Y() <= aEndPt1.Y() ) );
1202*b1cdbd2cSJim Jagielski
1203*b1cdbd2cSJim Jagielski if( rHatch.GetStyle() == HATCH_TRIPLE )
1204*b1cdbd2cSJim Jagielski {
1205*b1cdbd2cSJim Jagielski // Triple hatch
1206*b1cdbd2cSJim Jagielski ImplCalcHatchValues( aRect, nWidth, rHatch.GetAngle() + 450, aPt1, aPt2, aInc, aEndPt1 );
1207*b1cdbd2cSJim Jagielski do
1208*b1cdbd2cSJim Jagielski {
1209*b1cdbd2cSJim Jagielski ImplDrawHatchLine( Line( aPt1, aPt2 ), rPolyPoly, pPtBuffer, bMtf );
1210*b1cdbd2cSJim Jagielski aPt1.X() += aInc.Width(); aPt1.Y() += aInc.Height();
1211*b1cdbd2cSJim Jagielski aPt2.X() += aInc.Width(); aPt2.Y() += aInc.Height();
1212*b1cdbd2cSJim Jagielski }
1213*b1cdbd2cSJim Jagielski while( ( aPt1.X() <= aEndPt1.X() ) && ( aPt1.Y() <= aEndPt1.Y() ) );
1214*b1cdbd2cSJim Jagielski }
1215*b1cdbd2cSJim Jagielski }
1216*b1cdbd2cSJim Jagielski
1217*b1cdbd2cSJim Jagielski delete[] pPtBuffer;
1218*b1cdbd2cSJim Jagielski }
1219*b1cdbd2cSJim Jagielski }
1220*b1cdbd2cSJim Jagielski }
1221*b1cdbd2cSJim Jagielski
1222*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
1223*b1cdbd2cSJim Jagielski
ImplCalcHatchValues(const Rectangle & rRect,long nDist,sal_uInt16 nAngle10,Point & rPt1,Point & rPt2,Size & rInc,Point & rEndPt1)1224*b1cdbd2cSJim Jagielski void OutputDevice::ImplCalcHatchValues( const Rectangle& rRect, long nDist, sal_uInt16 nAngle10,
1225*b1cdbd2cSJim Jagielski Point& rPt1, Point& rPt2, Size& rInc, Point& rEndPt1 )
1226*b1cdbd2cSJim Jagielski {
1227*b1cdbd2cSJim Jagielski Point aRef;
1228*b1cdbd2cSJim Jagielski long nAngle = nAngle10 % 1800;
1229*b1cdbd2cSJim Jagielski long nOffset = 0;
1230*b1cdbd2cSJim Jagielski
1231*b1cdbd2cSJim Jagielski if( nAngle > 900 )
1232*b1cdbd2cSJim Jagielski nAngle -= 1800;
1233*b1cdbd2cSJim Jagielski
1234*b1cdbd2cSJim Jagielski aRef = ( !IsRefPoint() ? rRect.TopLeft() : GetRefPoint() );
1235*b1cdbd2cSJim Jagielski
1236*b1cdbd2cSJim Jagielski if( 0 == nAngle )
1237*b1cdbd2cSJim Jagielski {
1238*b1cdbd2cSJim Jagielski rInc = Size( 0, nDist );
1239*b1cdbd2cSJim Jagielski rPt1 = rRect.TopLeft();
1240*b1cdbd2cSJim Jagielski rPt2 = rRect.TopRight();
1241*b1cdbd2cSJim Jagielski rEndPt1 = rRect.BottomLeft();
1242*b1cdbd2cSJim Jagielski
1243*b1cdbd2cSJim Jagielski if( aRef.Y() <= rRect.Top() )
1244*b1cdbd2cSJim Jagielski nOffset = ( ( rRect.Top() - aRef.Y() ) % nDist );
1245*b1cdbd2cSJim Jagielski else
1246*b1cdbd2cSJim Jagielski nOffset = ( nDist - ( ( aRef.Y() - rRect.Top() ) % nDist ) );
1247*b1cdbd2cSJim Jagielski
1248*b1cdbd2cSJim Jagielski rPt1.Y() -= nOffset;
1249*b1cdbd2cSJim Jagielski rPt2.Y() -= nOffset;
1250*b1cdbd2cSJim Jagielski }
1251*b1cdbd2cSJim Jagielski else if( 900 == nAngle )
1252*b1cdbd2cSJim Jagielski {
1253*b1cdbd2cSJim Jagielski rInc = Size( nDist, 0 );
1254*b1cdbd2cSJim Jagielski rPt1 = rRect.TopLeft();
1255*b1cdbd2cSJim Jagielski rPt2 = rRect.BottomLeft();
1256*b1cdbd2cSJim Jagielski rEndPt1 = rRect.TopRight();
1257*b1cdbd2cSJim Jagielski
1258*b1cdbd2cSJim Jagielski if( aRef.X() <= rRect.Left() )
1259*b1cdbd2cSJim Jagielski nOffset = ( rRect.Left() - aRef.X() ) % nDist;
1260*b1cdbd2cSJim Jagielski else
1261*b1cdbd2cSJim Jagielski nOffset = nDist - ( ( aRef.X() - rRect.Left() ) % nDist );
1262*b1cdbd2cSJim Jagielski
1263*b1cdbd2cSJim Jagielski rPt1.X() -= nOffset;
1264*b1cdbd2cSJim Jagielski rPt2.X() -= nOffset;
1265*b1cdbd2cSJim Jagielski }
1266*b1cdbd2cSJim Jagielski else if( nAngle >= -450 && nAngle <= 450 )
1267*b1cdbd2cSJim Jagielski {
1268*b1cdbd2cSJim Jagielski const double fAngle = F_PI1800 * labs( nAngle );
1269*b1cdbd2cSJim Jagielski const double fTan = tan( fAngle );
1270*b1cdbd2cSJim Jagielski const long nYOff = FRound( ( rRect.Right() - rRect.Left() ) * fTan );
1271*b1cdbd2cSJim Jagielski long nPY;
1272*b1cdbd2cSJim Jagielski
1273*b1cdbd2cSJim Jagielski rInc = Size( 0, nDist = FRound( nDist / cos( fAngle ) ) );
1274*b1cdbd2cSJim Jagielski
1275*b1cdbd2cSJim Jagielski if( nAngle > 0 )
1276*b1cdbd2cSJim Jagielski {
1277*b1cdbd2cSJim Jagielski rPt1 = rRect.TopLeft();
1278*b1cdbd2cSJim Jagielski rPt2 = Point( rRect.Right(), rRect.Top() - nYOff );
1279*b1cdbd2cSJim Jagielski rEndPt1 = Point( rRect.Left(), rRect.Bottom() + nYOff );
1280*b1cdbd2cSJim Jagielski nPY = FRound( aRef.Y() - ( ( rPt1.X() - aRef.X() ) * fTan ) );
1281*b1cdbd2cSJim Jagielski }
1282*b1cdbd2cSJim Jagielski else
1283*b1cdbd2cSJim Jagielski {
1284*b1cdbd2cSJim Jagielski rPt1 = rRect.TopRight();
1285*b1cdbd2cSJim Jagielski rPt2 = Point( rRect.Left(), rRect.Top() - nYOff );
1286*b1cdbd2cSJim Jagielski rEndPt1 = Point( rRect.Right(), rRect.Bottom() + nYOff );
1287*b1cdbd2cSJim Jagielski nPY = FRound( aRef.Y() + ( ( rPt1.X() - aRef.X() ) * fTan ) );
1288*b1cdbd2cSJim Jagielski }
1289*b1cdbd2cSJim Jagielski
1290*b1cdbd2cSJim Jagielski if( nPY <= rPt1.Y() )
1291*b1cdbd2cSJim Jagielski nOffset = ( rPt1.Y() - nPY ) % nDist;
1292*b1cdbd2cSJim Jagielski else
1293*b1cdbd2cSJim Jagielski nOffset = nDist - ( ( nPY - rPt1.Y() ) % nDist );
1294*b1cdbd2cSJim Jagielski
1295*b1cdbd2cSJim Jagielski rPt1.Y() -= nOffset;
1296*b1cdbd2cSJim Jagielski rPt2.Y() -= nOffset;
1297*b1cdbd2cSJim Jagielski }
1298*b1cdbd2cSJim Jagielski else
1299*b1cdbd2cSJim Jagielski {
1300*b1cdbd2cSJim Jagielski const double fAngle = F_PI1800 * labs( nAngle );
1301*b1cdbd2cSJim Jagielski const double fTan = tan( fAngle );
1302*b1cdbd2cSJim Jagielski const long nXOff = FRound( ( rRect.Bottom() - rRect.Top() ) / fTan );
1303*b1cdbd2cSJim Jagielski long nPX;
1304*b1cdbd2cSJim Jagielski
1305*b1cdbd2cSJim Jagielski rInc = Size( nDist = FRound( nDist / sin( fAngle ) ), 0 );
1306*b1cdbd2cSJim Jagielski
1307*b1cdbd2cSJim Jagielski if( nAngle > 0 )
1308*b1cdbd2cSJim Jagielski {
1309*b1cdbd2cSJim Jagielski rPt1 = rRect.TopLeft();
1310*b1cdbd2cSJim Jagielski rPt2 = Point( rRect.Left() - nXOff, rRect.Bottom() );
1311*b1cdbd2cSJim Jagielski rEndPt1 = Point( rRect.Right() + nXOff, rRect.Top() );
1312*b1cdbd2cSJim Jagielski nPX = FRound( aRef.X() - ( ( rPt1.Y() - aRef.Y() ) / fTan ) );
1313*b1cdbd2cSJim Jagielski }
1314*b1cdbd2cSJim Jagielski else
1315*b1cdbd2cSJim Jagielski {
1316*b1cdbd2cSJim Jagielski rPt1 = rRect.BottomLeft();
1317*b1cdbd2cSJim Jagielski rPt2 = Point( rRect.Left() - nXOff, rRect.Top() );
1318*b1cdbd2cSJim Jagielski rEndPt1 = Point( rRect.Right() + nXOff, rRect.Bottom() );
1319*b1cdbd2cSJim Jagielski nPX = FRound( aRef.X() + ( ( rPt1.Y() - aRef.Y() ) / fTan ) );
1320*b1cdbd2cSJim Jagielski }
1321*b1cdbd2cSJim Jagielski
1322*b1cdbd2cSJim Jagielski if( nPX <= rPt1.X() )
1323*b1cdbd2cSJim Jagielski nOffset = ( rPt1.X() - nPX ) % nDist;
1324*b1cdbd2cSJim Jagielski else
1325*b1cdbd2cSJim Jagielski nOffset = nDist - ( ( nPX - rPt1.X() ) % nDist );
1326*b1cdbd2cSJim Jagielski
1327*b1cdbd2cSJim Jagielski rPt1.X() -= nOffset;
1328*b1cdbd2cSJim Jagielski rPt2.X() -= nOffset;
1329*b1cdbd2cSJim Jagielski }
1330*b1cdbd2cSJim Jagielski }
1331*b1cdbd2cSJim Jagielski
1332*b1cdbd2cSJim Jagielski // ------------------------------------------------------------------------
1333*b1cdbd2cSJim Jagielski
ImplDrawHatchLine(const Line & rLine,const PolyPolygon & rPolyPoly,Point * pPtBuffer,sal_Bool bMtf)1334*b1cdbd2cSJim Jagielski void OutputDevice::ImplDrawHatchLine( const Line& rLine, const PolyPolygon& rPolyPoly,
1335*b1cdbd2cSJim Jagielski Point* pPtBuffer, sal_Bool bMtf )
1336*b1cdbd2cSJim Jagielski {
1337*b1cdbd2cSJim Jagielski double fX, fY;
1338*b1cdbd2cSJim Jagielski long nAdd, nPCounter = 0;
1339*b1cdbd2cSJim Jagielski
1340*b1cdbd2cSJim Jagielski for( long nPoly = 0, nPolyCount = rPolyPoly.Count(); nPoly < nPolyCount; nPoly++ )
1341*b1cdbd2cSJim Jagielski {
1342*b1cdbd2cSJim Jagielski const Polygon& rPoly = rPolyPoly[ (sal_uInt16) nPoly ];
1343*b1cdbd2cSJim Jagielski
1344*b1cdbd2cSJim Jagielski if( rPoly.GetSize() > 1 )
1345*b1cdbd2cSJim Jagielski {
1346*b1cdbd2cSJim Jagielski Line aCurSegment( rPoly[ 0 ], Point() );
1347*b1cdbd2cSJim Jagielski
1348*b1cdbd2cSJim Jagielski for( long i = 1, nCount = rPoly.GetSize(); i <= nCount; i++ )
1349*b1cdbd2cSJim Jagielski {
1350*b1cdbd2cSJim Jagielski aCurSegment.SetEnd( rPoly[ (sal_uInt16)( i % nCount ) ] );
1351*b1cdbd2cSJim Jagielski nAdd = 0;
1352*b1cdbd2cSJim Jagielski
1353*b1cdbd2cSJim Jagielski if( rLine.Intersection( aCurSegment, fX, fY ) )
1354*b1cdbd2cSJim Jagielski {
1355*b1cdbd2cSJim Jagielski if( ( fabs( fX - aCurSegment.GetStart().X() ) <= 0.0000001 ) &&
1356*b1cdbd2cSJim Jagielski ( fabs( fY - aCurSegment.GetStart().Y() ) <= 0.0000001 ) )
1357*b1cdbd2cSJim Jagielski {
1358*b1cdbd2cSJim Jagielski const Line aPrevSegment( rPoly[ (sal_uInt16)( ( i > 1 ) ? ( i - 2 ) : ( nCount - 1 ) ) ], aCurSegment.GetStart() );
1359*b1cdbd2cSJim Jagielski const double fPrevDistance = rLine.GetDistance( aPrevSegment.GetStart() );
1360*b1cdbd2cSJim Jagielski const double fCurDistance = rLine.GetDistance( aCurSegment.GetEnd() );
1361*b1cdbd2cSJim Jagielski
1362*b1cdbd2cSJim Jagielski if( ( fPrevDistance <= 0.0 && fCurDistance > 0.0 ) ||
1363*b1cdbd2cSJim Jagielski ( fPrevDistance > 0.0 && fCurDistance < 0.0 ) )
1364*b1cdbd2cSJim Jagielski {
1365*b1cdbd2cSJim Jagielski nAdd = 1;
1366*b1cdbd2cSJim Jagielski }
1367*b1cdbd2cSJim Jagielski }
1368*b1cdbd2cSJim Jagielski else if( ( fabs( fX - aCurSegment.GetEnd().X() ) <= 0.0000001 ) &&
1369*b1cdbd2cSJim Jagielski ( fabs( fY - aCurSegment.GetEnd().Y() ) <= 0.0000001 ) )
1370*b1cdbd2cSJim Jagielski {
1371*b1cdbd2cSJim Jagielski const Line aNextSegment( aCurSegment.GetEnd(), rPoly[ (sal_uInt16)( ( i + 1 ) % nCount ) ] );
1372*b1cdbd2cSJim Jagielski
1373*b1cdbd2cSJim Jagielski if( ( fabs( rLine.GetDistance( aNextSegment.GetEnd() ) ) <= 0.0000001 ) &&
1374*b1cdbd2cSJim Jagielski ( rLine.GetDistance( aCurSegment.GetStart() ) > 0.0 ) )
1375*b1cdbd2cSJim Jagielski {
1376*b1cdbd2cSJim Jagielski nAdd = 1;
1377*b1cdbd2cSJim Jagielski }
1378*b1cdbd2cSJim Jagielski }
1379*b1cdbd2cSJim Jagielski else
1380*b1cdbd2cSJim Jagielski nAdd = 1;
1381*b1cdbd2cSJim Jagielski
1382*b1cdbd2cSJim Jagielski if( nAdd )
1383*b1cdbd2cSJim Jagielski pPtBuffer[ nPCounter++ ] = Point( FRound( fX ), FRound( fY ) );
1384*b1cdbd2cSJim Jagielski }
1385*b1cdbd2cSJim Jagielski
1386*b1cdbd2cSJim Jagielski aCurSegment.SetStart( aCurSegment.GetEnd() );
1387*b1cdbd2cSJim Jagielski }
1388*b1cdbd2cSJim Jagielski }
1389*b1cdbd2cSJim Jagielski }
1390*b1cdbd2cSJim Jagielski
1391*b1cdbd2cSJim Jagielski if( nPCounter > 1 )
1392*b1cdbd2cSJim Jagielski {
1393*b1cdbd2cSJim Jagielski qsort( pPtBuffer, nPCounter, sizeof( Point ), ImplHatchCmpFnc );
1394*b1cdbd2cSJim Jagielski
1395*b1cdbd2cSJim Jagielski if( nPCounter & 1 )
1396*b1cdbd2cSJim Jagielski nPCounter--;
1397*b1cdbd2cSJim Jagielski
1398*b1cdbd2cSJim Jagielski if( bMtf )
1399*b1cdbd2cSJim Jagielski {
1400*b1cdbd2cSJim Jagielski for( long i = 0; i < nPCounter; i += 2 )
1401*b1cdbd2cSJim Jagielski mpMetaFile->AddAction( new MetaLineAction( pPtBuffer[ i ], pPtBuffer[ i + 1 ] ) );
1402*b1cdbd2cSJim Jagielski }
1403*b1cdbd2cSJim Jagielski else
1404*b1cdbd2cSJim Jagielski {
1405*b1cdbd2cSJim Jagielski for( long i = 0; i < nPCounter; i += 2 )
1406*b1cdbd2cSJim Jagielski {
1407*b1cdbd2cSJim Jagielski if( mpPDFWriter )
1408*b1cdbd2cSJim Jagielski {
1409*b1cdbd2cSJim Jagielski mpPDFWriter->drawLine( pPtBuffer[ i ], pPtBuffer[ i+1 ] );
1410*b1cdbd2cSJim Jagielski }
1411*b1cdbd2cSJim Jagielski else
1412*b1cdbd2cSJim Jagielski {
1413*b1cdbd2cSJim Jagielski const Point aPt1( ImplLogicToDevicePixel( pPtBuffer[ i ] ) );
1414*b1cdbd2cSJim Jagielski const Point aPt2( ImplLogicToDevicePixel( pPtBuffer[ i + 1 ] ) );
1415*b1cdbd2cSJim Jagielski mpGraphics->DrawLine( aPt1.X(), aPt1.Y(), aPt2.X(), aPt2.Y(), this );
1416*b1cdbd2cSJim Jagielski }
1417*b1cdbd2cSJim Jagielski }
1418*b1cdbd2cSJim Jagielski }
1419*b1cdbd2cSJim Jagielski }
1420*b1cdbd2cSJim Jagielski }
1421