vcl/unx/source/gdi/salbmp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: salbmp.cxx,v $
  10  * $Revision: 1.32 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #include <string.h>
  35 #include <stdio.h>
  36 #include <errno.h>
  37 #ifdef FREEBSD
  38 #include <sys/types.h>
  39 #endif
  40 #include <tools/prex.h>
  41 #include "Xproto.h"
  42 #include <tools/postx.h>
  43 #include <salunx.h>
  44 #include <osl/endian.h>
  45 #include <rtl/memory.h>
  46 #include <vcl/salbtype.hxx>
  47 #include <saldata.hxx>
  48 #include <saldisp.hxx>
  49 #include <salgdi.h>
  50 #include <salbmp.h>
  51 #include <salinst.h>
  52 #include <vcl/bitmap.hxx>
  53 #include <com/sun/star/beans/XFastPropertySet.hpp>
  54
  55 // -----------
  56 // - Defines -
  57 // -----------
  58
  59 #define SAL_DRAWPIXMAP_MAX_EXT 4096
  60
  61 // -------------
  62 // - SalBitmap -
  63 // -------------
  64
  65 SalBitmap* X11SalInstance::CreateSalBitmap()
  66 {
  67     return new X11SalBitmap();
  68 }
  69
  70 ImplSalBitmapCache*     X11SalBitmap::mpCache = NULL;
  71 ULONG                           X11SalBitmap::mnCacheInstCount = 0;
  72
  73 // -----------------------------------------------------------------------------
  74
  75 X11SalBitmap::X11SalBitmap() :
  76     mpDIB( NULL ),
  77         mpDDB( NULL ),
  78     mbGrey( false )
  79 {
  80 }
  81
  82 // -----------------------------------------------------------------------------
  83
  84 X11SalBitmap::~X11SalBitmap()
  85 {
  86     Destroy();
  87 }
  88
  89 // -----------------------------------------------------------------------------
  90
  91 void X11SalBitmap::ImplCreateCache()
  92 {
  93     if( !mnCacheInstCount++ )
  94         mpCache = new ImplSalBitmapCache;
  95 }
  96
  97 // -----------------------------------------------------------------------------
  98
  99 void X11SalBitmap::ImplDestroyCache()
 100 {
 101     DBG_ASSERT( mnCacheInstCount, "X11SalBitmap::ImplDestroyCache(): underflow" );
 102
 103     if( mnCacheInstCount && !--mnCacheInstCount )
 104         delete mpCache, mpCache = NULL;
 105 }
 106
 107 // -----------------------------------------------------------------------------
 108
 109 void X11SalBitmap::ImplRemovedFromCache()
 110 {
 111     if( mpDDB )
 112         delete mpDDB, mpDDB = NULL;
 113 }
 114
 115 // -----------------------------------------------------------------------------
 116
 117 BitmapBuffer* X11SalBitmap::ImplCreateDIB( const Size& rSize, USHORT nBitCount, const BitmapPalette& rPal )
 118 {
 119     DBG_ASSERT( nBitCount == 1 || nBitCount == 4 || nBitCount == 8 || nBitCount == 16 || nBitCount == 24, "Unsupported BitCount!" );
 120
 121     BitmapBuffer* pDIB = NULL;
 122
 123     if( rSize.Width() && rSize.Height() )
 124     {
 125         try
 126         {
 127             pDIB = new BitmapBuffer;
 128         }
 129         catch( std::bad_alloc& )
 130         {
 131             pDIB = NULL;
 132         }
 133
 134         if( pDIB )
 135         {
 136             const USHORT nColors = ( nBitCount <= 8 ) ? ( 1 << nBitCount ) : 0;
 137
 138             pDIB->mnFormat = BMP_FORMAT_BOTTOM_UP;
 139
 140             switch( nBitCount )
 141             {
 142                 case( 1 ): pDIB->mnFormat |= BMP_FORMAT_1BIT_MSB_PAL; break;
 143                 case( 4 ): pDIB->mnFormat |= BMP_FORMAT_4BIT_MSN_PAL; break;
 144                 case( 8 ): pDIB->mnFormat |= BMP_FORMAT_8BIT_PAL; break;
 145 #ifdef OSL_BIGENDIAN
 146                 case(16 ):
 147                     pDIB->mnFormat|= BMP_FORMAT_16BIT_TC_MSB_MASK;
 148                     pDIB->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f );
 149                     break;
 150 #else
 151                 case(16 ):
 152                     pDIB->mnFormat|= BMP_FORMAT_16BIT_TC_LSB_MASK;
 153                     pDIB->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f );
 154                     break;
 155 #endif
 156                 default:
 157                     nBitCount = 24;
 158                     //fall through
 159                 case 24:
 160                     pDIB->mnFormat |= BMP_FORMAT_24BIT_TC_BGR;
 161                 break;
 162             }
 163
 164             pDIB->mnWidth = rSize.Width();
 165             pDIB->mnHeight = rSize.Height();
 166             pDIB->mnScanlineSize = AlignedWidth4Bytes( pDIB->mnWidth * nBitCount );
 167             pDIB->mnBitCount = nBitCount;
 168
 169             if( nColors )
 170             {
 171                 pDIB->maPalette = rPal;
 172                 pDIB->maPalette.SetEntryCount( nColors );
 173             }
 174
 175             try
 176             {
 177                 pDIB->mpBits = new BYTE[ pDIB->mnScanlineSize * pDIB->mnHeight ];
 178             }
 179             catch(std::bad_alloc&)
 180             {
 181                 delete pDIB;
 182                 pDIB = NULL;
 183             }
 184         }
 185     }
 186     else
 187         pDIB = NULL;
 188
 189     return pDIB;
 190 }
 191
 192 // -----------------------------------------------------------------------------
 193
 194 BitmapBuffer* X11SalBitmap::ImplCreateDIB( Drawable aDrawable,
 195                                            int nScreen,
 196                                            long nDrawableDepth,
 197                                            long nX, long nY,
 198                                            long nWidth, long nHeight,
 199                                            bool bGrey )
 200 {
 201     BitmapBuffer* pDIB = NULL;
 202
 203     if( aDrawable && nWidth && nHeight && nDrawableDepth )
 204     {
 205         SalDisplay*     pSalDisp = GetX11SalData()->GetDisplay();
 206         SalXLib*        pXLib = pSalDisp->GetXLib();
 207         Display*        pXDisp = pSalDisp->GetDisplay();
 208
 209         // do not die on XError here
 210         // alternatively one could check the coordinates for being offscreen
 211         // but this call can actually work on servers with backing store
 212         // defaults even if the rectangle is offscreen
 213         // so better catch the XError
 214         pXLib->PushXErrorLevel( true );
 215         XImage* pImage = XGetImage( pXDisp, aDrawable, nX, nY, nWidth, nHeight, AllPlanes, ZPixmap );
 216         bool bWasError = pXLib->HasXErrorOccured() && pXLib->GetLastXErrorRequestCode() == X_GetImage;
 217         pXLib->PopXErrorLevel();
 218
 219         if( ! bWasError && pImage && pImage->data )
 220         {
 221             const SalTwoRect            aTwoRect = { 0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight };
 222             BitmapBuffer                        aSrcBuf;
 223             ULONG                                       nDstFormat = BMP_FORMAT_BOTTOM_UP;
 224             const BitmapPalette*        pDstPal = NULL;
 225
 226             aSrcBuf.mnFormat = BMP_FORMAT_TOP_DOWN;
 227             aSrcBuf.mnWidth = nWidth;
 228             aSrcBuf.mnHeight = nHeight;
 229             aSrcBuf.mnBitCount = pImage->bits_per_pixel;
 230             aSrcBuf.mnScanlineSize = pImage->bytes_per_line;
 231             aSrcBuf.mpBits = (BYTE*) pImage->data;
 232
 233             pImage->red_mask = pSalDisp->GetVisual( nScreen ).red_mask;
 234             pImage->green_mask = pSalDisp->GetVisual( nScreen ).green_mask;
 235             pImage->blue_mask = pSalDisp->GetVisual( nScreen ).blue_mask;
 236
 237             switch( aSrcBuf.mnBitCount )
 238             {
 239                 case( 1 ):
 240                 {
 241                     aSrcBuf.mnFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_1BIT_LSB_PAL : BMP_FORMAT_1BIT_MSB_PAL );
 242                     nDstFormat |= BMP_FORMAT_1BIT_MSB_PAL;
 243                 }
 244                 break;
 245
 246                 case( 4 ):
 247                 {
 248                     aSrcBuf.mnFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_4BIT_LSN_PAL : BMP_FORMAT_4BIT_MSN_PAL );
 249                     nDstFormat |= BMP_FORMAT_4BIT_MSN_PAL;
 250                 }
 251                 break;
 252
 253                 case( 8 ):
 254                 {
 255                     aSrcBuf.mnFormat |= BMP_FORMAT_8BIT_PAL;
 256                     nDstFormat |= BMP_FORMAT_8BIT_PAL;
 257                 }
 258                 break;
 259
 260                 case( 16 ):
 261                 {
 262                     nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
 263                     aSrcBuf.maColorMask = ColorMask( pImage->red_mask, pImage->green_mask, pImage->blue_mask );
 264
 265                     if( LSBFirst == pImage->byte_order )
 266                     {
 267                         aSrcBuf.mnFormat |= BMP_FORMAT_16BIT_TC_LSB_MASK;
 268                     }
 269                     else
 270                     {
 271                         aSrcBuf.mnFormat |= BMP_FORMAT_16BIT_TC_MSB_MASK;
 272                         // aSrcBuf.maColorMask = ColorMask( pImage->red_mask ), SWAPSHORT( pImage->green_mask ), SWAPSHORT( pImage->blue_mask ) );
 273                     }
 274                 }
 275                 break;
 276
 277                 case( 24 ):
 278                 {
 279                     if( ( LSBFirst == pImage->byte_order ) && ( pImage->red_mask == 0xFF ) )
 280                         aSrcBuf.mnFormat |= BMP_FORMAT_24BIT_TC_RGB;
 281                     else
 282                         aSrcBuf.mnFormat |= BMP_FORMAT_24BIT_TC_BGR;
 283
 284                     nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
 285                 }
 286                 break;
 287
 288                 case( 32 ):
 289                 {
 290                     if( LSBFirst == pImage->byte_order )
 291                         aSrcBuf.mnFormat |= (  pSalDisp->GetVisual(nScreen).red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_RGBA : BMP_FORMAT_32BIT_TC_BGRA );
 292                     else
 293                         aSrcBuf.mnFormat |= (  pSalDisp->GetVisual(nScreen).red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_ABGR : BMP_FORMAT_32BIT_TC_ARGB );
 294
 295                     nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
 296                 }
 297                 break;
 298             }
 299
 300             BitmapPalette& rPal = aSrcBuf.maPalette;
 301
 302             if( aSrcBuf.mnBitCount == 1 )
 303             {
 304                 rPal.SetEntryCount( 2 );
 305                 pDstPal = &rPal;
 306
 307                 rPal[ 0 ] = Color( COL_BLACK );
 308                 rPal[ 1 ] = Color( COL_WHITE );
 309             }
 310             else if( pImage->depth == 8 && bGrey )
 311             {
 312                                 rPal.SetEntryCount( 256 );
 313                                 pDstPal = &rPal;
 314
 315                                 for( USHORT i = 0; i < 256; i++ )
 316                                 {
 317                                         BitmapColor&    rBmpCol = rPal[ i ];
 318
 319                                         rBmpCol.SetRed( i );
 320                                         rBmpCol.SetGreen( i );
 321                                         rBmpCol.SetBlue( i );
 322                                 }
 323
 324             }
 325             else if( aSrcBuf.mnBitCount <= 8 )
 326             {
 327                 const SalColormap& rColMap = pSalDisp->GetColormap( nScreen );
 328                 const USHORT nCols = Min( (ULONG)rColMap.GetUsed(), (ULONG)(1 << nDrawableDepth) );
 329
 330                 rPal.SetEntryCount( nCols );
 331                 pDstPal = &rPal;
 332
 333                 for( USHORT i = 0; i < nCols; i++ )
 334                 {
 335                     const SalColor      nColor( rColMap.GetColor( i ) );
 336                     BitmapColor&        rBmpCol = rPal[ i ];
 337
 338                     rBmpCol.SetRed( SALCOLOR_RED( nColor ) );
 339                     rBmpCol.SetGreen( SALCOLOR_GREEN( nColor ) );
 340                     rBmpCol.SetBlue( SALCOLOR_BLUE( nColor ) );
 341                 }
 342             }
 343
 344             nDstFormat = aSrcBuf.mnFormat;
 345             pDIB = StretchAndConvert( aSrcBuf, aTwoRect, nDstFormat,
 346                 const_cast<BitmapPalette*>(pDstPal), &aSrcBuf.maColorMask );
 347             XDestroyImage( pImage );
 348         }
 349     }
 350
 351     return pDIB;
 352 }
 353
 354 // -----------------------------------------------------------------------------
 355
 356 XImage* X11SalBitmap::ImplCreateXImage( SalDisplay *pSalDisp, int nScreen, long nDepth, const SalTwoRect& rTwoRect ) const
 357 {
 358     XImage* pImage = NULL;
 359
 360     if( !mpDIB && mpDDB )
 361     {
 362         const_cast<X11SalBitmap*>(this)->mpDIB =
 363             ImplCreateDIB( mpDDB->ImplGetPixmap(),
 364                            mpDDB->ImplGetScreen(),
 365                            mpDDB->ImplGetDepth(),
 366                            0, 0,
 367                            mpDDB->ImplGetWidth(),
 368                            mpDDB->ImplGetHeight(),
 369                            mbGrey );
 370     }
 371
 372     if( mpDIB && mpDIB->mnWidth && mpDIB->mnHeight )
 373     {
 374         Display*        pXDisp = pSalDisp->GetDisplay();
 375         long            nWidth = rTwoRect.mnDestWidth;
 376         long            nHeight = rTwoRect.mnDestHeight;
 377
 378         if( 1 == GetBitCount() )
 379             nDepth = 1;
 380
 381         pImage = XCreateImage( pXDisp, pSalDisp->GetVisual( nScreen ).GetVisual(),
 382                                nDepth, ( 1 == nDepth ) ? XYBitmap :ZPixmap, 0, NULL,
 383                                nWidth, nHeight, 32, 0 );
 384
 385         if( pImage )
 386         {
 387             BitmapBuffer*       pDstBuf;
 388             ULONG                       nDstFormat = BMP_FORMAT_TOP_DOWN;
 389             BitmapPalette*      pPal = NULL;
 390             ColorMask*          pMask = NULL;
 391
 392             switch( pImage->bits_per_pixel )
 393             {
 394                 case( 1 ):
 395                     nDstFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_1BIT_LSB_PAL : BMP_FORMAT_1BIT_MSB_PAL );
 396                 break;
 397
 398                 case( 4 ):
 399                     nDstFormat |= ( LSBFirst == pImage->bitmap_bit_order ? BMP_FORMAT_4BIT_LSN_PAL : BMP_FORMAT_4BIT_MSN_PAL );
 400                 break;
 401
 402                 case( 8 ):
 403                     nDstFormat |= BMP_FORMAT_8BIT_PAL;
 404                 break;
 405
 406                 case( 16 ):
 407                 {
 408                     #ifdef OSL_BIGENDIAN
 409
 410                     if( MSBFirst == pImage->byte_order )
 411                         nDstFormat |= BMP_FORMAT_16BIT_TC_MSB_MASK;
 412                     else
 413                         nDstFormat |= BMP_FORMAT_16BIT_TC_LSB_MASK;
 414
 415                     #else /* OSL_LITENDIAN */
 416
 417                     nDstFormat |= BMP_FORMAT_16BIT_TC_LSB_MASK;
 418                     if( MSBFirst == pImage->byte_order )
 419                         pImage->byte_order = LSBFirst;
 420
 421                     #endif
 422
 423                     pMask = new ColorMask( pImage->red_mask, pImage->green_mask, pImage->blue_mask );
 424                 }
 425                 break;
 426
 427                 case( 24 ):
 428                 {
 429                     if( ( LSBFirst == pImage->byte_order ) && ( pImage->red_mask == 0xFF ) )
 430                         nDstFormat |= BMP_FORMAT_24BIT_TC_RGB;
 431                     else
 432                         nDstFormat |= BMP_FORMAT_24BIT_TC_BGR;
 433                 }
 434                 break;
 435
 436                 case( 32 ):
 437                 {
 438                     if( LSBFirst == pImage->byte_order )
 439                         nDstFormat |= ( pImage->red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_RGBA : BMP_FORMAT_32BIT_TC_BGRA );
 440                     else
 441                         nDstFormat |= ( pImage->red_mask == 0xFF ? BMP_FORMAT_32BIT_TC_ABGR : BMP_FORMAT_32BIT_TC_ARGB );
 442                 }
 443                 break;
 444             }
 445
 446             if( pImage->depth == 1 )
 447             {
 448                 pPal = new BitmapPalette( 2 );
 449                 (*pPal)[ 0 ] = Color( COL_BLACK );
 450                 (*pPal)[ 1 ] = Color( COL_WHITE );
 451             }
 452             else if( pImage->depth == 8 && mbGrey )
 453             {
 454                                 pPal = new BitmapPalette( 256 );
 455
 456                                 for( USHORT i = 0; i < 256; i++ )
 457                                 {
 458                                         BitmapColor&    rBmpCol = (*pPal)[ i ];
 459
 460                                         rBmpCol.SetRed( i );
 461                                         rBmpCol.SetGreen( i );
 462                                         rBmpCol.SetBlue( i );
 463                                 }
 464
 465             }
 466             else if( pImage->depth <= 8 )
 467             {
 468                 const SalColormap& rColMap = pSalDisp->GetColormap( nScreen );
 469                 const USHORT nCols = Min( (ULONG)rColMap.GetUsed(), (ULONG)(1 << pImage->depth) );
 470
 471                 pPal = new BitmapPalette( nCols );
 472
 473                 for( USHORT i = 0; i < nCols; i++ )
 474                 {
 475                     const SalColor      nColor( rColMap.GetColor( i ) );
 476                     BitmapColor&        rBmpCol = (*pPal)[ i ];
 477
 478                     rBmpCol.SetRed( SALCOLOR_RED( nColor ) );
 479                     rBmpCol.SetGreen( SALCOLOR_GREEN( nColor ) );
 480                     rBmpCol.SetBlue( SALCOLOR_BLUE( nColor ) );
 481                 }
 482             }
 483
 484             pDstBuf = StretchAndConvert( *mpDIB, rTwoRect, nDstFormat, pPal, pMask );
 485             delete pPal;
 486             delete pMask;
 487
 488             if( pDstBuf && pDstBuf->mpBits )
 489             {
 490                 // set data in buffer as data member in pImage
 491                 pImage->data = (char*) pDstBuf->mpBits;
 492
 493                 // destroy buffer; don't destroy allocated data in buffer
 494                 delete pDstBuf;
 495             }
 496             else
 497             {
 498                 XDestroyImage( pImage );
 499                 pImage = NULL;
 500             }
 501         }
 502     }
 503
 504     return pImage;
 505 }
 506
 507 // -----------------------------------------------------------------------------
 508 bool X11SalBitmap::ImplCreateFromDrawable( Drawable aDrawable,
 509                                            int nScreen, long nDrawableDepth,
 510                                            long nX, long nY, long nWidth, long nHeight )
 511 {
 512     Destroy();
 513
 514     if( aDrawable && nWidth && nHeight && nDrawableDepth )
 515         mpDDB = new ImplSalDDB( aDrawable, nScreen, nDrawableDepth, nX, nY, nWidth, nHeight );
 516
 517     return( mpDDB != NULL );
 518 }
 519 // -----------------------------------------------------------------------------
 520
 521 bool
 522 X11SalBitmap::SnapShot (Display* pDisplay, XLIB_Window hWindow)
 523 {
 524     if (hWindow != None)
 525     {
 526         XWindowAttributes aAttribute;
 527         XGetWindowAttributes (pDisplay, hWindow, &aAttribute);
 528         if (aAttribute.map_state == IsViewable)
 529         {
 530             // get coordinates relative to root window
 531             XLIB_Window hPetitFleur;
 532             int nRootX, nRootY;
 533
 534             if (XTranslateCoordinates (pDisplay, hWindow, aAttribute.root,
 535                                        0, 0, &nRootX, &nRootY, &hPetitFleur))
 536             {
 537                 XWindowAttributes aRootAttribute;
 538                 XGetWindowAttributes (pDisplay, aAttribute.root, &aRootAttribute);
 539
 540                 int width  = aAttribute.width;
 541                 int height = aAttribute.height;
 542                 int x      = nRootX;
 543                 int y      = nRootY;
 544
 545                 // horizontal range check
 546                 if (x < 0)
 547                 {
 548                     width  = width + x;
 549                     x      = 0;
 550                 }
 551                 else
 552                 if (x > aRootAttribute.width)
 553                 {
 554                     width = 0;
 555                     x     = aRootAttribute.width;
 556                 }
 557                 else
 558                 if (x + width > aRootAttribute.width)
 559                 {
 560                     width = aRootAttribute.width - x;
 561                 }
 562
 563                 // vertical range check
 564                 if (y < 0)
 565                 {
 566                     height = height + y;
 567                     y      = 0;
 568                 }
 569                 else
 570                 if (y > aRootAttribute.height)
 571                 {
 572                     height = 0;
 573                     y      = aRootAttribute.height;
 574                 }
 575                 else
 576                 if (y + height > aRootAttribute.height)
 577                 {
 578                     height = aRootAttribute.height - y;
 579                 }
 580
 581                 if ((width > 0) && (height > 0))
 582                 {
 583                     XImage* pImage = XGetImage( pDisplay, aAttribute.root,
 584                                                 x, y, width, height, AllPlanes, ZPixmap );
 585                     bool bSnapShot = ImplCreateFromXImage( pDisplay,
 586                                                            aAttribute.root,
 587                                                            XScreenNumberOfScreen( aAttribute.screen ),
 588                                                            pImage );
 589                     XDestroyImage (pImage);
 590
 591                     return bSnapShot;
 592                 }
 593             }
 594         }
 595     }
 596
 597     return False;
 598 }
 599
 600 bool
 601 X11SalBitmap::ImplCreateFromXImage (Display* pDisplay, XLIB_Window hWindow, int nScreen, XImage* pImage)
 602 {
 603     Destroy();
 604
 605     if (pImage != NULL && pImage->width != 0 && pImage->height != 0 && pImage->depth != 0)
 606     {
 607         mpDDB = new ImplSalDDB (pDisplay, hWindow, nScreen, pImage);
 608         return True;
 609     }
 610     return False;
 611 }
 612
 613 ImplSalDDB* X11SalBitmap::ImplGetDDB( Drawable          aDrawable,
 614                                       int               nScreen,
 615                                       long              nDrawableDepth,
 616                                       const SalTwoRect& rTwoRect ) const
 617 {
 618     if( !mpDDB || !mpDDB->ImplMatches( nScreen, nDrawableDepth, rTwoRect ) )
 619     {
 620         if( mpDDB )
 621         {
 622             // do we already have a DIB? if not, create aDIB from current DDB first
 623             if( !mpDIB )
 624             {
 625                 const_cast<X11SalBitmap*>(this)->mpDIB = ImplCreateDIB( mpDDB->ImplGetPixmap(),
 626                                                                         mpDDB->ImplGetScreen(),
 627                                                                         mpDDB->ImplGetDepth(),
 628                                                                         0, 0,
 629                                                                         mpDDB->ImplGetWidth(),
 630                                                                         mpDDB->ImplGetHeight(),
 631                                                                         mbGrey );
 632             }
 633
 634             delete mpDDB, const_cast<X11SalBitmap*>(this)->mpDDB = NULL;
 635         }
 636
 637         if( mpCache )
 638             mpCache->ImplRemove( const_cast<X11SalBitmap*>(this) );
 639
 640         SalTwoRect aTwoRect( rTwoRect );
 641         if( aTwoRect.mnSrcX < 0 )
 642         {
 643             aTwoRect.mnSrcWidth += aTwoRect.mnSrcX;
 644             aTwoRect.mnSrcX = 0;
 645         }
 646         if( aTwoRect.mnSrcY < 0 )
 647         {
 648             aTwoRect.mnSrcHeight += aTwoRect.mnSrcY;
 649             aTwoRect.mnSrcY = 0;
 650         }
 651
 652         // create new DDB from DIB
 653         const Size aSize( GetSize() );
 654         if( aTwoRect.mnSrcWidth == aTwoRect.mnDestWidth &&
 655             aTwoRect.mnSrcHeight == aTwoRect.mnDestHeight )
 656         {
 657             aTwoRect.mnSrcX = aTwoRect.mnSrcY = aTwoRect.mnDestX = aTwoRect.mnDestY = 0;
 658             aTwoRect.mnSrcWidth = aTwoRect.mnDestWidth = aSize.Width();
 659             aTwoRect.mnSrcHeight = aTwoRect.mnDestHeight = aSize.Height();
 660         }
 661         else if( aTwoRect.mnSrcWidth+aTwoRect.mnSrcX > aSize.Width() ||
 662                  aTwoRect.mnSrcHeight+aTwoRect.mnSrcY > aSize.Height() )
 663         {
 664             // #i47823# this should not happen at all, but does nonetheless
 665             // because BitmapEx allows for mask bitmaps of different size
 666             // than image bitmap (broken)
 667             if( aTwoRect.mnSrcX >= aSize.Width() ||
 668                 aTwoRect.mnSrcY >= aSize.Height() )
 669                 return NULL; // this would be a really mad case
 670
 671             if( aTwoRect.mnSrcWidth+aTwoRect.mnSrcX > aSize.Width() )
 672             {
 673                 aTwoRect.mnSrcWidth = aSize.Width()-aTwoRect.mnSrcX;
 674                 if( aTwoRect.mnSrcWidth < 1 )
 675                 {
 676                     aTwoRect.mnSrcX = 0;
 677                     aTwoRect.mnSrcWidth = aSize.Width();
 678                 }
 679             }
 680             if( aTwoRect.mnSrcHeight+aTwoRect.mnSrcY > aSize.Height() )
 681             {
 682                 aTwoRect.mnSrcHeight = aSize.Height() - aTwoRect.mnSrcY;
 683                 if( aTwoRect.mnSrcHeight < 1 )
 684                 {
 685                     aTwoRect.mnSrcY = 0;
 686                     aTwoRect.mnSrcHeight = aSize.Height();
 687                 }
 688             }
 689         }
 690
 691         XImage* pImage = ImplCreateXImage( GetX11SalData()->GetDisplay(), nScreen,
 692                                            nDrawableDepth, aTwoRect );
 693
 694         if( pImage )
 695         {
 696             const_cast<X11SalBitmap*>(this)->mpDDB = new ImplSalDDB( pImage, aDrawable, nScreen, aTwoRect );
 697             delete[] pImage->data, pImage->data = NULL;
 698             XDestroyImage( pImage );
 699
 700             if( mpCache )
 701                 mpCache->ImplAdd( const_cast<X11SalBitmap*>(this), mpDDB->ImplGetMemSize() );
 702         }
 703     }
 704
 705     return mpDDB;
 706 }
 707
 708 // -----------------------------------------------------------------------------
 709
 710 void X11SalBitmap::ImplDraw( Drawable           aDrawable,
 711                              int                nScreen,
 712                              long               nDrawableDepth,
 713                              const SalTwoRect&  rTwoRect,
 714                              const GC&          rGC ) const
 715 {
 716     ImplGetDDB( aDrawable, nScreen, nDrawableDepth, rTwoRect );
 717     if( mpDDB )
 718         mpDDB->ImplDraw( aDrawable, nDrawableDepth, rTwoRect, rGC );
 719 }
 720
 721 // -----------------------------------------------------------------------------
 722
 723 bool X11SalBitmap::Create( const Size& rSize, USHORT nBitCount, const BitmapPalette& rPal )
 724 {
 725     Destroy();
 726     mpDIB = ImplCreateDIB( rSize, nBitCount, rPal );
 727
 728     return( mpDIB != NULL );
 729 }
 730
 731 // -----------------------------------------------------------------------------
 732
 733 bool X11SalBitmap::Create( const SalBitmap& rSSalBmp )
 734 {
 735     Destroy();
 736
 737     const X11SalBitmap& rSalBmp = static_cast<const X11SalBitmap&>( rSSalBmp );
 738
 739     if( rSalBmp.mpDIB )
 740     {
 741         // TODO: reference counting...
 742         mpDIB = new BitmapBuffer( *rSalBmp.mpDIB );
 743         // TODO: get rid of this when BitmapBuffer gets copy constructor
 744         try
 745         {
 746             mpDIB->mpBits = new BYTE[ mpDIB->mnScanlineSize * mpDIB->mnHeight ];
 747         }
 748         catch( std::bad_alloc& )
 749         {
 750             delete mpDIB;
 751             mpDIB = NULL;
 752         }
 753
 754         if( mpDIB )
 755             memcpy( mpDIB->mpBits, rSalBmp.mpDIB->mpBits, mpDIB->mnScanlineSize * mpDIB->mnHeight );
 756     }
 757     else if(  rSalBmp.mpDDB )
 758         ImplCreateFromDrawable( rSalBmp.mpDDB->ImplGetPixmap(),
 759                                 rSalBmp.mpDDB->ImplGetScreen(),
 760                                 rSalBmp.mpDDB->ImplGetDepth(),
 761                                 0, 0, rSalBmp.mpDDB->ImplGetWidth(), rSalBmp.mpDDB->ImplGetHeight() );
 762
 763     return( ( !rSalBmp.mpDIB && !rSalBmp.mpDDB ) ||
 764             ( rSalBmp.mpDIB && ( mpDIB != NULL ) ) ||
 765             ( rSalBmp.mpDDB && ( mpDDB != NULL ) ) );
 766 }
 767
 768 // -----------------------------------------------------------------------------
 769
 770 bool X11SalBitmap::Create( const SalBitmap&, SalGraphics* )
 771 {
 772     return FALSE;
 773 }
 774
 775 // -----------------------------------------------------------------------------
 776
 777 bool X11SalBitmap::Create( const SalBitmap&, USHORT )
 778 {
 779     return FALSE;
 780 }
 781
 782 // -----------------------------------------------------------------------------
 783
 784 bool X11SalBitmap::Create( const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XBitmapCanvas > xBitmapCanvas, Size& rSize, bool bMask )
 785 {
 786     ::com::sun::star::uno::Reference< ::com::sun::star::beans::XFastPropertySet > xFastPropertySet( xBitmapCanvas, ::com::sun::star::uno::UNO_QUERY );
 787     if( xFastPropertySet.get() ) {
 788         long pixmapHandle;
 789         sal_Int32 depth;
 790         ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > args;
 791
 792         if( xFastPropertySet->getFastPropertyValue(bMask ? 2 : 1) >>= args ) {
 793             if( ( args[1] >>= pixmapHandle ) && ( args[2] >>= depth ) ) {
 794
 795                 mbGrey = bMask;
 796                 bool bSuccess = ImplCreateFromDrawable( pixmapHandle, 0, depth, 0, 0, (long) rSize.Width(), (long) rSize.Height() );
 797                 bool bFreePixmap;
 798                 if( bSuccess && (args[0] >>= bFreePixmap) && bFreePixmap )
 799                     XFreePixmap( GetX11SalData()->GetDisplay()->GetDisplay(), pixmapHandle );
 800
 801                 return bSuccess;
 802             }
 803         }
 804     }
 805
 806     return false;
 807 }
 808
 809 // -----------------------------------------------------------------------------
 810
 811 void X11SalBitmap::Destroy()
 812 {
 813     if( mpDIB )
 814     {
 815         delete[] mpDIB->mpBits;
 816         delete mpDIB, mpDIB = NULL;
 817     }
 818
 819     if( mpDDB )
 820         delete mpDDB, mpDDB = NULL;
 821
 822     if( mpCache )
 823         mpCache->ImplRemove( this );
 824 }
 825
 826 // -----------------------------------------------------------------------------
 827
 828 Size X11SalBitmap::GetSize() const
 829 {
 830     Size aSize;
 831
 832     if( mpDIB )
 833         aSize.Width() = mpDIB->mnWidth, aSize.Height() = mpDIB->mnHeight;
 834     else if( mpDDB )
 835         aSize.Width() = mpDDB->ImplGetWidth(), aSize.Height() = mpDDB->ImplGetHeight();
 836
 837     return aSize;
 838 }
 839
 840 // -----------------------------------------------------------------------------
 841
 842 USHORT X11SalBitmap::GetBitCount() const
 843 {
 844     USHORT nBitCount;
 845
 846     if( mpDIB )
 847         nBitCount = mpDIB->mnBitCount;
 848     else if( mpDDB )
 849         nBitCount = mpDDB->ImplGetDepth();
 850     else
 851         nBitCount = 0;
 852
 853     return nBitCount;
 854 }
 855
 856 // -----------------------------------------------------------------------------
 857
 858 BitmapBuffer* X11SalBitmap::AcquireBuffer( bool )
 859 {
 860     if( !mpDIB && mpDDB )
 861     {
 862         mpDIB = ImplCreateDIB( mpDDB->ImplGetPixmap(),
 863                                mpDDB->ImplGetScreen(),
 864                                mpDDB->ImplGetDepth(),
 865                                                            0, 0, mpDDB->ImplGetWidth(), mpDDB->ImplGetHeight(), mbGrey );
 866     }
 867
 868     return mpDIB;
 869 }
 870
 871 // -----------------------------------------------------------------------------
 872
 873 void X11SalBitmap::ReleaseBuffer( BitmapBuffer*, bool bReadOnly )
 874 {
 875     if( !bReadOnly )
 876     {
 877         if( mpDDB )
 878             delete mpDDB, mpDDB = NULL;
 879
 880         if( mpCache )
 881             mpCache->ImplRemove( this );
 882     }
 883 }
 884
 885 // -----------------------------------------------------------------------------
 886
 887 bool X11SalBitmap::GetSystemData( BitmapSystemData& rData )
 888 {
 889     if( mpDDB )
 890     {
 891         // Rename/retype pDummy to your likings (though X11 Pixmap is
 892         // prolly not a good idea, since it's accessed from
 893         // non-platform aware code in vcl/bitmap.hxx)
 894         rData.aPixmap = (void*)mpDDB->ImplGetPixmap();
 895         rData.mnWidth = mpDDB->ImplGetWidth ();
 896         rData.mnHeight = mpDDB->ImplGetHeight ();
 897         return true;
 898     }
 899
 900     return false;
 901 }
 902
 903 // --------------
 904 // - ImplSalDDB -
 905 // --------------
 906
 907 ImplSalDDB::ImplSalDDB( XImage* pImage, Drawable aDrawable, int nScreen, const SalTwoRect& rTwoRect ) :
 908     maPixmap    ( 0 ),
 909     maTwoRect   ( rTwoRect ),
 910     mnDepth             ( pImage->depth ),
 911     mnScreen    ( nScreen )
 912 {
 913     SalDisplay* pSalDisp = GetX11SalData()->GetDisplay();
 914     Display*    pXDisp = pSalDisp->GetDisplay();
 915
 916     if( (maPixmap = XCreatePixmap( pXDisp, aDrawable, ImplGetWidth(), ImplGetHeight(), ImplGetDepth() )) )
 917     {
 918         XGCValues       aValues;
 919         GC                      aGC;
 920         int                     nValues = GCFunction;
 921
 922         aValues.function = GXcopy;
 923
 924         if( 1 == mnDepth )
 925         {
 926             nValues |= ( GCForeground | GCBackground );
 927             aValues.foreground = 1, aValues.background = 0;
 928         }
 929
 930         aGC = XCreateGC( pXDisp, maPixmap, nValues, &aValues );
 931         XPutImage( pXDisp, maPixmap, aGC, pImage, 0, 0, 0, 0, maTwoRect.mnDestWidth, maTwoRect.mnDestHeight );
 932         XFreeGC( pXDisp, aGC );
 933     }
 934 }
 935
 936 // -----------------------------------------------------------------------------------------
 937 // create from XImage
 938
 939 ImplSalDDB::ImplSalDDB (Display* pDisplay, XLIB_Window hWindow, int nScreen, XImage* pImage) :
 940     mnScreen( nScreen )
 941 {
 942     maPixmap = XCreatePixmap (pDisplay, hWindow, pImage->width, pImage->height, pImage->depth);
 943     if (maPixmap != 0)
 944     {
 945         XGCValues       aValues;
 946         GC                      aGC;
 947         int                     nValues = GCFunction;
 948
 949         aValues.function = GXcopy;
 950
 951         if (pImage->depth == 1)
 952         {
 953             nValues |= ( GCForeground | GCBackground );
 954             aValues.foreground = 1;
 955             aValues.background = 0;
 956         }
 957
 958         aGC = XCreateGC (pDisplay, maPixmap, nValues, &aValues);
 959         XPutImage (pDisplay, maPixmap, aGC, pImage, 0, 0, 0, 0, pImage->width, pImage->height);
 960         XFreeGC (pDisplay, aGC);
 961
 962         maTwoRect.mnSrcX       = 0;
 963         maTwoRect.mnSrcY       = 0;
 964         maTwoRect.mnDestX      = 0;
 965         maTwoRect.mnDestY      = 0;
 966         maTwoRect.mnSrcWidth   = pImage->width;
 967         maTwoRect.mnDestWidth  = pImage->width;
 968         maTwoRect.mnSrcHeight  = pImage->height;
 969         maTwoRect.mnDestHeight = pImage->height;
 970
 971         mnDepth = pImage->depth;
 972     }
 973 }
 974
 975 // -----------------------------------------------------------------------------
 976
 977 ImplSalDDB::ImplSalDDB( Drawable aDrawable, int nScreen, long nDrawableDepth, long nX, long nY, long nWidth, long nHeight ) :
 978     mnDepth( nDrawableDepth ),
 979     mnScreen( nScreen )
 980 {
 981     SalDisplay* pSalDisp = GetX11SalData()->GetDisplay();
 982     Display*    pXDisp = pSalDisp->GetDisplay();
 983
 984     if( (maPixmap = XCreatePixmap( pXDisp, aDrawable, nWidth, nHeight, nDrawableDepth )) )
 985     {
 986         XGCValues       aValues;
 987         GC                      aGC;
 988         int                     nValues = GCFunction;
 989
 990         aValues.function = GXcopy;
 991
 992         if( 1 == mnDepth )
 993         {
 994             nValues |= ( GCForeground | GCBackground );
 995             aValues.foreground = 1, aValues.background = 0;
 996         }
 997
 998         aGC = XCreateGC( pXDisp, maPixmap, nValues, &aValues );
 999         ImplDraw( aDrawable, nDrawableDepth, maPixmap, mnDepth,
1000                   nX, nY, nWidth, nHeight, 0, 0, aGC );
1001         XFreeGC( pXDisp, aGC );
1002
1003         maTwoRect.mnSrcX = maTwoRect.mnSrcY = maTwoRect.mnDestX = maTwoRect.mnDestY = 0;
1004         maTwoRect.mnSrcWidth = maTwoRect.mnDestWidth = nWidth;
1005         maTwoRect.mnSrcHeight = maTwoRect.mnDestHeight = nHeight;
1006     }
1007 }
1008
1009 // -----------------------------------------------------------------------------
1010
1011 ImplSalDDB::~ImplSalDDB()
1012 {
1013     if( maPixmap && ImplGetSVData() )
1014         XFreePixmap( GetX11SalData()->GetDisplay()->GetDisplay(), maPixmap );
1015 }
1016
1017 // -----------------------------------------------------------------------------
1018
1019 bool ImplSalDDB::ImplMatches( int nScreen, long nDepth, const SalTwoRect& rTwoRect ) const
1020 {
1021     bool bRet = FALSE;
1022
1023     if( ( maPixmap != 0 ) && ( ( mnDepth == nDepth ) || ( 1 == mnDepth ) ) && nScreen == mnScreen)
1024     {
1025         if( rTwoRect.mnSrcX == maTwoRect.mnSrcX && rTwoRect.mnSrcY == maTwoRect.mnSrcY &&
1026             rTwoRect.mnSrcWidth == maTwoRect.mnSrcWidth && rTwoRect.mnSrcHeight == maTwoRect.mnSrcHeight &&
1027             rTwoRect.mnDestWidth == maTwoRect.mnDestWidth && rTwoRect.mnDestHeight == maTwoRect.mnDestHeight )
1028         {
1029             // absolutely indentically
1030             bRet = TRUE;
1031         }
1032         else if( rTwoRect.mnSrcWidth == rTwoRect.mnDestWidth && rTwoRect.mnSrcHeight == rTwoRect.mnDestHeight &&
1033                  maTwoRect.mnSrcWidth == maTwoRect.mnDestWidth && maTwoRect.mnSrcHeight == maTwoRect.mnDestHeight &&
1034                  rTwoRect.mnSrcX >= maTwoRect.mnSrcX && rTwoRect.mnSrcY >= maTwoRect.mnSrcY &&
1035                  ( rTwoRect.mnSrcX + rTwoRect.mnSrcWidth ) <= ( maTwoRect.mnSrcX + maTwoRect.mnSrcWidth ) &&
1036                  ( rTwoRect.mnSrcY + rTwoRect.mnSrcHeight ) <= ( maTwoRect.mnSrcY + maTwoRect.mnSrcHeight ) )
1037         {
1038             bRet = TRUE;
1039         }
1040     }
1041
1042     return bRet;
1043 }
1044
1045 // -----------------------------------------------------------------------------
1046
1047 void ImplSalDDB::ImplDraw( Drawable aDrawable, long nDrawableDepth, const SalTwoRect& rTwoRect, const GC& rGC ) const
1048 {
1049     ImplDraw( maPixmap, mnDepth, aDrawable, nDrawableDepth,
1050               rTwoRect.mnSrcX - maTwoRect.mnSrcX, rTwoRect.mnSrcY - maTwoRect.mnSrcY,
1051               rTwoRect.mnDestWidth, rTwoRect.mnDestHeight,
1052               rTwoRect.mnDestX, rTwoRect.mnDestY, rGC );
1053 }
1054
1055 // -----------------------------------------------------------------------------
1056
1057 void ImplSalDDB::ImplDraw( Drawable aSrcDrawable, long nSrcDrawableDepth,
1058                            Drawable aDstDrawable, long,
1059                            long nSrcX, long nSrcY,
1060                            long nDestWidth, long nDestHeight,
1061                            long nDestX, long nDestY, const GC& rGC )
1062 {
1063     SalDisplay* pSalDisp = GetX11SalData()->GetDisplay();
1064     Display*    pXDisp = pSalDisp->GetDisplay();
1065
1066     if( 1 == nSrcDrawableDepth )
1067     {
1068         XCopyPlane( pXDisp, aSrcDrawable, aDstDrawable, rGC,
1069                     nSrcX, nSrcY, nDestWidth, nDestHeight, nDestX, nDestY, 1 );
1070     }
1071     else
1072     {
1073         XCopyArea( pXDisp, aSrcDrawable, aDstDrawable, rGC,
1074                    nSrcX, nSrcY, nDestWidth, nDestHeight, nDestX, nDestY );
1075     }
1076 }
1077
1078 // ----------------------
1079 // - ImplSalBitmapCache -
1080 // ----------------------
1081
1082 struct ImplBmpObj
1083 {
1084     X11SalBitmap*       mpBmp;
1085     ULONG               mnMemSize;
1086     ULONG               mnFlags;
1087
1088                 ImplBmpObj( X11SalBitmap* pBmp, ULONG nMemSize, ULONG nFlags ) :
1089                     mpBmp( pBmp ), mnMemSize( nMemSize ), mnFlags( nFlags ) {}
1090 };
1091
1092 // -----------------------------------------------------------------------------
1093
1094 ImplSalBitmapCache::ImplSalBitmapCache() :
1095     mnTotalSize( 0UL )
1096 {
1097 }
1098
1099 // -----------------------------------------------------------------------------
1100
1101 ImplSalBitmapCache::~ImplSalBitmapCache()
1102 {
1103     ImplClear();
1104 }
1105
1106 // -----------------------------------------------------------------------------
1107
1108 void ImplSalBitmapCache::ImplAdd( X11SalBitmap* pBmp, ULONG nMemSize, ULONG nFlags )
1109 {
1110     ImplBmpObj* pObj;
1111     bool                bFound = FALSE;
1112
1113     for( pObj = (ImplBmpObj*) maBmpList.Last(); pObj && !bFound; pObj = (ImplBmpObj*) maBmpList.Prev() )
1114         if( pObj->mpBmp == pBmp )
1115             bFound = TRUE;
1116
1117     mnTotalSize += nMemSize;
1118
1119     if( bFound )
1120     {
1121         mnTotalSize -= pObj->mnMemSize;
1122         pObj->mnMemSize = nMemSize, pObj->mnFlags = nFlags;
1123     }
1124     else
1125         maBmpList.Insert( new ImplBmpObj( pBmp, nMemSize, nFlags ), LIST_APPEND );
1126 }
1127
1128 // -----------------------------------------------------------------------------
1129
1130 void ImplSalBitmapCache::ImplRemove( X11SalBitmap* pBmp )
1131 {
1132     for( ImplBmpObj* pObj = (ImplBmpObj*) maBmpList.Last(); pObj; pObj = (ImplBmpObj*) maBmpList.Prev() )
1133     {
1134         if( pObj->mpBmp == pBmp )
1135         {
1136             maBmpList.Remove( pObj );
1137             pObj->mpBmp->ImplRemovedFromCache();
1138             mnTotalSize -= pObj->mnMemSize;
1139             delete pObj;
1140             break;
1141         }
1142     }
1143 }
1144
1145 // -----------------------------------------------------------------------------
1146
1147 void ImplSalBitmapCache::ImplClear()
1148 {
1149     for( ImplBmpObj* pObj = (ImplBmpObj*) maBmpList.First(); pObj; pObj = (ImplBmpObj*) maBmpList.Next() )
1150     {
1151         pObj->mpBmp->ImplRemovedFromCache();
1152         delete pObj;
1153     }
1154
1155     maBmpList.Clear();
1156     mnTotalSize = 0;
1157 }