Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <tools/debug.hxx>
21 : #include <tools/poly.hxx>
22 :
23 : #include <vcl/svapp.hxx>
24 : #include <vcl/region.hxx>
25 : #include <vcl/virdev.hxx>
26 : #include <vcl/window.hxx>
27 : #include <vcl/metaact.hxx>
28 : #include <vcl/gdimtf.hxx>
29 : #include <vcl/print.hxx>
30 : #include <vcl/outdev.hxx>
31 : #include <vcl/unowrap.hxx>
32 : #include <vcl/settings.hxx>
33 :
34 : #include <window.h>
35 : #include <outdev.h>
36 : #include <sallayout.hxx>
37 : #include <salgdi.hxx>
38 : #include <salframe.hxx>
39 : #include <salvd.hxx>
40 : #include <salprn.hxx>
41 : #include <svdata.hxx>
42 : #include <outdata.hxx>
43 : #include <boost/scoped_array.hpp>
44 : #include <boost/scoped_ptr.hpp>
45 :
46 : #include "basegfx/polygon/b2dpolygon.hxx"
47 :
48 : // The only common SalFrame method
49 :
50 44988 : SalFrameGeometry SalFrame::GetGeometry()
51 : {
52 : // mirror frame coordinates at parent
53 44988 : SalFrame *pParent = GetParent();
54 44988 : if( pParent && Application::GetSettings().GetLayoutRTL() )
55 : {
56 0 : SalFrameGeometry aGeom = maGeometry;
57 0 : int parent_x = aGeom.nX - pParent->maGeometry.nX;
58 0 : aGeom.nX = pParent->maGeometry.nX + pParent->maGeometry.nWidth - maGeometry.nWidth - parent_x;
59 0 : return aGeom;
60 : }
61 : else
62 44988 : return maGeometry;
63 : }
64 :
65 629208 : SalGraphics::SalGraphics()
66 : : m_nLayout( 0 ),
67 629208 : m_bAntiAliasB2DDraw(false)
68 : {
69 : // read global RTL settings
70 629208 : if( Application::GetSettings().GetLayoutRTL() )
71 0 : m_nLayout = SAL_LAYOUT_BIDI_RTL;
72 629208 : }
73 :
74 628417 : SalGraphics::~SalGraphics()
75 : {
76 628417 : }
77 :
78 0 : bool SalGraphics::drawTransformedBitmap(
79 : const basegfx::B2DPoint& /* rNull */,
80 : const basegfx::B2DPoint& /* rX */,
81 : const basegfx::B2DPoint& /* rY */,
82 : const SalBitmap& /* rSourceBitmap */,
83 : const SalBitmap* /* pAlphaBitmap */)
84 : {
85 : // here direct support for transformed bitmaps can be impemented
86 0 : return false;
87 : }
88 :
89 2852 : void SalGraphics::mirror( long& x, const OutputDevice *pOutDev, bool bBack ) const
90 : {
91 : long w;
92 2852 : if( pOutDev && pOutDev->GetOutDevType() == OUTDEV_VIRDEV )
93 2558 : w = pOutDev->GetOutputWidthPixel();
94 : else
95 294 : w = GetGraphicsWidth();
96 :
97 2852 : if( w )
98 : {
99 2852 : if( pOutDev && pOutDev->ImplIsAntiparallel() )
100 : {
101 294 : OutputDevice *pOutDevRef = (OutputDevice*) pOutDev;
102 : // mirror this window back
103 294 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) )
104 : {
105 0 : long devX = w-pOutDevRef->GetOutputWidthPixel()-pOutDevRef->GetOutOffXPixel(); // re-mirrored mnOutOffX
106 0 : if( bBack )
107 0 : x = x - devX + pOutDevRef->GetOutOffXPixel();
108 : else
109 0 : x = devX + (x - pOutDevRef->GetOutOffXPixel());
110 : }
111 : else
112 : {
113 294 : long devX = pOutDevRef->GetOutOffXPixel(); // re-mirrored mnOutOffX
114 294 : if( bBack )
115 0 : x = devX + (pOutDevRef->GetOutputWidthPixel() + devX) - (x + 1);
116 : else
117 294 : x = pOutDevRef->GetOutputWidthPixel() - (x - devX) + pOutDevRef->GetOutOffXPixel() - 1;
118 : }
119 : }
120 2558 : else if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) )
121 2558 : x = w-1-x;
122 : }
123 2852 : }
124 :
125 4606 : void SalGraphics::mirror( long& x, long& nWidth, const OutputDevice *pOutDev, bool bBack ) const
126 : {
127 : long w;
128 4606 : if( pOutDev && pOutDev->GetOutDevType() == OUTDEV_VIRDEV )
129 4431 : w = pOutDev->GetOutputWidthPixel();
130 : else
131 175 : w = GetGraphicsWidth();
132 :
133 4606 : if( w )
134 : {
135 4606 : if( pOutDev && pOutDev->ImplIsAntiparallel() )
136 : {
137 175 : OutputDevice *pOutDevRef = (OutputDevice*) pOutDev;
138 : // mirror this window back
139 175 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) )
140 : {
141 0 : long devX = w-pOutDevRef->GetOutputWidthPixel()-pOutDevRef->GetOutOffXPixel(); // re-mirrored mnOutOffX
142 0 : if( bBack )
143 0 : x = x - devX + pOutDevRef->GetOutOffXPixel();
144 : else
145 0 : x = devX + (x - pOutDevRef->GetOutOffXPixel());
146 : }
147 : else
148 : {
149 175 : long devX = pOutDevRef->GetOutOffXPixel(); // re-mirrored mnOutOffX
150 175 : if( bBack )
151 0 : x = devX + (pOutDevRef->GetOutputWidthPixel() + devX) - (x + nWidth);
152 : else
153 175 : x = pOutDevRef->GetOutputWidthPixel() - (x - devX) + pOutDevRef->GetOutOffXPixel() - nWidth;
154 : }
155 : }
156 4431 : else if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) )
157 4431 : x = w-nWidth-x;
158 :
159 : }
160 4606 : }
161 :
162 1364 : bool SalGraphics::mirror( sal_uInt32 nPoints, const SalPoint *pPtAry, SalPoint *pPtAry2, const OutputDevice *pOutDev, bool bBack ) const
163 : {
164 : long w;
165 1364 : if( pOutDev && pOutDev->GetOutDevType() == OUTDEV_VIRDEV )
166 1364 : w = pOutDev->GetOutputWidthPixel();
167 : else
168 0 : w = GetGraphicsWidth();
169 :
170 1364 : if( w )
171 : {
172 : sal_uInt32 i, j;
173 :
174 1364 : if( pOutDev && pOutDev->ImplIsAntiparallel() )
175 : {
176 0 : OutputDevice *pOutDevRef = (OutputDevice*) pOutDev;
177 : // mirror this window back
178 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) )
179 : {
180 0 : long devX = w-pOutDevRef->GetOutputWidthPixel()-pOutDevRef->GetOutOffXPixel(); // re-mirrored mnOutOffX
181 0 : if( bBack )
182 : {
183 0 : for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
184 : {
185 : //long x = w-1-pPtAry[i].mnX;
186 : //pPtAry2[j].mnX = devX + ( pOutDevRef->mnOutWidth - 1 - (x - devX) );
187 0 : pPtAry2[j].mnX = pOutDevRef->GetOutOffXPixel() + (pPtAry[i].mnX - devX);
188 0 : pPtAry2[j].mnY = pPtAry[i].mnY;
189 : }
190 : }
191 : else
192 : {
193 0 : for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
194 : {
195 : //long x = w-1-pPtAry[i].mnX;
196 : //pPtAry2[j].mnX = devX + ( pOutDevRef->mnOutWidth - 1 - (x - devX) );
197 0 : pPtAry2[j].mnX = devX + (pPtAry[i].mnX - pOutDevRef->GetOutOffXPixel());
198 0 : pPtAry2[j].mnY = pPtAry[i].mnY;
199 : }
200 : }
201 : }
202 : else
203 : {
204 0 : long devX = pOutDevRef->GetOutOffXPixel(); // re-mirrored mnOutOffX
205 0 : if( bBack )
206 : {
207 0 : for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
208 : {
209 : //long x = w-1-pPtAry[i].mnX;
210 : //pPtAry2[j].mnX = devX + ( pOutDevRef->mnOutWidth - 1 - (x - devX) );
211 0 : pPtAry2[j].mnX = pPtAry[i].mnX - pOutDevRef->GetOutputWidthPixel() + devX - pOutDevRef->GetOutOffXPixel() + 1;
212 0 : pPtAry2[j].mnY = pPtAry[i].mnY;
213 : }
214 : }
215 : else
216 : {
217 0 : for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
218 : {
219 : //long x = w-1-pPtAry[i].mnX;
220 : //pPtAry2[j].mnX = devX + ( pOutDevRef->mnOutWidth - 1 - (x - devX) );
221 0 : pPtAry2[j].mnX = pOutDevRef->GetOutputWidthPixel() - (pPtAry[i].mnX - devX) + pOutDevRef->GetOutOffXPixel() - 1;
222 0 : pPtAry2[j].mnY = pPtAry[i].mnY;
223 : }
224 : }
225 : }
226 : }
227 1364 : else if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) )
228 : {
229 10992 : for( i=0, j=nPoints-1; i<nPoints; i++,j-- )
230 : {
231 9628 : pPtAry2[j].mnX = w-1-pPtAry[i].mnX;
232 9628 : pPtAry2[j].mnY = pPtAry[i].mnY;
233 : }
234 : }
235 1364 : return true;
236 : }
237 : else
238 0 : return false;
239 : }
240 :
241 1070 : void SalGraphics::mirror( vcl::Region& rRgn, const OutputDevice *pOutDev, bool bBack ) const
242 : {
243 1070 : if( rRgn.HasPolyPolygonOrB2DPolyPolygon() )
244 : {
245 0 : const basegfx::B2DPolyPolygon aPolyPoly(mirror(rRgn.GetAsB2DPolyPolygon(), pOutDev, bBack));
246 :
247 0 : rRgn = vcl::Region(aPolyPoly);
248 : }
249 : else
250 : {
251 1070 : RectangleVector aRectangles;
252 1070 : rRgn.GetRegionRectangles(aRectangles);
253 1070 : rRgn.SetEmpty();
254 :
255 2140 : for(RectangleVector::iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); ++aRectIter)
256 : {
257 1070 : mirror(*aRectIter, pOutDev, bBack);
258 1070 : rRgn.Union(*aRectIter);
259 1070 : }
260 :
261 : //ImplRegionInfo aInfo;
262 : //bool bRegionRect;
263 : //Region aMirroredRegion;
264 : //long nX, nY, nWidth, nHeight;
265 :
266 : //bRegionRect = rRgn.ImplGetFirstRect( aInfo, nX, nY, nWidth, nHeight );
267 : //while ( bRegionRect )
268 : //{
269 : // Rectangle aRect( Point(nX, nY), Size(nWidth, nHeight) );
270 : // mirror( aRect, pOutDev, bBack );
271 : // aMirroredRegion.Union( aRect );
272 : // bRegionRect = rRgn.ImplGetNextRect( aInfo, nX, nY, nWidth, nHeight );
273 : //}
274 : //rRgn = aMirroredRegion;
275 : }
276 1070 : }
277 :
278 1170 : void SalGraphics::mirror( Rectangle& rRect, const OutputDevice *pOutDev, bool bBack ) const
279 : {
280 1170 : long nWidth = rRect.GetWidth();
281 1170 : long x = rRect.Left();
282 1170 : long x_org = x;
283 :
284 1170 : mirror( x, nWidth, pOutDev, bBack );
285 1170 : rRect.Move( x - x_org, 0 );
286 1170 : }
287 :
288 0 : basegfx::B2DPoint SalGraphics::mirror( const basegfx::B2DPoint& i_rPoint, const OutputDevice *i_pOutDev, bool i_bBack ) const
289 : {
290 : long w;
291 0 : if( i_pOutDev && i_pOutDev->GetOutDevType() == OUTDEV_VIRDEV )
292 0 : w = i_pOutDev->GetOutputWidthPixel();
293 : else
294 0 : w = GetGraphicsWidth();
295 :
296 : DBG_ASSERT( w, "missing graphics width" );
297 :
298 0 : basegfx::B2DPoint aRet( i_rPoint );
299 0 : if( w )
300 : {
301 0 : if( i_pOutDev && !i_pOutDev->IsRTLEnabled() )
302 : {
303 0 : OutputDevice *pOutDevRef = (OutputDevice*)i_pOutDev;
304 : // mirror this window back
305 0 : double devX = w-pOutDevRef->GetOutputWidthPixel()-pOutDevRef->GetOutOffXPixel(); // re-mirrored mnOutOffX
306 0 : if( i_bBack )
307 0 : aRet.setX( i_rPoint.getX() - devX + pOutDevRef->GetOutOffXPixel() );
308 : else
309 0 : aRet.setX( devX + (i_rPoint.getX() - pOutDevRef->GetOutOffXPixel()) );
310 : }
311 : else
312 0 : aRet.setX( w-1-i_rPoint.getX() );
313 : }
314 0 : return aRet;
315 : }
316 :
317 0 : basegfx::B2DPolygon SalGraphics::mirror( const basegfx::B2DPolygon& i_rPoly, const OutputDevice *i_pOutDev, bool i_bBack ) const
318 : {
319 : long w;
320 0 : if( i_pOutDev && i_pOutDev->GetOutDevType() == OUTDEV_VIRDEV )
321 0 : w = i_pOutDev->GetOutputWidthPixel();
322 : else
323 0 : w = GetGraphicsWidth();
324 :
325 : DBG_ASSERT( w, "missing graphics width" );
326 :
327 0 : basegfx::B2DPolygon aRet;
328 0 : if( w )
329 : {
330 0 : sal_Int32 nPoints = i_rPoly.count();
331 0 : for( sal_Int32 i = 0; i < nPoints; i++ )
332 : {
333 0 : aRet.append( mirror( i_rPoly.getB2DPoint( i ), i_pOutDev, i_bBack ) );
334 0 : if( i_rPoly.isPrevControlPointUsed( i ) )
335 0 : aRet.setPrevControlPoint( i, mirror( i_rPoly.getPrevControlPoint( i ), i_pOutDev, i_bBack ) );
336 0 : if( i_rPoly.isNextControlPointUsed( i ) )
337 0 : aRet.setNextControlPoint( i, mirror( i_rPoly.getNextControlPoint( i ), i_pOutDev, i_bBack ) );
338 : }
339 0 : aRet.setClosed( i_rPoly.isClosed() );
340 0 : aRet.flip();
341 : }
342 : else
343 0 : aRet = i_rPoly;
344 0 : return aRet;
345 : }
346 :
347 0 : basegfx::B2DPolyPolygon SalGraphics::mirror( const basegfx::B2DPolyPolygon& i_rPoly, const OutputDevice *i_pOutDev, bool i_bBack ) const
348 : {
349 : long w;
350 0 : if( i_pOutDev && i_pOutDev->GetOutDevType() == OUTDEV_VIRDEV )
351 0 : w = i_pOutDev->GetOutputWidthPixel();
352 : else
353 0 : w = GetGraphicsWidth();
354 :
355 : DBG_ASSERT( w, "missing graphics width" );
356 :
357 0 : basegfx::B2DPolyPolygon aRet;
358 0 : if( w )
359 : {
360 0 : sal_Int32 nPoly = i_rPoly.count();
361 0 : for( sal_Int32 i = 0; i < nPoly; i++ )
362 0 : aRet.append( mirror( i_rPoly.getB2DPolygon( i ), i_pOutDev, i_bBack ) );
363 0 : aRet.setClosed( i_rPoly.isClosed() );
364 0 : aRet.flip();
365 : }
366 : else
367 0 : aRet = i_rPoly;
368 0 : return aRet;
369 : }
370 :
371 1005100 : bool SalGraphics::SetClipRegion( const vcl::Region& i_rClip, const OutputDevice *pOutDev )
372 : {
373 1005100 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
374 : {
375 1070 : vcl::Region aMirror( i_rClip );
376 1070 : mirror( aMirror, pOutDev );
377 1070 : return setClipRegion( aMirror );
378 : }
379 1004030 : return setClipRegion( i_rClip );
380 : }
381 :
382 173229 : void SalGraphics::DrawPixel( long nX, long nY, const OutputDevice *pOutDev )
383 : {
384 173229 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
385 124 : mirror( nX, pOutDev );
386 173229 : drawPixel( nX, nY );
387 173229 : }
388 :
389 1166846 : void SalGraphics::DrawPixel( long nX, long nY, SalColor nSalColor, const OutputDevice *pOutDev )
390 : {
391 1166846 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
392 0 : mirror( nX, pOutDev );
393 1166846 : drawPixel( nX, nY, nSalColor );
394 1166846 : }
395 :
396 3330173 : void SalGraphics::DrawLine( long nX1, long nY1, long nX2, long nY2, const OutputDevice *pOutDev )
397 : {
398 3330173 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
399 : {
400 1364 : mirror( nX1, pOutDev );
401 1364 : mirror( nX2, pOutDev );
402 : }
403 3330173 : drawLine( nX1, nY1, nX2, nY2 );
404 3330173 : }
405 :
406 1324793 : void SalGraphics::DrawRect( long nX, long nY, long nWidth, long nHeight, const OutputDevice *pOutDev )
407 : {
408 1324793 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
409 2826 : mirror( nX, nWidth, pOutDev );
410 1324793 : drawRect( nX, nY, nWidth, nHeight );
411 1324793 : }
412 :
413 235942 : void SalGraphics::DrawPolyLine( sal_uInt32 nPoints, const SalPoint* pPtAry, const OutputDevice *pOutDev )
414 : {
415 235942 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
416 : {
417 0 : boost::scoped_array<SalPoint> pPtAry2(new SalPoint[nPoints]);
418 0 : bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
419 0 : drawPolyLine( nPoints, bCopied ? pPtAry2.get() : pPtAry );
420 : }
421 : else
422 235942 : drawPolyLine( nPoints, pPtAry );
423 235942 : }
424 :
425 3125008 : void SalGraphics::DrawPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry, const OutputDevice *pOutDev )
426 : {
427 3125008 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
428 : {
429 1364 : boost::scoped_array<SalPoint> pPtAry2(new SalPoint[nPoints]);
430 1364 : bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
431 1364 : drawPolygon( nPoints, bCopied ? pPtAry2.get() : pPtAry );
432 : }
433 : else
434 3123644 : drawPolygon( nPoints, pPtAry );
435 3125008 : }
436 :
437 2379 : void SalGraphics::DrawPolyPolygon( sal_uInt32 nPoly, const sal_uInt32* pPoints, PCONSTSALPOINT* pPtAry, const OutputDevice *pOutDev )
438 : {
439 2379 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
440 : {
441 : // TODO: optimize, reduce new/delete calls
442 0 : SalPoint **pPtAry2 = new SalPoint*[nPoly];
443 : sal_uLong i;
444 0 : for(i=0; i<nPoly; i++)
445 : {
446 0 : sal_uLong nPoints = pPoints[i];
447 0 : pPtAry2[i] = new SalPoint[ nPoints ];
448 0 : mirror( nPoints, pPtAry[i], pPtAry2[i], pOutDev );
449 : }
450 :
451 0 : drawPolyPolygon( nPoly, pPoints, (PCONSTSALPOINT*)pPtAry2 );
452 :
453 0 : for(i=0; i<nPoly; i++)
454 0 : delete [] pPtAry2[i];
455 0 : delete [] pPtAry2;
456 : }
457 : else
458 2379 : drawPolyPolygon( nPoly, pPoints, pPtAry );
459 2379 : }
460 :
461 0 : bool SalGraphics::DrawPolyPolygon( const basegfx::B2DPolyPolygon& i_rPolyPolygon, double i_fTransparency, const OutputDevice* i_pOutDev )
462 : {
463 0 : bool bRet = false;
464 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (i_pOutDev && i_pOutDev->IsRTLEnabled()) )
465 : {
466 0 : basegfx::B2DPolyPolygon aMirror( mirror( i_rPolyPolygon, i_pOutDev ) );
467 0 : bRet = drawPolyPolygon( aMirror, i_fTransparency );
468 : }
469 : else
470 0 : bRet = drawPolyPolygon( i_rPolyPolygon, i_fTransparency );
471 0 : return bRet;
472 : }
473 :
474 0 : bool SalGraphics::DrawPolyLineBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry, const OutputDevice* pOutDev )
475 : {
476 0 : bool bResult = false;
477 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
478 : {
479 0 : boost::scoped_array<SalPoint> pPtAry2(new SalPoint[nPoints]);
480 0 : bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
481 0 : bResult = drawPolyLineBezier( nPoints, bCopied ? pPtAry2.get() : pPtAry, pFlgAry );
482 : }
483 : else
484 0 : bResult = drawPolyLineBezier( nPoints, pPtAry, pFlgAry );
485 0 : return bResult;
486 : }
487 :
488 11071 : bool SalGraphics::DrawPolygonBezier( sal_uInt32 nPoints, const SalPoint* pPtAry, const sal_uInt8* pFlgAry, const OutputDevice* pOutDev )
489 : {
490 11071 : bool bResult = false;
491 11071 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
492 : {
493 0 : boost::scoped_array<SalPoint> pPtAry2(new SalPoint[nPoints]);
494 0 : bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
495 0 : bResult = drawPolygonBezier( nPoints, bCopied ? pPtAry2.get() : pPtAry, pFlgAry );
496 : }
497 : else
498 11071 : bResult = drawPolygonBezier( nPoints, pPtAry, pFlgAry );
499 11071 : return bResult;
500 : }
501 :
502 1389 : bool SalGraphics::DrawPolyPolygonBezier( sal_uInt32 i_nPoly, const sal_uInt32* i_pPoints,
503 : const SalPoint* const* i_pPtAry, const sal_uInt8* const* i_pFlgAry, const OutputDevice* i_pOutDev )
504 : {
505 1389 : bool bRet = false;
506 1389 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (i_pOutDev && i_pOutDev->IsRTLEnabled()) )
507 : {
508 : // TODO: optimize, reduce new/delete calls
509 0 : SalPoint **pPtAry2 = new SalPoint*[i_nPoly];
510 : sal_uLong i;
511 0 : for(i=0; i<i_nPoly; i++)
512 : {
513 0 : sal_uLong nPoints = i_pPoints[i];
514 0 : pPtAry2[i] = new SalPoint[ nPoints ];
515 0 : mirror( nPoints, i_pPtAry[i], pPtAry2[i], i_pOutDev );
516 : }
517 :
518 0 : bRet = drawPolyPolygonBezier( i_nPoly, i_pPoints, (PCONSTSALPOINT*)pPtAry2, i_pFlgAry );
519 :
520 0 : for(i=0; i<i_nPoly; i++)
521 0 : delete [] pPtAry2[i];
522 0 : delete [] pPtAry2;
523 : }
524 : else
525 1389 : bRet = drawPolyPolygonBezier( i_nPoly, i_pPoints, i_pPtAry, i_pFlgAry );
526 1389 : return bRet;
527 : }
528 :
529 0 : bool SalGraphics::DrawPolyLine( const basegfx::B2DPolygon& i_rPolygon,
530 : double i_fTransparency,
531 : const basegfx::B2DVector& i_rLineWidth,
532 : basegfx::B2DLineJoin i_eLineJoin,
533 : com::sun::star::drawing::LineCap i_eLineCap,
534 : const OutputDevice* i_pOutDev )
535 : {
536 0 : bool bRet = false;
537 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (i_pOutDev && i_pOutDev->IsRTLEnabled()) )
538 : {
539 0 : basegfx::B2DPolygon aMirror( mirror( i_rPolygon, i_pOutDev ) );
540 0 : bRet = drawPolyLine( aMirror, i_fTransparency, i_rLineWidth, i_eLineJoin, i_eLineCap );
541 : }
542 : else
543 0 : bRet = drawPolyLine( i_rPolygon, i_fTransparency, i_rLineWidth, i_eLineJoin, i_eLineCap );
544 0 : return bRet;
545 : }
546 :
547 1597 : void SalGraphics::CopyArea( long nDestX, long nDestY,
548 : long nSrcX, long nSrcY,
549 : long nSrcWidth, long nSrcHeight,
550 : sal_uInt16 nFlags, const OutputDevice *pOutDev )
551 : {
552 1597 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
553 : {
554 0 : mirror( nDestX, nSrcWidth, pOutDev );
555 0 : mirror( nSrcX, nSrcWidth, pOutDev );
556 : }
557 1597 : copyArea( nDestX, nDestY, nSrcX, nSrcY, nSrcWidth, nSrcHeight, nFlags );
558 1597 : }
559 :
560 75741 : void SalGraphics::CopyBits( const SalTwoRect& rPosAry,
561 : SalGraphics* pSrcGraphics, const OutputDevice *pOutDev, const OutputDevice *pSrcOutDev )
562 : {
563 75741 : if( ( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) ) ||
564 74253 : (pSrcGraphics && ( (pSrcGraphics->GetLayout() & SAL_LAYOUT_BIDI_RTL) || (pSrcOutDev && pSrcOutDev->IsRTLEnabled()) ) ) )
565 : {
566 0 : SalTwoRect aPosAry2 = rPosAry;
567 0 : if( (pSrcGraphics && (pSrcGraphics->GetLayout() & SAL_LAYOUT_BIDI_RTL)) || (pSrcOutDev && pSrcOutDev->IsRTLEnabled()) )
568 0 : mirror( aPosAry2.mnSrcX, aPosAry2.mnSrcWidth, pSrcOutDev );
569 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
570 0 : mirror( aPosAry2.mnDestX, aPosAry2.mnDestWidth, pOutDev );
571 0 : copyBits( aPosAry2, pSrcGraphics );
572 : }
573 : else
574 75741 : copyBits( rPosAry, pSrcGraphics );
575 75741 : }
576 :
577 235396 : void SalGraphics::DrawBitmap( const SalTwoRect& rPosAry,
578 : const SalBitmap& rSalBitmap, const OutputDevice *pOutDev )
579 : {
580 235396 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
581 : {
582 78 : SalTwoRect aPosAry2 = rPosAry;
583 78 : mirror( aPosAry2.mnDestX, aPosAry2.mnDestWidth, pOutDev );
584 78 : drawBitmap( aPosAry2, rSalBitmap );
585 : }
586 : else
587 235318 : drawBitmap( rPosAry, rSalBitmap );
588 235396 : }
589 :
590 19367 : void SalGraphics::DrawBitmap( const SalTwoRect& rPosAry,
591 : const SalBitmap& rSalBitmap,
592 : const SalBitmap& rTransparentBitmap, const OutputDevice *pOutDev )
593 : {
594 19367 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
595 : {
596 8 : SalTwoRect aPosAry2 = rPosAry;
597 8 : mirror( aPosAry2.mnDestX, aPosAry2.mnDestWidth, pOutDev );
598 8 : drawBitmap( aPosAry2, rSalBitmap, rTransparentBitmap );
599 : }
600 : else
601 19359 : drawBitmap( rPosAry, rSalBitmap, rTransparentBitmap );
602 19367 : }
603 :
604 0 : void SalGraphics::DrawMask( const SalTwoRect& rPosAry,
605 : const SalBitmap& rSalBitmap,
606 : SalColor nMaskColor, const OutputDevice *pOutDev )
607 : {
608 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
609 : {
610 0 : SalTwoRect aPosAry2 = rPosAry;
611 0 : mirror( aPosAry2.mnDestX, aPosAry2.mnDestWidth, pOutDev );
612 0 : drawMask( aPosAry2, rSalBitmap, nMaskColor );
613 : }
614 : else
615 0 : drawMask( rPosAry, rSalBitmap, nMaskColor );
616 0 : }
617 :
618 250977 : SalBitmap* SalGraphics::GetBitmap( long nX, long nY, long nWidth, long nHeight, const OutputDevice *pOutDev )
619 : {
620 250977 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
621 524 : mirror( nX, nWidth, pOutDev );
622 250977 : return getBitmap( nX, nY, nWidth, nHeight );
623 : }
624 :
625 0 : SalColor SalGraphics::GetPixel( long nX, long nY, const OutputDevice *pOutDev )
626 : {
627 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
628 0 : mirror( nX, pOutDev );
629 0 : return getPixel( nX, nY );
630 : }
631 :
632 105208 : void SalGraphics::Invert( long nX, long nY, long nWidth, long nHeight, SalInvert nFlags, const OutputDevice *pOutDev )
633 : {
634 105208 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
635 0 : mirror( nX, nWidth, pOutDev );
636 105208 : invert( nX, nY, nWidth, nHeight, nFlags );
637 105208 : }
638 :
639 24 : void SalGraphics::Invert( sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert nFlags, const OutputDevice *pOutDev )
640 : {
641 24 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
642 : {
643 0 : boost::scoped_array<SalPoint> pPtAry2(new SalPoint[nPoints]);
644 0 : bool bCopied = mirror( nPoints, pPtAry, pPtAry2.get(), pOutDev );
645 0 : invert( nPoints, bCopied ? pPtAry2.get() : pPtAry, nFlags );
646 : }
647 : else
648 24 : invert( nPoints, pPtAry, nFlags );
649 24 : }
650 :
651 0 : bool SalGraphics::DrawEPS( long nX, long nY, long nWidth, long nHeight, void* pPtr, sal_uLong nSize, const OutputDevice *pOutDev )
652 : {
653 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
654 0 : mirror( nX, nWidth, pOutDev );
655 0 : return drawEPS( nX, nY, nWidth, nHeight, pPtr, nSize );
656 : }
657 :
658 0 : bool SalGraphics::HitTestNativeControl( ControlType nType, ControlPart nPart, const Rectangle& rControlRegion,
659 : const Point& aPos, bool& rIsInside, const OutputDevice *pOutDev )
660 : {
661 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
662 : {
663 0 : Point pt( aPos );
664 0 : Rectangle rgn( rControlRegion );
665 0 : mirror( pt.X(), pOutDev );
666 0 : mirror( rgn, pOutDev );
667 0 : return hitTestNativeControl( nType, nPart, rgn, pt, rIsInside );
668 : }
669 : else
670 0 : return hitTestNativeControl( nType, nPart, rControlRegion, aPos, rIsInside );
671 : }
672 :
673 100 : void SalGraphics::mirror( ImplControlValue& rVal, const OutputDevice* pOutDev, bool bBack ) const
674 : {
675 100 : switch( rVal.getType() )
676 : {
677 : case CTRL_SLIDER:
678 : {
679 0 : SliderValue* pSlVal = static_cast<SliderValue*>(&rVal);
680 0 : mirror(pSlVal->maThumbRect,pOutDev,bBack);
681 : }
682 0 : break;
683 : case CTRL_SCROLLBAR:
684 : {
685 0 : ScrollbarValue* pScVal = static_cast<ScrollbarValue*>(&rVal);
686 0 : mirror(pScVal->maThumbRect,pOutDev,bBack);
687 0 : mirror(pScVal->maButton1Rect,pOutDev,bBack);
688 0 : mirror(pScVal->maButton2Rect,pOutDev,bBack);
689 : }
690 0 : break;
691 : case CTRL_SPINBOX:
692 : case CTRL_SPINBUTTONS:
693 : {
694 0 : SpinbuttonValue* pSpVal = static_cast<SpinbuttonValue*>(&rVal);
695 0 : mirror(pSpVal->maUpperRect,pOutDev,bBack);
696 0 : mirror(pSpVal->maLowerRect,pOutDev,bBack);
697 : }
698 0 : break;
699 : case CTRL_TOOLBAR:
700 : {
701 0 : ToolbarValue* pTVal = static_cast<ToolbarValue*>(&rVal);
702 0 : mirror(pTVal->maGripRect,pOutDev,bBack);
703 : }
704 0 : break;
705 : }
706 100 : }
707 :
708 0 : bool SalGraphics::DrawNativeControl( ControlType nType, ControlPart nPart, const Rectangle& rControlRegion,
709 : ControlState nState, const ImplControlValue& aValue,
710 : const OUString& aCaption, const OutputDevice *pOutDev )
711 : {
712 0 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
713 : {
714 0 : Rectangle rgn( rControlRegion );
715 0 : mirror( rgn, pOutDev );
716 0 : boost::scoped_ptr< ImplControlValue > mirrorValue( aValue.clone());
717 0 : mirror( *mirrorValue, pOutDev );
718 0 : bool bRet = drawNativeControl( nType, nPart, rgn, nState, *mirrorValue, aCaption );
719 0 : return bRet;
720 : }
721 : else
722 0 : return drawNativeControl( nType, nPart, rControlRegion, nState, aValue, aCaption );
723 : }
724 :
725 312221 : bool SalGraphics::GetNativeControlRegion( ControlType nType, ControlPart nPart, const Rectangle& rControlRegion, ControlState nState,
726 : const ImplControlValue& aValue, const OUString& aCaption,
727 : Rectangle &rNativeBoundingRegion, Rectangle &rNativeContentRegion, const OutputDevice *pOutDev )
728 : {
729 312221 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
730 : {
731 100 : Rectangle rgn( rControlRegion );
732 100 : mirror( rgn, pOutDev );
733 100 : boost::scoped_ptr< ImplControlValue > mirrorValue( aValue.clone());
734 100 : mirror( *mirrorValue, pOutDev );
735 100 : if( getNativeControlRegion( nType, nPart, rgn, nState, *mirrorValue, aCaption,
736 100 : rNativeBoundingRegion, rNativeContentRegion ) )
737 : {
738 0 : mirror( rNativeBoundingRegion, pOutDev, true );
739 0 : mirror( rNativeContentRegion, pOutDev, true );
740 0 : return true;
741 : }
742 100 : return false;
743 : }
744 : else
745 : return getNativeControlRegion( nType, nPart, rControlRegion, nState, aValue, aCaption,
746 312121 : rNativeBoundingRegion, rNativeContentRegion );
747 : }
748 :
749 211722 : bool SalGraphics::DrawAlphaBitmap( const SalTwoRect& rPosAry,
750 : const SalBitmap& rSourceBitmap,
751 : const SalBitmap& rAlphaBitmap,
752 : const OutputDevice *pOutDev )
753 : {
754 211722 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
755 : {
756 0 : SalTwoRect aPosAry2 = rPosAry;
757 0 : mirror( aPosAry2.mnDestX, aPosAry2.mnDestWidth, pOutDev );
758 0 : return drawAlphaBitmap( aPosAry2, rSourceBitmap, rAlphaBitmap );
759 : }
760 : else
761 211722 : return drawAlphaBitmap( rPosAry, rSourceBitmap, rAlphaBitmap );
762 : }
763 :
764 34 : bool SalGraphics::DrawTransformedBitmap(
765 : const basegfx::B2DPoint& rNull,
766 : const basegfx::B2DPoint& rX,
767 : const basegfx::B2DPoint& rY,
768 : const SalBitmap& rSourceBitmap,
769 : const SalBitmap* pAlphaBitmap,
770 : const OutputDevice* pOutDev)
771 : {
772 34 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
773 : {
774 0 : basegfx::B2DPoint aNull(rNull);
775 0 : basegfx::B2DPoint aX(rX);
776 0 : basegfx::B2DPoint aY(rY);
777 :
778 0 : mirror(aNull, pOutDev);
779 0 : mirror(aX, pOutDev);
780 0 : mirror(aY, pOutDev);
781 :
782 0 : return drawTransformedBitmap(aNull, aX, aY, rSourceBitmap, pAlphaBitmap);
783 : }
784 : else
785 : {
786 34 : return drawTransformedBitmap(rNull, rX, rY, rSourceBitmap, pAlphaBitmap);
787 : }
788 : }
789 :
790 32 : bool SalGraphics::DrawAlphaRect( long nX, long nY, long nWidth, long nHeight,
791 : sal_uInt8 nTransparency, const OutputDevice *pOutDev )
792 : {
793 32 : if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
794 0 : mirror( nX, nWidth, pOutDev );
795 :
796 32 : return drawAlphaRect( nX, nY, nWidth, nHeight, nTransparency );
797 1233 : }
798 :
799 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
