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