LCOV - code coverage report
Current view: top level - vcl/unx/generic/gdi - salgdi2.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 0 427 0.0 %
Date: 2014-11-03 Functions: 0 25 0.0 %
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 <stdio.h>
      21             : #include <poll.h>
      22             : 
      23             : #include "vcl/salbtype.hxx"
      24             : 
      25             : #include "unx/salunx.h"
      26             : #include "unx/saldata.hxx"
      27             : #include "unx/saldisp.hxx"
      28             : #include "unx/salbmp.h"
      29             : #include "unx/salgdi.h"
      30             : #include "unx/salframe.h"
      31             : #include "unx/salvd.h"
      32             : #include <unx/x11/xlimits.hxx>
      33             : #include "xrender_peer.hxx"
      34             : 
      35             : #include "generic/printergfx.hxx"
      36             : 
      37             : #include "vcl/bmpacc.hxx"
      38             : #include <outdata.hxx>
      39             : #include <boost/scoped_ptr.hpp>
      40             : 
      41             : #undef SALGDI2_TESTTRANS
      42             : 
      43             : #if (OSL_DEBUG_LEVEL > 1) && defined SALGDI2_TESTTRANS
      44             : #define DBG_TESTTRANS( _def_drawable )                              \
      45             : {                                                                   \
      46             :     XCopyArea( pXDisp, _def_drawable, aDrawable, GetCopyGC(),       \
      47             :                0, 0,                                                \
      48             :                rPosAry.mnDestWidth, rPosAry.mnDestHeight,         \
      49             :                0, 0 );                                              \
      50             : }
      51             : #else // (OSL_DEBUG_LEVEL > 1) && defined SALGDI2_TESTTRANS
      52             : #define DBG_TESTTRANS( _def_drawable )
      53             : #endif // (OSL_DEBUG_LEVEL > 1) && defined SALGDI2_TESTTRANS
      54             : 
      55           0 : void X11SalGraphics::CopyScreenArea( Display* pDisplay,
      56             :                                      Drawable aSrc, SalX11Screen nXScreenSrc, int nSrcDepth,
      57             :                                      Drawable aDest, SalX11Screen nXScreenDest, int nDestDepth,
      58             :                                      GC aDestGC,
      59             :                                      int src_x, int src_y,
      60             :                                      unsigned int w, unsigned int h,
      61             :                                      int dest_x, int dest_y )
      62             : {
      63           0 :     if( nSrcDepth == nDestDepth )
      64             :     {
      65           0 :         if( nXScreenSrc == nXScreenDest )
      66             :             XCopyArea( pDisplay, aSrc, aDest, aDestGC,
      67           0 :                        src_x, src_y, w, h, dest_x, dest_y );
      68             :         else
      69             :         {
      70           0 :             GetGenericData()->ErrorTrapPush();
      71             :             XImage* pImage = XGetImage( pDisplay, aSrc, src_x, src_y, w, h,
      72           0 :                                         AllPlanes, ZPixmap );
      73           0 :             if( pImage )
      74             :             {
      75           0 :                 if( pImage->data )
      76             :                     XPutImage( pDisplay, aDest, aDestGC, pImage,
      77           0 :                                0, 0, dest_x, dest_y, w, h );
      78           0 :                 XDestroyImage( pImage );
      79             :             }
      80           0 :             GetGenericData()->ErrorTrapPop();
      81             :         }
      82             :     }
      83             :     else
      84             :     {
      85           0 :         X11SalBitmap aBM;
      86           0 :         aBM.ImplCreateFromDrawable( aSrc, nXScreenSrc, nSrcDepth, src_x, src_y, w, h );
      87             :         SalTwoRect aTwoRect;
      88           0 :         aTwoRect.mnSrcX = aTwoRect.mnSrcY = 0;
      89           0 :         aTwoRect.mnSrcWidth = aTwoRect.mnDestWidth = w;
      90           0 :         aTwoRect.mnSrcHeight = aTwoRect.mnDestHeight = h;
      91           0 :         aTwoRect.mnDestX = dest_x;
      92           0 :         aTwoRect.mnDestY = dest_y;
      93           0 :         aBM.ImplDraw( aDest, nXScreenDest, nDestDepth, aTwoRect,aDestGC );
      94             :     }
      95           0 : }
      96             : 
      97           0 : GC X11SalGraphics::CreateGC( Drawable hDrawable, unsigned long nMask )
      98             : {
      99             :     XGCValues values;
     100             : 
     101           0 :     values.graphics_exposures   = False;
     102           0 :     values.foreground           = m_pColormap->GetBlackPixel()
     103           0 :                                   ^ m_pColormap->GetWhitePixel();
     104           0 :     values.function             = GXxor;
     105           0 :     values.line_width           = 1;
     106           0 :     values.fill_style           = FillStippled;
     107           0 :     values.stipple              = GetDisplay()->GetInvert50( m_nXScreen );
     108           0 :     values.subwindow_mode       = ClipByChildren;
     109             : 
     110           0 :     return XCreateGC( GetXDisplay(), hDrawable, nMask | GCSubwindowMode, &values );
     111             : }
     112             : 
     113             : inline GC X11SalGraphics::GetMonoGC( Pixmap hPixmap )
     114             : {
     115             :     if( !pMonoGC_ )
     116             :         pMonoGC_ = CreateGC( hPixmap );
     117             : 
     118             :     if( !bMonoGC_ )
     119             :     {
     120             :         SetClipRegion( pMonoGC_ );
     121             :         bMonoGC_ = true;
     122             :     }
     123             : 
     124             :     return pMonoGC_;
     125             : }
     126             : 
     127           0 : inline GC X11SalGraphics::GetCopyGC()
     128             : {
     129           0 :     if( bXORMode_ ) return GetInvertGC();
     130             : 
     131           0 :     if( !pCopyGC_ )
     132           0 :         pCopyGC_ = CreateGC( GetDrawable() );
     133             : 
     134           0 :     if( !bCopyGC_ )
     135             :     {
     136           0 :         SetClipRegion( pCopyGC_ );
     137           0 :         bCopyGC_ = true;
     138             :     }
     139           0 :     return pCopyGC_;
     140             : }
     141             : 
     142           0 : GC X11SalGraphics::GetInvertGC()
     143             : {
     144           0 :     if( !pInvertGC_ )
     145             :         pInvertGC_ = CreateGC( GetDrawable(),
     146             :                                GCGraphicsExposures
     147             :                                | GCForeground
     148             :                                | GCFunction
     149           0 :                                | GCLineWidth );
     150             : 
     151           0 :     if( !bInvertGC_ )
     152             :     {
     153           0 :         SetClipRegion( pInvertGC_ );
     154           0 :         bInvertGC_ = true;
     155             :     }
     156           0 :     return pInvertGC_;
     157             : }
     158             : 
     159           0 : GC X11SalGraphics::GetInvert50GC()
     160             : {
     161           0 :     if( !pInvert50GC_ )
     162             :     {
     163             :         XGCValues values;
     164             : 
     165           0 :         values.graphics_exposures   = False;
     166           0 :         values.foreground           = m_pColormap->GetWhitePixel();
     167           0 :         values.background           = m_pColormap->GetBlackPixel();
     168           0 :         values.function             = GXinvert;
     169           0 :         values.line_width           = 1;
     170           0 :         values.line_style           = LineSolid;
     171             :         unsigned long nValueMask =
     172             :                                   GCGraphicsExposures
     173             :                                   | GCForeground
     174             :                                   | GCBackground
     175             :                                   | GCFunction
     176             :                                   | GCLineWidth
     177             :                                   | GCLineStyle
     178             :                                   | GCFillStyle
     179           0 :                                   | GCStipple;
     180             : 
     181           0 :         char* pEnv = getenv( "SAL_DO_NOT_USE_INVERT50" );
     182           0 :         if( pEnv && ! strcasecmp( pEnv, "true" ) )
     183             :         {
     184           0 :             values.fill_style = FillSolid;
     185           0 :             nValueMask &= ~ GCStipple;
     186             :         }
     187             :         else
     188             :         {
     189           0 :             values.fill_style           = FillStippled;
     190           0 :             values.stipple              = GetDisplay()->GetInvert50( m_nXScreen );
     191             :         }
     192             : 
     193             :         pInvert50GC_ = XCreateGC( GetXDisplay(), GetDrawable(),
     194             :                                   nValueMask,
     195           0 :                                   &values );
     196             :     }
     197             : 
     198           0 :     if( !bInvert50GC_ )
     199             :     {
     200           0 :         SetClipRegion( pInvert50GC_ );
     201           0 :         bInvert50GC_ = true;
     202             :     }
     203           0 :     return pInvert50GC_;
     204             : }
     205             : 
     206           0 : inline GC X11SalGraphics::GetStippleGC()
     207             : {
     208           0 :     if( !pStippleGC_ )
     209             :         pStippleGC_ = CreateGC( GetDrawable(),
     210             :                                 GCGraphicsExposures
     211             :                                 | GCFillStyle
     212           0 :                                 | GCLineWidth );
     213             : 
     214           0 :     if( !bStippleGC_ )
     215             :     {
     216           0 :         XSetFunction( GetXDisplay(), pStippleGC_, bXORMode_ ? GXxor : GXcopy );
     217           0 :         SetClipRegion( pStippleGC_ );
     218           0 :         bStippleGC_ = true;
     219             :     }
     220             : 
     221           0 :     return pStippleGC_;
     222             : }
     223             : 
     224             : extern "C"
     225             : {
     226           0 :     static Bool GraphicsExposePredicate( Display*, XEvent* pEvent, XPointer pFrameWindow )
     227             :     {
     228           0 :         Bool bRet = False;
     229           0 :         if( (pEvent->type == GraphicsExpose || pEvent->type == NoExpose) &&
     230           0 :             pEvent->xnoexpose.drawable == reinterpret_cast<Drawable>(pFrameWindow) )
     231             :         {
     232           0 :             bRet = True;
     233             :         }
     234           0 :         return bRet;
     235             :     }
     236             : }
     237             : 
     238           0 : void X11SalGraphics::YieldGraphicsExpose()
     239             : {
     240             :     // get frame if necessary
     241           0 :     SalFrame* pFrame    = m_pFrame;
     242           0 :     Display* pDisplay   = GetXDisplay();
     243           0 :     ::Window aWindow = GetDrawable();
     244           0 :     if( ! pFrame )
     245             :     {
     246           0 :         const std::list< SalFrame* >& rFrames = GetGenericData()->GetSalDisplay()->getFrames();
     247           0 :         for( std::list< SalFrame* >::const_iterator it = rFrames.begin(); it != rFrames.end() && ! pFrame; ++it )
     248             :         {
     249           0 :             const SystemEnvData* pEnvData = (*it)->GetSystemData();
     250           0 :             if( Drawable(pEnvData->aWindow) == aWindow )
     251           0 :                 pFrame = *it;
     252             :         }
     253           0 :         if( ! pFrame )
     254           0 :             return;
     255             :     }
     256             : 
     257             :     XEvent aEvent;
     258           0 :     while( XCheckTypedWindowEvent( pDisplay, aWindow, Expose, &aEvent ) )
     259             :     {
     260           0 :         SalPaintEvent aPEvt( aEvent.xexpose.x, aEvent.xexpose.y, aEvent.xexpose.width+1, aEvent.xexpose.height+1 );
     261           0 :         pFrame->CallCallback( SALEVENT_PAINT, &aPEvt );
     262             :     }
     263             : 
     264           0 :     do
     265             :     {
     266           0 :         if( ! GetDisplay()->XIfEventWithTimeout( &aEvent, reinterpret_cast<XPointer>(aWindow), GraphicsExposePredicate ) )
     267             :             // this should not happen at all; still sometimes it happens
     268           0 :             break;
     269             : 
     270           0 :         if( aEvent.type == NoExpose )
     271           0 :             break;
     272             : 
     273           0 :         if( pFrame )
     274             :         {
     275           0 :             SalPaintEvent aPEvt( aEvent.xgraphicsexpose.x, aEvent.xgraphicsexpose.y, aEvent.xgraphicsexpose.width+1, aEvent.xgraphicsexpose.height+1 );
     276           0 :             pFrame->CallCallback( SALEVENT_PAINT, &aPEvt );
     277             :         }
     278           0 :     } while( aEvent.xgraphicsexpose.count != 0 );
     279             : }
     280             : 
     281           0 : void X11SalGraphics::copyBits( const SalTwoRect& rPosAry,
     282             :                                   SalGraphics      *pSSrcGraphics )
     283             : {
     284             :     X11SalGraphics* pSrcGraphics = pSSrcGraphics
     285             :         ? static_cast<X11SalGraphics*>(pSSrcGraphics)
     286           0 :         : this;
     287             : 
     288           0 :     if( rPosAry.mnSrcWidth <= 0
     289           0 :         || rPosAry.mnSrcHeight <= 0
     290           0 :         || rPosAry.mnDestWidth <= 0
     291           0 :         || rPosAry.mnDestHeight <= 0 )
     292             :     {
     293           0 :         return;
     294             :     }
     295             : 
     296             :     int n;
     297           0 :     if( pSrcGraphics == this )
     298             :     {
     299           0 :         n = 2;
     300             :     }
     301           0 :     else if( pSrcGraphics->bWindow_ )
     302             :     {
     303             :         // window or compatible virtual device
     304           0 :         if( pSrcGraphics->GetDisplay() == GetDisplay() &&
     305           0 :             pSrcGraphics->m_nXScreen == m_nXScreen &&
     306           0 :             pSrcGraphics->GetVisual().GetDepth() == GetVisual().GetDepth()
     307             :             )
     308           0 :             n = 2; // same Display
     309             :         else
     310           0 :             n = 1; // printer or other display
     311             :     }
     312           0 :     else if( pSrcGraphics->bVirDev_ )
     313             :     {
     314             :         // printer compatible virtual device
     315           0 :         if( bPrinter_ )
     316           0 :             n = 2; // printer or compatible virtual device == same display
     317             :         else
     318           0 :             n = 1; // window or compatible virtual device
     319             :     }
     320             :     else
     321           0 :         n = 0;
     322             : 
     323           0 :     if( n == 2
     324           0 :         && rPosAry.mnSrcWidth   == rPosAry.mnDestWidth
     325           0 :         && rPosAry.mnSrcHeight == rPosAry.mnDestHeight
     326             :         )
     327             :     {
     328             :         // #i60699# Need to generate graphics exposures (to repaint
     329             :         // obscured areas beneath overlapping windows), src and dest
     330             :         // are the same window.
     331           0 :         const bool bNeedGraphicsExposures( pSrcGraphics == this &&
     332           0 :                                            !bVirDev_ &&
     333           0 :                                            pSrcGraphics->bWindow_ );
     334             : 
     335             :         GC pCopyGC;
     336             : 
     337           0 :         if( bXORMode_
     338           0 :             && !pSrcGraphics->bVirDev_
     339           0 :             && (GetDisplay()->GetProperties() & PROPERTY_BUG_XCopyArea_GXxor) )
     340             :         {
     341             :             Pixmap hPixmap = limitXCreatePixmap( GetXDisplay(),
     342             :                                             pSrcGraphics->GetDrawable(),        // source
     343             :                                             rPosAry.mnSrcWidth, rPosAry.mnSrcHeight,
     344           0 :                                             pSrcGraphics->GetBitCount() );
     345             : 
     346           0 :             pCopyGC = GetDisplay()->GetCopyGC( m_nXScreen );
     347             : 
     348           0 :             if( bNeedGraphicsExposures )
     349             :                 XSetGraphicsExposures( GetXDisplay(),
     350             :                                        pCopyGC,
     351           0 :                                        True );
     352             : 
     353             :             XCopyArea( GetXDisplay(),
     354             :                        pSrcGraphics->GetDrawable(),     // source
     355             :                        hPixmap,                         // destination
     356             :                        pCopyGC,                         // no clipping
     357             :                        rPosAry.mnSrcX,     rPosAry.mnSrcY,
     358             :                        rPosAry.mnSrcWidth, rPosAry.mnSrcHeight,
     359           0 :                        0,                   0 );            // destination
     360             :             XCopyArea( GetXDisplay(),
     361             :                        hPixmap,                             // source
     362             :                        GetDrawable(),                       // destination
     363             :                        GetInvertGC(),       // destination clipping
     364             :                        0,                   0,              // source
     365             :                        rPosAry.mnSrcWidth, rPosAry.mnSrcHeight,
     366           0 :                        rPosAry.mnDestX,    rPosAry.mnDestY );
     367           0 :             XFreePixmap( GetXDisplay(), hPixmap );
     368             :         }
     369             :         else
     370             :         {
     371           0 :             pCopyGC = GetCopyGC();
     372             : 
     373           0 :             if( bNeedGraphicsExposures )
     374             :                 XSetGraphicsExposures( GetXDisplay(),
     375             :                                        pCopyGC,
     376           0 :                                        True );
     377             : 
     378             :             XCopyArea( GetXDisplay(),
     379             :                        pSrcGraphics->GetDrawable(),     // source
     380             :                        GetDrawable(),                   // destination
     381             :                        pCopyGC,                         // destination clipping
     382             :                        rPosAry.mnSrcX,     rPosAry.mnSrcY,
     383             :                        rPosAry.mnSrcWidth, rPosAry.mnSrcHeight,
     384           0 :                        rPosAry.mnDestX,    rPosAry.mnDestY );
     385             :         }
     386             : 
     387           0 :         if( bNeedGraphicsExposures )
     388             :         {
     389           0 :             YieldGraphicsExpose();
     390             : 
     391           0 :             if( pCopyGC )
     392             :                 XSetGraphicsExposures( GetXDisplay(),
     393             :                                        pCopyGC,
     394           0 :                                        False );
     395           0 :         }
     396             :     }
     397           0 :     else if( n )
     398             :     {
     399             :         // #i60699# No chance to handle graphics exposures - we copy
     400             :         // to a temp bitmap first, into which no repaints are
     401             :         // technically possible.
     402             :         boost::scoped_ptr<SalBitmap> pDDB(pSrcGraphics->getBitmap( rPosAry.mnSrcX,
     403             :                                                                    rPosAry.mnSrcY,
     404             :                                                                    rPosAry.mnSrcWidth,
     405           0 :                                                                    rPosAry.mnSrcHeight ));
     406             : 
     407           0 :         if( !pDDB )
     408             :         {
     409             :             stderr0( "SalGraphics::CopyBits !pSrcGraphics->GetBitmap()\n" );
     410           0 :             return;
     411             :         }
     412             : 
     413           0 :         SalTwoRect aPosAry( rPosAry );
     414             : 
     415           0 :         aPosAry.mnSrcX = 0, aPosAry.mnSrcY = 0;
     416           0 :         drawBitmap( aPosAry, *pDDB );
     417             :     }
     418             :     else {
     419             :         stderr0( "X11SalGraphics::CopyBits from Printer not yet implemented\n" );
     420             :     }
     421             : }
     422             : 
     423           0 : void X11SalGraphics::copyArea ( long nDestX,    long nDestY,
     424             :                                 long nSrcX,     long nSrcY,
     425             :                                 long nSrcWidth, long nSrcHeight,
     426             :                                 sal_uInt16 )
     427             : {
     428             :     SalTwoRect aPosAry;
     429             : 
     430           0 :     aPosAry.mnDestX = nDestX;
     431           0 :     aPosAry.mnDestY = nDestY;
     432           0 :     aPosAry.mnDestWidth  = nSrcWidth;
     433           0 :     aPosAry.mnDestHeight = nSrcHeight;
     434             : 
     435           0 :     aPosAry.mnSrcX = nSrcX;
     436           0 :     aPosAry.mnSrcY = nSrcY;
     437           0 :     aPosAry.mnSrcWidth  = nSrcWidth;
     438           0 :     aPosAry.mnSrcHeight = nSrcHeight;
     439             : 
     440           0 :     copyBits ( aPosAry, 0 );
     441           0 : }
     442             : 
     443             : namespace
     444             : {
     445           0 :     void setForeBack(XGCValues& rValues, const SalColormap& rColMap, const SalBitmap& rSalBitmap)
     446             :     {
     447           0 :         rValues.foreground = rColMap.GetWhitePixel();
     448           0 :         rValues.background = rColMap.GetBlackPixel();
     449             : 
     450             :         //fdo#33455 and fdo#80160 handle 1 bit depth pngs with palette entries
     451             :         //to set fore/back colors
     452           0 :         SalBitmap& rBitmap = const_cast<SalBitmap&>(rSalBitmap);
     453           0 :         if (BitmapBuffer* pBitmapBuffer = rBitmap.AcquireBuffer(true))
     454             :         {
     455           0 :             const BitmapPalette& rPalette = pBitmapBuffer->maPalette;
     456           0 :             if (rPalette.GetEntryCount() == 2)
     457             :             {
     458           0 :                 const BitmapColor aWhite(rPalette[rPalette.GetBestIndex(Color(COL_WHITE))]);
     459           0 :                 rValues.foreground = rColMap.GetPixel(ImplColorToSal(aWhite));
     460             : 
     461           0 :                 const BitmapColor aBlack(rPalette[rPalette.GetBestIndex(Color(COL_BLACK))]);
     462           0 :                 rValues.background = rColMap.GetPixel(ImplColorToSal(aBlack));
     463             :             }
     464           0 :             rBitmap.ReleaseBuffer(pBitmapBuffer, true);
     465             :         }
     466           0 :     }
     467             : }
     468             : 
     469           0 : void X11SalGraphics::drawBitmap( const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap )
     470             : {
     471           0 :     const SalDisplay*   pSalDisp = GetDisplay();
     472           0 :     Display*            pXDisp = pSalDisp->GetDisplay();
     473           0 :     const Drawable      aDrawable( GetDrawable() );
     474           0 :     const SalColormap&  rColMap = pSalDisp->GetColormap( m_nXScreen );
     475           0 :     const long          nDepth = GetDisplay()->GetVisual( m_nXScreen ).GetDepth();
     476           0 :     GC                  aGC( GetCopyGC() );
     477             :     XGCValues           aOldVal, aNewVal;
     478           0 :     int                 nValues = GCForeground | GCBackground;
     479             : 
     480           0 :     if( rSalBitmap.GetBitCount() == 1 )
     481             :     {
     482             :         // set foreground/background values for 1Bit bitmaps
     483           0 :         XGetGCValues( pXDisp, aGC, nValues, &aOldVal );
     484           0 :         setForeBack(aNewVal, rColMap, rSalBitmap);
     485           0 :         XChangeGC( pXDisp, aGC, nValues, &aNewVal );
     486             :     }
     487             : 
     488           0 :     static_cast<const X11SalBitmap&>(rSalBitmap).ImplDraw( aDrawable, m_nXScreen, nDepth, rPosAry, aGC );
     489             : 
     490           0 :     if( rSalBitmap.GetBitCount() == 1 )
     491           0 :         XChangeGC( pXDisp, aGC, nValues, &aOldVal );
     492           0 :     XFlush( pXDisp );
     493           0 : }
     494             : 
     495           0 : void X11SalGraphics::drawBitmap( const SalTwoRect& rPosAry,
     496             :                                  const SalBitmap& rSrcBitmap,
     497             :                                  const SalBitmap& rMaskBitmap )
     498             : {
     499             :     DBG_ASSERT( !bPrinter_, "Drawing of transparent bitmaps on printer devices is strictly forbidden" );
     500             : 
     501             :     // decide if alpha masking or transparency masking is needed
     502           0 :     BitmapBuffer* pAlphaBuffer = const_cast<SalBitmap&>(rMaskBitmap).AcquireBuffer( true );
     503           0 :     if( pAlphaBuffer != NULL )
     504             :     {
     505           0 :         int nMaskFormat = pAlphaBuffer->mnFormat;
     506           0 :         const_cast<SalBitmap&>(rMaskBitmap).ReleaseBuffer( pAlphaBuffer, true );
     507           0 :         if( nMaskFormat == BMP_FORMAT_8BIT_PAL )
     508           0 :             drawAlphaBitmap( rPosAry, rSrcBitmap, rMaskBitmap );
     509             :     }
     510             : 
     511           0 :     drawMaskedBitmap( rPosAry, rSrcBitmap, rMaskBitmap );
     512           0 : }
     513             : 
     514           0 : void X11SalGraphics::drawMaskedBitmap( const SalTwoRect& rPosAry,
     515             :                                        const SalBitmap& rSalBitmap,
     516             :                                        const SalBitmap& rTransBitmap )
     517             : {
     518           0 :     const SalDisplay*   pSalDisp = GetDisplay();
     519           0 :     Display*            pXDisp = pSalDisp->GetDisplay();
     520           0 :     Drawable            aDrawable( GetDrawable() );
     521             : 
     522             :     // figure work mode depth. If this is a VDev Drawable, use its
     523             :     // bitdepth to create pixmaps for, otherwise, XCopyArea will
     524             :     // refuse to work.
     525             :     const sal_uInt16    nDepth( m_pVDev ?
     526           0 :                             m_pVDev->GetDepth() :
     527           0 :                             pSalDisp->GetVisual( m_nXScreen ).GetDepth() );
     528             :     Pixmap          aFG( limitXCreatePixmap( pXDisp, aDrawable, rPosAry.mnDestWidth,
     529           0 :                                         rPosAry.mnDestHeight, nDepth ) );
     530             :     Pixmap          aBG( limitXCreatePixmap( pXDisp, aDrawable, rPosAry.mnDestWidth,
     531           0 :                                         rPosAry.mnDestHeight, nDepth ) );
     532             : 
     533           0 :     if( aFG && aBG )
     534             :     {
     535             :         GC                  aTmpGC;
     536             :         XGCValues           aValues;
     537           0 :         setForeBack(aValues, pSalDisp->GetColormap(m_nXScreen), rSalBitmap);
     538           0 :         const int           nValues = GCFunction | GCForeground | GCBackground;
     539           0 :         SalTwoRect          aTmpRect( rPosAry ); aTmpRect.mnDestX = aTmpRect.mnDestY = 0;
     540             : 
     541             :         // draw paint bitmap in pixmap #1
     542           0 :         aValues.function = GXcopy;
     543           0 :         aTmpGC = XCreateGC( pXDisp, aFG, nValues, &aValues );
     544           0 :         static_cast<const X11SalBitmap&>(rSalBitmap).ImplDraw( aFG, m_nXScreen, nDepth, aTmpRect, aTmpGC );
     545             :         DBG_TESTTRANS( aFG );
     546             : 
     547             :         // draw background in pixmap #2
     548             :         XCopyArea( pXDisp, aDrawable, aBG, aTmpGC,
     549             :                    rPosAry.mnDestX, rPosAry.mnDestY,
     550             :                    rPosAry.mnDestWidth, rPosAry.mnDestHeight,
     551           0 :                    0, 0 );
     552             : 
     553             :         DBG_TESTTRANS( aBG );
     554             : 
     555             :         // mask out paint bitmap in pixmap #1 (transparent areas 0)
     556           0 :         aValues.function = GXand, aValues.foreground = 0x00000000, aValues.background = 0xffffffff;
     557           0 :         XChangeGC( pXDisp, aTmpGC, nValues, &aValues );
     558           0 :         static_cast<const X11SalBitmap&>(rTransBitmap).ImplDraw( aFG, m_nXScreen, 1, aTmpRect, aTmpGC );
     559             : 
     560             :         DBG_TESTTRANS( aFG );
     561             : 
     562             :         // #105055# For XOR mode, keep background behind bitmap intact
     563           0 :         if( !bXORMode_ )
     564             :         {
     565             :             // mask out background in pixmap #2 (nontransparent areas 0)
     566           0 :             aValues.function = GXand, aValues.foreground = 0xffffffff, aValues.background = 0x00000000;
     567           0 :             XChangeGC( pXDisp, aTmpGC, nValues, &aValues );
     568           0 :             static_cast<const X11SalBitmap&>(rTransBitmap).ImplDraw( aBG, m_nXScreen, 1, aTmpRect, aTmpGC );
     569             : 
     570             :             DBG_TESTTRANS( aBG );
     571             :         }
     572             : 
     573             :         // merge pixmap #1 and pixmap #2 in pixmap #2
     574           0 :         aValues.function = GXxor, aValues.foreground = 0xffffffff, aValues.background = 0x00000000;
     575           0 :         XChangeGC( pXDisp, aTmpGC, nValues, &aValues );
     576             :         XCopyArea( pXDisp, aFG, aBG, aTmpGC,
     577             :                    0, 0,
     578             :                    rPosAry.mnDestWidth, rPosAry.mnDestHeight,
     579           0 :                    0, 0 );
     580             :         DBG_TESTTRANS( aBG );
     581             : 
     582             :         // #105055# Disable XOR temporarily
     583           0 :         bool bOldXORMode( bXORMode_ );
     584           0 :         bXORMode_ = false;
     585             : 
     586             :         // copy pixmap #2 (result) to background
     587             :         XCopyArea( pXDisp, aBG, aDrawable, GetCopyGC(),
     588             :                    0, 0,
     589             :                    rPosAry.mnDestWidth, rPosAry.mnDestHeight,
     590           0 :                    rPosAry.mnDestX, rPosAry.mnDestY );
     591             : 
     592             :         DBG_TESTTRANS( aBG );
     593             : 
     594           0 :         bXORMode_ = bOldXORMode;
     595             : 
     596           0 :         XFreeGC( pXDisp, aTmpGC );
     597           0 :         XFlush( pXDisp );
     598             :     }
     599             :     else
     600           0 :         drawBitmap( rPosAry, rSalBitmap );
     601             : 
     602           0 :     if( aFG )
     603           0 :         XFreePixmap( pXDisp, aFG );
     604             : 
     605           0 :     if( aBG )
     606           0 :         XFreePixmap( pXDisp, aBG );
     607           0 : }
     608             : 
     609           0 : bool X11SalGraphics::drawAlphaBitmap( const SalTwoRect& rTR,
     610             :     const SalBitmap& rSrcBitmap, const SalBitmap& rAlphaBmp )
     611             : {
     612             :     // non 8-bit alpha not implemented yet
     613           0 :     if( rAlphaBmp.GetBitCount() != 8 )
     614           0 :         return false;
     615             : 
     616             :     // horizontal mirroring not implemented yet
     617           0 :     if( rTR.mnDestWidth < 0 )
     618           0 :         return false;
     619             : 
     620             :     // stretched conversion is not implemented yet
     621           0 :     if( rTR.mnDestWidth != rTR.mnSrcWidth )
     622           0 :         return false;
     623           0 :     if( rTR.mnDestHeight!= rTR.mnSrcHeight )
     624           0 :         return false;
     625             : 
     626             :     // create destination picture
     627           0 :     Picture aDstPic = GetXRenderPicture();
     628           0 :     if( !aDstPic )
     629           0 :         return false;
     630             : 
     631           0 :     const SalDisplay* pSalDisp = GetDisplay();
     632           0 :     const SalVisual& rSalVis = pSalDisp->GetVisual( m_nXScreen );
     633           0 :     Display* pXDisplay = pSalDisp->GetDisplay();
     634             : 
     635             :     // create source Picture
     636           0 :     int nDepth = m_pVDev ? m_pVDev->GetDepth() : rSalVis.GetDepth();
     637           0 :     const X11SalBitmap& rSrcX11Bmp = static_cast<const X11SalBitmap&>( rSrcBitmap );
     638           0 :     ImplSalDDB* pSrcDDB = rSrcX11Bmp.ImplGetDDB( hDrawable_, m_nXScreen, nDepth, rTR );
     639           0 :     if( !pSrcDDB )
     640           0 :         return false;
     641             : 
     642             :     //#i75249# workaround for ImplGetDDB() giving us back a different depth than
     643             :     // we requested. E.g. mask pixmaps are always compatible with the drawable
     644             :     // TODO: find an appropriate picture format for these cases
     645             :     //       then remove the workaround below and the one for #i75531#
     646           0 :     if( nDepth != pSrcDDB->ImplGetDepth() )
     647           0 :         return false;
     648             : 
     649           0 :     Pixmap aSrcPM = pSrcDDB->ImplGetPixmap();
     650           0 :     if( !aSrcPM )
     651           0 :         return false;
     652             : 
     653             :     // create source picture
     654             :     // TODO: use scoped picture
     655           0 :     Visual* pSrcXVisual = rSalVis.GetVisual();
     656           0 :     XRenderPeer& rPeer = XRenderPeer::GetInstance();
     657           0 :     XRenderPictFormat* pSrcVisFmt = rPeer.FindVisualFormat( pSrcXVisual );
     658           0 :     if( !pSrcVisFmt )
     659           0 :         return false;
     660           0 :     Picture aSrcPic = rPeer.CreatePicture( aSrcPM, pSrcVisFmt, 0, NULL );
     661           0 :     if( !aSrcPic )
     662           0 :         return false;
     663             : 
     664             :     // create alpha Picture
     665             : 
     666             :     // TODO: use SalX11Bitmap functionality and caching for the Alpha Pixmap
     667             :     // problem is that they don't provide an 8bit Pixmap on a non-8bit display
     668           0 :     BitmapBuffer* pAlphaBuffer = const_cast<SalBitmap&>(rAlphaBmp).AcquireBuffer( true );
     669             : 
     670             :     // an XImage needs its data top_down
     671             :     // TODO: avoid wrongly oriented images in upper layers!
     672           0 :     const int nImageSize = pAlphaBuffer->mnHeight * pAlphaBuffer->mnScanlineSize;
     673           0 :     const char* pSrcBits = (char*)pAlphaBuffer->mpBits;
     674           0 :     char* pAlphaBits = new char[ nImageSize ];
     675           0 :     if( BMP_SCANLINE_ADJUSTMENT( pAlphaBuffer->mnFormat ) == BMP_FORMAT_TOP_DOWN )
     676           0 :         memcpy( pAlphaBits, pSrcBits, nImageSize );
     677             :     else
     678             :     {
     679           0 :         char* pDstBits = pAlphaBits + nImageSize;
     680           0 :         const int nLineSize = pAlphaBuffer->mnScanlineSize;
     681           0 :         for(; (pDstBits -= nLineSize) >= pAlphaBits; pSrcBits += nLineSize )
     682           0 :             memcpy( pDstBits, pSrcBits, nLineSize );
     683             :     }
     684             : 
     685             :     // the alpha values need to be inverted for XRender
     686             :     // TODO: make upper layers use standard alpha
     687           0 :     long* pLDst = (long*)pAlphaBits;
     688           0 :     for( int i = nImageSize/sizeof(long); --i >= 0; ++pLDst )
     689           0 :         *pLDst = ~*pLDst;
     690             : 
     691           0 :     char* pCDst = (char*)pLDst;
     692           0 :     for( int i = nImageSize & (sizeof(long)-1); --i >= 0; ++pCDst )
     693           0 :         *pCDst = ~*pCDst;
     694             : 
     695           0 :     const XRenderPictFormat* pAlphaFormat = rPeer.GetStandardFormatA8();
     696             :     XImage* pAlphaImg = XCreateImage( pXDisplay, pSrcXVisual, 8, ZPixmap, 0,
     697             :         pAlphaBits, pAlphaBuffer->mnWidth, pAlphaBuffer->mnHeight,
     698           0 :         pAlphaFormat->depth, pAlphaBuffer->mnScanlineSize );
     699             : 
     700             :     Pixmap aAlphaPM = limitXCreatePixmap( pXDisplay, hDrawable_,
     701           0 :         rTR.mnDestWidth, rTR.mnDestHeight, 8 );
     702             : 
     703             :     XGCValues aAlphaGCV;
     704           0 :     aAlphaGCV.function = GXcopy;
     705           0 :     GC aAlphaGC = XCreateGC( pXDisplay, aAlphaPM, GCFunction, &aAlphaGCV );
     706             :     XPutImage( pXDisplay, aAlphaPM, aAlphaGC, pAlphaImg,
     707           0 :         rTR.mnSrcX, rTR.mnSrcY, 0, 0, rTR.mnDestWidth, rTR.mnDestHeight );
     708           0 :     XFreeGC( pXDisplay, aAlphaGC );
     709           0 :     XFree( pAlphaImg );
     710           0 :     if( pAlphaBits != (char*)pAlphaBuffer->mpBits )
     711           0 :         delete[] pAlphaBits;
     712             : 
     713           0 :     const_cast<SalBitmap&>(rAlphaBmp).ReleaseBuffer( pAlphaBuffer, true );
     714             : 
     715             :     XRenderPictureAttributes aAttr;
     716           0 :     aAttr.repeat = int(true);
     717           0 :     Picture aAlphaPic = rPeer.CreatePicture( aAlphaPM, pAlphaFormat, CPRepeat, &aAttr );
     718           0 :     if( !aAlphaPic )
     719           0 :         return false;
     720             : 
     721             :     // set clipping
     722           0 :     if( mpClipRegion && !XEmptyRegion( mpClipRegion ) )
     723           0 :         rPeer.SetPictureClipRegion( aDstPic, mpClipRegion );
     724             : 
     725             :     // paint source * mask over destination picture
     726             :     rPeer.CompositePicture( PictOpOver, aSrcPic, aAlphaPic, aDstPic,
     727             :         rTR.mnSrcX, rTR.mnSrcY, 0, 0,
     728           0 :         rTR.mnDestX, rTR.mnDestY, rTR.mnDestWidth, rTR.mnDestHeight );
     729             : 
     730           0 :     rPeer.FreePicture( aAlphaPic );
     731           0 :     XFreePixmap(pXDisplay, aAlphaPM);
     732           0 :     rPeer.FreePicture( aSrcPic );
     733           0 :     return true;
     734             : }
     735             : 
     736           0 : bool X11SalGraphics::drawTransformedBitmap(
     737             :     const basegfx::B2DPoint& rNull,
     738             :     const basegfx::B2DPoint& rX,
     739             :     const basegfx::B2DPoint& rY,
     740             :     const SalBitmap& rSourceBitmap,
     741             :     const SalBitmap* pAlphaBitmap)
     742             : {
     743             :     // here direct support for transformed bitmaps can be impemented
     744             :     (void)rNull; (void)rX; (void)rY; (void)rSourceBitmap; (void)pAlphaBitmap;
     745           0 :     return false;
     746             : }
     747             : 
     748           0 : bool X11SalGraphics::drawAlphaRect( long nX, long nY, long nWidth,
     749             :                                     long nHeight, sal_uInt8 nTransparency )
     750             : {
     751           0 :     if( ! m_pFrame && ! m_pVDev )
     752           0 :         return false;
     753             : 
     754           0 :     if( bPenGC_ || !bBrushGC_ || bXORMode_ )
     755           0 :         return false; // can only perform solid fills without XOR.
     756             : 
     757           0 :     if( m_pVDev && m_pVDev->GetDepth() < 8 )
     758           0 :         return false;
     759             : 
     760           0 :     Picture aDstPic = GetXRenderPicture();
     761           0 :     if( !aDstPic )
     762           0 :         return false;
     763             : 
     764           0 :     const double fTransparency = (100 - nTransparency) * (1.0/100);
     765           0 :     const XRenderColor aRenderColor = GetXRenderColor( nBrushColor_ , fTransparency);
     766             : 
     767           0 :     XRenderPeer& rPeer = XRenderPeer::GetInstance();
     768             :     rPeer.FillRectangle( PictOpOver,
     769             :                          aDstPic,
     770             :                          &aRenderColor,
     771             :                          nX, nY,
     772           0 :                          nWidth, nHeight );
     773             : 
     774           0 :     return true;
     775             : }
     776             : 
     777           0 : void X11SalGraphics::drawBitmap( const SalTwoRect&,
     778             :                                  const SalBitmap&,
     779             :                                  SalColor )
     780             : {
     781             :     OSL_FAIL( "::DrawBitmap with transparent color not supported" );
     782           0 : }
     783             : 
     784           0 : void X11SalGraphics::drawMask( const SalTwoRect& rPosAry,
     785             :                                const SalBitmap &rSalBitmap,
     786             :                                SalColor nMaskColor )
     787             : {
     788           0 :     const SalDisplay*   pSalDisp = GetDisplay();
     789           0 :     Display*            pXDisp = pSalDisp->GetDisplay();
     790           0 :     Drawable            aDrawable( GetDrawable() );
     791             :     Pixmap              aStipple( limitXCreatePixmap( pXDisp, aDrawable,
     792             :                                                  rPosAry.mnDestWidth,
     793           0 :                                                  rPosAry.mnDestHeight, 1 ) );
     794             : 
     795           0 :     if( aStipple )
     796             :     {
     797           0 :         SalTwoRect  aTwoRect( rPosAry ); aTwoRect.mnDestX = aTwoRect.mnDestY = 0;
     798             :         GC          aTmpGC;
     799             :         XGCValues   aValues;
     800             : 
     801             :         // create a stipple bitmap first (set bits are changed to unset bits and vice versa)
     802           0 :         aValues.function = GXcopyInverted;
     803           0 :         aValues.foreground = 1, aValues.background = 0;
     804           0 :         aTmpGC = XCreateGC( pXDisp, aStipple, GCFunction | GCForeground | GCBackground, &aValues );
     805           0 :         static_cast<const X11SalBitmap&>(rSalBitmap).ImplDraw( aStipple, m_nXScreen, 1, aTwoRect, aTmpGC );
     806             : 
     807           0 :         XFreeGC( pXDisp, aTmpGC );
     808             : 
     809             :         // Set stipple and draw rectangle
     810           0 :         GC  aStippleGC( GetStippleGC() );
     811           0 :         int nX = rPosAry.mnDestX, nY = rPosAry.mnDestY;
     812             : 
     813           0 :         XSetStipple( pXDisp, aStippleGC, aStipple );
     814           0 :         XSetTSOrigin( pXDisp, aStippleGC, nX, nY );
     815           0 :         XSetForeground( pXDisp, aStippleGC, GetPixel( nMaskColor ) );
     816             :         XFillRectangle( pXDisp, aDrawable, aStippleGC,
     817             :                         nX, nY,
     818           0 :                         rPosAry.mnDestWidth, rPosAry.mnDestHeight );
     819           0 :         XFreePixmap( pXDisp, aStipple );
     820           0 :         XFlush( pXDisp );
     821             :     }
     822             :     else
     823           0 :         drawBitmap( rPosAry, rSalBitmap );
     824           0 : }
     825             : 
     826           0 : SalBitmap *X11SalGraphics::getBitmap( long nX, long nY, long nDX, long nDY )
     827             : {
     828           0 :     if( bPrinter_ && !bVirDev_ )
     829           0 :         return NULL;
     830             : 
     831           0 :     bool bFakeWindowBG = false;
     832             : 
     833             :     // normalize
     834           0 :     if( nDX < 0 )
     835             :     {
     836           0 :         nX += nDX;
     837           0 :         nDX = -nDX;
     838             :     }
     839           0 :     if ( nDY < 0 )
     840             :     {
     841           0 :         nY += nDY;
     842           0 :         nDY = -nDY;
     843             :     }
     844             : 
     845           0 :     if( bWindow_ && !bVirDev_ )
     846             :     {
     847             :         XWindowAttributes aAttrib;
     848             : 
     849           0 :         XGetWindowAttributes( GetXDisplay(), GetDrawable(), &aAttrib );
     850           0 :         if( aAttrib.map_state != IsViewable )
     851           0 :             bFakeWindowBG = true;
     852             :         else
     853             :         {
     854           0 :             long nOrgDX = nDX, nOrgDY = nDY;
     855             : 
     856             :             // clip to window size
     857           0 :             if ( nX < 0 )
     858             :             {
     859           0 :                 nDX += nX;
     860           0 :                 nX   = 0;
     861             :             }
     862           0 :             if ( nY < 0 )
     863             :             {
     864           0 :                 nDY += nY;
     865           0 :                 nY   = 0;
     866             :             }
     867           0 :             if( nX + nDX > aAttrib.width )
     868           0 :                 nDX = aAttrib.width  - nX;
     869           0 :             if( nY + nDY > aAttrib.height )
     870           0 :                 nDY = aAttrib.height - nY;
     871             : 
     872             :             // inside ?
     873           0 :             if( nDX <= 0 || nDY <= 0 )
     874             :             {
     875           0 :                 bFakeWindowBG = true;
     876           0 :                 nDX = nOrgDX;
     877           0 :                 nDY = nOrgDY;
     878             :             }
     879             :         }
     880             :     }
     881             : 
     882           0 :     X11SalBitmap*   pSalBitmap = new X11SalBitmap;
     883           0 :     sal_uInt16          nBitCount = GetBitCount();
     884             : 
     885           0 :     if( &GetDisplay()->GetColormap( m_nXScreen ) != &GetColormap() )
     886           0 :         nBitCount = 1;
     887             : 
     888           0 :     if( ! bFakeWindowBG )
     889           0 :         pSalBitmap->ImplCreateFromDrawable( GetDrawable(), m_nXScreen, nBitCount, nX, nY, nDX, nDY );
     890             :     else
     891           0 :         pSalBitmap->Create( Size( nDX, nDY ), (nBitCount > 8) ? 24 : nBitCount, BitmapPalette( nBitCount > 8 ? nBitCount : 0 ) );
     892             : 
     893           0 :     return pSalBitmap;
     894             : }
     895             : 
     896           0 : SalColor X11SalGraphics::getPixel( long nX, long nY )
     897             : {
     898           0 :     if( bWindow_ && !bVirDev_ )
     899             :     {
     900             :         XWindowAttributes aAttrib;
     901             : 
     902           0 :         XGetWindowAttributes( GetXDisplay(), GetDrawable(), &aAttrib );
     903           0 :         if( aAttrib.map_state != IsViewable )
     904             :         {
     905             :             stderr0( "X11SalGraphics::GetPixel drawable not viewable\n" );
     906           0 :             return 0;
     907             :         }
     908             :     }
     909             : 
     910             :     XImage *pXImage = XGetImage( GetXDisplay(),
     911             :                                      GetDrawable(),
     912             :                                  nX, nY,
     913             :                                  1,  1,
     914             :                                  AllPlanes,
     915           0 :                                  ZPixmap );
     916           0 :     if( !pXImage )
     917             :     {
     918             :         stderr0( "X11SalGraphics::GetPixel !XGetImage()\n" );
     919           0 :         return 0;
     920             :     }
     921             : 
     922             :     XColor aXColor;
     923             : 
     924           0 :     aXColor.pixel = XGetPixel( pXImage, 0, 0 );
     925           0 :     XDestroyImage( pXImage );
     926             : 
     927           0 :     return GetColormap().GetColor( aXColor.pixel );
     928             : }
     929             : 
     930           0 : void X11SalGraphics::invert( long       nX,
     931             :                                 long        nY,
     932             :                                 long        nDX,
     933             :                                 long        nDY,
     934             :                                 SalInvert   nFlags )
     935             : {
     936             :     GC pGC;
     937           0 :     if( SAL_INVERT_50 & nFlags )
     938             :     {
     939           0 :         pGC = GetInvert50GC();
     940           0 :         XFillRectangle( GetXDisplay(), GetDrawable(), pGC, nX, nY, nDX, nDY );
     941             :     }
     942             :     else
     943             :     {
     944           0 :         if ( SAL_INVERT_TRACKFRAME & nFlags )
     945             :         {
     946           0 :             pGC = GetTrackingGC();
     947           0 :             XDrawRectangle( GetXDisplay(), GetDrawable(),  pGC, nX, nY, nDX, nDY );
     948             :         }
     949             :         else
     950             :         {
     951           0 :             pGC = GetInvertGC();
     952           0 :             XFillRectangle( GetXDisplay(), GetDrawable(),  pGC, nX, nY, nDX, nDY );
     953             :         }
     954             :     }
     955           0 : }
     956             : 
     957           0 : bool X11SalGraphics::supportsOperation( OutDevSupportType eType ) const
     958             : {
     959           0 :     bool bRet = false;
     960           0 :     switch( eType )
     961             :     {
     962             :     case OutDevSupport_TransparentRect:
     963             :     case OutDevSupport_B2DDraw:
     964             :         {
     965           0 :             XRenderPeer& rPeer = XRenderPeer::GetInstance();
     966           0 :             const SalDisplay* pSalDisp = GetDisplay();
     967           0 :             const SalVisual& rSalVis = pSalDisp->GetVisual( m_nXScreen );
     968             : 
     969           0 :             Visual* pDstXVisual = rSalVis.GetVisual();
     970           0 :             XRenderPictFormat* pDstVisFmt = rPeer.FindVisualFormat( pDstXVisual );
     971           0 :             if( pDstVisFmt )
     972           0 :                 bRet = true;
     973             :         }
     974           0 :         break;
     975           0 :     default: break;
     976             :     }
     977           0 :     return bRet;
     978           0 : }
     979             : 
     980             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10