LCOV - code coverage report
Current view: top level - vcl/source/gdi - salgdilayout.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 174 377 46.2 %
Date: 2014-11-03 Functions: 32 45 71.1 %
Legend: Lines: hit not hit

          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: */

Generated by: LCOV version 1.10