| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_canvas.hxx" |
| |
| #include <canvas/debug.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <canvas/verbosetrace.hxx> |
| |
| #include <rtl/math.hxx> |
| |
| #include <vcl/outdev.hxx> |
| #include <vcl/bitmap.hxx> |
| #include <vcl/alpha.hxx> |
| #include <vcl/bitmapex.hxx> |
| #include <vcl/canvastools.hxx> |
| |
| #include <basegfx/matrix/b2dhommatrix.hxx> |
| #include <basegfx/point/b2dpoint.hxx> |
| #include <basegfx/tools/canvastools.hxx> |
| #include <basegfx/polygon/b2dpolygon.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <basegfx/polygon/b2dpolypolygontools.hxx> |
| #include <basegfx/polygon/b2dpolygoncutandtouch.hxx> |
| #include <basegfx/polygon/b2dpolygontriangulator.hxx> |
| #include <basegfx/polygon/b2dpolygonclipper.hxx> |
| #include <basegfx/numeric/ftools.hxx> |
| |
| #include <canvas/canvastools.hxx> |
| |
| #include "spritehelper.hxx" |
| |
| using namespace ::com::sun::star; |
| |
| |
| namespace vclcanvas |
| { |
| SpriteHelper::SpriteHelper() : |
| mpBackBuffer(), |
| mpBackBufferMask(), |
| maContent(), |
| mbShowSpriteBounds(false) |
| { |
| } |
| |
| void SpriteHelper::init( const geometry::RealSize2D& rSpriteSize, |
| const ::canvas::SpriteSurface::Reference& rOwningSpriteCanvas, |
| const BackBufferSharedPtr& rBackBuffer, |
| const BackBufferSharedPtr& rBackBufferMask, |
| bool bShowSpriteBounds ) |
| { |
| ENSURE_OR_THROW( rOwningSpriteCanvas.get() && rBackBuffer && rBackBufferMask, |
| "SpriteHelper::init(): Invalid sprite canvas or back buffer" ); |
| |
| mpBackBuffer = rBackBuffer; |
| mpBackBufferMask = rBackBufferMask; |
| mbShowSpriteBounds = bShowSpriteBounds; |
| |
| init( rSpriteSize, rOwningSpriteCanvas ); |
| } |
| |
| void SpriteHelper::disposing() |
| { |
| mpBackBuffer.reset(); |
| mpBackBufferMask.reset(); |
| |
| // forward to parent |
| CanvasCustomSpriteHelper::disposing(); |
| } |
| |
| void SpriteHelper::redraw( OutputDevice& rTargetSurface, |
| const ::basegfx::B2DPoint& rPos, |
| bool& io_bSurfacesDirty, |
| bool bBufferedUpdate ) const |
| { |
| (void)bBufferedUpdate; // not used on every platform |
| |
| if( !mpBackBuffer || |
| !mpBackBufferMask ) |
| { |
| return; // we're disposed |
| } |
| |
| // log output pos in device pixel |
| VERBOSE_TRACE( "SpriteHelper::redraw(): output pos is (%f, %f)", |
| rPos.getX(), |
| rPos.getY() ); |
| |
| const double fAlpha( getAlpha() ); |
| |
| if( isActive() && |
| !::basegfx::fTools::equalZero( fAlpha ) ) |
| { |
| const Point aEmptyPoint; |
| const ::basegfx::B2DVector& rOrigOutputSize( getSizePixel() ); |
| |
| // might get changed below (e.g. adapted for |
| // transformations). IMPORTANT: both position and size are |
| // rounded to integer values. From now on, only those |
| // rounded values are used, to keep clip and content in |
| // sync. |
| ::Size aOutputSize( ::vcl::unotools::sizeFromB2DSize( rOrigOutputSize ) ); |
| ::Point aOutPos( ::vcl::unotools::pointFromB2DPoint( rPos ) ); |
| |
| |
| // TODO(F3): Support for alpha-VDev |
| |
| // Do we have to update our bitmaps (necessary if virdev |
| // was painted to, or transformation changed)? |
| const bool bNeedBitmapUpdate( io_bSurfacesDirty || |
| hasTransformChanged() || |
| maContent->IsEmpty() ); |
| |
| // updating content of sprite cache - surface is no |
| // longer dirty in relation to our cache |
| io_bSurfacesDirty = false; |
| transformUpdated(); |
| |
| if( bNeedBitmapUpdate ) |
| { |
| Bitmap aBmp( mpBackBuffer->getOutDev().GetBitmap( aEmptyPoint, |
| aOutputSize ) ); |
| |
| if( isContentFullyOpaque() ) |
| { |
| // optimized case: content canvas is fully |
| // opaque. Note: since we retrieved aBmp directly |
| // from an OutDev, it's already a 'display bitmap' |
| // on windows. |
| maContent = BitmapEx( aBmp ); |
| } |
| else |
| { |
| // sprite content might contain alpha, create |
| // BmpEx, then. |
| Bitmap aMask( mpBackBufferMask->getOutDev().GetBitmap( aEmptyPoint, |
| aOutputSize ) ); |
| |
| // bitmasks are much faster than alphamasks on some platforms |
| // so convert to bitmask if useful |
| #if defined LINUX || defined FREEBSD || defined NETBSD || defined QUARTZ |
| // #122485# allow more than 1bit masks for Linux and Mac, |
| // but reduce to mono now |
| aMask.MakeMono(255); |
| #else |
| // #122485# assert when mask uses more than 1bit and reduce |
| // to mono |
| if( aMask.GetBitCount() != 1 ) |
| { |
| OSL_ENSURE(false, |
| "CanvasCustomSprite::redraw(): Mask bitmap is not " |
| "monochrome (performance!)"); |
| aMask.MakeMono(255); |
| } |
| #endif |
| |
| // Note: since we retrieved aBmp and aMask |
| // directly from an OutDev, it's already a |
| // 'display bitmap' on windows. |
| maContent = BitmapEx( aBmp, aMask ); |
| } |
| } |
| |
| ::basegfx::B2DHomMatrix aTransform( getTransformation() ); |
| |
| // check whether matrix is "easy" to handle - pure |
| // translations or scales are handled by OutputDevice |
| // alone |
| const bool bIdentityTransform( aTransform.isIdentity() ); |
| |
| // make transformation absolute (put sprite to final |
| // output position). Need to happen here, as we also have |
| // to translate the clip polygon |
| aTransform.translate( aOutPos.X(), |
| aOutPos.Y() ); |
| |
| if( !bIdentityTransform ) |
| { |
| if( !::basegfx::fTools::equalZero( aTransform.get(0,1) ) || |
| !::basegfx::fTools::equalZero( aTransform.get(1,0) ) ) |
| { |
| // "complex" transformation, employ affine |
| // transformator |
| |
| // modify output position, to account for the fact |
| // that transformBitmap() always normalizes its output |
| // bitmap into the smallest enclosing box. |
| ::basegfx::B2DRectangle aDestRect; |
| ::canvas::tools::calcTransformedRectBounds( aDestRect, |
| ::basegfx::B2DRectangle(0, |
| 0, |
| rOrigOutputSize.getX(), |
| rOrigOutputSize.getY()), |
| aTransform ); |
| |
| aOutPos.X() = ::basegfx::fround( aDestRect.getMinX() ); |
| aOutPos.Y() = ::basegfx::fround( aDestRect.getMinY() ); |
| |
| // TODO(P3): Use optimized bitmap transformation here. |
| |
| // actually re-create the bitmap ONLY if necessary |
| if( bNeedBitmapUpdate ) |
| maContent = tools::transformBitmap( *maContent, |
| aTransform, |
| uno::Sequence<double>(), |
| tools::MODULATE_NONE ); |
| |
| aOutputSize = maContent->GetSizePixel(); |
| } |
| else |
| { |
| // relatively 'simplistic' transformation - |
| // retrieve scale and translational offset |
| aOutputSize.setWidth ( |
| ::basegfx::fround( rOrigOutputSize.getX() * aTransform.get(0,0) ) ); |
| aOutputSize.setHeight( |
| ::basegfx::fround( rOrigOutputSize.getY() * aTransform.get(1,1) ) ); |
| |
| aOutPos.X() = ::basegfx::fround( aTransform.get(0,2) ); |
| aOutPos.Y() = ::basegfx::fround( aTransform.get(1,2) ); |
| } |
| } |
| |
| // transformBitmap() might return empty bitmaps, for tiny |
| // scales. |
| if( !!(*maContent) ) |
| { |
| // when true, fast path for slide transition has |
| // already redrawn the sprite. |
| bool bSpriteRedrawn( false ); |
| |
| rTargetSurface.Push( PUSH_CLIPREGION ); |
| |
| // apply clip (if any) |
| if( getClip().is() ) |
| { |
| ::basegfx::B2DPolyPolygon aClipPoly( |
| ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( |
| getClip() )); |
| |
| if( aClipPoly.count() ) |
| { |
| // aTransform already contains the |
| // translational component, moving the clip to |
| // the final sprite output position. |
| aClipPoly.transform( aTransform ); |
| |
| #if ! defined WNT && ! defined QUARTZ |
| // non-Windows only - bAtLeastOnePolygon is |
| // only used in non-WNT code below |
| |
| // check whether maybe the clip consists |
| // solely out of rectangular polygons. If this |
| // is the case, enforce using the triangle |
| // clip region setup - non-optimized X11 |
| // drivers tend to perform abyssmally on |
| // XPolygonRegion, which is used internally, |
| // when filling complex polypolygons. |
| bool bAtLeastOnePolygon( false ); |
| const sal_Int32 nPolygons( aClipPoly.count() ); |
| |
| for( sal_Int32 i=0; i<nPolygons; ++i ) |
| { |
| if( !::basegfx::tools::isRectangle( |
| aClipPoly.getB2DPolygon(i)) ) |
| { |
| bAtLeastOnePolygon = true; |
| break; |
| } |
| } |
| #endif |
| |
| if( mbShowSpriteBounds ) |
| { |
| // Paint green sprite clip area |
| rTargetSurface.SetLineColor( Color( 0,255,0 ) ); |
| rTargetSurface.SetFillColor(); |
| |
| rTargetSurface.DrawPolyPolygon(PolyPolygon(aClipPoly)); // #i76339# |
| } |
| |
| #if ! defined WNT && ! defined QUARTZ |
| // as a matter of fact, this fast path only |
| // performs well for X11 - under Windows, the |
| // clip via SetTriangleClipRegion is faster. |
| if( bAtLeastOnePolygon && |
| bBufferedUpdate && |
| ::rtl::math::approxEqual(fAlpha, 1.0) && |
| !maContent->IsTransparent() ) |
| { |
| // fast path for slide transitions |
| // (buffered, no alpha, no mask (because |
| // full slide is contained in the sprite)) |
| |
| // XOR bitmap onto backbuffer, clear area |
| // that should be _visible_ with black, |
| // XOR bitmap again on top of that - |
| // result: XOR cancels out where no black |
| // has been rendered, and yields the |
| // original bitmap, where black is |
| // underneath. |
| rTargetSurface.Push( PUSH_RASTEROP ); |
| rTargetSurface.SetRasterOp( ROP_XOR ); |
| rTargetSurface.DrawBitmap( aOutPos, |
| aOutputSize, |
| maContent->GetBitmap() ); |
| |
| rTargetSurface.SetLineColor(); |
| rTargetSurface.SetFillColor( COL_BLACK ); |
| rTargetSurface.SetRasterOp( ROP_0 ); |
| rTargetSurface.DrawPolyPolygon(PolyPolygon(aClipPoly)); // #i76339# |
| |
| rTargetSurface.SetRasterOp( ROP_XOR ); |
| rTargetSurface.DrawBitmap( aOutPos, |
| aOutputSize, |
| maContent->GetBitmap() ); |
| |
| rTargetSurface.Pop(); |
| |
| bSpriteRedrawn = true; |
| } |
| else |
| #endif |
| { |
| Region aClipRegion( aClipPoly ); |
| rTargetSurface.SetClipRegion( aClipRegion ); |
| } |
| } |
| } |
| |
| if( !bSpriteRedrawn ) |
| { |
| if( ::rtl::math::approxEqual(fAlpha, 1.0) ) |
| { |
| // no alpha modulation -> just copy to output |
| if( maContent->IsTransparent() ) |
| rTargetSurface.DrawBitmapEx( aOutPos, aOutputSize, *maContent ); |
| else |
| rTargetSurface.DrawBitmap( aOutPos, aOutputSize, maContent->GetBitmap() ); |
| } |
| else |
| { |
| // TODO(P3): Switch to OutputDevice::DrawTransparent() |
| // here |
| |
| // draw semi-transparent |
| sal_uInt8 nColor( static_cast<sal_uInt8>( ::basegfx::fround( 255.0*(1.0 - fAlpha) + .5) ) ); |
| AlphaMask aAlpha( maContent->GetSizePixel(), |
| &nColor ); |
| |
| // mask out fully transparent areas |
| if( maContent->IsTransparent() ) |
| aAlpha.Replace( maContent->GetMask(), 255 ); |
| |
| // alpha-blend to output |
| rTargetSurface.DrawBitmapEx( aOutPos, aOutputSize, |
| BitmapEx( maContent->GetBitmap(), |
| aAlpha ) ); |
| } |
| } |
| |
| rTargetSurface.Pop(); |
| |
| if( mbShowSpriteBounds ) |
| { |
| ::PolyPolygon aMarkerPoly( |
| ::canvas::tools::getBoundMarksPolyPolygon( |
| ::basegfx::B2DRectangle(aOutPos.X(), |
| aOutPos.Y(), |
| aOutPos.X() + aOutputSize.Width()-1, |
| aOutPos.Y() + aOutputSize.Height()-1) ) ); |
| |
| // Paint little red sprite area markers |
| rTargetSurface.SetLineColor( COL_RED ); |
| rTargetSurface.SetFillColor(); |
| |
| for( int i=0; i<aMarkerPoly.Count(); ++i ) |
| { |
| rTargetSurface.DrawPolyLine( aMarkerPoly.GetObject((sal_uInt16)i) ); |
| } |
| |
| // paint sprite prio |
| Font aVCLFont; |
| aVCLFont.SetHeight( std::min(long(20),aOutputSize.Height()) ); |
| aVCLFont.SetColor( COL_RED ); |
| |
| rTargetSurface.SetTextAlign(ALIGN_TOP); |
| rTargetSurface.SetTextColor( COL_RED ); |
| rTargetSurface.SetFont( aVCLFont ); |
| |
| ::rtl::OUString text( ::rtl::math::doubleToUString( getPriority(), |
| rtl_math_StringFormat_F, |
| 2,'.',NULL,' ') ); |
| |
| rTargetSurface.DrawText( aOutPos+Point(2,2), text ); |
| |
| #if defined(VERBOSE) && OSL_DEBUG_LEVEL > 0 |
| OSL_TRACE( "SpriteHelper::redraw(): sprite %X has prio %f\n", |
| this, getPriority() ); |
| #endif |
| } |
| } |
| } |
| } |
| |
| ::basegfx::B2DPolyPolygon SpriteHelper::polyPolygonFromXPolyPolygon2D( uno::Reference< rendering::XPolyPolygon2D >& xPoly ) const |
| { |
| return ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D( xPoly ); |
| } |
| |
| } |
