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