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