19f62ea84SAndrew Rist /************************************************************** 2cdf0e10cSrcweir * 39f62ea84SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 49f62ea84SAndrew Rist * or more contributor license agreements. See the NOTICE file 59f62ea84SAndrew Rist * distributed with this work for additional information 69f62ea84SAndrew Rist * regarding copyright ownership. The ASF licenses this file 79f62ea84SAndrew Rist * to you under the Apache License, Version 2.0 (the 89f62ea84SAndrew Rist * "License"); you may not use this file except in compliance 99f62ea84SAndrew Rist * with the License. You may obtain a copy of the License at 109f62ea84SAndrew Rist * 119f62ea84SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 129f62ea84SAndrew Rist * 139f62ea84SAndrew Rist * Unless required by applicable law or agreed to in writing, 149f62ea84SAndrew Rist * software distributed under the License is distributed on an 159f62ea84SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 169f62ea84SAndrew Rist * KIND, either express or implied. See the License for the 179f62ea84SAndrew Rist * specific language governing permissions and limitations 189f62ea84SAndrew Rist * under the License. 199f62ea84SAndrew Rist * 209f62ea84SAndrew Rist *************************************************************/ 219f62ea84SAndrew Rist 22cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 23cdf0e10cSrcweir #include "precompiled_vcl.hxx" 24cdf0e10cSrcweir 25cdf0e10cSrcweir #include <tools/debug.hxx> 26cdf0e10cSrcweir #include <vcl/bitmap.hxx> 27cdf0e10cSrcweir #include <vcl/bitmapex.hxx> 28cdf0e10cSrcweir #include <vcl/window.hxx> 29cdf0e10cSrcweir #include <vcl/metaact.hxx> 30cdf0e10cSrcweir #include <vcl/gdimtf.hxx> 31cdf0e10cSrcweir #include <vcl/virdev.hxx> 32cdf0e10cSrcweir #include <vcl/bmpacc.hxx> 33cdf0e10cSrcweir #include <vcl/outdev.hxx> 34cdf0e10cSrcweir #include <vcl/window.hxx> 35cdf0e10cSrcweir #include <vcl/image.hxx> 36cdf0e10cSrcweir #include <bmpfast.hxx> 37cdf0e10cSrcweir #include <salbmp.hxx> 38cdf0e10cSrcweir #include <salgdi.hxx> 39cdf0e10cSrcweir #include <impbmp.hxx> 40cdf0e10cSrcweir #include <sallayout.hxx> 41cdf0e10cSrcweir #include <image.h> 42cdf0e10cSrcweir #include <outdev.h> 43cdf0e10cSrcweir #include <window.h> 44cdf0e10cSrcweir #include <outdata.hxx> 45*5f27b83cSArmin Le Grand #include <basegfx/matrix/b2dhommatrix.hxx> 46cdf0e10cSrcweir 47cdf0e10cSrcweir #define BAND_MAX_SIZE 512000 48cdf0e10cSrcweir 49cdf0e10cSrcweir // ======================================================================= 50cdf0e10cSrcweir 51cdf0e10cSrcweir DBG_NAMEEX( OutputDevice ) 52cdf0e10cSrcweir 53cdf0e10cSrcweir // ======================================================================= 54cdf0e10cSrcweir 55cdf0e10cSrcweir // ----------- 56cdf0e10cSrcweir // - Defines - 57cdf0e10cSrcweir // ----------- 58cdf0e10cSrcweir 59cdf0e10cSrcweir #define OUTDEV_INIT() \ 60cdf0e10cSrcweir { \ 61cdf0e10cSrcweir if ( !IsDeviceOutputNecessary() ) \ 62cdf0e10cSrcweir return; \ 63cdf0e10cSrcweir \ 64cdf0e10cSrcweir if ( !mpGraphics ) \ 65cdf0e10cSrcweir if ( !ImplGetGraphics() ) \ 66cdf0e10cSrcweir return; \ 67cdf0e10cSrcweir \ 68cdf0e10cSrcweir if ( mbInitClipRegion ) \ 69cdf0e10cSrcweir ImplInitClipRegion(); \ 70cdf0e10cSrcweir \ 71cdf0e10cSrcweir if ( mbOutputClipped ) \ 72cdf0e10cSrcweir return; \ 73cdf0e10cSrcweir } 74cdf0e10cSrcweir 75cdf0e10cSrcweir // ------------- 76cdf0e10cSrcweir // - externals - 77cdf0e10cSrcweir // ------------- 78cdf0e10cSrcweir 79cdf0e10cSrcweir extern sal_uLong nVCLRLut[ 6 ]; 80cdf0e10cSrcweir extern sal_uLong nVCLGLut[ 6 ]; 81cdf0e10cSrcweir extern sal_uLong nVCLBLut[ 6 ]; 82cdf0e10cSrcweir extern sal_uLong nVCLDitherLut[ 256 ]; 83cdf0e10cSrcweir extern sal_uLong nVCLLut[ 256 ]; 84cdf0e10cSrcweir 85cdf0e10cSrcweir // ======================================================================= 86cdf0e10cSrcweir 87*5f27b83cSArmin Le Grand sal_uLong ImplAdjustTwoRect( SalTwoRect& rTwoRect, const Size& rSizePix ) 88cdf0e10cSrcweir { 89cdf0e10cSrcweir sal_uLong nMirrFlags = 0; 90cdf0e10cSrcweir 91cdf0e10cSrcweir if ( rTwoRect.mnDestWidth < 0 ) 92cdf0e10cSrcweir { 93cdf0e10cSrcweir rTwoRect.mnSrcX = rSizePix.Width() - rTwoRect.mnSrcX - rTwoRect.mnSrcWidth; 94cdf0e10cSrcweir rTwoRect.mnDestWidth = -rTwoRect.mnDestWidth; 95cdf0e10cSrcweir rTwoRect.mnDestX -= rTwoRect.mnDestWidth-1; 96cdf0e10cSrcweir nMirrFlags |= BMP_MIRROR_HORZ; 97cdf0e10cSrcweir } 98cdf0e10cSrcweir 99cdf0e10cSrcweir if ( rTwoRect.mnDestHeight < 0 ) 100cdf0e10cSrcweir { 101cdf0e10cSrcweir rTwoRect.mnSrcY = rSizePix.Height() - rTwoRect.mnSrcY - rTwoRect.mnSrcHeight; 102cdf0e10cSrcweir rTwoRect.mnDestHeight = -rTwoRect.mnDestHeight; 103cdf0e10cSrcweir rTwoRect.mnDestY -= rTwoRect.mnDestHeight-1; 104cdf0e10cSrcweir nMirrFlags |= BMP_MIRROR_VERT; 105cdf0e10cSrcweir } 106cdf0e10cSrcweir 107cdf0e10cSrcweir if( ( rTwoRect.mnSrcX < 0 ) || ( rTwoRect.mnSrcX >= rSizePix.Width() ) || 108cdf0e10cSrcweir ( rTwoRect.mnSrcY < 0 ) || ( rTwoRect.mnSrcY >= rSizePix.Height() ) || 109cdf0e10cSrcweir ( ( rTwoRect.mnSrcX + rTwoRect.mnSrcWidth ) > rSizePix.Width() ) || 110cdf0e10cSrcweir ( ( rTwoRect.mnSrcY + rTwoRect.mnSrcHeight ) > rSizePix.Height() ) ) 111cdf0e10cSrcweir { 112cdf0e10cSrcweir const Rectangle aSourceRect( Point( rTwoRect.mnSrcX, rTwoRect.mnSrcY ), 113cdf0e10cSrcweir Size( rTwoRect.mnSrcWidth, rTwoRect.mnSrcHeight ) ); 114cdf0e10cSrcweir Rectangle aCropRect( aSourceRect ); 115cdf0e10cSrcweir 116cdf0e10cSrcweir aCropRect.Intersection( Rectangle( Point(), rSizePix ) ); 117cdf0e10cSrcweir 118cdf0e10cSrcweir if( aCropRect.IsEmpty() ) 119cdf0e10cSrcweir rTwoRect.mnSrcWidth = rTwoRect.mnSrcHeight = rTwoRect.mnDestWidth = rTwoRect.mnDestHeight = 0; 120cdf0e10cSrcweir else 121cdf0e10cSrcweir { 122cdf0e10cSrcweir const double fFactorX = ( rTwoRect.mnSrcWidth > 1 ) ? (double) ( rTwoRect.mnDestWidth - 1 ) / ( rTwoRect.mnSrcWidth - 1 ) : 0.0; 123cdf0e10cSrcweir const double fFactorY = ( rTwoRect.mnSrcHeight > 1 ) ? (double) ( rTwoRect.mnDestHeight - 1 ) / ( rTwoRect.mnSrcHeight - 1 ) : 0.0; 124cdf0e10cSrcweir 125cdf0e10cSrcweir const long nDstX1 = rTwoRect.mnDestX + FRound( fFactorX * ( aCropRect.Left() - rTwoRect.mnSrcX ) ); 126cdf0e10cSrcweir const long nDstY1 = rTwoRect.mnDestY + FRound( fFactorY * ( aCropRect.Top() - rTwoRect.mnSrcY ) ); 127cdf0e10cSrcweir const long nDstX2 = rTwoRect.mnDestX + FRound( fFactorX * ( aCropRect.Right() - rTwoRect.mnSrcX ) ); 128cdf0e10cSrcweir const long nDstY2 = rTwoRect.mnDestY + FRound( fFactorY * ( aCropRect.Bottom() - rTwoRect.mnSrcY ) ); 129cdf0e10cSrcweir 130cdf0e10cSrcweir rTwoRect.mnSrcX = aCropRect.Left(); 131cdf0e10cSrcweir rTwoRect.mnSrcY = aCropRect.Top(); 132cdf0e10cSrcweir rTwoRect.mnSrcWidth = aCropRect.GetWidth(); 133cdf0e10cSrcweir rTwoRect.mnSrcHeight = aCropRect.GetHeight(); 134cdf0e10cSrcweir rTwoRect.mnDestX = nDstX1; 135cdf0e10cSrcweir rTwoRect.mnDestY = nDstY1; 136cdf0e10cSrcweir rTwoRect.mnDestWidth = nDstX2 - nDstX1 + 1; 137cdf0e10cSrcweir rTwoRect.mnDestHeight = nDstY2 - nDstY1 + 1; 138cdf0e10cSrcweir } 139cdf0e10cSrcweir } 140cdf0e10cSrcweir 141cdf0e10cSrcweir return nMirrFlags; 142cdf0e10cSrcweir } 143cdf0e10cSrcweir 144cdf0e10cSrcweir // ======================================================================= 145cdf0e10cSrcweir 146*5f27b83cSArmin Le Grand void OutputDevice::ImplDrawOutDevDirect( const OutputDevice* pSrcDev, SalTwoRect& rPosAry ) 147cdf0e10cSrcweir { 148cdf0e10cSrcweir SalGraphics* pGraphics2; 149cdf0e10cSrcweir 150*5f27b83cSArmin Le Grand if ( rPosAry.mnSrcWidth && rPosAry.mnSrcHeight && rPosAry.mnDestWidth && rPosAry.mnDestHeight ) 151cdf0e10cSrcweir { 152cdf0e10cSrcweir if ( this == pSrcDev ) 153cdf0e10cSrcweir pGraphics2 = NULL; 154cdf0e10cSrcweir else 155cdf0e10cSrcweir { 156cdf0e10cSrcweir if ( (GetOutDevType() != pSrcDev->GetOutDevType()) || 157cdf0e10cSrcweir (GetOutDevType() != OUTDEV_WINDOW) ) 158cdf0e10cSrcweir { 159cdf0e10cSrcweir if ( !pSrcDev->mpGraphics ) 160cdf0e10cSrcweir { 161cdf0e10cSrcweir if ( !((OutputDevice*)pSrcDev)->ImplGetGraphics() ) 162cdf0e10cSrcweir return; 163cdf0e10cSrcweir } 164cdf0e10cSrcweir pGraphics2 = pSrcDev->mpGraphics; 165cdf0e10cSrcweir } 166cdf0e10cSrcweir else 167cdf0e10cSrcweir { 168cdf0e10cSrcweir if ( ((Window*)this)->mpWindowImpl->mpFrameWindow == ((Window*)pSrcDev)->mpWindowImpl->mpFrameWindow ) 169cdf0e10cSrcweir pGraphics2 = NULL; 170cdf0e10cSrcweir else 171cdf0e10cSrcweir { 172cdf0e10cSrcweir if ( !pSrcDev->mpGraphics ) 173cdf0e10cSrcweir { 174cdf0e10cSrcweir if ( !((OutputDevice*)pSrcDev)->ImplGetGraphics() ) 175cdf0e10cSrcweir return; 176cdf0e10cSrcweir } 177cdf0e10cSrcweir pGraphics2 = pSrcDev->mpGraphics; 178cdf0e10cSrcweir 179cdf0e10cSrcweir if ( !mpGraphics ) 180cdf0e10cSrcweir { 181cdf0e10cSrcweir if ( !ImplGetGraphics() ) 182cdf0e10cSrcweir return; 183cdf0e10cSrcweir } 184cdf0e10cSrcweir DBG_ASSERT( mpGraphics && pSrcDev->mpGraphics, 185cdf0e10cSrcweir "OutputDevice::DrawOutDev(): We need more than one Graphics" ); 186cdf0e10cSrcweir } 187cdf0e10cSrcweir } 188cdf0e10cSrcweir } 189cdf0e10cSrcweir 190cdf0e10cSrcweir // #102532# Offset only has to be pseudo window offset 191cdf0e10cSrcweir Rectangle aSrcOutRect( Point( pSrcDev->mnOutOffX, pSrcDev->mnOutOffY ), 192cdf0e10cSrcweir Size( pSrcDev->mnOutWidth, pSrcDev->mnOutHeight ) ); 193*5f27b83cSArmin Le Grand Rectangle aSrcRect( Point( rPosAry.mnSrcX, rPosAry.mnSrcY ), 194*5f27b83cSArmin Le Grand Size( rPosAry.mnSrcWidth, rPosAry.mnSrcHeight ) ); 195cdf0e10cSrcweir const long nOldRight = aSrcRect.Right(); 196cdf0e10cSrcweir const long nOldBottom = aSrcRect.Bottom(); 197cdf0e10cSrcweir 198cdf0e10cSrcweir if ( !aSrcRect.Intersection( aSrcOutRect ).IsEmpty() ) 199cdf0e10cSrcweir { 200*5f27b83cSArmin Le Grand if ( (rPosAry.mnSrcX+rPosAry.mnSrcWidth-1) > aSrcOutRect.Right() ) 201cdf0e10cSrcweir { 202*5f27b83cSArmin Le Grand const long nOldWidth = rPosAry.mnSrcWidth; 203*5f27b83cSArmin Le Grand rPosAry.mnSrcWidth -= (nOldRight - aSrcRect.Right()); 204*5f27b83cSArmin Le Grand rPosAry.mnDestWidth = rPosAry.mnDestWidth * rPosAry.mnSrcWidth / nOldWidth; 205cdf0e10cSrcweir } 206cdf0e10cSrcweir 207*5f27b83cSArmin Le Grand if ( (rPosAry.mnSrcY+rPosAry.mnSrcHeight-1) > aSrcOutRect.Bottom() ) 208cdf0e10cSrcweir { 209*5f27b83cSArmin Le Grand const long nOldHeight = rPosAry.mnSrcHeight; 210*5f27b83cSArmin Le Grand rPosAry.mnSrcHeight -= (nOldBottom - aSrcRect.Bottom()); 211*5f27b83cSArmin Le Grand rPosAry.mnDestHeight = rPosAry.mnDestHeight * rPosAry.mnSrcHeight / nOldHeight; 212cdf0e10cSrcweir } 213cdf0e10cSrcweir 214cdf0e10cSrcweir // --- RTL --- if this is no window, but pSrcDev is a window 215cdf0e10cSrcweir // mirroring may be required 216cdf0e10cSrcweir // because only windows have a SalGraphicsLayout 217cdf0e10cSrcweir // mirroring is performed here 218cdf0e10cSrcweir if( (GetOutDevType() != OUTDEV_WINDOW) && pGraphics2 && (pGraphics2->GetLayout() & SAL_LAYOUT_BIDI_RTL) ) 219cdf0e10cSrcweir { 220*5f27b83cSArmin Le Grand SalTwoRect aPosAry2 = rPosAry; 221*5f27b83cSArmin Le Grand pGraphics2->mirror( aPosAry2.mnSrcX, aPosAry2.mnSrcWidth, pSrcDev ); 222*5f27b83cSArmin Le Grand mpGraphics->CopyBits( aPosAry2, pGraphics2, this, pSrcDev ); 223cdf0e10cSrcweir } 224cdf0e10cSrcweir else 225*5f27b83cSArmin Le Grand mpGraphics->CopyBits( rPosAry, pGraphics2, this, pSrcDev ); 226cdf0e10cSrcweir } 227cdf0e10cSrcweir } 228cdf0e10cSrcweir } 229cdf0e10cSrcweir 230cdf0e10cSrcweir // ------------------------------------------------------------------ 231cdf0e10cSrcweir 232cdf0e10cSrcweir void OutputDevice::DrawOutDev( const Point& rDestPt, const Size& rDestSize, 233cdf0e10cSrcweir const Point& rSrcPt, const Size& rSrcSize ) 234cdf0e10cSrcweir { 235cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawOutDev()" ); 236cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 237cdf0e10cSrcweir DBG_ASSERT( meOutDevType != OUTDEV_PRINTER, "Don't use OutputDevice::DrawOutDev(...) with printer devices!" ); 238cdf0e10cSrcweir 239cdf0e10cSrcweir if( ImplIsRecordLayout() ) 240cdf0e10cSrcweir return; 241cdf0e10cSrcweir 242cdf0e10cSrcweir if ( meOutDevType == OUTDEV_PRINTER ) 243cdf0e10cSrcweir return; 244cdf0e10cSrcweir 245cdf0e10cSrcweir if ( ROP_INVERT == meRasterOp ) 246cdf0e10cSrcweir { 247cdf0e10cSrcweir DrawRect( Rectangle( rDestPt, rDestSize ) ); 248cdf0e10cSrcweir return; 249cdf0e10cSrcweir } 250cdf0e10cSrcweir 251cdf0e10cSrcweir if ( mpMetaFile ) 252cdf0e10cSrcweir { 253cdf0e10cSrcweir const Bitmap aBmp( GetBitmap( rSrcPt, rSrcSize ) ); 254cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpScaleAction( rDestPt, rDestSize, aBmp ) ); 255cdf0e10cSrcweir } 256cdf0e10cSrcweir 257cdf0e10cSrcweir OUTDEV_INIT(); 258cdf0e10cSrcweir 259*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 260cdf0e10cSrcweir aPosAry.mnSrcWidth = ImplLogicWidthToDevicePixel( rSrcSize.Width() ); 261cdf0e10cSrcweir aPosAry.mnSrcHeight = ImplLogicHeightToDevicePixel( rSrcSize.Height() ); 262cdf0e10cSrcweir aPosAry.mnDestWidth = ImplLogicWidthToDevicePixel( rDestSize.Width() ); 263cdf0e10cSrcweir aPosAry.mnDestHeight = ImplLogicHeightToDevicePixel( rDestSize.Height() ); 264cdf0e10cSrcweir 265cdf0e10cSrcweir if ( aPosAry.mnSrcWidth && aPosAry.mnSrcHeight && aPosAry.mnDestWidth && aPosAry.mnDestHeight ) 266cdf0e10cSrcweir { 267cdf0e10cSrcweir aPosAry.mnSrcX = ImplLogicXToDevicePixel( rSrcPt.X() ); 268cdf0e10cSrcweir aPosAry.mnSrcY = ImplLogicYToDevicePixel( rSrcPt.Y() ); 269cdf0e10cSrcweir aPosAry.mnDestX = ImplLogicXToDevicePixel( rDestPt.X() ); 270cdf0e10cSrcweir aPosAry.mnDestY = ImplLogicYToDevicePixel( rDestPt.Y() ); 271cdf0e10cSrcweir 272cdf0e10cSrcweir Rectangle aSrcOutRect( Point( mnOutOffX, mnOutOffY ), 273cdf0e10cSrcweir Size( mnOutWidth, mnOutHeight ) ); 274cdf0e10cSrcweir Rectangle aSrcRect( Point( aPosAry.mnSrcX, aPosAry.mnSrcY ), 275cdf0e10cSrcweir Size( aPosAry.mnSrcWidth, aPosAry.mnSrcHeight ) ); 276cdf0e10cSrcweir long nOldRight = aSrcRect.Right(); 277cdf0e10cSrcweir long nOldBottom = aSrcRect.Bottom(); 278cdf0e10cSrcweir 279cdf0e10cSrcweir if ( !aSrcRect.Intersection( aSrcOutRect ).IsEmpty() ) 280cdf0e10cSrcweir { 281cdf0e10cSrcweir if ( (aPosAry.mnSrcX+aPosAry.mnSrcWidth-1) > aSrcOutRect.Right() ) 282cdf0e10cSrcweir { 283cdf0e10cSrcweir long nOldWidth = aPosAry.mnSrcWidth; 284cdf0e10cSrcweir aPosAry.mnSrcWidth -= nOldRight-aSrcRect.Right(); 285cdf0e10cSrcweir aPosAry.mnDestWidth = aPosAry.mnDestWidth*aPosAry.mnSrcWidth/nOldWidth; 286cdf0e10cSrcweir } 287cdf0e10cSrcweir 288cdf0e10cSrcweir if ( (aPosAry.mnSrcY+aPosAry.mnSrcHeight-1) > aSrcOutRect.Bottom() ) 289cdf0e10cSrcweir { 290cdf0e10cSrcweir long nOldHeight = aPosAry.mnSrcHeight; 291cdf0e10cSrcweir aPosAry.mnSrcHeight -= nOldBottom-aSrcRect.Bottom(); 292cdf0e10cSrcweir aPosAry.mnDestHeight = aPosAry.mnDestHeight*aPosAry.mnSrcHeight/nOldHeight; 293cdf0e10cSrcweir } 294cdf0e10cSrcweir 295*5f27b83cSArmin Le Grand mpGraphics->CopyBits( aPosAry, NULL, this, NULL ); 296cdf0e10cSrcweir } 297cdf0e10cSrcweir } 298cdf0e10cSrcweir 299cdf0e10cSrcweir if( mpAlphaVDev ) 300cdf0e10cSrcweir mpAlphaVDev->DrawOutDev( rDestPt, rDestSize, rSrcPt, rSrcSize ); 301cdf0e10cSrcweir } 302cdf0e10cSrcweir 303cdf0e10cSrcweir // ------------------------------------------------------------------ 304cdf0e10cSrcweir 305cdf0e10cSrcweir void OutputDevice::DrawOutDev( const Point& rDestPt, const Size& rDestSize, 306cdf0e10cSrcweir const Point& rSrcPt, const Size& rSrcSize, 307cdf0e10cSrcweir const OutputDevice& rOutDev ) 308cdf0e10cSrcweir { 309cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawOutDev()" ); 310cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 311cdf0e10cSrcweir DBG_CHKOBJ( &rOutDev, OutputDevice, ImplDbgCheckOutputDevice ); 312cdf0e10cSrcweir DBG_ASSERT( meOutDevType != OUTDEV_PRINTER, "Don't use OutputDevice::DrawOutDev(...) with printer devices!" ); 313cdf0e10cSrcweir DBG_ASSERT( rOutDev.meOutDevType != OUTDEV_PRINTER, "Don't use OutputDevice::DrawOutDev(...) with printer devices!" ); 314cdf0e10cSrcweir 315cdf0e10cSrcweir if ( (meOutDevType == OUTDEV_PRINTER) || (rOutDev.meOutDevType == OUTDEV_PRINTER) || ImplIsRecordLayout() ) 316cdf0e10cSrcweir return; 317cdf0e10cSrcweir 318cdf0e10cSrcweir if ( ROP_INVERT == meRasterOp ) 319cdf0e10cSrcweir { 320cdf0e10cSrcweir DrawRect( Rectangle( rDestPt, rDestSize ) ); 321cdf0e10cSrcweir return; 322cdf0e10cSrcweir } 323cdf0e10cSrcweir 324cdf0e10cSrcweir if ( mpMetaFile ) 325cdf0e10cSrcweir { 326cdf0e10cSrcweir const Bitmap aBmp( rOutDev.GetBitmap( rSrcPt, rSrcSize ) ); 327cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpScaleAction( rDestPt, rDestSize, aBmp ) ); 328cdf0e10cSrcweir } 329cdf0e10cSrcweir 330cdf0e10cSrcweir OUTDEV_INIT(); 331cdf0e10cSrcweir 332*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 333cdf0e10cSrcweir aPosAry.mnSrcX = rOutDev.ImplLogicXToDevicePixel( rSrcPt.X() ); 334cdf0e10cSrcweir aPosAry.mnSrcY = rOutDev.ImplLogicYToDevicePixel( rSrcPt.Y() ); 335cdf0e10cSrcweir aPosAry.mnSrcWidth = rOutDev.ImplLogicWidthToDevicePixel( rSrcSize.Width() ); 336cdf0e10cSrcweir aPosAry.mnSrcHeight = rOutDev.ImplLogicHeightToDevicePixel( rSrcSize.Height() ); 337cdf0e10cSrcweir aPosAry.mnDestX = ImplLogicXToDevicePixel( rDestPt.X() ); 338cdf0e10cSrcweir aPosAry.mnDestY = ImplLogicYToDevicePixel( rDestPt.Y() ); 339cdf0e10cSrcweir aPosAry.mnDestWidth = ImplLogicWidthToDevicePixel( rDestSize.Width() ); 340cdf0e10cSrcweir aPosAry.mnDestHeight = ImplLogicHeightToDevicePixel( rDestSize.Height() ); 341cdf0e10cSrcweir 342cdf0e10cSrcweir if( mpAlphaVDev ) 343cdf0e10cSrcweir { 344cdf0e10cSrcweir if( rOutDev.mpAlphaVDev ) 345cdf0e10cSrcweir { 346cdf0e10cSrcweir // alpha-blend source over destination 347cdf0e10cSrcweir DrawBitmapEx( rDestPt, rDestSize, rOutDev.GetBitmapEx(rSrcPt, rSrcSize) ); 348cdf0e10cSrcweir 349cdf0e10cSrcweir // This would be mode SOURCE: 350cdf0e10cSrcweir // copy source alpha channel to our alpha channel 351cdf0e10cSrcweir //mpAlphaVDev->DrawOutDev( rDestPt, rDestSize, rSrcPt, rSrcSize, *rOutDev.mpAlphaVDev ); 352cdf0e10cSrcweir } 353cdf0e10cSrcweir else 354cdf0e10cSrcweir { 355*5f27b83cSArmin Le Grand ImplDrawOutDevDirect( &rOutDev, aPosAry ); 356cdf0e10cSrcweir 357cdf0e10cSrcweir // #i32109#: make destination rectangle opaque - source has no alpha 358cdf0e10cSrcweir mpAlphaVDev->ImplFillOpaqueRectangle( Rectangle(rDestPt, rDestSize) ); 359cdf0e10cSrcweir } 360cdf0e10cSrcweir } 361cdf0e10cSrcweir else 362cdf0e10cSrcweir { 363cdf0e10cSrcweir if( rOutDev.mpAlphaVDev ) 364cdf0e10cSrcweir { 365cdf0e10cSrcweir // alpha-blend source over destination 366cdf0e10cSrcweir DrawBitmapEx( rDestPt, rDestSize, rOutDev.GetBitmapEx(rSrcPt, rSrcSize) ); 367cdf0e10cSrcweir } 368cdf0e10cSrcweir else 369cdf0e10cSrcweir { 370cdf0e10cSrcweir // no alpha at all, neither in source nor destination device 371*5f27b83cSArmin Le Grand ImplDrawOutDevDirect( &rOutDev, aPosAry ); 372cdf0e10cSrcweir } 373cdf0e10cSrcweir } 374cdf0e10cSrcweir } 375cdf0e10cSrcweir 376cdf0e10cSrcweir // ------------------------------------------------------------------ 377cdf0e10cSrcweir 378cdf0e10cSrcweir void OutputDevice::CopyArea( const Point& rDestPt, 379cdf0e10cSrcweir const Point& rSrcPt, const Size& rSrcSize, 380cdf0e10cSrcweir sal_uInt16 nFlags ) 381cdf0e10cSrcweir { 382cdf0e10cSrcweir DBG_TRACE( "OutputDevice::CopyArea()" ); 383cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 384cdf0e10cSrcweir DBG_ASSERT( meOutDevType != OUTDEV_PRINTER, "Don't use OutputDevice::CopyArea(...) with printer devices!" ); 385cdf0e10cSrcweir 386cdf0e10cSrcweir if ( meOutDevType == OUTDEV_PRINTER || ImplIsRecordLayout() ) 387cdf0e10cSrcweir return; 388cdf0e10cSrcweir 389cdf0e10cSrcweir RasterOp eOldRop = GetRasterOp(); 390cdf0e10cSrcweir SetRasterOp( ROP_OVERPAINT ); 391cdf0e10cSrcweir 392cdf0e10cSrcweir OUTDEV_INIT(); 393cdf0e10cSrcweir 394*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 395cdf0e10cSrcweir aPosAry.mnSrcWidth = ImplLogicWidthToDevicePixel( rSrcSize.Width() ); 396cdf0e10cSrcweir aPosAry.mnSrcHeight = ImplLogicHeightToDevicePixel( rSrcSize.Height() ); 397cdf0e10cSrcweir 398cdf0e10cSrcweir if ( aPosAry.mnSrcWidth && aPosAry.mnSrcHeight ) 399cdf0e10cSrcweir { 400cdf0e10cSrcweir aPosAry.mnSrcX = ImplLogicXToDevicePixel( rSrcPt.X() ); 401cdf0e10cSrcweir aPosAry.mnSrcY = ImplLogicYToDevicePixel( rSrcPt.Y() ); 402cdf0e10cSrcweir aPosAry.mnDestX = ImplLogicXToDevicePixel( rDestPt.X() ); 403cdf0e10cSrcweir aPosAry.mnDestY = ImplLogicYToDevicePixel( rDestPt.Y() ); 404cdf0e10cSrcweir 405cdf0e10cSrcweir Rectangle aSrcOutRect( Point( mnOutOffX, mnOutOffY ), 406cdf0e10cSrcweir Size( mnOutWidth, mnOutHeight ) ); 407cdf0e10cSrcweir Rectangle aSrcRect( Point( aPosAry.mnSrcX, aPosAry.mnSrcY ), 408cdf0e10cSrcweir Size( aPosAry.mnSrcWidth, aPosAry.mnSrcHeight ) ); 409cdf0e10cSrcweir long nOldRight = aSrcRect.Right(); 410cdf0e10cSrcweir long nOldBottom = aSrcRect.Bottom(); 411cdf0e10cSrcweir 412cdf0e10cSrcweir if ( !aSrcRect.Intersection( aSrcOutRect ).IsEmpty() ) 413cdf0e10cSrcweir { 414cdf0e10cSrcweir if ( (aPosAry.mnSrcX+aPosAry.mnSrcWidth-1) > aSrcOutRect.Right() ) 415cdf0e10cSrcweir aPosAry.mnSrcWidth -= nOldRight-aSrcRect.Right(); 416cdf0e10cSrcweir 417cdf0e10cSrcweir if ( (aPosAry.mnSrcY+aPosAry.mnSrcHeight-1) > aSrcOutRect.Bottom() ) 418cdf0e10cSrcweir aPosAry.mnSrcHeight -= nOldBottom-aSrcRect.Bottom(); 419cdf0e10cSrcweir 420cdf0e10cSrcweir if ( (meOutDevType == OUTDEV_WINDOW) && (nFlags & COPYAREA_WINDOWINVALIDATE) ) 421cdf0e10cSrcweir { 422cdf0e10cSrcweir ((Window*)this)->ImplMoveAllInvalidateRegions( aSrcRect, 423cdf0e10cSrcweir aPosAry.mnDestX-aPosAry.mnSrcX, 424cdf0e10cSrcweir aPosAry.mnDestY-aPosAry.mnSrcY, 425cdf0e10cSrcweir sal_False ); 426cdf0e10cSrcweir 427cdf0e10cSrcweir mpGraphics->CopyArea( aPosAry.mnDestX, aPosAry.mnDestY, 428cdf0e10cSrcweir aPosAry.mnSrcX, aPosAry.mnSrcY, 429cdf0e10cSrcweir aPosAry.mnSrcWidth, aPosAry.mnSrcHeight, 430cdf0e10cSrcweir SAL_COPYAREA_WINDOWINVALIDATE, this ); 431cdf0e10cSrcweir } 432cdf0e10cSrcweir else 433cdf0e10cSrcweir { 434cdf0e10cSrcweir aPosAry.mnDestWidth = aPosAry.mnSrcWidth; 435cdf0e10cSrcweir aPosAry.mnDestHeight = aPosAry.mnSrcHeight; 436*5f27b83cSArmin Le Grand mpGraphics->CopyBits( aPosAry, NULL, this, NULL ); 437cdf0e10cSrcweir } 438cdf0e10cSrcweir } 439cdf0e10cSrcweir } 440cdf0e10cSrcweir 441cdf0e10cSrcweir SetRasterOp( eOldRop ); 442cdf0e10cSrcweir 443cdf0e10cSrcweir if( mpAlphaVDev ) 444cdf0e10cSrcweir mpAlphaVDev->CopyArea( rDestPt, rSrcPt, rSrcSize, nFlags ); 445cdf0e10cSrcweir } 446cdf0e10cSrcweir 447cdf0e10cSrcweir // ------------------------------------------------------------------ 448cdf0e10cSrcweir 449cdf0e10cSrcweir void OutputDevice::ImplDrawFrameDev( const Point& rPt, const Point& rDevPt, const Size& rDevSize, 450cdf0e10cSrcweir const OutputDevice& rOutDev, const Region& rRegion ) 451cdf0e10cSrcweir { 452cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 453cdf0e10cSrcweir 454cdf0e10cSrcweir GDIMetaFile* pOldMetaFile = mpMetaFile; 455cdf0e10cSrcweir sal_Bool bOldMap = mbMap; 456cdf0e10cSrcweir RasterOp eOldROP = GetRasterOp(); 457cdf0e10cSrcweir mpMetaFile = NULL; 458cdf0e10cSrcweir mbMap = sal_False; 459cdf0e10cSrcweir SetRasterOp( ROP_OVERPAINT ); 460cdf0e10cSrcweir 461cdf0e10cSrcweir if ( !IsDeviceOutputNecessary() ) 462cdf0e10cSrcweir return; 463cdf0e10cSrcweir 464cdf0e10cSrcweir if ( !mpGraphics ) 465cdf0e10cSrcweir { 466cdf0e10cSrcweir if ( !ImplGetGraphics() ) 467cdf0e10cSrcweir return; 468cdf0e10cSrcweir } 469cdf0e10cSrcweir 470cdf0e10cSrcweir // ClipRegion zuruecksetzen 471cdf0e10cSrcweir if ( rRegion.IsNull() ) 472cdf0e10cSrcweir mpGraphics->ResetClipRegion(); 473cdf0e10cSrcweir else 474cdf0e10cSrcweir ImplSelectClipRegion( rRegion ); 475cdf0e10cSrcweir 476*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 477cdf0e10cSrcweir aPosAry.mnSrcX = rDevPt.X(); 478cdf0e10cSrcweir aPosAry.mnSrcY = rDevPt.Y(); 479cdf0e10cSrcweir aPosAry.mnSrcWidth = rDevSize.Width(); 480cdf0e10cSrcweir aPosAry.mnSrcHeight = rDevSize.Height(); 481cdf0e10cSrcweir aPosAry.mnDestX = rPt.X(); 482cdf0e10cSrcweir aPosAry.mnDestY = rPt.Y(); 483cdf0e10cSrcweir aPosAry.mnDestWidth = rDevSize.Width(); 484cdf0e10cSrcweir aPosAry.mnDestHeight = rDevSize.Height(); 485*5f27b83cSArmin Le Grand ImplDrawOutDevDirect( &rOutDev, aPosAry ); 486cdf0e10cSrcweir 487cdf0e10cSrcweir // Dafuer sorgen, das ClipRegion neu berechnet und gesetzt wird 488cdf0e10cSrcweir mbInitClipRegion = sal_True; 489cdf0e10cSrcweir 490cdf0e10cSrcweir SetRasterOp( eOldROP ); 491cdf0e10cSrcweir mbMap = bOldMap; 492cdf0e10cSrcweir mpMetaFile = pOldMetaFile; 493cdf0e10cSrcweir } 494cdf0e10cSrcweir 495cdf0e10cSrcweir // ------------------------------------------------------------------ 496cdf0e10cSrcweir 497cdf0e10cSrcweir void OutputDevice::ImplGetFrameDev( const Point& rPt, const Point& rDevPt, const Size& rDevSize, 498cdf0e10cSrcweir OutputDevice& rDev ) 499cdf0e10cSrcweir { 500cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 501cdf0e10cSrcweir 502cdf0e10cSrcweir sal_Bool bOldMap = mbMap; 503cdf0e10cSrcweir mbMap = sal_False; 504cdf0e10cSrcweir rDev.DrawOutDev( rDevPt, rDevSize, rPt, rDevSize, *this ); 505cdf0e10cSrcweir mbMap = bOldMap; 506cdf0e10cSrcweir } 507cdf0e10cSrcweir 508cdf0e10cSrcweir // ------------------------------------------------------------------ 509cdf0e10cSrcweir 510cdf0e10cSrcweir void OutputDevice::DrawBitmap( const Point& rDestPt, const Bitmap& rBitmap ) 511cdf0e10cSrcweir { 512cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawBitmap()" ); 513cdf0e10cSrcweir 514cdf0e10cSrcweir if( ImplIsRecordLayout() ) 515cdf0e10cSrcweir return; 516cdf0e10cSrcweir 517cdf0e10cSrcweir const Size aSizePix( rBitmap.GetSizePixel() ); 518cdf0e10cSrcweir ImplDrawBitmap( rDestPt, PixelToLogic( aSizePix ), Point(), aSizePix, rBitmap, META_BMP_ACTION ); 519cdf0e10cSrcweir 520cdf0e10cSrcweir if( mpAlphaVDev ) 521cdf0e10cSrcweir { 522cdf0e10cSrcweir // #i32109#: Make bitmap area opaque 523cdf0e10cSrcweir mpAlphaVDev->ImplFillOpaqueRectangle( Rectangle(rDestPt, PixelToLogic( aSizePix )) ); 524cdf0e10cSrcweir } 525cdf0e10cSrcweir } 526cdf0e10cSrcweir 527cdf0e10cSrcweir // ------------------------------------------------------------------ 528cdf0e10cSrcweir 529cdf0e10cSrcweir void OutputDevice::DrawBitmap( const Point& rDestPt, const Size& rDestSize, const Bitmap& rBitmap ) 530cdf0e10cSrcweir { 531cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawBitmap( Size )" ); 532cdf0e10cSrcweir 533cdf0e10cSrcweir if( ImplIsRecordLayout() ) 534cdf0e10cSrcweir return; 535cdf0e10cSrcweir 536cdf0e10cSrcweir ImplDrawBitmap( rDestPt, rDestSize, Point(), rBitmap.GetSizePixel(), rBitmap, META_BMPSCALE_ACTION ); 537cdf0e10cSrcweir 538cdf0e10cSrcweir if( mpAlphaVDev ) 539cdf0e10cSrcweir { 540cdf0e10cSrcweir // #i32109#: Make bitmap area opaque 541cdf0e10cSrcweir mpAlphaVDev->ImplFillOpaqueRectangle( Rectangle(rDestPt, rDestSize) ); 542cdf0e10cSrcweir } 543cdf0e10cSrcweir } 544cdf0e10cSrcweir 545cdf0e10cSrcweir // ------------------------------------------------------------------ 546cdf0e10cSrcweir 547cdf0e10cSrcweir void OutputDevice::DrawBitmap( const Point& rDestPt, const Size& rDestSize, 548cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel, 549cdf0e10cSrcweir const Bitmap& rBitmap ) 550cdf0e10cSrcweir { 551cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawBitmap( Point, Size )" ); 552cdf0e10cSrcweir 553cdf0e10cSrcweir if( ImplIsRecordLayout() ) 554cdf0e10cSrcweir return; 555cdf0e10cSrcweir 556cdf0e10cSrcweir ImplDrawBitmap( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, rBitmap, META_BMPSCALEPART_ACTION ); 557cdf0e10cSrcweir 558cdf0e10cSrcweir if( mpAlphaVDev ) 559cdf0e10cSrcweir { 560cdf0e10cSrcweir // #i32109#: Make bitmap area opaque 561cdf0e10cSrcweir mpAlphaVDev->ImplFillOpaqueRectangle( Rectangle(rDestPt, rDestSize) ); 562cdf0e10cSrcweir } 563cdf0e10cSrcweir } 564cdf0e10cSrcweir 565cdf0e10cSrcweir // ----------------------------------------------------------------------------- 566cdf0e10cSrcweir 567cdf0e10cSrcweir void OutputDevice::ImplDrawBitmap( const Point& rDestPt, const Size& rDestSize, 568cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel, 569cdf0e10cSrcweir const Bitmap& rBitmap, const sal_uLong nAction ) 570cdf0e10cSrcweir { 571cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 572cdf0e10cSrcweir 573cdf0e10cSrcweir if ( ( mnDrawMode & DRAWMODE_NOBITMAP ) ) 574cdf0e10cSrcweir return; 575*5f27b83cSArmin Le Grand 576*5f27b83cSArmin Le Grand if ( ROP_INVERT == meRasterOp ) 577cdf0e10cSrcweir { 578cdf0e10cSrcweir DrawRect( Rectangle( rDestPt, rDestSize ) ); 579cdf0e10cSrcweir return; 580cdf0e10cSrcweir } 581*5f27b83cSArmin Le Grand 582*5f27b83cSArmin Le Grand Bitmap aBmp( rBitmap ); 583*5f27b83cSArmin Le Grand 584*5f27b83cSArmin Le Grand if ( mnDrawMode & ( DRAWMODE_BLACKBITMAP | DRAWMODE_WHITEBITMAP | 585cdf0e10cSrcweir DRAWMODE_GRAYBITMAP | DRAWMODE_GHOSTEDBITMAP ) ) 586cdf0e10cSrcweir { 587cdf0e10cSrcweir if ( mnDrawMode & ( DRAWMODE_BLACKBITMAP | DRAWMODE_WHITEBITMAP ) ) 588cdf0e10cSrcweir { 589cdf0e10cSrcweir sal_uInt8 cCmpVal; 590cdf0e10cSrcweir 591cdf0e10cSrcweir if ( mnDrawMode & DRAWMODE_BLACKBITMAP ) 592cdf0e10cSrcweir cCmpVal = ( mnDrawMode & DRAWMODE_GHOSTEDBITMAP ) ? 0x80 : 0; 593cdf0e10cSrcweir else 594cdf0e10cSrcweir cCmpVal = 255; 595cdf0e10cSrcweir 596cdf0e10cSrcweir Color aCol( cCmpVal, cCmpVal, cCmpVal ); 597cdf0e10cSrcweir Push( PUSH_LINECOLOR | PUSH_FILLCOLOR ); 598cdf0e10cSrcweir SetLineColor( aCol ); 599cdf0e10cSrcweir SetFillColor( aCol ); 600cdf0e10cSrcweir DrawRect( Rectangle( rDestPt, rDestSize ) ); 601cdf0e10cSrcweir Pop(); 602cdf0e10cSrcweir return; 603cdf0e10cSrcweir } 604cdf0e10cSrcweir else if( !!aBmp ) 605cdf0e10cSrcweir { 606cdf0e10cSrcweir if ( mnDrawMode & DRAWMODE_GRAYBITMAP ) 607cdf0e10cSrcweir aBmp.Convert( BMP_CONVERSION_8BIT_GREYS ); 608cdf0e10cSrcweir 609cdf0e10cSrcweir if ( mnDrawMode & DRAWMODE_GHOSTEDBITMAP ) 610cdf0e10cSrcweir aBmp.Convert( BMP_CONVERSION_GHOSTED ); 611cdf0e10cSrcweir } 612cdf0e10cSrcweir } 613cdf0e10cSrcweir 614cdf0e10cSrcweir if ( mpMetaFile ) 615cdf0e10cSrcweir { 616cdf0e10cSrcweir switch( nAction ) 617cdf0e10cSrcweir { 618cdf0e10cSrcweir case( META_BMP_ACTION ): 619cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpAction( rDestPt, aBmp ) ); 620cdf0e10cSrcweir break; 621cdf0e10cSrcweir 622cdf0e10cSrcweir case( META_BMPSCALE_ACTION ): 623cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpScaleAction( rDestPt, rDestSize, aBmp ) ); 624cdf0e10cSrcweir break; 625cdf0e10cSrcweir 626cdf0e10cSrcweir case( META_BMPSCALEPART_ACTION ): 627cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpScalePartAction( 628cdf0e10cSrcweir rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, aBmp ) ); 629cdf0e10cSrcweir break; 630cdf0e10cSrcweir } 631cdf0e10cSrcweir } 632cdf0e10cSrcweir 633cdf0e10cSrcweir OUTDEV_INIT(); 634cdf0e10cSrcweir 635cdf0e10cSrcweir if( !aBmp.IsEmpty() ) 636cdf0e10cSrcweir { 637*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 638cdf0e10cSrcweir 639cdf0e10cSrcweir aPosAry.mnSrcX = rSrcPtPixel.X(); 640cdf0e10cSrcweir aPosAry.mnSrcY = rSrcPtPixel.Y(); 641cdf0e10cSrcweir aPosAry.mnSrcWidth = rSrcSizePixel.Width(); 642cdf0e10cSrcweir aPosAry.mnSrcHeight = rSrcSizePixel.Height(); 643cdf0e10cSrcweir aPosAry.mnDestX = ImplLogicXToDevicePixel( rDestPt.X() ); 644cdf0e10cSrcweir aPosAry.mnDestY = ImplLogicYToDevicePixel( rDestPt.Y() ); 645cdf0e10cSrcweir aPosAry.mnDestWidth = ImplLogicWidthToDevicePixel( rDestSize.Width() ); 646cdf0e10cSrcweir aPosAry.mnDestHeight = ImplLogicHeightToDevicePixel( rDestSize.Height() ); 647cdf0e10cSrcweir 648cdf0e10cSrcweir const sal_uLong nMirrFlags = ImplAdjustTwoRect( aPosAry, aBmp.GetSizePixel() ); 649cdf0e10cSrcweir 650cdf0e10cSrcweir if ( aPosAry.mnSrcWidth && aPosAry.mnSrcHeight && aPosAry.mnDestWidth && aPosAry.mnDestHeight ) 651cdf0e10cSrcweir { 652cdf0e10cSrcweir if ( nMirrFlags ) 653cdf0e10cSrcweir aBmp.Mirror( nMirrFlags ); 654cdf0e10cSrcweir 655cdf0e10cSrcweir /* #i75264# (corrected with #i81576#) 656cdf0e10cSrcweir * sometimes a bitmap is scaled to a ridiculous size and drawn 657cdf0e10cSrcweir * to a quite normal VDev, so only a very small part of 658cdf0e10cSrcweir * the scaled bitmap will be visible. However actually scaling 659cdf0e10cSrcweir * the bitmap will use so much memory that we end with a crash. 660cdf0e10cSrcweir * Workaround: since only a small part of the scaled bitmap will 661cdf0e10cSrcweir * be actually drawn anyway (because of clipping on the device 662cdf0e10cSrcweir * boundary), limit the destination and source rectangles so 663cdf0e10cSrcweir * that the destination rectangle will overlap the device but only 664cdf0e10cSrcweir * be reasonably (say factor 2) larger than the device itself. 665cdf0e10cSrcweir */ 666*5f27b83cSArmin Le Grand 667*5f27b83cSArmin Le Grand // not needed for win32, it uses GdiPlus and is able to do everything without 668*5f27b83cSArmin Le Grand // internally scaling the bitmap 669*5f27b83cSArmin Le Grand #ifndef WIN32 670*5f27b83cSArmin Le Grand 671cdf0e10cSrcweir if( aPosAry.mnDestWidth > 2048 || aPosAry.mnDestHeight > 2048 ) 672cdf0e10cSrcweir { 673cdf0e10cSrcweir if( meOutDevType == OUTDEV_WINDOW || 674cdf0e10cSrcweir (meOutDevType == OUTDEV_VIRDEV && mpPDFWriter == 0 ) ) 675cdf0e10cSrcweir { 676cdf0e10cSrcweir // #i81576# do the following trick only if there is overlap at all 677cdf0e10cSrcweir // else the formulae don't work 678cdf0e10cSrcweir // theoretically in this case we wouldn't need to draw the bitmap at all 679cdf0e10cSrcweir // however there are some esoteric case where that is needed 680cdf0e10cSrcweir if( aPosAry.mnDestX + aPosAry.mnDestWidth >= 0 681cdf0e10cSrcweir && aPosAry.mnDestX < mnOutWidth 682cdf0e10cSrcweir && aPosAry.mnDestY + aPosAry.mnDestHeight >= 0 683cdf0e10cSrcweir && aPosAry.mnDestY < mnOutHeight ) 684cdf0e10cSrcweir { 685cdf0e10cSrcweir // reduce scaling to something reasonable taking into account the output size 686cdf0e10cSrcweir if( aPosAry.mnDestWidth > 3*mnOutWidth && aPosAry.mnSrcWidth ) 687cdf0e10cSrcweir { 688cdf0e10cSrcweir const double nScaleX = aPosAry.mnDestWidth/double(aPosAry.mnSrcWidth); 689cdf0e10cSrcweir 690cdf0e10cSrcweir if( aPosAry.mnDestX + aPosAry.mnDestWidth > mnOutWidth ) 691cdf0e10cSrcweir { 692cdf0e10cSrcweir aPosAry.mnDestWidth = Max(long(0),mnOutWidth-aPosAry.mnDestX); 693cdf0e10cSrcweir } 694cdf0e10cSrcweir if( aPosAry.mnDestX < 0 ) 695cdf0e10cSrcweir { 696cdf0e10cSrcweir aPosAry.mnDestWidth += aPosAry.mnDestX; 697cdf0e10cSrcweir aPosAry.mnSrcX -= sal::static_int_cast<long>(aPosAry.mnDestX / nScaleX); 698cdf0e10cSrcweir aPosAry.mnDestX = 0; 699cdf0e10cSrcweir } 700cdf0e10cSrcweir 701cdf0e10cSrcweir aPosAry.mnSrcWidth = sal::static_int_cast<long>(aPosAry.mnDestWidth / nScaleX); 702cdf0e10cSrcweir } 703cdf0e10cSrcweir 704cdf0e10cSrcweir if( aPosAry.mnDestHeight > 3*mnOutHeight && aPosAry.mnSrcHeight != 0 ) 705cdf0e10cSrcweir { 706cdf0e10cSrcweir const double nScaleY = aPosAry.mnDestHeight/double(aPosAry.mnSrcHeight); 707cdf0e10cSrcweir 708cdf0e10cSrcweir if( aPosAry.mnDestY + aPosAry.mnDestHeight > mnOutHeight ) 709cdf0e10cSrcweir { 710cdf0e10cSrcweir aPosAry.mnDestHeight = Max(long(0),mnOutHeight-aPosAry.mnDestY); 711cdf0e10cSrcweir } 712cdf0e10cSrcweir if( aPosAry.mnDestY < 0 ) 713cdf0e10cSrcweir { 714cdf0e10cSrcweir aPosAry.mnDestHeight += aPosAry.mnDestY; 715cdf0e10cSrcweir aPosAry.mnSrcY -= sal::static_int_cast<long>(aPosAry.mnDestY / nScaleY); 716cdf0e10cSrcweir aPosAry.mnDestY = 0; 717cdf0e10cSrcweir } 718cdf0e10cSrcweir 719cdf0e10cSrcweir aPosAry.mnSrcHeight = sal::static_int_cast<long>(aPosAry.mnDestHeight / nScaleY); 720cdf0e10cSrcweir } 721cdf0e10cSrcweir } 722cdf0e10cSrcweir } 723cdf0e10cSrcweir } 724*5f27b83cSArmin Le Grand #endif 725cdf0e10cSrcweir 726cdf0e10cSrcweir if ( aPosAry.mnSrcWidth && aPosAry.mnSrcHeight && aPosAry.mnDestWidth && aPosAry.mnDestHeight ) 727*5f27b83cSArmin Le Grand { 728*5f27b83cSArmin Le Grand mpGraphics->DrawBitmap( aPosAry, *aBmp.ImplGetImpBitmap()->ImplGetSalBitmap(), this ); 729*5f27b83cSArmin Le Grand } 730cdf0e10cSrcweir } 731cdf0e10cSrcweir } 732cdf0e10cSrcweir } 733cdf0e10cSrcweir 734cdf0e10cSrcweir // ------------------------------------------------------------------ 735cdf0e10cSrcweir 736cdf0e10cSrcweir void OutputDevice::DrawBitmapEx( const Point& rDestPt, 737cdf0e10cSrcweir const BitmapEx& rBitmapEx ) 738cdf0e10cSrcweir { 739cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawBitmapEx()" ); 740cdf0e10cSrcweir 741cdf0e10cSrcweir if( ImplIsRecordLayout() ) 742cdf0e10cSrcweir return; 743cdf0e10cSrcweir 744cdf0e10cSrcweir if( TRANSPARENT_NONE == rBitmapEx.GetTransparentType() ) 745*5f27b83cSArmin Le Grand { 746cdf0e10cSrcweir DrawBitmap( rDestPt, rBitmapEx.GetBitmap() ); 747*5f27b83cSArmin Le Grand } 748cdf0e10cSrcweir else 749cdf0e10cSrcweir { 750cdf0e10cSrcweir const Size aSizePix( rBitmapEx.GetSizePixel() ); 751cdf0e10cSrcweir ImplDrawBitmapEx( rDestPt, PixelToLogic( aSizePix ), Point(), aSizePix, rBitmapEx, META_BMPEX_ACTION ); 752cdf0e10cSrcweir } 753cdf0e10cSrcweir } 754cdf0e10cSrcweir 755cdf0e10cSrcweir // ------------------------------------------------------------------ 756cdf0e10cSrcweir 757cdf0e10cSrcweir void OutputDevice::DrawBitmapEx( const Point& rDestPt, const Size& rDestSize, 758cdf0e10cSrcweir const BitmapEx& rBitmapEx ) 759cdf0e10cSrcweir { 760cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawBitmapEx( Size )" ); 761cdf0e10cSrcweir 762cdf0e10cSrcweir if( ImplIsRecordLayout() ) 763cdf0e10cSrcweir return; 764cdf0e10cSrcweir 765cdf0e10cSrcweir if ( TRANSPARENT_NONE == rBitmapEx.GetTransparentType() ) 766*5f27b83cSArmin Le Grand { 767cdf0e10cSrcweir DrawBitmap( rDestPt, rDestSize, rBitmapEx.GetBitmap() ); 768*5f27b83cSArmin Le Grand } 769cdf0e10cSrcweir else 770*5f27b83cSArmin Le Grand { 771cdf0e10cSrcweir ImplDrawBitmapEx( rDestPt, rDestSize, Point(), rBitmapEx.GetSizePixel(), rBitmapEx, META_BMPEXSCALE_ACTION ); 772*5f27b83cSArmin Le Grand } 773cdf0e10cSrcweir } 774cdf0e10cSrcweir 775cdf0e10cSrcweir // ------------------------------------------------------------------ 776cdf0e10cSrcweir 777cdf0e10cSrcweir void OutputDevice::DrawBitmapEx( const Point& rDestPt, const Size& rDestSize, 778cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel, 779cdf0e10cSrcweir const BitmapEx& rBitmapEx ) 780cdf0e10cSrcweir { 781cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawBitmapEx( Point, Size )" ); 782cdf0e10cSrcweir 783cdf0e10cSrcweir if( ImplIsRecordLayout() ) 784cdf0e10cSrcweir return; 785cdf0e10cSrcweir 786cdf0e10cSrcweir if( TRANSPARENT_NONE == rBitmapEx.GetTransparentType() ) 787*5f27b83cSArmin Le Grand { 788cdf0e10cSrcweir DrawBitmap( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, rBitmapEx.GetBitmap() ); 789*5f27b83cSArmin Le Grand } 790cdf0e10cSrcweir else 791*5f27b83cSArmin Le Grand { 792cdf0e10cSrcweir ImplDrawBitmapEx( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, rBitmapEx, META_BMPEXSCALEPART_ACTION ); 793*5f27b83cSArmin Le Grand } 794*5f27b83cSArmin Le Grand } 795*5f27b83cSArmin Le Grand 796*5f27b83cSArmin Le Grand // ------------------------------------------------------------------ 797*5f27b83cSArmin Le Grand 798*5f27b83cSArmin Le Grand void OutputDevice::DrawTransformedBitmapEx( 799*5f27b83cSArmin Le Grand const basegfx::B2DHomMatrix& rTransformation, 800*5f27b83cSArmin Le Grand const BitmapEx& rBitmapEx) 801*5f27b83cSArmin Le Grand { 802*5f27b83cSArmin Le Grand DBG_TRACE( "OutputDevice::DrawBitmapEx( Point, Size )" ); 803*5f27b83cSArmin Le Grand 804*5f27b83cSArmin Le Grand if( ImplIsRecordLayout() ) 805*5f27b83cSArmin Le Grand return; 806*5f27b83cSArmin Le Grand 807*5f27b83cSArmin Le Grand if(rBitmapEx.IsEmpty()) 808*5f27b83cSArmin Le Grand return; 809*5f27b83cSArmin Le Grand 810*5f27b83cSArmin Le Grand if ( mnDrawMode & DRAWMODE_NOBITMAP ) 811*5f27b83cSArmin Le Grand return; 812*5f27b83cSArmin Le Grand 813*5f27b83cSArmin Le Grand // decompose matrix to check rotation and shear 814*5f27b83cSArmin Le Grand basegfx::B2DVector aScale, aTranslate; 815*5f27b83cSArmin Le Grand double fRotate, fShearX; 816*5f27b83cSArmin Le Grand rTransformation.decompose(aScale, aTranslate, fRotate, fShearX); 817*5f27b83cSArmin Le Grand const bool bRotated(!basegfx::fTools::equalZero(fRotate)); 818*5f27b83cSArmin Le Grand const bool bSheared(!basegfx::fTools::equalZero(fShearX)); 819*5f27b83cSArmin Le Grand const bool bMirroredX(basegfx::fTools::less(aScale.getX(), 0.0)); 820*5f27b83cSArmin Le Grand const bool bMirroredY(basegfx::fTools::less(aScale.getY(), 0.0)); 821*5f27b83cSArmin Le Grand 822*5f27b83cSArmin Le Grand if(!bRotated && !bSheared && !bMirroredX && !bMirroredY) 823*5f27b83cSArmin Le Grand { 824*5f27b83cSArmin Le Grand // with no rotation, shear or mirroring it can be mapped to DrawBitmapEx 825*5f27b83cSArmin Le Grand // do *not* execute the mirroring here, it's done in the fallback 826*5f27b83cSArmin Le Grand const Point aDestPt(basegfx::fround(aTranslate.getX()), basegfx::fround(aTranslate.getY())); 827*5f27b83cSArmin Le Grand const Size aDestSize(basegfx::fround(aScale.getX()), basegfx::fround(aScale.getY())); 828*5f27b83cSArmin Le Grand 829*5f27b83cSArmin Le Grand DrawBitmapEx(aDestPt, aDestSize, rBitmapEx); 830*5f27b83cSArmin Le Grand return; 831*5f27b83cSArmin Le Grand } 832*5f27b83cSArmin Le Grand 833*5f27b83cSArmin Le Grand // we have rotation,shear or mirror, check if some crazy mode needs the 834*5f27b83cSArmin Le Grand // created transformed bitmap 835*5f27b83cSArmin Le Grand const bool bInvert(ROP_INVERT == meRasterOp); 836*5f27b83cSArmin Le Grand const bool bBitmapChangedColor(mnDrawMode & (DRAWMODE_BLACKBITMAP | DRAWMODE_WHITEBITMAP | DRAWMODE_GRAYBITMAP | DRAWMODE_GHOSTEDBITMAP)); 837*5f27b83cSArmin Le Grand const bool bMetafile(mpMetaFile); 838*5f27b83cSArmin Le Grand const bool bPrinter(OUTDEV_PRINTER == meOutDevType); 839*5f27b83cSArmin Le Grand bool bDone(false); 840*5f27b83cSArmin Le Grand const basegfx::B2DHomMatrix aFullTransform(GetViewTransformation() * rTransformation); 841*5f27b83cSArmin Le Grand const bool bTryDirectPaint(!bInvert && !bBitmapChangedColor && !bMetafile && !bPrinter); 842*5f27b83cSArmin Le Grand 843*5f27b83cSArmin Le Grand if(bTryDirectPaint) 844*5f27b83cSArmin Le Grand { 845*5f27b83cSArmin Le Grand // try to paint directly 846*5f27b83cSArmin Le Grand const basegfx::B2DPoint aNull(aFullTransform * basegfx::B2DPoint(0.0, 0.0)); 847*5f27b83cSArmin Le Grand const basegfx::B2DPoint aTopX(aFullTransform * basegfx::B2DPoint(1.0, 0.0)); 848*5f27b83cSArmin Le Grand const basegfx::B2DPoint aTopY(aFullTransform * basegfx::B2DPoint(0.0, 1.0)); 849*5f27b83cSArmin Le Grand SalBitmap* pSalSrcBmp = rBitmapEx.GetBitmap().ImplGetImpBitmap()->ImplGetSalBitmap(); 850*5f27b83cSArmin Le Grand SalBitmap* pSalAlphaBmp = 0; 851*5f27b83cSArmin Le Grand 852*5f27b83cSArmin Le Grand if(rBitmapEx.IsTransparent()) 853*5f27b83cSArmin Le Grand { 854*5f27b83cSArmin Le Grand if(rBitmapEx.IsAlpha()) 855*5f27b83cSArmin Le Grand { 856*5f27b83cSArmin Le Grand pSalAlphaBmp = rBitmapEx.GetAlpha().ImplGetImpBitmap()->ImplGetSalBitmap(); 857*5f27b83cSArmin Le Grand } 858*5f27b83cSArmin Le Grand else 859*5f27b83cSArmin Le Grand { 860*5f27b83cSArmin Le Grand pSalAlphaBmp = rBitmapEx.GetMask().ImplGetImpBitmap()->ImplGetSalBitmap(); 861*5f27b83cSArmin Le Grand } 862*5f27b83cSArmin Le Grand } 863*5f27b83cSArmin Le Grand 864*5f27b83cSArmin Le Grand bDone = mpGraphics->DrawTransformedBitmap( 865*5f27b83cSArmin Le Grand aNull, 866*5f27b83cSArmin Le Grand aTopX, 867*5f27b83cSArmin Le Grand aTopY, 868*5f27b83cSArmin Le Grand *pSalSrcBmp, 869*5f27b83cSArmin Le Grand pSalAlphaBmp, 870*5f27b83cSArmin Le Grand this); 871*5f27b83cSArmin Le Grand } 872*5f27b83cSArmin Le Grand 873*5f27b83cSArmin Le Grand if(!bDone) 874*5f27b83cSArmin Le Grand { 875*5f27b83cSArmin Le Grand // take the fallback when no rotate and shear, but mirror (else we would have done this above) 876*5f27b83cSArmin Le Grand if(!bRotated && !bSheared) 877*5f27b83cSArmin Le Grand { 878*5f27b83cSArmin Le Grand // with no rotation or shear it can be mapped to DrawBitmapEx 879*5f27b83cSArmin Le Grand // do *not* execute the mirroring here, it's done in the fallback 880*5f27b83cSArmin Le Grand const Point aDestPt(basegfx::fround(aTranslate.getX()), basegfx::fround(aTranslate.getY())); 881*5f27b83cSArmin Le Grand const Size aDestSize(basegfx::fround(aScale.getX()), basegfx::fround(aScale.getY())); 882*5f27b83cSArmin Le Grand 883*5f27b83cSArmin Le Grand DrawBitmapEx(aDestPt, aDestSize, rBitmapEx); 884*5f27b83cSArmin Le Grand return; 885*5f27b83cSArmin Le Grand } 886*5f27b83cSArmin Le Grand 887*5f27b83cSArmin Le Grand // fallback; create transformed bitmap the hard way (back-transform 888*5f27b83cSArmin Le Grand // the pixels) and paint 889*5f27b83cSArmin Le Grand basegfx::B2DRange aTargetRange(0.0, 0.0, 1.0, 1.0); 890*5f27b83cSArmin Le Grand const double fMaximumArea(bMetafile ? 800000.0 : 200000.0); 891*5f27b83cSArmin Le Grand const BitmapEx aTransformed(rBitmapEx.getTransformed(aFullTransform, fMaximumArea)); 892*5f27b83cSArmin Le Grand aTargetRange.transform(rTransformation); 893*5f27b83cSArmin Le Grand const Point aDestPt(basegfx::fround(aTargetRange.getMinX()), basegfx::fround(aTargetRange.getMinY())); 894*5f27b83cSArmin Le Grand const Size aDestSize(basegfx::fround(aTargetRange.getWidth()), basegfx::fround(aTargetRange.getHeight())); 895*5f27b83cSArmin Le Grand 896*5f27b83cSArmin Le Grand DrawBitmapEx(aDestPt, aDestSize, aTransformed); 897*5f27b83cSArmin Le Grand } 898cdf0e10cSrcweir } 899cdf0e10cSrcweir 900cdf0e10cSrcweir // ------------------------------------------------------------------ 901cdf0e10cSrcweir 902cdf0e10cSrcweir void OutputDevice::ImplDrawBitmapEx( const Point& rDestPt, const Size& rDestSize, 903cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel, 904cdf0e10cSrcweir const BitmapEx& rBitmapEx, const sal_uLong nAction ) 905cdf0e10cSrcweir { 906cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 907*5f27b83cSArmin Le Grand OSL_ENSURE(TRANSPARENT_NONE != rBitmapEx.GetTransparentType(), "ImplDrawBitmapEx not needed, no transparency in BitmapEx (!)"); 908cdf0e10cSrcweir 909cdf0e10cSrcweir if ( mnDrawMode & DRAWMODE_NOBITMAP ) 910cdf0e10cSrcweir return; 911*5f27b83cSArmin Le Grand 912*5f27b83cSArmin Le Grand if ( ROP_INVERT == meRasterOp ) 913cdf0e10cSrcweir { 914cdf0e10cSrcweir DrawRect( Rectangle( rDestPt, rDestSize ) ); 915cdf0e10cSrcweir return; 916cdf0e10cSrcweir } 917*5f27b83cSArmin Le Grand 918*5f27b83cSArmin Le Grand BitmapEx aBmpEx( rBitmapEx ); 919*5f27b83cSArmin Le Grand 920*5f27b83cSArmin Le Grand if ( mnDrawMode & ( DRAWMODE_BLACKBITMAP | DRAWMODE_WHITEBITMAP | 921cdf0e10cSrcweir DRAWMODE_GRAYBITMAP | DRAWMODE_GHOSTEDBITMAP ) ) 922cdf0e10cSrcweir { 923cdf0e10cSrcweir if ( mnDrawMode & ( DRAWMODE_BLACKBITMAP | DRAWMODE_WHITEBITMAP ) ) 924cdf0e10cSrcweir { 925cdf0e10cSrcweir Bitmap aColorBmp( aBmpEx.GetSizePixel(), ( mnDrawMode & DRAWMODE_GHOSTEDBITMAP ) ? 4 : 1 ); 926cdf0e10cSrcweir sal_uInt8 cCmpVal; 927cdf0e10cSrcweir 928cdf0e10cSrcweir if ( mnDrawMode & DRAWMODE_BLACKBITMAP ) 929cdf0e10cSrcweir cCmpVal = ( mnDrawMode & DRAWMODE_GHOSTEDBITMAP ) ? 0x80 : 0; 930cdf0e10cSrcweir else 931cdf0e10cSrcweir cCmpVal = 255; 932cdf0e10cSrcweir 933cdf0e10cSrcweir aColorBmp.Erase( Color( cCmpVal, cCmpVal, cCmpVal ) ); 934cdf0e10cSrcweir 935cdf0e10cSrcweir if( aBmpEx.IsAlpha() ) 936cdf0e10cSrcweir { 937cdf0e10cSrcweir // Create one-bit mask out of alpha channel, by 938cdf0e10cSrcweir // thresholding it at alpha=0.5. As 939cdf0e10cSrcweir // DRAWMODE_BLACK/WHITEBITMAP requires monochrome 940cdf0e10cSrcweir // output, having alpha-induced grey levels is not 941cdf0e10cSrcweir // acceptable. 942cdf0e10cSrcweir Bitmap aMask( aBmpEx.GetAlpha().GetBitmap() ); 943cdf0e10cSrcweir aMask.MakeMono( 128 ); 944cdf0e10cSrcweir aBmpEx = BitmapEx( aColorBmp, aMask ); 945cdf0e10cSrcweir } 946cdf0e10cSrcweir else 947cdf0e10cSrcweir { 948cdf0e10cSrcweir aBmpEx = BitmapEx( aColorBmp, aBmpEx.GetMask() ); 949cdf0e10cSrcweir } 950cdf0e10cSrcweir } 951cdf0e10cSrcweir else if( !!aBmpEx ) 952cdf0e10cSrcweir { 953cdf0e10cSrcweir if ( mnDrawMode & DRAWMODE_GRAYBITMAP ) 954cdf0e10cSrcweir aBmpEx.Convert( BMP_CONVERSION_8BIT_GREYS ); 955cdf0e10cSrcweir 956cdf0e10cSrcweir if ( mnDrawMode & DRAWMODE_GHOSTEDBITMAP ) 957cdf0e10cSrcweir aBmpEx.Convert( BMP_CONVERSION_GHOSTED ); 958cdf0e10cSrcweir } 959cdf0e10cSrcweir } 960cdf0e10cSrcweir 961cdf0e10cSrcweir if ( mpMetaFile ) 962cdf0e10cSrcweir { 963cdf0e10cSrcweir switch( nAction ) 964cdf0e10cSrcweir { 965cdf0e10cSrcweir case( META_BMPEX_ACTION ): 966cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpExAction( rDestPt, aBmpEx ) ); 967cdf0e10cSrcweir break; 968cdf0e10cSrcweir 969cdf0e10cSrcweir case( META_BMPEXSCALE_ACTION ): 970cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpExScaleAction( rDestPt, rDestSize, aBmpEx ) ); 971cdf0e10cSrcweir break; 972cdf0e10cSrcweir 973cdf0e10cSrcweir case( META_BMPEXSCALEPART_ACTION ): 974cdf0e10cSrcweir mpMetaFile->AddAction( new MetaBmpExScalePartAction( rDestPt, rDestSize, 975cdf0e10cSrcweir rSrcPtPixel, rSrcSizePixel, aBmpEx ) ); 976cdf0e10cSrcweir break; 977cdf0e10cSrcweir } 978cdf0e10cSrcweir } 979cdf0e10cSrcweir 980cdf0e10cSrcweir OUTDEV_INIT(); 981cdf0e10cSrcweir 982cdf0e10cSrcweir if( OUTDEV_PRINTER == meOutDevType ) 983cdf0e10cSrcweir { 984cdf0e10cSrcweir if( aBmpEx.IsAlpha() ) 985cdf0e10cSrcweir { 986cdf0e10cSrcweir // #107169# For true alpha bitmaps, no longer masking the 987cdf0e10cSrcweir // bitmap, but perform a full alpha blend against a white 988cdf0e10cSrcweir // background here. 989cdf0e10cSrcweir Bitmap aBmp( aBmpEx.GetBitmap() ); 990cdf0e10cSrcweir aBmp.Blend( aBmpEx.GetAlpha(), Color( COL_WHITE) ); 991cdf0e10cSrcweir DrawBitmap( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, aBmp ); 992cdf0e10cSrcweir } 993cdf0e10cSrcweir else 994cdf0e10cSrcweir { 995cdf0e10cSrcweir Bitmap aBmp( aBmpEx.GetBitmap() ), aMask( aBmpEx.GetMask() ); 996cdf0e10cSrcweir aBmp.Replace( aMask, Color( COL_WHITE ) ); 997cdf0e10cSrcweir ImplPrintTransparent( aBmp, aMask, rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel ); 998cdf0e10cSrcweir } 999*5f27b83cSArmin Le Grand 1000*5f27b83cSArmin Le Grand return; 1001cdf0e10cSrcweir } 1002*5f27b83cSArmin Le Grand 1003*5f27b83cSArmin Le Grand if(aBmpEx.IsAlpha()) 1004cdf0e10cSrcweir { 1005cdf0e10cSrcweir ImplDrawAlpha( aBmpEx.GetBitmap(), aBmpEx.GetAlpha(), rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel ); 1006cdf0e10cSrcweir return; 1007cdf0e10cSrcweir } 1008cdf0e10cSrcweir 1009cdf0e10cSrcweir if( !( !aBmpEx ) ) 1010cdf0e10cSrcweir { 1011*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 1012cdf0e10cSrcweir 1013cdf0e10cSrcweir aPosAry.mnSrcX = rSrcPtPixel.X(); 1014cdf0e10cSrcweir aPosAry.mnSrcY = rSrcPtPixel.Y(); 1015cdf0e10cSrcweir aPosAry.mnSrcWidth = rSrcSizePixel.Width(); 1016cdf0e10cSrcweir aPosAry.mnSrcHeight = rSrcSizePixel.Height(); 1017cdf0e10cSrcweir aPosAry.mnDestX = ImplLogicXToDevicePixel( rDestPt.X() ); 1018cdf0e10cSrcweir aPosAry.mnDestY = ImplLogicYToDevicePixel( rDestPt.Y() ); 1019cdf0e10cSrcweir aPosAry.mnDestWidth = ImplLogicWidthToDevicePixel( rDestSize.Width() ); 1020cdf0e10cSrcweir aPosAry.mnDestHeight = ImplLogicHeightToDevicePixel( rDestSize.Height() ); 1021cdf0e10cSrcweir 1022cdf0e10cSrcweir const sal_uLong nMirrFlags = ImplAdjustTwoRect( aPosAry, aBmpEx.GetSizePixel() ); 1023cdf0e10cSrcweir 1024cdf0e10cSrcweir if( aPosAry.mnSrcWidth && aPosAry.mnSrcHeight && aPosAry.mnDestWidth && aPosAry.mnDestHeight ) 1025cdf0e10cSrcweir { 1026cdf0e10cSrcweir 1027cdf0e10cSrcweir if( nMirrFlags ) 1028cdf0e10cSrcweir aBmpEx.Mirror( nMirrFlags ); 1029cdf0e10cSrcweir 1030*5f27b83cSArmin Le Grand const SalBitmap* pSalSrcBmp = aBmpEx.ImplGetBitmapImpBitmap()->ImplGetSalBitmap(); 1031cdf0e10cSrcweir const ImpBitmap* pMaskBmp = aBmpEx.ImplGetMaskImpBitmap(); 1032cdf0e10cSrcweir 1033cdf0e10cSrcweir if ( pMaskBmp ) 1034cdf0e10cSrcweir { 1035*5f27b83cSArmin Le Grand SalBitmap* pSalAlphaBmp = pMaskBmp->ImplGetSalBitmap(); 1036*5f27b83cSArmin Le Grand bool bTryDirectPaint(pSalSrcBmp && pSalAlphaBmp); 1037*5f27b83cSArmin Le Grand 1038*5f27b83cSArmin Le Grand if(bTryDirectPaint) 1039cdf0e10cSrcweir { 1040*5f27b83cSArmin Le Grand // only paint direct when no scaling and no MapMode, else the 1041*5f27b83cSArmin Le Grand // more expensive conversions may be done for short-time Bitmap/BitmapEx 1042*5f27b83cSArmin Le Grand // used for buffering only 1043*5f27b83cSArmin Le Grand if(!IsMapMode() && aPosAry.mnSrcWidth == aPosAry.mnDestWidth && aPosAry.mnSrcHeight == aPosAry.mnDestHeight) 1044cdf0e10cSrcweir { 1045*5f27b83cSArmin Le Grand bTryDirectPaint = false; 1046cdf0e10cSrcweir } 1047cdf0e10cSrcweir } 1048cdf0e10cSrcweir 1049*5f27b83cSArmin Le Grand if(bTryDirectPaint && mpGraphics->DrawAlphaBitmap(aPosAry, *pSalSrcBmp, *pSalAlphaBmp, this)) 1050*5f27b83cSArmin Le Grand { 1051*5f27b83cSArmin Le Grand // tried to paint as alpha directly. If tis worked, we are done (except 1052*5f27b83cSArmin Le Grand // alpha, see below) 1053*5f27b83cSArmin Le Grand } 1054*5f27b83cSArmin Le Grand else 1055*5f27b83cSArmin Le Grand { 1056*5f27b83cSArmin Le Grand // #4919452# reduce operation area to bounds of 1057*5f27b83cSArmin Le Grand // cliprect. since masked transparency involves 1058*5f27b83cSArmin Le Grand // creation of a large vdev and copying the screen 1059*5f27b83cSArmin Le Grand // content into that (slooow read from framebuffer), 1060*5f27b83cSArmin Le Grand // that should considerably increase performance for 1061*5f27b83cSArmin Le Grand // large bitmaps and small clippings. 1062*5f27b83cSArmin Le Grand 1063*5f27b83cSArmin Le Grand // Note that this optimisation is a workaround for a 1064*5f27b83cSArmin Le Grand // Writer peculiarity, namely, to decompose background 1065*5f27b83cSArmin Le Grand // graphics into myriads of disjunct, tiny 1066*5f27b83cSArmin Le Grand // rectangles. That otherwise kills us here, since for 1067*5f27b83cSArmin Le Grand // transparent output, SAL always prepares the whole 1068*5f27b83cSArmin Le Grand // bitmap, if aPosAry contains the whole bitmap (and 1069*5f27b83cSArmin Le Grand // it's _not_ to blame for that). 1070*5f27b83cSArmin Le Grand 1071*5f27b83cSArmin Le Grand // Note the call to ImplPixelToDevicePixel(), since 1072*5f27b83cSArmin Le Grand // aPosAry already contains the mnOutOff-offsets, they 1073*5f27b83cSArmin Le Grand // also have to be applied to the region 1074*5f27b83cSArmin Le Grand Rectangle aClipRegionBounds( ImplPixelToDevicePixel(maRegion).GetBoundRect() ); 1075*5f27b83cSArmin Le Grand 1076*5f27b83cSArmin Le Grand // TODO: Also respect scaling (that's a bit tricky, 1077*5f27b83cSArmin Le Grand // since the source points have to move fractional 1078*5f27b83cSArmin Le Grand // amounts (which is not possible, thus has to be 1079*5f27b83cSArmin Le Grand // emulated by increases copy area) 1080*5f27b83cSArmin Le Grand // const double nScaleX( aPosAry.mnDestWidth / aPosAry.mnSrcWidth ); 1081*5f27b83cSArmin Le Grand // const double nScaleY( aPosAry.mnDestHeight / aPosAry.mnSrcHeight ); 1082*5f27b83cSArmin Le Grand 1083*5f27b83cSArmin Le Grand // for now, only identity scales allowed 1084*5f27b83cSArmin Le Grand if( !aClipRegionBounds.IsEmpty() && 1085*5f27b83cSArmin Le Grand aPosAry.mnDestWidth == aPosAry.mnSrcWidth && 1086*5f27b83cSArmin Le Grand aPosAry.mnDestHeight == aPosAry.mnSrcHeight ) 1087*5f27b83cSArmin Le Grand { 1088*5f27b83cSArmin Le Grand // now intersect dest rect with clip region 1089*5f27b83cSArmin Le Grand aClipRegionBounds.Intersection( Rectangle( aPosAry.mnDestX, 1090*5f27b83cSArmin Le Grand aPosAry.mnDestY, 1091*5f27b83cSArmin Le Grand aPosAry.mnDestX + aPosAry.mnDestWidth - 1, 1092*5f27b83cSArmin Le Grand aPosAry.mnDestY + aPosAry.mnDestHeight - 1 ) ); 1093*5f27b83cSArmin Le Grand 1094*5f27b83cSArmin Le Grand // Note: I could theoretically optimize away the 1095*5f27b83cSArmin Le Grand // DrawBitmap below, if the region is empty 1096*5f27b83cSArmin Le Grand // here. Unfortunately, cannot rule out that 1097*5f27b83cSArmin Le Grand // somebody relies on the side effects. 1098*5f27b83cSArmin Le Grand if( !aClipRegionBounds.IsEmpty() ) 1099*5f27b83cSArmin Le Grand { 1100*5f27b83cSArmin Le Grand aPosAry.mnSrcX += aClipRegionBounds.Left() - aPosAry.mnDestX; 1101*5f27b83cSArmin Le Grand aPosAry.mnSrcY += aClipRegionBounds.Top() - aPosAry.mnDestY; 1102*5f27b83cSArmin Le Grand aPosAry.mnSrcWidth = aClipRegionBounds.GetWidth(); 1103*5f27b83cSArmin Le Grand aPosAry.mnSrcHeight = aClipRegionBounds.GetHeight(); 1104*5f27b83cSArmin Le Grand 1105*5f27b83cSArmin Le Grand aPosAry.mnDestX = aClipRegionBounds.Left(); 1106*5f27b83cSArmin Le Grand aPosAry.mnDestY = aClipRegionBounds.Top(); 1107*5f27b83cSArmin Le Grand aPosAry.mnDestWidth = aClipRegionBounds.GetWidth(); 1108*5f27b83cSArmin Le Grand aPosAry.mnDestHeight = aClipRegionBounds.GetHeight(); 1109*5f27b83cSArmin Le Grand } 1110*5f27b83cSArmin Le Grand } 1111*5f27b83cSArmin Le Grand 1112*5f27b83cSArmin Le Grand mpGraphics->DrawBitmap( aPosAry, *pSalSrcBmp, 1113*5f27b83cSArmin Le Grand *pMaskBmp->ImplGetSalBitmap(), 1114*5f27b83cSArmin Le Grand this ); 1115*5f27b83cSArmin Le Grand } 1116cdf0e10cSrcweir 1117cdf0e10cSrcweir // #110958# Paint mask to alpha channel. Luckily, the 1118cdf0e10cSrcweir // black and white representation of the mask maps to 1119cdf0e10cSrcweir // the alpha channel 1120cdf0e10cSrcweir 1121cdf0e10cSrcweir // #i25167# Restrict mask painting to _opaque_ areas 1122cdf0e10cSrcweir // of the mask, otherwise we spoil areas where no 1123cdf0e10cSrcweir // bitmap content was ever visible. Interestingly 1124cdf0e10cSrcweir // enough, this can be achieved by taking the mask as 1125cdf0e10cSrcweir // the transparency mask of itself 1126cdf0e10cSrcweir if( mpAlphaVDev ) 1127cdf0e10cSrcweir mpAlphaVDev->DrawBitmapEx( rDestPt, 1128cdf0e10cSrcweir rDestSize, 1129cdf0e10cSrcweir BitmapEx( aBmpEx.GetMask(), 1130cdf0e10cSrcweir aBmpEx.GetMask() ) ); 1131cdf0e10cSrcweir } 1132cdf0e10cSrcweir else 1133cdf0e10cSrcweir { 1134*5f27b83cSArmin Le Grand mpGraphics->DrawBitmap( aPosAry, *pSalSrcBmp, this ); 1135cdf0e10cSrcweir 1136cdf0e10cSrcweir if( mpAlphaVDev ) 1137cdf0e10cSrcweir { 1138cdf0e10cSrcweir // #i32109#: Make bitmap area opaque 1139cdf0e10cSrcweir mpAlphaVDev->ImplFillOpaqueRectangle( Rectangle(rDestPt, rDestSize) ); 1140cdf0e10cSrcweir } 1141cdf0e10cSrcweir } 1142cdf0e10cSrcweir } 1143cdf0e10cSrcweir } 1144cdf0e10cSrcweir } 1145cdf0e10cSrcweir 1146cdf0e10cSrcweir // ------------------------------------------------------------------ 1147cdf0e10cSrcweir 1148cdf0e10cSrcweir void OutputDevice::DrawMask( const Point& rDestPt, 1149cdf0e10cSrcweir const Bitmap& rBitmap, const Color& rMaskColor ) 1150cdf0e10cSrcweir { 1151cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawMask()" ); 1152cdf0e10cSrcweir 1153cdf0e10cSrcweir if( ImplIsRecordLayout() ) 1154cdf0e10cSrcweir return; 1155cdf0e10cSrcweir 1156cdf0e10cSrcweir const Size aSizePix( rBitmap.GetSizePixel() ); 1157cdf0e10cSrcweir ImplDrawMask( rDestPt, PixelToLogic( aSizePix ), Point(), aSizePix, rBitmap, rMaskColor, META_MASK_ACTION ); 1158cdf0e10cSrcweir 1159cdf0e10cSrcweir if( mpAlphaVDev ) 1160cdf0e10cSrcweir { 1161cdf0e10cSrcweir const Bitmap& rMask( rBitmap.CreateMask( rMaskColor ) ); 1162cdf0e10cSrcweir 1163cdf0e10cSrcweir // #i25167# Restrict mask painting to _opaque_ areas 1164cdf0e10cSrcweir // of the mask, otherwise we spoil areas where no 1165cdf0e10cSrcweir // bitmap content was ever visible. Interestingly 1166cdf0e10cSrcweir // enough, this can be achieved by taking the mask as 1167cdf0e10cSrcweir // the transparency mask of itself 1168cdf0e10cSrcweir mpAlphaVDev->DrawBitmapEx( rDestPt, 1169cdf0e10cSrcweir PixelToLogic( aSizePix ), 1170cdf0e10cSrcweir BitmapEx( rMask, rMask ) ); 1171cdf0e10cSrcweir } 1172cdf0e10cSrcweir } 1173cdf0e10cSrcweir 1174cdf0e10cSrcweir // ------------------------------------------------------------------ 1175cdf0e10cSrcweir 1176cdf0e10cSrcweir void OutputDevice::DrawMask( const Point& rDestPt, const Size& rDestSize, 1177cdf0e10cSrcweir const Bitmap& rBitmap, const Color& rMaskColor ) 1178cdf0e10cSrcweir { 1179cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawMask( Size )" ); 1180cdf0e10cSrcweir 1181cdf0e10cSrcweir if( ImplIsRecordLayout() ) 1182cdf0e10cSrcweir return; 1183cdf0e10cSrcweir 1184cdf0e10cSrcweir ImplDrawMask( rDestPt, rDestSize, Point(), rBitmap.GetSizePixel(), rBitmap, rMaskColor, META_MASKSCALE_ACTION ); 1185cdf0e10cSrcweir 1186cdf0e10cSrcweir // TODO: Use mask here 1187cdf0e10cSrcweir if( mpAlphaVDev ) 1188cdf0e10cSrcweir { 1189cdf0e10cSrcweir const Bitmap& rMask( rBitmap.CreateMask( rMaskColor ) ); 1190cdf0e10cSrcweir 1191cdf0e10cSrcweir // #i25167# Restrict mask painting to _opaque_ areas 1192cdf0e10cSrcweir // of the mask, otherwise we spoil areas where no 1193cdf0e10cSrcweir // bitmap content was ever visible. Interestingly 1194cdf0e10cSrcweir // enough, this can be achieved by taking the mask as 1195cdf0e10cSrcweir // the transparency mask of itself 1196cdf0e10cSrcweir mpAlphaVDev->DrawBitmapEx( rDestPt, 1197cdf0e10cSrcweir rDestSize, 1198cdf0e10cSrcweir BitmapEx( rMask, rMask ) ); 1199cdf0e10cSrcweir } 1200cdf0e10cSrcweir } 1201cdf0e10cSrcweir 1202cdf0e10cSrcweir // ------------------------------------------------------------------ 1203cdf0e10cSrcweir 1204cdf0e10cSrcweir void OutputDevice::DrawMask( const Point& rDestPt, const Size& rDestSize, 1205cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel, 1206cdf0e10cSrcweir const Bitmap& rBitmap, const Color& rMaskColor ) 1207cdf0e10cSrcweir { 1208cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawMask( Point, Size )" ); 1209cdf0e10cSrcweir 1210cdf0e10cSrcweir if( ImplIsRecordLayout() ) 1211cdf0e10cSrcweir return; 1212cdf0e10cSrcweir 1213cdf0e10cSrcweir ImplDrawMask( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, rBitmap, rMaskColor, META_MASKSCALEPART_ACTION ); 1214cdf0e10cSrcweir 1215cdf0e10cSrcweir // TODO: Use mask here 1216cdf0e10cSrcweir if( mpAlphaVDev ) 1217cdf0e10cSrcweir { 1218cdf0e10cSrcweir const Bitmap& rMask( rBitmap.CreateMask( rMaskColor ) ); 1219cdf0e10cSrcweir 1220cdf0e10cSrcweir // #i25167# Restrict mask painting to _opaque_ areas 1221cdf0e10cSrcweir // of the mask, otherwise we spoil areas where no 1222cdf0e10cSrcweir // bitmap content was ever visible. Interestingly 1223cdf0e10cSrcweir // enough, this can be achieved by taking the mask as 1224cdf0e10cSrcweir // the transparency mask of itself 1225cdf0e10cSrcweir mpAlphaVDev->DrawBitmapEx( rDestPt, 1226cdf0e10cSrcweir rDestSize, 1227cdf0e10cSrcweir rSrcPtPixel, 1228cdf0e10cSrcweir rSrcSizePixel, 1229cdf0e10cSrcweir BitmapEx( rMask, rMask ) ); 1230cdf0e10cSrcweir } 1231cdf0e10cSrcweir } 1232cdf0e10cSrcweir 1233cdf0e10cSrcweir // ------------------------------------------------------------------ 1234cdf0e10cSrcweir 1235cdf0e10cSrcweir void OutputDevice::ImplDrawMask( const Point& rDestPt, const Size& rDestSize, 1236cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel, 1237cdf0e10cSrcweir const Bitmap& rBitmap, const Color& rMaskColor, 1238cdf0e10cSrcweir const sal_uLong nAction ) 1239cdf0e10cSrcweir { 1240cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1241cdf0e10cSrcweir 1242cdf0e10cSrcweir if( ROP_INVERT == meRasterOp ) 1243cdf0e10cSrcweir { 1244cdf0e10cSrcweir DrawRect( Rectangle( rDestPt, rDestSize ) ); 1245cdf0e10cSrcweir return; 1246cdf0e10cSrcweir } 1247cdf0e10cSrcweir 1248cdf0e10cSrcweir if ( mpMetaFile ) 1249cdf0e10cSrcweir { 1250cdf0e10cSrcweir switch( nAction ) 1251cdf0e10cSrcweir { 1252cdf0e10cSrcweir case( META_MASK_ACTION ): 1253cdf0e10cSrcweir mpMetaFile->AddAction( new MetaMaskAction( rDestPt, 1254cdf0e10cSrcweir rBitmap, rMaskColor ) ); 1255cdf0e10cSrcweir break; 1256cdf0e10cSrcweir 1257cdf0e10cSrcweir case( META_MASKSCALE_ACTION ): 1258cdf0e10cSrcweir mpMetaFile->AddAction( new MetaMaskScaleAction( rDestPt, 1259cdf0e10cSrcweir rDestSize, rBitmap, rMaskColor ) ); 1260cdf0e10cSrcweir break; 1261cdf0e10cSrcweir 1262cdf0e10cSrcweir case( META_MASKSCALEPART_ACTION ): 1263cdf0e10cSrcweir mpMetaFile->AddAction( new MetaMaskScalePartAction( rDestPt, rDestSize, 1264cdf0e10cSrcweir rSrcPtPixel, rSrcSizePixel, rBitmap, rMaskColor ) ); 1265cdf0e10cSrcweir break; 1266cdf0e10cSrcweir } 1267cdf0e10cSrcweir } 1268cdf0e10cSrcweir 1269cdf0e10cSrcweir OUTDEV_INIT(); 1270cdf0e10cSrcweir 1271cdf0e10cSrcweir if ( OUTDEV_PRINTER == meOutDevType ) 1272cdf0e10cSrcweir { 1273cdf0e10cSrcweir ImplPrintMask( rBitmap, rMaskColor, rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel ); 1274cdf0e10cSrcweir return; 1275cdf0e10cSrcweir } 1276cdf0e10cSrcweir 1277cdf0e10cSrcweir const ImpBitmap* pImpBmp = rBitmap.ImplGetImpBitmap(); 1278cdf0e10cSrcweir if ( pImpBmp ) 1279cdf0e10cSrcweir { 1280*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 1281cdf0e10cSrcweir 1282cdf0e10cSrcweir aPosAry.mnSrcX = rSrcPtPixel.X(); 1283cdf0e10cSrcweir aPosAry.mnSrcY = rSrcPtPixel.Y(); 1284cdf0e10cSrcweir aPosAry.mnSrcWidth = rSrcSizePixel.Width(); 1285cdf0e10cSrcweir aPosAry.mnSrcHeight = rSrcSizePixel.Height(); 1286cdf0e10cSrcweir aPosAry.mnDestX = ImplLogicXToDevicePixel( rDestPt.X() ); 1287cdf0e10cSrcweir aPosAry.mnDestY = ImplLogicYToDevicePixel( rDestPt.Y() ); 1288cdf0e10cSrcweir aPosAry.mnDestWidth = ImplLogicWidthToDevicePixel( rDestSize.Width() ); 1289cdf0e10cSrcweir aPosAry.mnDestHeight = ImplLogicHeightToDevicePixel( rDestSize.Height() ); 1290cdf0e10cSrcweir 1291cdf0e10cSrcweir // spiegeln via Koordinaten wollen wir nicht 1292cdf0e10cSrcweir const sal_uLong nMirrFlags = ImplAdjustTwoRect( aPosAry, pImpBmp->ImplGetSize() ); 1293cdf0e10cSrcweir 1294cdf0e10cSrcweir // check if output is necessary 1295cdf0e10cSrcweir if( aPosAry.mnSrcWidth && aPosAry.mnSrcHeight && aPosAry.mnDestWidth && aPosAry.mnDestHeight ) 1296cdf0e10cSrcweir { 1297cdf0e10cSrcweir 1298cdf0e10cSrcweir if( nMirrFlags ) 1299cdf0e10cSrcweir { 1300cdf0e10cSrcweir Bitmap aTmp( rBitmap ); 1301cdf0e10cSrcweir aTmp.Mirror( nMirrFlags ); 1302*5f27b83cSArmin Le Grand mpGraphics->DrawMask( aPosAry, *aTmp.ImplGetImpBitmap()->ImplGetSalBitmap(), 1303cdf0e10cSrcweir ImplColorToSal( rMaskColor ) , this); 1304cdf0e10cSrcweir } 1305cdf0e10cSrcweir else 1306*5f27b83cSArmin Le Grand mpGraphics->DrawMask( aPosAry, *pImpBmp->ImplGetSalBitmap(), 1307cdf0e10cSrcweir ImplColorToSal( rMaskColor ), this ); 1308cdf0e10cSrcweir 1309cdf0e10cSrcweir } 1310cdf0e10cSrcweir } 1311cdf0e10cSrcweir } 1312cdf0e10cSrcweir 1313cdf0e10cSrcweir // ------------------------------------------------------------------ 1314cdf0e10cSrcweir 1315cdf0e10cSrcweir void OutputDevice::DrawImage( const Point& rPos, const Image& rImage, sal_uInt16 nStyle ) 1316cdf0e10cSrcweir { 1317cdf0e10cSrcweir DBG_ASSERT( GetOutDevType() != OUTDEV_PRINTER, "DrawImage(): Images can't be drawn on any mprinter" ); 1318cdf0e10cSrcweir 1319cdf0e10cSrcweir if( !rImage.mpImplData || ImplIsRecordLayout() ) 1320cdf0e10cSrcweir return; 1321cdf0e10cSrcweir 1322cdf0e10cSrcweir switch( rImage.mpImplData->meType ) 1323cdf0e10cSrcweir { 1324cdf0e10cSrcweir case IMAGETYPE_BITMAP: 1325cdf0e10cSrcweir DrawBitmap( rPos, *static_cast< Bitmap* >( rImage.mpImplData->mpData ) ); 1326cdf0e10cSrcweir break; 1327cdf0e10cSrcweir 1328cdf0e10cSrcweir case IMAGETYPE_IMAGE: 1329cdf0e10cSrcweir { 1330cdf0e10cSrcweir ImplImageData* pData = static_cast< ImplImageData* >( rImage.mpImplData->mpData ); 1331cdf0e10cSrcweir 1332cdf0e10cSrcweir if( !pData->mpImageBitmap ) 1333cdf0e10cSrcweir { 1334cdf0e10cSrcweir const Size aSize( pData->maBmpEx.GetSizePixel() ); 1335cdf0e10cSrcweir 1336cdf0e10cSrcweir pData->mpImageBitmap = new ImplImageBmp; 1337cdf0e10cSrcweir pData->mpImageBitmap->Create( pData->maBmpEx, aSize.Width(), aSize.Height(), 1 ); 1338cdf0e10cSrcweir } 1339cdf0e10cSrcweir 1340cdf0e10cSrcweir pData->mpImageBitmap->Draw( 0, this, rPos, nStyle ); 1341cdf0e10cSrcweir } 1342cdf0e10cSrcweir break; 1343cdf0e10cSrcweir 1344cdf0e10cSrcweir default: 1345cdf0e10cSrcweir break; 1346cdf0e10cSrcweir } 1347cdf0e10cSrcweir } 1348cdf0e10cSrcweir 1349cdf0e10cSrcweir // ------------------------------------------------------------------ 1350cdf0e10cSrcweir 1351cdf0e10cSrcweir void OutputDevice::DrawImage( const Point& rPos, const Size& rSize, 1352cdf0e10cSrcweir const Image& rImage, sal_uInt16 nStyle ) 1353cdf0e10cSrcweir { 1354cdf0e10cSrcweir DBG_ASSERT( GetOutDevType() != OUTDEV_PRINTER, "DrawImage(): Images can't be drawn on any mprinter" ); 1355cdf0e10cSrcweir 1356cdf0e10cSrcweir if( rImage.mpImplData && !ImplIsRecordLayout() ) 1357cdf0e10cSrcweir { 1358cdf0e10cSrcweir switch( rImage.mpImplData->meType ) 1359cdf0e10cSrcweir { 1360cdf0e10cSrcweir case IMAGETYPE_BITMAP: 1361cdf0e10cSrcweir DrawBitmap( rPos, rSize, *static_cast< Bitmap* >( rImage.mpImplData->mpData ) ); 1362cdf0e10cSrcweir break; 1363cdf0e10cSrcweir 1364cdf0e10cSrcweir case IMAGETYPE_IMAGE: 1365cdf0e10cSrcweir { 1366cdf0e10cSrcweir ImplImageData* pData = static_cast< ImplImageData* >( rImage.mpImplData->mpData ); 1367cdf0e10cSrcweir 1368cdf0e10cSrcweir if ( !pData->mpImageBitmap ) 1369cdf0e10cSrcweir { 1370cdf0e10cSrcweir const Size aSize( pData->maBmpEx.GetSizePixel() ); 1371cdf0e10cSrcweir 1372cdf0e10cSrcweir pData->mpImageBitmap = new ImplImageBmp; 1373cdf0e10cSrcweir pData->mpImageBitmap->Create( pData->maBmpEx, aSize.Width(), aSize.Height(), 1 ); 1374cdf0e10cSrcweir } 1375cdf0e10cSrcweir 1376cdf0e10cSrcweir pData->mpImageBitmap->Draw( 0, this, rPos, nStyle, &rSize ); 1377cdf0e10cSrcweir } 1378cdf0e10cSrcweir break; 1379cdf0e10cSrcweir 1380cdf0e10cSrcweir default: 1381cdf0e10cSrcweir break; 1382cdf0e10cSrcweir } 1383cdf0e10cSrcweir } 1384cdf0e10cSrcweir } 1385cdf0e10cSrcweir 1386cdf0e10cSrcweir // ------------------------------------------------------------------ 1387cdf0e10cSrcweir 1388cdf0e10cSrcweir Bitmap OutputDevice::GetBitmap( const Point& rSrcPt, const Size& rSize ) const 1389cdf0e10cSrcweir { 1390cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1391cdf0e10cSrcweir 1392cdf0e10cSrcweir Bitmap aBmp; 1393cdf0e10cSrcweir long nX = ImplLogicXToDevicePixel( rSrcPt.X() ); 1394cdf0e10cSrcweir long nY = ImplLogicYToDevicePixel( rSrcPt.Y() ); 1395cdf0e10cSrcweir long nWidth = ImplLogicWidthToDevicePixel( rSize.Width() ); 1396cdf0e10cSrcweir long nHeight = ImplLogicHeightToDevicePixel( rSize.Height() ); 1397cdf0e10cSrcweir 1398cdf0e10cSrcweir if ( mpGraphics || ( (OutputDevice*) this )->ImplGetGraphics() ) 1399cdf0e10cSrcweir { 1400cdf0e10cSrcweir if ( nWidth && nHeight ) 1401cdf0e10cSrcweir { 1402cdf0e10cSrcweir Rectangle aRect( Point( nX, nY ), Size( nWidth, nHeight ) ); 1403cdf0e10cSrcweir sal_Bool bClipped = sal_False; 1404cdf0e10cSrcweir 1405cdf0e10cSrcweir // X-Koordinate ausserhalb des Bereichs? 1406cdf0e10cSrcweir if ( nX < mnOutOffX ) 1407cdf0e10cSrcweir { 1408cdf0e10cSrcweir nWidth -= ( mnOutOffX - nX ); 1409cdf0e10cSrcweir nX = mnOutOffX; 1410cdf0e10cSrcweir bClipped = sal_True; 1411cdf0e10cSrcweir } 1412cdf0e10cSrcweir 1413cdf0e10cSrcweir // Y-Koordinate ausserhalb des Bereichs? 1414cdf0e10cSrcweir if ( nY < mnOutOffY ) 1415cdf0e10cSrcweir { 1416cdf0e10cSrcweir nHeight -= ( mnOutOffY - nY ); 1417cdf0e10cSrcweir nY = mnOutOffY; 1418cdf0e10cSrcweir bClipped = sal_True; 1419cdf0e10cSrcweir } 1420cdf0e10cSrcweir 1421cdf0e10cSrcweir // Breite ausserhalb des Bereichs? 1422cdf0e10cSrcweir if ( (nWidth + nX) > (mnOutWidth + mnOutOffX) ) 1423cdf0e10cSrcweir { 1424cdf0e10cSrcweir nWidth = mnOutOffX + mnOutWidth - nX; 1425cdf0e10cSrcweir bClipped = sal_True; 1426cdf0e10cSrcweir } 1427cdf0e10cSrcweir 1428cdf0e10cSrcweir // Hoehe ausserhalb des Bereichs? 1429cdf0e10cSrcweir if ( (nHeight + nY) > (mnOutHeight + mnOutOffY) ) 1430cdf0e10cSrcweir { 1431cdf0e10cSrcweir nHeight = mnOutOffY + mnOutHeight - nY; 1432cdf0e10cSrcweir bClipped = sal_True; 1433cdf0e10cSrcweir } 1434cdf0e10cSrcweir 1435cdf0e10cSrcweir if ( bClipped ) 1436cdf0e10cSrcweir { 1437cdf0e10cSrcweir // Falls auf den sichtbaren Bereich geclipped wurde, 1438cdf0e10cSrcweir // muessen wir eine Bitmap in der rchtigen Groesse 1439cdf0e10cSrcweir // erzeugen, in die die geclippte Bitmap an die angepasste 1440cdf0e10cSrcweir // Position kopiert wird 1441cdf0e10cSrcweir VirtualDevice aVDev( *this ); 1442cdf0e10cSrcweir 1443cdf0e10cSrcweir if ( aVDev.SetOutputSizePixel( aRect.GetSize() ) ) 1444cdf0e10cSrcweir { 1445cdf0e10cSrcweir if ( ((OutputDevice*)&aVDev)->mpGraphics || ((OutputDevice*)&aVDev)->ImplGetGraphics() ) 1446cdf0e10cSrcweir { 1447*5f27b83cSArmin Le Grand SalTwoRect aPosAry; 1448cdf0e10cSrcweir 1449cdf0e10cSrcweir aPosAry.mnSrcX = nX; 1450cdf0e10cSrcweir aPosAry.mnSrcY = nY; 1451cdf0e10cSrcweir aPosAry.mnSrcWidth = nWidth; 1452cdf0e10cSrcweir aPosAry.mnSrcHeight = nHeight; 1453cdf0e10cSrcweir aPosAry.mnDestX = ( aRect.Left() < mnOutOffX ) ? ( mnOutOffX - aRect.Left() ) : 0L; 1454cdf0e10cSrcweir aPosAry.mnDestY = ( aRect.Top() < mnOutOffY ) ? ( mnOutOffY - aRect.Top() ) : 0L; 1455cdf0e10cSrcweir aPosAry.mnDestWidth = nWidth; 1456cdf0e10cSrcweir aPosAry.mnDestHeight = nHeight; 1457cdf0e10cSrcweir 1458cdf0e10cSrcweir if ( (nWidth > 0) && (nHeight > 0) ) 1459*5f27b83cSArmin Le Grand (((OutputDevice*)&aVDev)->mpGraphics)->CopyBits( aPosAry, mpGraphics, this, this ); 1460cdf0e10cSrcweir 1461cdf0e10cSrcweir aBmp = aVDev.GetBitmap( Point(), aVDev.GetOutputSizePixel() ); 1462cdf0e10cSrcweir } 1463cdf0e10cSrcweir else 1464cdf0e10cSrcweir bClipped = sal_False; 1465cdf0e10cSrcweir } 1466cdf0e10cSrcweir else 1467cdf0e10cSrcweir bClipped = sal_False; 1468cdf0e10cSrcweir } 1469cdf0e10cSrcweir 1470cdf0e10cSrcweir if ( !bClipped ) 1471cdf0e10cSrcweir { 1472cdf0e10cSrcweir SalBitmap* pSalBmp = mpGraphics->GetBitmap( nX, nY, nWidth, nHeight, this ); 1473cdf0e10cSrcweir 1474cdf0e10cSrcweir if( pSalBmp ) 1475cdf0e10cSrcweir { 1476cdf0e10cSrcweir ImpBitmap* pImpBmp = new ImpBitmap; 1477cdf0e10cSrcweir pImpBmp->ImplSetSalBitmap( pSalBmp ); 1478cdf0e10cSrcweir aBmp.ImplSetImpBitmap( pImpBmp ); 1479cdf0e10cSrcweir } 1480cdf0e10cSrcweir } 1481cdf0e10cSrcweir } 1482cdf0e10cSrcweir } 1483cdf0e10cSrcweir 1484cdf0e10cSrcweir return aBmp; 1485cdf0e10cSrcweir } 1486cdf0e10cSrcweir 1487cdf0e10cSrcweir // ------------------------------------------------------------------ 1488cdf0e10cSrcweir 1489cdf0e10cSrcweir BitmapEx OutputDevice::GetBitmapEx( const Point& rSrcPt, const Size& rSize ) const 1490cdf0e10cSrcweir { 1491cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1492cdf0e10cSrcweir 1493cdf0e10cSrcweir // #110958# Extract alpha value from VDev, if any 1494cdf0e10cSrcweir if( mpAlphaVDev ) 1495cdf0e10cSrcweir { 1496cdf0e10cSrcweir Bitmap aAlphaBitmap( mpAlphaVDev->GetBitmap( rSrcPt, rSize ) ); 1497cdf0e10cSrcweir 1498cdf0e10cSrcweir // ensure 8 bit alpha 1499cdf0e10cSrcweir if( aAlphaBitmap.GetBitCount() > 8 ) 1500cdf0e10cSrcweir aAlphaBitmap.Convert( BMP_CONVERSION_8BIT_GREYS ); 1501cdf0e10cSrcweir 1502cdf0e10cSrcweir return BitmapEx(GetBitmap( rSrcPt, rSize ), AlphaMask( aAlphaBitmap ) ); 1503cdf0e10cSrcweir } 1504cdf0e10cSrcweir else 1505cdf0e10cSrcweir return GetBitmap( rSrcPt, rSize ); 1506cdf0e10cSrcweir } 1507cdf0e10cSrcweir 1508cdf0e10cSrcweir // ------------------------------------------------------------------ 1509cdf0e10cSrcweir 1510cdf0e10cSrcweir void OutputDevice::ImplGetFrameBitmap( const Point& rDestPt, const Size& rSize, 1511cdf0e10cSrcweir Bitmap& rBitmap ) const 1512cdf0e10cSrcweir { 1513cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1514cdf0e10cSrcweir 1515cdf0e10cSrcweir sal_Bool bOldMap = mbMap; 1516cdf0e10cSrcweir ((OutputDevice*)this)->mbMap = sal_False; 1517cdf0e10cSrcweir rBitmap = GetBitmap( rDestPt, rSize ); 1518cdf0e10cSrcweir ((OutputDevice*)this)->mbMap = bOldMap; 1519cdf0e10cSrcweir } 1520cdf0e10cSrcweir 1521cdf0e10cSrcweir // ------------------------------------------------------------------ 1522cdf0e10cSrcweir 1523cdf0e10cSrcweir Color OutputDevice::GetPixel( const Point& rPt ) const 1524cdf0e10cSrcweir { 1525cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1526cdf0e10cSrcweir 1527cdf0e10cSrcweir Color aColor; 1528cdf0e10cSrcweir 1529cdf0e10cSrcweir if ( mpGraphics || ((OutputDevice*)this)->ImplGetGraphics() ) 1530cdf0e10cSrcweir { 1531cdf0e10cSrcweir if ( mbInitClipRegion ) 1532cdf0e10cSrcweir ((OutputDevice*)this)->ImplInitClipRegion(); 1533cdf0e10cSrcweir 1534cdf0e10cSrcweir if ( !mbOutputClipped ) 1535cdf0e10cSrcweir { 1536cdf0e10cSrcweir const long nX = ImplLogicXToDevicePixel( rPt.X() ); 1537cdf0e10cSrcweir const long nY = ImplLogicYToDevicePixel( rPt.Y() ); 1538cdf0e10cSrcweir const SalColor aSalCol = mpGraphics->GetPixel( nX, nY, this ); 1539cdf0e10cSrcweir aColor.SetRed( SALCOLOR_RED( aSalCol ) ); 1540cdf0e10cSrcweir aColor.SetGreen( SALCOLOR_GREEN( aSalCol ) ); 1541cdf0e10cSrcweir aColor.SetBlue( SALCOLOR_BLUE( aSalCol ) ); 1542cdf0e10cSrcweir } 1543cdf0e10cSrcweir } 1544cdf0e10cSrcweir return aColor; 1545cdf0e10cSrcweir } 1546cdf0e10cSrcweir 1547cdf0e10cSrcweir // ------------------------------------------------------------------ 1548cdf0e10cSrcweir 1549cdf0e10cSrcweir Color* OutputDevice::GetPixel( const Polygon& rPts ) const 1550cdf0e10cSrcweir { 1551cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1552cdf0e10cSrcweir 1553cdf0e10cSrcweir Color* pColors = NULL; 1554cdf0e10cSrcweir const sal_uInt16 nSize = rPts.GetSize(); 1555cdf0e10cSrcweir 1556cdf0e10cSrcweir if( nSize ) 1557cdf0e10cSrcweir { 1558cdf0e10cSrcweir if ( mpGraphics || ((OutputDevice*)this)->ImplGetGraphics() ) 1559cdf0e10cSrcweir { 1560cdf0e10cSrcweir if ( mbInitClipRegion ) 1561cdf0e10cSrcweir ((OutputDevice*)this)->ImplInitClipRegion(); 1562cdf0e10cSrcweir 1563cdf0e10cSrcweir if ( !mbOutputClipped ) 1564cdf0e10cSrcweir { 1565cdf0e10cSrcweir pColors = new Color[ nSize ]; 1566cdf0e10cSrcweir 1567cdf0e10cSrcweir for( sal_uInt16 i = 0; i < nSize; i++ ) 1568cdf0e10cSrcweir { 1569cdf0e10cSrcweir Color& rCol = pColors[ i ]; 1570cdf0e10cSrcweir const Point& rPt = rPts[ i ]; 1571cdf0e10cSrcweir const SalColor aSalCol( mpGraphics->GetPixel( ImplLogicXToDevicePixel( rPt.X() ), 1572cdf0e10cSrcweir ImplLogicYToDevicePixel( rPt.Y() ) , this) ); 1573cdf0e10cSrcweir 1574cdf0e10cSrcweir rCol.SetRed( SALCOLOR_RED( aSalCol ) ); 1575cdf0e10cSrcweir rCol.SetGreen( SALCOLOR_GREEN( aSalCol ) ); 1576cdf0e10cSrcweir rCol.SetBlue( SALCOLOR_BLUE( aSalCol ) ); 1577cdf0e10cSrcweir } 1578cdf0e10cSrcweir } 1579cdf0e10cSrcweir } 1580cdf0e10cSrcweir } 1581cdf0e10cSrcweir 1582cdf0e10cSrcweir return pColors; 1583cdf0e10cSrcweir } 1584cdf0e10cSrcweir 1585cdf0e10cSrcweir // ----------------------------------------------------------------------- 1586cdf0e10cSrcweir 1587cdf0e10cSrcweir void OutputDevice::DrawPixel( const Point& rPt ) 1588cdf0e10cSrcweir { 1589cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawPixel()" ); 1590cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1591cdf0e10cSrcweir 1592cdf0e10cSrcweir if ( mpMetaFile ) 1593cdf0e10cSrcweir mpMetaFile->AddAction( new MetaPointAction( rPt ) ); 1594cdf0e10cSrcweir 1595cdf0e10cSrcweir if ( !IsDeviceOutputNecessary() || !mbLineColor || ImplIsRecordLayout() ) 1596cdf0e10cSrcweir return; 1597cdf0e10cSrcweir 1598cdf0e10cSrcweir Point aPt = ImplLogicToDevicePixel( rPt ); 1599cdf0e10cSrcweir 1600cdf0e10cSrcweir // we need a graphics 1601cdf0e10cSrcweir if ( !mpGraphics ) 1602cdf0e10cSrcweir { 1603cdf0e10cSrcweir if ( !ImplGetGraphics() ) 1604cdf0e10cSrcweir return; 1605cdf0e10cSrcweir } 1606cdf0e10cSrcweir 1607cdf0e10cSrcweir if ( mbInitClipRegion ) 1608cdf0e10cSrcweir ImplInitClipRegion(); 1609cdf0e10cSrcweir if ( mbOutputClipped ) 1610cdf0e10cSrcweir return; 1611cdf0e10cSrcweir 1612cdf0e10cSrcweir if ( mbInitLineColor ) 1613cdf0e10cSrcweir ImplInitLineColor(); 1614cdf0e10cSrcweir 1615cdf0e10cSrcweir mpGraphics->DrawPixel( aPt.X(), aPt.Y(), this ); 1616cdf0e10cSrcweir 1617cdf0e10cSrcweir if( mpAlphaVDev ) 1618cdf0e10cSrcweir mpAlphaVDev->DrawPixel( rPt ); 1619cdf0e10cSrcweir } 1620cdf0e10cSrcweir 1621cdf0e10cSrcweir // ----------------------------------------------------------------------- 1622cdf0e10cSrcweir 1623cdf0e10cSrcweir void OutputDevice::DrawPixel( const Point& rPt, const Color& rColor ) 1624cdf0e10cSrcweir { 1625cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawPixel()" ); 1626cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1627cdf0e10cSrcweir 1628cdf0e10cSrcweir Color aColor( rColor ); 1629cdf0e10cSrcweir 1630cdf0e10cSrcweir if( mnDrawMode & ( DRAWMODE_BLACKLINE | DRAWMODE_WHITELINE | 1631cdf0e10cSrcweir DRAWMODE_GRAYLINE | DRAWMODE_GHOSTEDLINE | 1632cdf0e10cSrcweir DRAWMODE_SETTINGSLINE ) ) 1633cdf0e10cSrcweir { 1634cdf0e10cSrcweir if( !ImplIsColorTransparent( aColor ) ) 1635cdf0e10cSrcweir { 1636cdf0e10cSrcweir if( mnDrawMode & DRAWMODE_BLACKLINE ) 1637cdf0e10cSrcweir { 1638cdf0e10cSrcweir aColor = Color( COL_BLACK ); 1639cdf0e10cSrcweir } 1640cdf0e10cSrcweir else if( mnDrawMode & DRAWMODE_WHITELINE ) 1641cdf0e10cSrcweir { 1642cdf0e10cSrcweir aColor = Color( COL_WHITE ); 1643cdf0e10cSrcweir } 1644cdf0e10cSrcweir else if( mnDrawMode & DRAWMODE_GRAYLINE ) 1645cdf0e10cSrcweir { 1646cdf0e10cSrcweir const sal_uInt8 cLum = aColor.GetLuminance(); 1647cdf0e10cSrcweir aColor = Color( cLum, cLum, cLum ); 1648cdf0e10cSrcweir } 1649cdf0e10cSrcweir else if( mnDrawMode & DRAWMODE_SETTINGSLINE ) 1650cdf0e10cSrcweir { 1651cdf0e10cSrcweir aColor = GetSettings().GetStyleSettings().GetFontColor(); 1652cdf0e10cSrcweir } 1653cdf0e10cSrcweir 1654cdf0e10cSrcweir if( mnDrawMode & DRAWMODE_GHOSTEDLINE ) 1655cdf0e10cSrcweir { 1656cdf0e10cSrcweir aColor = Color( ( aColor.GetRed() >> 1 ) | 0x80, 1657cdf0e10cSrcweir ( aColor.GetGreen() >> 1 ) | 0x80, 1658cdf0e10cSrcweir ( aColor.GetBlue() >> 1 ) | 0x80 ); 1659cdf0e10cSrcweir } 1660cdf0e10cSrcweir } 1661cdf0e10cSrcweir } 1662cdf0e10cSrcweir 1663cdf0e10cSrcweir if ( mpMetaFile ) 1664cdf0e10cSrcweir mpMetaFile->AddAction( new MetaPixelAction( rPt, aColor ) ); 1665cdf0e10cSrcweir 1666cdf0e10cSrcweir if ( !IsDeviceOutputNecessary() || ImplIsColorTransparent( aColor ) || ImplIsRecordLayout() ) 1667cdf0e10cSrcweir return; 1668cdf0e10cSrcweir 1669cdf0e10cSrcweir Point aPt = ImplLogicToDevicePixel( rPt ); 1670cdf0e10cSrcweir 1671cdf0e10cSrcweir // we need a graphics 1672cdf0e10cSrcweir if ( !mpGraphics ) 1673cdf0e10cSrcweir { 1674cdf0e10cSrcweir if ( !ImplGetGraphics() ) 1675cdf0e10cSrcweir return; 1676cdf0e10cSrcweir } 1677cdf0e10cSrcweir 1678cdf0e10cSrcweir if ( mbInitClipRegion ) 1679cdf0e10cSrcweir ImplInitClipRegion(); 1680cdf0e10cSrcweir if ( mbOutputClipped ) 1681cdf0e10cSrcweir return; 1682cdf0e10cSrcweir 1683cdf0e10cSrcweir mpGraphics->DrawPixel( aPt.X(), aPt.Y(), ImplColorToSal( aColor ), this ); 1684cdf0e10cSrcweir 1685cdf0e10cSrcweir if( mpAlphaVDev ) 1686cdf0e10cSrcweir mpAlphaVDev->DrawPixel( rPt ); 1687cdf0e10cSrcweir } 1688cdf0e10cSrcweir 1689cdf0e10cSrcweir // ----------------------------------------------------------------------- 1690cdf0e10cSrcweir 1691cdf0e10cSrcweir void OutputDevice::DrawPixel( const Polygon& rPts, const Color* pColors ) 1692cdf0e10cSrcweir { 1693cdf0e10cSrcweir if ( !pColors ) 1694cdf0e10cSrcweir DrawPixel( rPts, GetLineColor() ); 1695cdf0e10cSrcweir else 1696cdf0e10cSrcweir { 1697cdf0e10cSrcweir DBG_TRACE( "OutputDevice::DrawPixel()" ); 1698cdf0e10cSrcweir DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice ); 1699cdf0e10cSrcweir DBG_ASSERT( pColors, "OutputDevice::DrawPixel: No color array specified" ); 1700cdf0e10cSrcweir 1701cdf0e10cSrcweir const sal_uInt16 nSize = rPts.GetSize(); 1702cdf0e10cSrcweir 1703cdf0e10cSrcweir if ( nSize ) 1704cdf0e10cSrcweir { 1705cdf0e10cSrcweir if ( mpMetaFile ) 1706cdf0e10cSrcweir for ( sal_uInt16 i = 0; i < nSize; i++ ) 1707cdf0e10cSrcweir mpMetaFile->AddAction( new MetaPixelAction( rPts[ i ], pColors[ i ] ) ); 1708cdf0e10cSrcweir 1709cdf0e10cSrcweir if ( !IsDeviceOutputNecessary() || ImplIsRecordLayout() ) 1710cdf0e10cSrcweir return; 1711cdf0e10cSrcweir 1712cdf0e10cSrcweir // we need a graphics 1713cdf0e10cSrcweir if ( mpGraphics || ImplGetGraphics() ) 1714cdf0e10cSrcweir { 1715cdf0e10cSrcweir if ( mbInitClipRegion ) 1716cdf0e10cSrcweir ImplInitClipRegion(); 1717cdf0e10cSrcweir 1718cdf0e10cSrcweir if ( mbOutputClipped ) 1719cdf0e10cSrcweir return; 1720cdf0e10cSrcweir 1721cdf0e10cSrcweir for ( sal_uInt16 i = 0; i < nSize; i++ ) 1722cdf0e10cSrcweir { 1723cdf0e10cSrcweir const Point aPt( ImplLogicToDevicePixel( rPts[ i ] ) ); 1724cdf0e10cSrcweir mpGraphics->DrawPixel( aPt.X(), aPt.Y(), ImplColorToSal( pColors[ i ] ), this ); 1725cdf0e10cSrcweir } 1726cdf0e10cSrcweir } 1727cdf0e10cSrcweir } 1728cdf0e10cSrcweir } 1729cdf0e10cSrcweir 1730cdf0e10cSrcweir if( mpAlphaVDev ) 1731cdf0e10cSrcweir mpAlphaVDev->DrawPixel( rPts, pColors ); 1732cdf0e10cSrcweir } 1733cdf0e10cSrcweir 1734cdf0e10cSrcweir // ----------------------------------------------------------------------- 1735cdf0e10cSrcweir 1736cdf0e10cSrcweir void OutputDevice::DrawPixel( const Polygon& rPts, const Color& rColor ) 1737cdf0e10cSrcweir { 1738cdf0e10cSrcweir if( rColor != COL_TRANSPARENT && ! ImplIsRecordLayout() ) 1739cdf0e10cSrcweir { 1740cdf0e10cSrcweir const sal_uInt16 nSize = rPts.GetSize(); 1741cdf0e10cSrcweir Color* pColArray = new Color[ nSize ]; 1742cdf0e10cSrcweir 1743cdf0e10cSrcweir for( sal_uInt16 i = 0; i < nSize; i++ ) 1744cdf0e10cSrcweir pColArray[ i ] = rColor; 1745cdf0e10cSrcweir 1746cdf0e10cSrcweir DrawPixel( rPts, pColArray ); 1747cdf0e10cSrcweir delete[] pColArray; 1748cdf0e10cSrcweir } 1749cdf0e10cSrcweir 1750cdf0e10cSrcweir if( mpAlphaVDev ) 1751cdf0e10cSrcweir mpAlphaVDev->DrawPixel( rPts, rColor ); 1752cdf0e10cSrcweir } 1753cdf0e10cSrcweir 1754cdf0e10cSrcweir // ------------------------------------------------------------------------ 1755cdf0e10cSrcweir 1756cdf0e10cSrcweir namespace 1757cdf0e10cSrcweir { 1758cdf0e10cSrcweir sal_uInt8 lcl_calcColor( const sal_uInt8 nSourceColor, const sal_uInt8 nSourceOpaq, const sal_uInt8 nDestColor ) 1759cdf0e10cSrcweir { 1760cdf0e10cSrcweir int c = ( (int)nDestColor * ( 255 - nSourceOpaq ) ) 1761cdf0e10cSrcweir + (int)nSourceOpaq * (int)nSourceColor; 1762cdf0e10cSrcweir return sal_uInt8( c / 255 ); 1763cdf0e10cSrcweir } 1764cdf0e10cSrcweir } 1765cdf0e10cSrcweir 1766cdf0e10cSrcweir // ------------------------------------------------------------------------ 1767cdf0e10cSrcweir 1768cdf0e10cSrcweir Bitmap OutputDevice::ImplBlendWithAlpha( Bitmap aBmp, 1769cdf0e10cSrcweir BitmapReadAccess* pP, 1770cdf0e10cSrcweir BitmapReadAccess* pA, 1771cdf0e10cSrcweir const Rectangle& aDstRect, 1772cdf0e10cSrcweir const sal_Int32 nOffY, 1773cdf0e10cSrcweir const sal_Int32 nDstHeight, 1774cdf0e10cSrcweir const sal_Int32 nOffX, 1775cdf0e10cSrcweir const sal_Int32 nDstWidth, 1776cdf0e10cSrcweir const long* pMapX, 1777cdf0e10cSrcweir const long* pMapY ) 1778cdf0e10cSrcweir { 1779cdf0e10cSrcweir BitmapColor aDstCol,aSrcCol; 1780cdf0e10cSrcweir Bitmap res; 1781cdf0e10cSrcweir int nX, nOutX, nY, nOutY; 1782cdf0e10cSrcweir 1783cdf0e10cSrcweir OSL_ENSURE(mpAlphaVDev, 1784cdf0e10cSrcweir "ImplBlendWithAlpha(): call me only with valid alpha VDev!" ); 1785cdf0e10cSrcweir 1786cdf0e10cSrcweir sal_Bool bOldMapMode( mpAlphaVDev->IsMapModeEnabled() ); 1787cdf0e10cSrcweir mpAlphaVDev->EnableMapMode(sal_False); 1788cdf0e10cSrcweir 1789cdf0e10cSrcweir Bitmap aAlphaBitmap( mpAlphaVDev->GetBitmap( aDstRect.TopLeft(), aDstRect.GetSize() ) ); 1790cdf0e10cSrcweir BitmapWriteAccess* pAlphaW = aAlphaBitmap.AcquireWriteAccess(); 1791cdf0e10cSrcweir 1792cdf0e10cSrcweir if( GetBitCount() <= 8 ) 1793cdf0e10cSrcweir { 1794cdf0e10cSrcweir Bitmap aDither( aBmp.GetSizePixel(), 8 ); 1795cdf0e10cSrcweir BitmapColor aIndex( 0 ); 1796cdf0e10cSrcweir BitmapReadAccess* pB = aBmp.AcquireReadAccess(); 1797cdf0e10cSrcweir BitmapWriteAccess* pW = aDither.AcquireWriteAccess(); 1798cdf0e10cSrcweir 1799cdf0e10cSrcweir if( pB && pP && pA && pW && pAlphaW ) 1800cdf0e10cSrcweir { 1801cdf0e10cSrcweir for( nY = 0, nOutY = nOffY; nY < nDstHeight; nY++, nOutY++ ) 1802cdf0e10cSrcweir { 1803cdf0e10cSrcweir const long nMapY = pMapY[ nY ]; 1804cdf0e10cSrcweir const long nModY = ( nOutY & 0x0FL ) << 4L; 1805cdf0e10cSrcweir 1806cdf0e10cSrcweir for( nX = 0, nOutX = nOffX; nX < nDstWidth; nX++, nOutX++ ) 1807cdf0e10cSrcweir { 1808cdf0e10cSrcweir const long nMapX = pMapX[ nX ]; 1809cdf0e10cSrcweir const sal_uLong nD = nVCLDitherLut[ nModY | ( nOutX & 0x0FL ) ]; 1810cdf0e10cSrcweir 1811cdf0e10cSrcweir aSrcCol = pP->GetColor( nMapY, nMapX ); 1812cdf0e10cSrcweir aDstCol = pB->GetColor( nY, nX ); 181387bc88d3SHerbert Dürr const sal_uInt8 nSrcOpaq = 255 - pA->GetPixelIndex( nMapY, nMapX ); 181487bc88d3SHerbert Dürr const sal_uInt8 nDstOpaq = 255 - pAlphaW->GetPixelIndex( nY, nX ); 1815cdf0e10cSrcweir 1816cdf0e10cSrcweir aDstCol.SetRed( lcl_calcColor( aSrcCol.GetRed(), nSrcOpaq, aDstCol.GetRed() ) ); 1817cdf0e10cSrcweir aDstCol.SetBlue( lcl_calcColor( aSrcCol.GetBlue(), nSrcOpaq, aDstCol.GetBlue() ) ); 1818cdf0e10cSrcweir aDstCol.SetGreen( lcl_calcColor( aSrcCol.GetGreen(), nSrcOpaq, aDstCol.GetGreen() ) ); 1819cdf0e10cSrcweir 1820cdf0e10cSrcweir aIndex.SetIndex( (sal_uInt8) ( nVCLRLut[ ( nVCLLut[ aDstCol.GetRed() ] + nD ) >> 16UL ] + 1821cdf0e10cSrcweir nVCLGLut[ ( nVCLLut[ aDstCol.GetGreen() ] + nD ) >> 16UL ] + 1822cdf0e10cSrcweir nVCLBLut[ ( nVCLLut[ aDstCol.GetBlue() ] + nD ) >> 16UL ] ) ); 1823cdf0e10cSrcweir pW->SetPixel( nY, nX, aIndex ); 1824cdf0e10cSrcweir 1825cdf0e10cSrcweir // Have to perform the compositing 'algebra' in 1826cdf0e10cSrcweir // the inverse alpha space (with 255 meaning 1827cdf0e10cSrcweir // opaque), otherwise, transitivity is not 1828cdf0e10cSrcweir // achieved. 1829cdf0e10cSrcweir const sal_uInt8 nSrcAlpha = 255-COLOR_CHANNEL_MERGE( 255, (sal_uInt8)nDstOpaq, nSrcOpaq ); 1830cdf0e10cSrcweir 1831cdf0e10cSrcweir aIndex.SetIndex( (sal_uInt8) ( nVCLRLut[ ( nVCLLut[ nSrcAlpha ] + nD ) >> 16UL ] + 1832cdf0e10cSrcweir nVCLGLut[ ( nVCLLut[ nSrcAlpha ] + nD ) >> 16UL ] + 1833cdf0e10cSrcweir nVCLBLut[ ( nVCLLut[ nSrcAlpha ] + nD ) >> 16UL ] ) ); 1834cdf0e10cSrcweir pAlphaW->SetPixel( nY, nX, aIndex ); 1835cdf0e10cSrcweir } 1836cdf0e10cSrcweir } 1837cdf0e10cSrcweir } 1838cdf0e10cSrcweir 1839cdf0e10cSrcweir aBmp.ReleaseAccess( pB ); 1840cdf0e10cSrcweir aDither.ReleaseAccess( pW ); 1841cdf0e10cSrcweir res = aDither; 1842cdf0e10cSrcweir } 1843cdf0e10cSrcweir else 1844cdf0e10cSrcweir { 1845cdf0e10cSrcweir BitmapWriteAccess* pB = aBmp.AcquireWriteAccess(); 1846cdf0e10cSrcweir if( pP && pA && pB ) 1847cdf0e10cSrcweir { 1848cdf0e10cSrcweir for( nY = 0; nY < nDstHeight; nY++ ) 1849cdf0e10cSrcweir { 1850cdf0e10cSrcweir const long nMapY = pMapY[ nY ]; 1851cdf0e10cSrcweir 1852cdf0e10cSrcweir for( nX = 0; nX < nDstWidth; nX++ ) 1853cdf0e10cSrcweir { 1854cdf0e10cSrcweir const long nMapX = pMapX[ nX ]; 1855cdf0e10cSrcweir 1856cdf0e10cSrcweir aSrcCol = pP->GetColor( nMapY, nMapX ); 1857cdf0e10cSrcweir aDstCol = pB->GetColor( nY, nX ); 185887bc88d3SHerbert Dürr const sal_uInt8 nSrcOpaq = 255 - pA->GetPixelIndex( nMapY, nMapX ); 185987bc88d3SHerbert Dürr const sal_uInt8 nDstOpaq = 255 - pAlphaW->GetPixelIndex( nY, nX ); 1860cdf0e10cSrcweir 1861cdf0e10cSrcweir aDstCol.SetRed( lcl_calcColor( aSrcCol.GetRed(), nSrcOpaq, aDstCol.GetRed() ) ); 1862cdf0e10cSrcweir aDstCol.SetBlue( lcl_calcColor( aSrcCol.GetBlue(), nSrcOpaq, aDstCol.GetBlue() ) ); 1863cdf0e10cSrcweir aDstCol.SetGreen( lcl_calcColor( aSrcCol.GetGreen(), nSrcOpaq, aDstCol.GetGreen() ) ); 1864cdf0e10cSrcweir 1865cdf0e10cSrcweir pB->SetPixel( nY, nX, aDstCol ); 1866cdf0e10cSrcweir 1867cdf0e10cSrcweir // Have to perform the compositing 'algebra' in 1868cdf0e10cSrcweir // the inverse alpha space (with 255 meaning 1869cdf0e10cSrcweir // opaque), otherwise, transitivity is not 1870cdf0e10cSrcweir // achieved. 1871cdf0e10cSrcweir const sal_uInt8 nSrcAlpha = 255-COLOR_CHANNEL_MERGE( 255, (sal_uInt8)nDstOpaq, nSrcOpaq ); 1872cdf0e10cSrcweir 1873cdf0e10cSrcweir pAlphaW->SetPixel( nY, nX, Color(nSrcAlpha, nSrcAlpha, nSrcAlpha) ); 1874cdf0e10cSrcweir } 1875cdf0e10cSrcweir } 1876cdf0e10cSrcweir } 1877cdf0e10cSrcweir 1878cdf0e10cSrcweir aBmp.ReleaseAccess( pB ); 1879cdf0e10cSrcweir res = aBmp; 1880cdf0e10cSrcweir } 1881cdf0e10cSrcweir 1882cdf0e10cSrcweir aAlphaBitmap.ReleaseAccess( pAlphaW ); 1883cdf0e10cSrcweir mpAlphaVDev->DrawBitmap( aDstRect.TopLeft(), aAlphaBitmap ); 1884cdf0e10cSrcweir mpAlphaVDev->EnableMapMode( bOldMapMode ); 1885cdf0e10cSrcweir 1886cdf0e10cSrcweir return res; 1887cdf0e10cSrcweir } 1888cdf0e10cSrcweir 1889cdf0e10cSrcweir // ------------------------------------------------------------------------ 1890cdf0e10cSrcweir 1891cdf0e10cSrcweir Bitmap OutputDevice::ImplBlend( Bitmap aBmp, 1892cdf0e10cSrcweir BitmapReadAccess* pP, 1893cdf0e10cSrcweir BitmapReadAccess* pA, 1894cdf0e10cSrcweir const sal_Int32 nOffY, 1895cdf0e10cSrcweir const sal_Int32 nDstHeight, 1896cdf0e10cSrcweir const sal_Int32 nOffX, 1897cdf0e10cSrcweir const sal_Int32 nDstWidth, 1898cdf0e10cSrcweir const Rectangle& aBmpRect, 1899cdf0e10cSrcweir const Size& aOutSz, 1900cdf0e10cSrcweir const bool bHMirr, 1901cdf0e10cSrcweir const bool bVMirr, 1902cdf0e10cSrcweir const long* pMapX, 1903cdf0e10cSrcweir const long* pMapY ) 1904cdf0e10cSrcweir { 1905cdf0e10cSrcweir BitmapColor aDstCol; 1906cdf0e10cSrcweir Bitmap res; 1907cdf0e10cSrcweir int nX, nOutX, nY, nOutY; 1908cdf0e10cSrcweir 1909cdf0e10cSrcweir if( GetBitCount() <= 8 ) 1910cdf0e10cSrcweir { 1911cdf0e10cSrcweir Bitmap aDither( aBmp.GetSizePixel(), 8 ); 1912cdf0e10cSrcweir BitmapColor aIndex( 0 ); 1913cdf0e10cSrcweir BitmapReadAccess* pB = aBmp.AcquireReadAccess(); 1914cdf0e10cSrcweir BitmapWriteAccess* pW = aDither.AcquireWriteAccess(); 1915cdf0e10cSrcweir 1916cdf0e10cSrcweir if( pB && pP && pA && pW ) 1917cdf0e10cSrcweir { 1918cdf0e10cSrcweir for( nY = 0, nOutY = nOffY; nY < nDstHeight; nY++, nOutY++ ) 1919cdf0e10cSrcweir { 1920cdf0e10cSrcweir const long nMapY = pMapY[ nY ]; 1921cdf0e10cSrcweir const long nModY = ( nOutY & 0x0FL ) << 4L; 1922cdf0e10cSrcweir 1923cdf0e10cSrcweir for( nX = 0, nOutX = nOffX; nX < nDstWidth; nX++, nOutX++ ) 1924cdf0e10cSrcweir { 1925cdf0e10cSrcweir const long nMapX = pMapX[ nX ]; 1926cdf0e10cSrcweir const sal_uLong nD = nVCLDitherLut[ nModY | ( nOutX & 0x0FL ) ]; 1927cdf0e10cSrcweir 1928cdf0e10cSrcweir aDstCol = pB->GetColor( nY, nX ); 192987bc88d3SHerbert Dürr aDstCol.Merge( pP->GetColor( nMapY, nMapX ), pA->GetPixelIndex( nMapY, nMapX ) ); 1930cdf0e10cSrcweir aIndex.SetIndex( (sal_uInt8) ( nVCLRLut[ ( nVCLLut[ aDstCol.GetRed() ] + nD ) >> 16UL ] + 1931cdf0e10cSrcweir nVCLGLut[ ( nVCLLut[ aDstCol.GetGreen() ] + nD ) >> 16UL ] + 1932cdf0e10cSrcweir nVCLBLut[ ( nVCLLut[ aDstCol.GetBlue() ] + nD ) >> 16UL ] ) ); 1933cdf0e10cSrcweir pW->SetPixel( nY, nX, aIndex ); 1934cdf0e10cSrcweir } 1935cdf0e10cSrcweir } 1936cdf0e10cSrcweir } 1937cdf0e10cSrcweir 1938cdf0e10cSrcweir aBmp.ReleaseAccess( pB ); 1939cdf0e10cSrcweir aDither.ReleaseAccess( pW ); 1940cdf0e10cSrcweir res = aDither; 1941cdf0e10cSrcweir } 1942cdf0e10cSrcweir else 1943cdf0e10cSrcweir { 1944cdf0e10cSrcweir BitmapWriteAccess* pB = aBmp.AcquireWriteAccess(); 1945cdf0e10cSrcweir 1946cdf0e10cSrcweir bool bFastBlend = false; 1947cdf0e10cSrcweir if( pP && pA && pB ) 1948cdf0e10cSrcweir { 1949cdf0e10cSrcweir SalTwoRect aTR; 1950cdf0e10cSrcweir aTR.mnSrcX = aBmpRect.Left(); 1951cdf0e10cSrcweir aTR.mnSrcY = aBmpRect.Top(); 1952cdf0e10cSrcweir aTR.mnSrcWidth = aBmpRect.GetWidth(); 1953cdf0e10cSrcweir aTR.mnSrcHeight = aBmpRect.GetHeight(); 1954cdf0e10cSrcweir aTR.mnDestX = nOffX; 1955cdf0e10cSrcweir aTR.mnDestY = nOffY; 1956cdf0e10cSrcweir aTR.mnDestWidth = aOutSz.Width(); 1957cdf0e10cSrcweir aTR.mnDestHeight= aOutSz.Height(); 1958cdf0e10cSrcweir 1959cdf0e10cSrcweir if( !bHMirr || !bVMirr ) 1960cdf0e10cSrcweir bFastBlend = ImplFastBitmapBlending( *pB,*pP,*pA, aTR ); 1961cdf0e10cSrcweir } 1962cdf0e10cSrcweir 1963cdf0e10cSrcweir if( pP && pA && pB && !bFastBlend ) 1964cdf0e10cSrcweir { 1965cdf0e10cSrcweir switch( pP->GetScanlineFormat() ) 1966cdf0e10cSrcweir { 1967cdf0e10cSrcweir case( BMP_FORMAT_8BIT_PAL ): 1968cdf0e10cSrcweir { 1969cdf0e10cSrcweir for( nY = 0; nY < nDstHeight; nY++ ) 1970cdf0e10cSrcweir { 1971cdf0e10cSrcweir const long nMapY = pMapY[ nY ]; 1972cdf0e10cSrcweir Scanline pPScan = pP->GetScanline( nMapY ); 1973cdf0e10cSrcweir Scanline pAScan = pA->GetScanline( nMapY ); 1974cdf0e10cSrcweir 1975cdf0e10cSrcweir for( nX = 0; nX < nDstWidth; nX++ ) 1976cdf0e10cSrcweir { 1977cdf0e10cSrcweir const long nMapX = pMapX[ nX ]; 1978cdf0e10cSrcweir aDstCol = pB->GetPixel( nY, nX ); 1979cdf0e10cSrcweir pB->SetPixel( nY, nX, aDstCol.Merge( pP->GetPaletteColor( pPScan[ nMapX ] ), 1980cdf0e10cSrcweir pAScan[ nMapX ] ) ); 1981cdf0e10cSrcweir } 1982cdf0e10cSrcweir } 1983cdf0e10cSrcweir } 1984cdf0e10cSrcweir break; 1985cdf0e10cSrcweir 1986cdf0e10cSrcweir case( BMP_FORMAT_24BIT_TC_BGR ): 1987cdf0e10cSrcweir { 1988cdf0e10cSrcweir for( nY = 0; nY < nDstHeight; nY++ ) 1989cdf0e10cSrcweir { 1990cdf0e10cSrcweir const long nMapY = pMapY[ nY ]; 1991cdf0e10cSrcweir Scanline pPScan = pP->GetScanline( nMapY ); 1992cdf0e10cSrcweir Scanline pAScan = pA->GetScanline( nMapY ); 1993cdf0e10cSrcweir 1994cdf0e10cSrcweir for( nX = 0; nX < nDstWidth; nX++ ) 1995cdf0e10cSrcweir { 1996cdf0e10cSrcweir const long nMapX = pMapX[ nX ]; 1997cdf0e10cSrcweir Scanline pTmp = pPScan + nMapX * 3; 1998cdf0e10cSrcweir 1999cdf0e10cSrcweir aDstCol = pB->GetPixel( nY, nX ); 2000cdf0e10cSrcweir pB->SetPixel( nY, nX, aDstCol.Merge( pTmp[ 2 ], pTmp[ 1 ], pTmp[ 0 ], 2001cdf0e10cSrcweir pAScan[ nMapX ] ) ); 2002cdf0e10cSrcweir } 2003cdf0e10cSrcweir } 2004cdf0e10cSrcweir } 2005cdf0e10cSrcweir break; 2006cdf0e10cSrcweir 2007cdf0e10cSrcweir case( BMP_FORMAT_24BIT_TC_RGB ): 2008cdf0e10cSrcweir { 2009cdf0e10cSrcweir for( nY = 0; nY < nDstHeight; nY++ ) 2010cdf0e10cSrcweir { 2011cdf0e10cSrcweir const long nMapY = pMapY[ nY ]; 2012cdf0e10cSrcweir Scanline pPScan = pP->GetScanline( nMapY ); 2013cdf0e10cSrcweir Scanline pAScan = pA->GetScanline( nMapY ); 2014cdf0e10cSrcweir 2015cdf0e10cSrcweir for( nX = 0; nX < nDstWidth; nX++ ) 2016cdf0e10cSrcweir { 2017cdf0e10cSrcweir const long nMapX = pMapX[ nX ]; 2018cdf0e10cSrcweir Scanline pTmp = pPScan + nMapX * 3; 2019cdf0e10cSrcweir 2020cdf0e10cSrcweir aDstCol = pB->GetPixel( nY, nX ); 2021cdf0e10cSrcweir pB->SetPixel( nY, nX, aDstCol.Merge( pTmp[ 0 ], pTmp[ 1 ], pTmp[ 2 ], 2022cdf0e10cSrcweir pAScan[ nMapX ] ) ); 2023cdf0e10cSrcweir } 2024cdf0e10cSrcweir } 2025cdf0e10cSrcweir } 2026cdf0e10cSrcweir break; 2027cdf0e10cSrcweir 2028cdf0e10cSrcweir default: 2029cdf0e10cSrcweir { 2030cdf0e10cSrcweir for( nY = 0; nY < nDstHeight; nY++ ) 2031cdf0e10cSrcweir { 2032cdf0e10cSrcweir const long nMapY = pMapY[ nY ]; 2033cdf0e10cSrcweir Scanline pAScan = pA->GetScanline( nMapY ); 2034cdf0e10cSrcweir 2035cdf0e10cSrcweir for( nX = 0; nX < nDstWidth; nX++ ) 2036cdf0e10cSrcweir { 2037cdf0e10cSrcweir const long nMapX = pMapX[ nX ]; 2038cdf0e10cSrcweir aDstCol = pB->GetPixel( nY, nX ); 2039cdf0e10cSrcweir pB->SetPixel( nY, nX, aDstCol.Merge( pP->GetColor( nMapY, nMapX ), 2040cdf0e10cSrcweir pAScan[ nMapX ] ) ); 2041cdf0e10cSrcweir } 2042cdf0e10cSrcweir } 2043cdf0e10cSrcweir } 2044cdf0e10cSrcweir break; 2045cdf0e10cSrcweir } 2046cdf0e10cSrcweir } 2047cdf0e10cSrcweir 2048cdf0e10cSrcweir aBmp.ReleaseAccess( pB ); 2049cdf0e10cSrcweir res = aBmp; 2050cdf0e10cSrcweir } 2051cdf0e10cSrcweir 2052cdf0e10cSrcweir return res; 2053cdf0e10cSrcweir } 2054cdf0e10cSrcweir 2055cdf0e10cSrcweir // ------------------------------------------------------------------------ 2056cdf0e10cSrcweir 2057cdf0e10cSrcweir void OutputDevice::ImplDrawAlpha( const Bitmap& rBmp, const AlphaMask& rAlpha, 2058cdf0e10cSrcweir const Point& rDestPt, const Size& rDestSize, 2059cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel ) 2060cdf0e10cSrcweir { 2061cdf0e10cSrcweir const Point aNullPt; 2062cdf0e10cSrcweir Point aOutPt( LogicToPixel( rDestPt ) ); 2063cdf0e10cSrcweir Size aOutSz( LogicToPixel( rDestSize ) ); 2064cdf0e10cSrcweir Rectangle aDstRect( aNullPt, GetOutputSizePixel() ); 2065cdf0e10cSrcweir const sal_Bool bHMirr = aOutSz.Width() < 0, bVMirr = aOutSz.Height() < 0; 2066cdf0e10cSrcweir 2067cdf0e10cSrcweir if( OUTDEV_WINDOW == meOutDevType ) 2068cdf0e10cSrcweir { 2069cdf0e10cSrcweir const Region aPaintRgn( ( (Window*) this )->GetPaintRegion() ); 2070cdf0e10cSrcweir 2071cdf0e10cSrcweir if( !aPaintRgn.IsNull() ) 2072cdf0e10cSrcweir aDstRect.Intersection( LogicToPixel( aPaintRgn.GetBoundRect() ) ); 2073cdf0e10cSrcweir } 2074cdf0e10cSrcweir 2075cdf0e10cSrcweir if( bHMirr ) 2076cdf0e10cSrcweir { 2077cdf0e10cSrcweir aOutSz.Width() = -aOutSz.Width(); 2078cdf0e10cSrcweir aOutPt.X() -= ( aOutSz.Width() - 1L ); 2079cdf0e10cSrcweir } 2080cdf0e10cSrcweir 2081cdf0e10cSrcweir if( bVMirr ) 2082cdf0e10cSrcweir { 2083cdf0e10cSrcweir aOutSz.Height() = -aOutSz.Height(); 2084cdf0e10cSrcweir aOutPt.Y() -= ( aOutSz.Height() - 1L ); 2085cdf0e10cSrcweir } 2086cdf0e10cSrcweir 2087cdf0e10cSrcweir if( !aDstRect.Intersection( Rectangle( aOutPt, aOutSz ) ).IsEmpty() ) 2088cdf0e10cSrcweir { 2089cdf0e10cSrcweir bool bNativeAlpha = false; 2090cdf0e10cSrcweir static const char* pDisableNative = getenv( "SAL_DISABLE_NATIVE_ALPHA"); 2091cdf0e10cSrcweir // #i83087# Naturally, system alpha blending cannot work with 2092cdf0e10cSrcweir // separate alpha VDev 2093*5f27b83cSArmin Le Grand bool bTryDirectPaint(!mpAlphaVDev && !pDisableNative && !bHMirr && !bVMirr); 2094*5f27b83cSArmin Le Grand 2095*5f27b83cSArmin Le Grand #ifdef WNT 2096*5f27b83cSArmin Le Grand if(bTryDirectPaint) 2097*5f27b83cSArmin Le Grand { 2098*5f27b83cSArmin Le Grand // only paint direct when no scaling and no MapMode, else the 2099*5f27b83cSArmin Le Grand // more expensive conversions may be done for short-time Bitmap/BitmapEx 2100*5f27b83cSArmin Le Grand // used for buffering only 2101*5f27b83cSArmin Le Grand if(!IsMapMode() && rSrcSizePixel.Width() == aOutSz.Width() && rSrcSizePixel.Height() == aOutSz.Height()) 2102*5f27b83cSArmin Le Grand { 2103*5f27b83cSArmin Le Grand bTryDirectPaint = false; 2104*5f27b83cSArmin Le Grand } 2105*5f27b83cSArmin Le Grand } 2106*5f27b83cSArmin Le Grand #endif 2107*5f27b83cSArmin Le Grand 2108*5f27b83cSArmin Le Grand if(bTryDirectPaint) 2109cdf0e10cSrcweir { 2110cdf0e10cSrcweir Point aRelPt = aOutPt + Point( mnOutOffX, mnOutOffY ); 2111cdf0e10cSrcweir SalTwoRect aTR = { 2112cdf0e10cSrcweir rSrcPtPixel.X(), rSrcPtPixel.Y(), 2113cdf0e10cSrcweir rSrcSizePixel.Width(), rSrcSizePixel.Height(), 2114cdf0e10cSrcweir aRelPt.X(), aRelPt.Y(), 2115cdf0e10cSrcweir aOutSz.Width(), aOutSz.Height() 2116cdf0e10cSrcweir }; 2117cdf0e10cSrcweir SalBitmap* pSalSrcBmp = rBmp.ImplGetImpBitmap()->ImplGetSalBitmap(); 2118cdf0e10cSrcweir SalBitmap* pSalAlphaBmp = rAlpha.ImplGetImpBitmap()->ImplGetSalBitmap(); 2119cdf0e10cSrcweir bNativeAlpha = mpGraphics->DrawAlphaBitmap( aTR, *pSalSrcBmp, *pSalAlphaBmp, this ); 2120cdf0e10cSrcweir } 2121cdf0e10cSrcweir 2122cdf0e10cSrcweir VirtualDevice* pOldVDev = mpAlphaVDev; 2123cdf0e10cSrcweir 2124cdf0e10cSrcweir Rectangle aBmpRect( aNullPt, rBmp.GetSizePixel() ); 2125cdf0e10cSrcweir if( !bNativeAlpha 2126cdf0e10cSrcweir && !aBmpRect.Intersection( Rectangle( rSrcPtPixel, rSrcSizePixel ) ).IsEmpty() ) 2127cdf0e10cSrcweir { 2128cdf0e10cSrcweir GDIMetaFile* pOldMetaFile = mpMetaFile; mpMetaFile = NULL; 2129cdf0e10cSrcweir const sal_Bool bOldMap = mbMap; mbMap = sal_False; 2130cdf0e10cSrcweir Bitmap aBmp( GetBitmap( aDstRect.TopLeft(), aDstRect.GetSize() ) ); 2131cdf0e10cSrcweir 2132cdf0e10cSrcweir // #109044# The generated bitmap need not necessarily be 2133cdf0e10cSrcweir // of aDstRect dimensions, it's internally clipped to 2134cdf0e10cSrcweir // window bounds. Thus, we correct the dest size here, 2135cdf0e10cSrcweir // since we later use it (in nDstWidth/Height) for pixel 2136cdf0e10cSrcweir // access) 2137cdf0e10cSrcweir // #i38887# reading from screen may sometimes fail 2138cdf0e10cSrcweir if( aBmp.ImplGetImpBitmap() ) 2139cdf0e10cSrcweir aDstRect.SetSize( aBmp.GetSizePixel() ); 2140cdf0e10cSrcweir 2141cdf0e10cSrcweir BitmapColor aDstCol; 2142cdf0e10cSrcweir const long nSrcWidth = aBmpRect.GetWidth(), nSrcHeight = aBmpRect.GetHeight(); 2143cdf0e10cSrcweir const long nDstWidth = aDstRect.GetWidth(), nDstHeight = aDstRect.GetHeight(); 2144cdf0e10cSrcweir const long nOutWidth = aOutSz.Width(), nOutHeight = aOutSz.Height(); 2145cdf0e10cSrcweir // calculate offset in original bitmap 2146cdf0e10cSrcweir // in RTL case this is a little more complicated since the contents of the 2147cdf0e10cSrcweir // bitmap is not mirrored (it never is), however the paint region and bmp region 2148cdf0e10cSrcweir // are in mirrored coordinates, so the intersection of (aOutPt,aOutSz) with these 2149cdf0e10cSrcweir // is content wise somewhere else and needs to take mirroring into account 2150cdf0e10cSrcweir const long nOffX = IsRTLEnabled() 2151cdf0e10cSrcweir ? aOutSz.Width() - aDstRect.GetWidth() - (aDstRect.Left() - aOutPt.X()) 2152cdf0e10cSrcweir : aDstRect.Left() - aOutPt.X(), 2153cdf0e10cSrcweir nOffY = aDstRect.Top() - aOutPt.Y(); 2154cdf0e10cSrcweir long nX, nOutX, nY, nOutY; 2155cdf0e10cSrcweir long nMirrOffX = 0; 2156cdf0e10cSrcweir long nMirrOffY = 0; 2157cdf0e10cSrcweir long* pMapX = new long[ nDstWidth ]; 2158cdf0e10cSrcweir long* pMapY = new long[ nDstHeight ]; 2159cdf0e10cSrcweir 2160cdf0e10cSrcweir // create horizontal mapping table 2161cdf0e10cSrcweir if( bHMirr ) 2162cdf0e10cSrcweir nMirrOffX = ( aBmpRect.Left() << 1 ) + nSrcWidth - 1; 2163cdf0e10cSrcweir 2164cdf0e10cSrcweir for( nX = 0L, nOutX = nOffX; nX < nDstWidth; nX++, nOutX++ ) 2165cdf0e10cSrcweir { 2166cdf0e10cSrcweir pMapX[ nX ] = aBmpRect.Left() + nOutX * nSrcWidth / nOutWidth; 2167cdf0e10cSrcweir if( bHMirr ) 2168cdf0e10cSrcweir pMapX[ nX ] = nMirrOffX - pMapX[ nX ]; 2169cdf0e10cSrcweir } 2170cdf0e10cSrcweir 2171cdf0e10cSrcweir // create vertical mapping table 2172cdf0e10cSrcweir if( bVMirr ) 2173cdf0e10cSrcweir nMirrOffY = ( aBmpRect.Top() << 1 ) + nSrcHeight - 1; 2174cdf0e10cSrcweir 2175cdf0e10cSrcweir for( nY = 0L, nOutY = nOffY; nY < nDstHeight; nY++, nOutY++ ) 2176cdf0e10cSrcweir { 2177cdf0e10cSrcweir pMapY[ nY ] = aBmpRect.Top() + nOutY * nSrcHeight / nOutHeight; 2178cdf0e10cSrcweir 2179cdf0e10cSrcweir if( bVMirr ) 2180cdf0e10cSrcweir pMapY[ nY ] = nMirrOffY - pMapY[ nY ]; 2181cdf0e10cSrcweir } 2182cdf0e10cSrcweir 2183cdf0e10cSrcweir BitmapReadAccess* pP = ( (Bitmap&) rBmp ).AcquireReadAccess(); 2184cdf0e10cSrcweir BitmapReadAccess* pA = ( (AlphaMask&) rAlpha ).AcquireReadAccess(); 2185cdf0e10cSrcweir 2186cdf0e10cSrcweir DBG_ASSERT( pA->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL || 2187cdf0e10cSrcweir pA->GetScanlineFormat() == BMP_FORMAT_8BIT_TC_MASK, 2188cdf0e10cSrcweir "OutputDevice::ImplDrawAlpha(): non-8bit alpha no longer supported!" ); 2189cdf0e10cSrcweir 2190cdf0e10cSrcweir // #i38887# reading from screen may sometimes fail 2191cdf0e10cSrcweir if( aBmp.ImplGetImpBitmap() ) 2192cdf0e10cSrcweir { 2193cdf0e10cSrcweir Bitmap aTmp; 2194cdf0e10cSrcweir 2195cdf0e10cSrcweir if( mpAlphaVDev ) 2196cdf0e10cSrcweir { 2197cdf0e10cSrcweir aTmp = ImplBlendWithAlpha( 2198cdf0e10cSrcweir aBmp,pP,pA, 2199cdf0e10cSrcweir aDstRect, 2200cdf0e10cSrcweir nOffY,nDstHeight, 2201cdf0e10cSrcweir nOffX,nDstWidth, 2202cdf0e10cSrcweir pMapX,pMapY ); 2203cdf0e10cSrcweir } 2204cdf0e10cSrcweir else 2205cdf0e10cSrcweir { 2206cdf0e10cSrcweir aTmp = ImplBlend( 2207cdf0e10cSrcweir aBmp,pP,pA, 2208cdf0e10cSrcweir nOffY,nDstHeight, 2209cdf0e10cSrcweir nOffX,nDstWidth, 2210cdf0e10cSrcweir aBmpRect,aOutSz, 2211cdf0e10cSrcweir bHMirr,bVMirr, 2212cdf0e10cSrcweir pMapX,pMapY ); 2213cdf0e10cSrcweir } 2214cdf0e10cSrcweir 2215cdf0e10cSrcweir // #110958# Disable alpha VDev, we're doing the necessary 2216cdf0e10cSrcweir // stuff explicitely furher below 2217cdf0e10cSrcweir if( mpAlphaVDev ) 2218cdf0e10cSrcweir mpAlphaVDev = NULL; 2219cdf0e10cSrcweir 2220cdf0e10cSrcweir DrawBitmap( aDstRect.TopLeft(), 2221cdf0e10cSrcweir aTmp ); 2222cdf0e10cSrcweir 2223cdf0e10cSrcweir // #110958# Enable alpha VDev again 2224cdf0e10cSrcweir mpAlphaVDev = pOldVDev; 2225cdf0e10cSrcweir } 2226cdf0e10cSrcweir 2227cdf0e10cSrcweir ( (Bitmap&) rBmp ).ReleaseAccess( pP ); 2228cdf0e10cSrcweir ( (AlphaMask&) rAlpha ).ReleaseAccess( pA ); 2229cdf0e10cSrcweir 2230cdf0e10cSrcweir delete[] pMapX; 2231cdf0e10cSrcweir delete[] pMapY; 2232cdf0e10cSrcweir mbMap = bOldMap; 2233cdf0e10cSrcweir mpMetaFile = pOldMetaFile; 2234cdf0e10cSrcweir } 2235cdf0e10cSrcweir } 2236cdf0e10cSrcweir } 2237cdf0e10cSrcweir 2238cdf0e10cSrcweir // ------------------------------------------------------------------------ 2239cdf0e10cSrcweir 2240cdf0e10cSrcweir void OutputDevice::ImplPrintTransparent( const Bitmap& rBmp, const Bitmap& rMask, 2241cdf0e10cSrcweir const Point& rDestPt, const Size& rDestSize, 2242cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel ) 2243cdf0e10cSrcweir { 2244cdf0e10cSrcweir Point aPt; 2245cdf0e10cSrcweir Point aDestPt( LogicToPixel( rDestPt ) ); 2246cdf0e10cSrcweir Size aDestSz( LogicToPixel( rDestSize ) ); 2247cdf0e10cSrcweir Rectangle aSrcRect( rSrcPtPixel, rSrcSizePixel ); 2248cdf0e10cSrcweir 2249cdf0e10cSrcweir aSrcRect.Justify(); 2250cdf0e10cSrcweir 2251cdf0e10cSrcweir if( !rBmp.IsEmpty() && aSrcRect.GetWidth() && aSrcRect.GetHeight() && aDestSz.Width() && aDestSz.Height() ) 2252cdf0e10cSrcweir { 2253cdf0e10cSrcweir Bitmap aPaint( rBmp ), aMask( rMask ); 2254cdf0e10cSrcweir sal_uLong nMirrFlags = 0UL; 2255cdf0e10cSrcweir 2256cdf0e10cSrcweir if( aMask.GetBitCount() > 1 ) 2257cdf0e10cSrcweir aMask.Convert( BMP_CONVERSION_1BIT_THRESHOLD ); 2258cdf0e10cSrcweir 2259cdf0e10cSrcweir // mirrored horizontically 2260cdf0e10cSrcweir if( aDestSz.Width() < 0L ) 2261cdf0e10cSrcweir { 2262cdf0e10cSrcweir aDestSz.Width() = -aDestSz.Width(); 2263cdf0e10cSrcweir aDestPt.X() -= ( aDestSz.Width() - 1L ); 2264cdf0e10cSrcweir nMirrFlags |= BMP_MIRROR_HORZ; 2265cdf0e10cSrcweir } 2266cdf0e10cSrcweir 2267cdf0e10cSrcweir // mirrored vertically 2268cdf0e10cSrcweir if( aDestSz.Height() < 0L ) 2269cdf0e10cSrcweir { 2270cdf0e10cSrcweir aDestSz.Height() = -aDestSz.Height(); 2271cdf0e10cSrcweir aDestPt.Y() -= ( aDestSz.Height() - 1L ); 2272cdf0e10cSrcweir nMirrFlags |= BMP_MIRROR_VERT; 2273cdf0e10cSrcweir } 2274cdf0e10cSrcweir 2275cdf0e10cSrcweir // source cropped? 2276cdf0e10cSrcweir if( aSrcRect != Rectangle( aPt, aPaint.GetSizePixel() ) ) 2277cdf0e10cSrcweir { 2278cdf0e10cSrcweir aPaint.Crop( aSrcRect ); 2279cdf0e10cSrcweir aMask.Crop( aSrcRect ); 2280cdf0e10cSrcweir } 2281cdf0e10cSrcweir 2282cdf0e10cSrcweir // destination mirrored 2283cdf0e10cSrcweir if( nMirrFlags ) 2284cdf0e10cSrcweir { 2285cdf0e10cSrcweir aPaint.Mirror( nMirrFlags ); 2286cdf0e10cSrcweir aMask.Mirror( nMirrFlags ); 2287cdf0e10cSrcweir } 2288cdf0e10cSrcweir 2289cdf0e10cSrcweir // we always want to have a mask 2290cdf0e10cSrcweir if( aMask.IsEmpty() ) 2291cdf0e10cSrcweir { 2292cdf0e10cSrcweir aMask = Bitmap( aSrcRect.GetSize(), 1 ); 2293cdf0e10cSrcweir aMask.Erase( Color( COL_BLACK ) ); 2294cdf0e10cSrcweir } 2295cdf0e10cSrcweir 2296cdf0e10cSrcweir // do painting 2297cdf0e10cSrcweir const long nSrcWidth = aSrcRect.GetWidth(), nSrcHeight = aSrcRect.GetHeight(); 2298e6f63103SArmin Le Grand long nX, nY; // , nWorkX, nWorkY, nWorkWidth, nWorkHeight; 2299cdf0e10cSrcweir long* pMapX = new long[ nSrcWidth + 1 ]; 2300cdf0e10cSrcweir long* pMapY = new long[ nSrcHeight + 1 ]; 2301cdf0e10cSrcweir const sal_Bool bOldMap = mbMap; 2302cdf0e10cSrcweir 2303cdf0e10cSrcweir mbMap = sal_False; 2304cdf0e10cSrcweir 2305cdf0e10cSrcweir // create forward mapping tables 2306cdf0e10cSrcweir for( nX = 0L; nX <= nSrcWidth; nX++ ) 2307cdf0e10cSrcweir pMapX[ nX ] = aDestPt.X() + FRound( (double) aDestSz.Width() * nX / nSrcWidth ); 2308cdf0e10cSrcweir 2309cdf0e10cSrcweir for( nY = 0L; nY <= nSrcHeight; nY++ ) 2310cdf0e10cSrcweir pMapY[ nY ] = aDestPt.Y() + FRound( (double) aDestSz.Height() * nY / nSrcHeight ); 2311cdf0e10cSrcweir 2312cdf0e10cSrcweir // walk through all rectangles of mask 2313e6f63103SArmin Le Grand const Region aWorkRgn(aMask.CreateRegion(COL_BLACK, Rectangle(Point(), aMask.GetSizePixel()))); 2314e6f63103SArmin Le Grand RectangleVector aRectangles; 2315e6f63103SArmin Le Grand aWorkRgn.GetRegionRectangles(aRectangles); 2316cdf0e10cSrcweir 2317e6f63103SArmin Le Grand for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++) 2318e6f63103SArmin Le Grand { 2319e6f63103SArmin Le Grand const Point aMapPt(pMapX[aRectIter->Left()], pMapY[aRectIter->Top()]); 2320e6f63103SArmin Le Grand const Size aMapSz( 2321e6f63103SArmin Le Grand pMapX[aRectIter->Right() + 1] - aMapPt.X(), // pMapX[L + W] -> L + ((R - L) + 1) -> R + 1 2322e6f63103SArmin Le Grand pMapY[aRectIter->Bottom() + 1] - aMapPt.Y()); // same for Y 2323e6f63103SArmin Le Grand Bitmap aBandBmp(aPaint); 2324e6f63103SArmin Le Grand 2325e6f63103SArmin Le Grand aBandBmp.Crop(*aRectIter); 2326e6f63103SArmin Le Grand ImplDrawBitmap(aMapPt, aMapSz, Point(), aBandBmp.GetSizePixel(), aBandBmp, META_BMPSCALEPART_ACTION); 2327e6f63103SArmin Le Grand } 2328e6f63103SArmin Le Grand 2329e6f63103SArmin Le Grand //Region aWorkRgn( aMask.CreateRegion( COL_BLACK, Rectangle( Point(), aMask.GetSizePixel() ) ) ); 2330e6f63103SArmin Le Grand //ImplRegionInfo aInfo; 2331e6f63103SArmin Le Grand //sal_Bool bRgnRect = aWorkRgn.ImplGetFirstRect( aInfo, nWorkX, nWorkY, nWorkWidth, nWorkHeight ); 2332e6f63103SArmin Le Grand // 2333e6f63103SArmin Le Grand //while( bRgnRect ) 2334e6f63103SArmin Le Grand //{ 2335e6f63103SArmin Le Grand // Bitmap aBandBmp( aPaint ); 2336e6f63103SArmin Le Grand // const Rectangle aBandRect( Point( nWorkX, nWorkY ), Size( nWorkWidth, nWorkHeight ) ); 2337e6f63103SArmin Le Grand // const Point aMapPt( pMapX[ nWorkX ], pMapY[ nWorkY ] ); 2338e6f63103SArmin Le Grand // const Size aMapSz( pMapX[ nWorkX + nWorkWidth ] - aMapPt.X(), pMapY[ nWorkY + nWorkHeight ] - aMapPt.Y() ); 2339e6f63103SArmin Le Grand // 2340e6f63103SArmin Le Grand // aBandBmp.Crop( aBandRect ); 2341e6f63103SArmin Le Grand // ImplDrawBitmap( aMapPt, aMapSz, Point(), aBandBmp.GetSizePixel(), aBandBmp, META_BMPSCALEPART_ACTION ); 2342e6f63103SArmin Le Grand // bRgnRect = aWorkRgn.ImplGetNextRect( aInfo, nWorkX, nWorkY, nWorkWidth, nWorkHeight ); 2343e6f63103SArmin Le Grand //} 2344cdf0e10cSrcweir 2345cdf0e10cSrcweir mbMap = bOldMap; 2346cdf0e10cSrcweir 2347cdf0e10cSrcweir delete[] pMapX; 2348cdf0e10cSrcweir delete[] pMapY; 2349cdf0e10cSrcweir } 2350cdf0e10cSrcweir } 2351cdf0e10cSrcweir 2352cdf0e10cSrcweir // ------------------------------------------------------------------------ 2353cdf0e10cSrcweir 2354cdf0e10cSrcweir void OutputDevice::ImplPrintMask( const Bitmap& rMask, const Color& rMaskColor, 2355cdf0e10cSrcweir const Point& rDestPt, const Size& rDestSize, 2356cdf0e10cSrcweir const Point& rSrcPtPixel, const Size& rSrcSizePixel ) 2357cdf0e10cSrcweir { 2358cdf0e10cSrcweir Point aPt; 2359cdf0e10cSrcweir Point aDestPt( LogicToPixel( rDestPt ) ); 2360cdf0e10cSrcweir Size aDestSz( LogicToPixel( rDestSize ) ); 2361cdf0e10cSrcweir Rectangle aSrcRect( rSrcPtPixel, rSrcSizePixel ); 2362cdf0e10cSrcweir 2363cdf0e10cSrcweir aSrcRect.Justify(); 2364cdf0e10cSrcweir 2365cdf0e10cSrcweir if( !rMask.IsEmpty() && aSrcRect.GetWidth() && aSrcRect.GetHeight() && aDestSz.Width() && aDestSz.Height() ) 2366cdf0e10cSrcweir { 2367cdf0e10cSrcweir Bitmap aMask( rMask ); 2368cdf0e10cSrcweir sal_uLong nMirrFlags = 0UL; 2369cdf0e10cSrcweir 2370cdf0e10cSrcweir if( aMask.GetBitCount() > 1 ) 2371cdf0e10cSrcweir aMask.Convert( BMP_CONVERSION_1BIT_THRESHOLD ); 2372cdf0e10cSrcweir 2373cdf0e10cSrcweir // mirrored horizontically 2374cdf0e10cSrcweir if( aDestSz.Width() < 0L ) 2375cdf0e10cSrcweir { 2376cdf0e10cSrcweir aDestSz.Width() = -aDestSz.Width(); 2377cdf0e10cSrcweir aDestPt.X() -= ( aDestSz.Width() - 1L ); 2378cdf0e10cSrcweir nMirrFlags |= BMP_MIRROR_HORZ; 2379cdf0e10cSrcweir } 2380cdf0e10cSrcweir 2381cdf0e10cSrcweir // mirrored vertically 2382cdf0e10cSrcweir if( aDestSz.Height() < 0L ) 2383cdf0e10cSrcweir { 2384cdf0e10cSrcweir aDestSz.Height() = -aDestSz.Height(); 2385cdf0e10cSrcweir aDestPt.Y() -= ( aDestSz.Height() - 1L ); 2386cdf0e10cSrcweir nMirrFlags |= BMP_MIRROR_VERT; 2387cdf0e10cSrcweir } 2388cdf0e10cSrcweir 2389cdf0e10cSrcweir // source cropped? 2390cdf0e10cSrcweir if( aSrcRect != Rectangle( aPt, aMask.GetSizePixel() ) ) 2391cdf0e10cSrcweir aMask.Crop( aSrcRect ); 2392cdf0e10cSrcweir 2393cdf0e10cSrcweir // destination mirrored 2394cdf0e10cSrcweir if( nMirrFlags ) 2395cdf0e10cSrcweir aMask.Mirror( nMirrFlags ); 2396cdf0e10cSrcweir 2397cdf0e10cSrcweir // do painting 2398cdf0e10cSrcweir const long nSrcWidth = aSrcRect.GetWidth(), nSrcHeight = aSrcRect.GetHeight(); 2399e6f63103SArmin Le Grand long nX, nY; //, nWorkX, nWorkY, nWorkWidth, nWorkHeight; 2400cdf0e10cSrcweir long* pMapX = new long[ nSrcWidth + 1 ]; 2401cdf0e10cSrcweir long* pMapY = new long[ nSrcHeight + 1 ]; 2402cdf0e10cSrcweir GDIMetaFile* pOldMetaFile = mpMetaFile; 2403cdf0e10cSrcweir const sal_Bool bOldMap = mbMap; 2404cdf0e10cSrcweir 2405cdf0e10cSrcweir mpMetaFile = NULL; 2406cdf0e10cSrcweir mbMap = sal_False; 2407cdf0e10cSrcweir Push( PUSH_FILLCOLOR | PUSH_LINECOLOR ); 2408cdf0e10cSrcweir SetLineColor( rMaskColor ); 2409cdf0e10cSrcweir SetFillColor( rMaskColor ); 2410cdf0e10cSrcweir ImplInitLineColor(); 2411cdf0e10cSrcweir ImplInitFillColor(); 2412cdf0e10cSrcweir 2413cdf0e10cSrcweir // create forward mapping tables 2414cdf0e10cSrcweir for( nX = 0L; nX <= nSrcWidth; nX++ ) 2415cdf0e10cSrcweir pMapX[ nX ] = aDestPt.X() + FRound( (double) aDestSz.Width() * nX / nSrcWidth ); 2416cdf0e10cSrcweir 2417cdf0e10cSrcweir for( nY = 0L; nY <= nSrcHeight; nY++ ) 2418cdf0e10cSrcweir pMapY[ nY ] = aDestPt.Y() + FRound( (double) aDestSz.Height() * nY / nSrcHeight ); 2419cdf0e10cSrcweir 2420cdf0e10cSrcweir // walk through all rectangles of mask 2421e6f63103SArmin Le Grand const Region aWorkRgn(aMask.CreateRegion(COL_BLACK, Rectangle(Point(), aMask.GetSizePixel()))); 2422e6f63103SArmin Le Grand RectangleVector aRectangles; 2423e6f63103SArmin Le Grand aWorkRgn.GetRegionRectangles(aRectangles); 2424cdf0e10cSrcweir 2425e6f63103SArmin Le Grand for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++) 2426e6f63103SArmin Le Grand { 2427e6f63103SArmin Le Grand const Point aMapPt(pMapX[aRectIter->Left()], pMapY[aRectIter->Top()]); 2428e6f63103SArmin Le Grand const Size aMapSz( 2429e6f63103SArmin Le Grand pMapX[aRectIter->Right() + 1] - aMapPt.X(), // pMapX[L + W] -> L + ((R - L) + 1) -> R + 1 2430e6f63103SArmin Le Grand pMapY[aRectIter->Bottom() + 1] - aMapPt.Y()); // same for Y 2431cdf0e10cSrcweir 2432e6f63103SArmin Le Grand DrawRect(Rectangle(aMapPt, aMapSz)); 2433e6f63103SArmin Le Grand } 2434e6f63103SArmin Le Grand 2435e6f63103SArmin Le Grand //Region aWorkRgn( aMask.CreateRegion( COL_BLACK, Rectangle( Point(), aMask.GetSizePixel() ) ) ); 2436e6f63103SArmin Le Grand //ImplRegionInfo aInfo; 2437e6f63103SArmin Le Grand //sal_Bool bRgnRect = aWorkRgn.ImplGetFirstRect( aInfo, nWorkX, nWorkY, nWorkWidth, nWorkHeight ); 2438e6f63103SArmin Le Grand // 2439e6f63103SArmin Le Grand //while( bRgnRect ) 2440e6f63103SArmin Le Grand //{ 2441e6f63103SArmin Le Grand // const Point aMapPt( pMapX[ nWorkX ], pMapY[ nWorkY ] ); 2442e6f63103SArmin Le Grand // const Size aMapSz( pMapX[ nWorkX + nWorkWidth ] - aMapPt.X(), pMapY[ nWorkY + nWorkHeight ] - aMapPt.Y() ); 2443e6f63103SArmin Le Grand // 2444e6f63103SArmin Le Grand // DrawRect( Rectangle( aMapPt, aMapSz ) ); 2445e6f63103SArmin Le Grand // bRgnRect = aWorkRgn.ImplGetNextRect( aInfo, nWorkX, nWorkY, nWorkWidth, nWorkHeight ); 2446e6f63103SArmin Le Grand //} 2447cdf0e10cSrcweir 2448cdf0e10cSrcweir Pop(); 2449cdf0e10cSrcweir delete[] pMapX; 2450cdf0e10cSrcweir delete[] pMapY; 2451cdf0e10cSrcweir mbMap = bOldMap; 2452cdf0e10cSrcweir mpMetaFile = pOldMetaFile; 2453cdf0e10cSrcweir } 2454cdf0e10cSrcweir } 2455