| /************************************************************** | |
| * | |
| * 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_cppcanvas.hxx" | |
| #include <tools/gen.hxx> | |
| #include <canvas/debug.hxx> | |
| #include <canvas/verbosetrace.hxx> | |
| #include <canvas/canvastools.hxx> | |
| #include <rtl/logfile.hxx> | |
| #include <com/sun/star/rendering/XBitmap.hpp> | |
| #include <com/sun/star/rendering/XCanvas.hpp> | |
| #include <rtl/math.hxx> | |
| #include <vcl/metaact.hxx> | |
| #include <vcl/bitmapex.hxx> | |
| #include <vcl/canvastools.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <vcl/outdev.hxx> | |
| #include <vcl/virdev.hxx> | |
| #include <vcl/virdev.hxx> | |
| #include <vcl/gdimtf.hxx> | |
| #include <vcl/gradient.hxx> | |
| #include <canvas/canvastools.hxx> | |
| #include <basegfx/range/b2drange.hxx> | |
| #include <basegfx/point/b2dpoint.hxx> | |
| #include <basegfx/vector/b2dsize.hxx> | |
| #include <basegfx/numeric/ftools.hxx> | |
| #include <basegfx/matrix/b2dhommatrix.hxx> | |
| #include <basegfx/tuple/b2dtuple.hxx> | |
| #include <basegfx/tools/canvastools.hxx> | |
| #include <boost/utility.hpp> | |
| #include "transparencygroupaction.hxx" | |
| #include "outdevstate.hxx" | |
| #include "mtftools.hxx" | |
| #include "cppcanvas/vclfactory.hxx" | |
| using namespace ::com::sun::star; | |
| namespace cppcanvas | |
| { | |
| namespace internal | |
| { | |
| // free support functions | |
| // ====================== | |
| namespace | |
| { | |
| class TransparencyGroupAction : public Action, private ::boost::noncopyable | |
| { | |
| public: | |
| /** Create new transparency group action. | |
| @param rGroupMtf | |
| Metafile that groups all actions to be rendered | |
| transparent | |
| @param rParms | |
| Render parameters | |
| @param rDstPoint | |
| Left, top edge of destination, in current state | |
| coordinate system | |
| @param rDstSize | |
| Size of the transparency group object, in current | |
| state coordinate system. | |
| @param nAlpha | |
| Alpha value, must be in the range [0,1] | |
| */ | |
| TransparencyGroupAction( MtfAutoPtr& rGroupMtf, | |
| const Renderer::Parameters& rParms, | |
| const ::basegfx::B2DPoint& rDstPoint, | |
| const ::basegfx::B2DVector& rDstSize, | |
| double nAlpha, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ); | |
| /** Create new transparency group action. | |
| @param rGroupMtf | |
| Metafile that groups all actions to be rendered | |
| transparent. | |
| @param rAlphaGradient | |
| VCL gradient, to be rendered into the action's alpha | |
| channel. | |
| @param rParms | |
| Render parameters | |
| @param rDstPoint | |
| Left, top edge of destination, in current state | |
| coordinate system | |
| @param rDstSize | |
| Size of the transparency group object, in current | |
| state coordinate system. | |
| */ | |
| TransparencyGroupAction( MtfAutoPtr& rGroupMtf, | |
| GradientAutoPtr& rAlphaGradient, | |
| const Renderer::Parameters& rParms, | |
| const ::basegfx::B2DPoint& rDstPoint, | |
| const ::basegfx::B2DVector& rDstSize, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ); | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| virtual bool render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const; | |
| virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const; | |
| virtual sal_Int32 getActionCount() const; | |
| private: | |
| MtfAutoPtr mpGroupMtf; | |
| GradientAutoPtr mpAlphaGradient; | |
| const Renderer::Parameters maParms; | |
| const ::basegfx::B2DSize maDstSize; | |
| mutable uno::Reference< rendering::XBitmap > mxBufferBitmap; // contains last rendered version | |
| mutable ::basegfx::B2DHomMatrix maLastTransformation; // contains last active transformation | |
| mutable Subset maLastSubset; // contains last effective subset | |
| // transformation for | |
| // mxBufferBitmap content | |
| CanvasSharedPtr mpCanvas; | |
| rendering::RenderState maState; | |
| const double mnAlpha; | |
| }; | |
| /** Setup transformation such that the next render call is | |
| moved rPoint away, and scaled according to the ratio | |
| given by src and dst size. | |
| */ | |
| void implSetupTransform( rendering::RenderState& rRenderState, | |
| const ::basegfx::B2DPoint& rDstPoint ) | |
| { | |
| ::basegfx::B2DHomMatrix aLocalTransformation; | |
| aLocalTransformation.translate( rDstPoint.getX(), | |
| rDstPoint.getY() ); | |
| ::canvas::tools::appendToRenderState( rRenderState, | |
| aLocalTransformation ); | |
| } | |
| TransparencyGroupAction::TransparencyGroupAction( MtfAutoPtr& rGroupMtf, | |
| const Renderer::Parameters& rParms, | |
| const ::basegfx::B2DPoint& rDstPoint, | |
| const ::basegfx::B2DVector& rDstSize, | |
| double nAlpha, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) : | |
| mpGroupMtf( rGroupMtf ), | |
| mpAlphaGradient(), | |
| maParms( rParms ), | |
| maDstSize( rDstSize ), | |
| mxBufferBitmap(), | |
| maLastTransformation(), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| mnAlpha( nAlpha ) | |
| { | |
| tools::initRenderState(maState,rState); | |
| implSetupTransform( maState, rDstPoint ); | |
| // correct clip (which is relative to original transform) | |
| tools::modifyClip( maState, | |
| rState, | |
| rCanvas, | |
| rDstPoint, | |
| NULL, | |
| NULL ); | |
| maLastSubset.mnSubsetBegin = 0; | |
| maLastSubset.mnSubsetEnd = -1; | |
| } | |
| TransparencyGroupAction::TransparencyGroupAction( MtfAutoPtr& rGroupMtf, | |
| GradientAutoPtr& rAlphaGradient, | |
| const Renderer::Parameters& rParms, | |
| const ::basegfx::B2DPoint& rDstPoint, | |
| const ::basegfx::B2DVector& rDstSize, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) : | |
| mpGroupMtf( rGroupMtf ), | |
| mpAlphaGradient( rAlphaGradient ), | |
| maParms( rParms ), | |
| maDstSize( rDstSize ), | |
| mxBufferBitmap(), | |
| maLastTransformation(), | |
| mpCanvas( rCanvas ), | |
| maState(), | |
| mnAlpha( 1.0 ) | |
| { | |
| tools::initRenderState(maState,rState); | |
| implSetupTransform( maState, rDstPoint ); | |
| // correct clip (which is relative to original transform) | |
| tools::modifyClip( maState, | |
| rState, | |
| rCanvas, | |
| rDstPoint, | |
| NULL, | |
| NULL ); | |
| maLastSubset.mnSubsetBegin = 0; | |
| maLastSubset.mnSubsetEnd = -1; | |
| } | |
| // TODO(P3): The whole float transparency handling is a mess, | |
| // this should be refactored. What's more, the old idea of | |
| // having only internal 'metaactions', and not the original | |
| // GDIMetaFile now looks a lot less attractive. Try to move | |
| // into the direction of having a direct GDIMetaFile2XCanvas | |
| // renderer, and maybe a separate metafile XCanvas | |
| // implementation. | |
| bool TransparencyGroupAction::render( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| RTL_LOGFILE_CONTEXT( aLog, "::cppcanvas::internal::TransparencyGroupAction::render()" ); | |
| RTL_LOGFILE_CONTEXT_TRACE1( aLog, "::cppcanvas::internal::TransparencyGroupAction: 0x%X", this ); | |
| // determine overall transformation matrix (render, view, | |
| // and passed transformation) | |
| ::basegfx::B2DHomMatrix aTransform; | |
| ::canvas::tools::getRenderStateTransform( aTransform, maState ); | |
| aTransform = rTransformation * aTransform; | |
| ::basegfx::B2DHomMatrix aTotalTransform; | |
| ::canvas::tools::getViewStateTransform( aTotalTransform, mpCanvas->getViewState() ); | |
| aTotalTransform = aTotalTransform * aTransform; | |
| // since pure translational changes to the transformation | |
| // does not matter, remove them before comparing | |
| aTotalTransform.set( 0, 2, 0.0 ); | |
| aTotalTransform.set( 1, 2, 0.0 ); | |
| // if there's no buffer bitmap, or as soon as the | |
| // total transformation changes, we've got to | |
| // re-render the bitmap | |
| if( !mxBufferBitmap.is() || | |
| aTotalTransform != maLastTransformation || | |
| rSubset.mnSubsetBegin != maLastSubset.mnSubsetBegin || | |
| rSubset.mnSubsetEnd != maLastSubset.mnSubsetEnd ) | |
| { | |
| DBG_TESTSOLARMUTEX(); | |
| // determine total scaling factor of the | |
| // transformation matrix - need to make the bitmap | |
| // large enough | |
| ::basegfx::B2DTuple aScale; | |
| ::basegfx::B2DTuple aTranslate; | |
| double nRotate; | |
| double nShearX; | |
| if( !aTotalTransform.decompose( aScale, | |
| aTranslate, | |
| nRotate, | |
| nShearX ) ) | |
| { | |
| OSL_ENSURE( false, | |
| "TransparencyGroupAction::render(): non-decomposable transformation" ); | |
| return false; | |
| } | |
| // output size of metafile | |
| ::Size aOutputSizePixel( ::basegfx::fround( aScale.getX() * maDstSize.getX() ), | |
| ::basegfx::fround( aScale.getY() * maDstSize.getY() ) ); | |
| // pixel size of cache bitmap: round up to nearest int | |
| ::Size aBitmapSizePixel( static_cast<sal_Int32>( aScale.getX() * maDstSize.getX() )+1, | |
| static_cast<sal_Int32>( aScale.getY() * maDstSize.getY() )+1 ); | |
| ::Point aEmptyPoint; | |
| // render our content into an appropriately sized | |
| // VirtualDevice with alpha channel | |
| VirtualDevice aVDev( | |
| *::Application::GetDefaultDevice(), 0, 0 ); | |
| aVDev.SetOutputSizePixel( aBitmapSizePixel ); | |
| aVDev.SetMapMode(); | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != -1 ) | |
| { | |
| // true subset - extract referenced | |
| // metaactions from mpGroupMtf | |
| GDIMetaFile aMtf; | |
| MetaAction* pCurrAct; | |
| int nCurrActionIndex; | |
| // extract subset actions | |
| for( nCurrActionIndex=0, | |
| pCurrAct=mpGroupMtf->FirstAction(); | |
| pCurrAct; | |
| ++nCurrActionIndex, pCurrAct = mpGroupMtf->NextAction() ) | |
| { | |
| switch( pCurrAct->GetType() ) | |
| { | |
| case META_PUSH_ACTION: | |
| case META_POP_ACTION: | |
| case META_CLIPREGION_ACTION: | |
| case META_ISECTRECTCLIPREGION_ACTION: | |
| case META_ISECTREGIONCLIPREGION_ACTION: | |
| case META_MOVECLIPREGION_ACTION: | |
| case META_LINECOLOR_ACTION: | |
| case META_FILLCOLOR_ACTION: | |
| case META_TEXTCOLOR_ACTION: | |
| case META_TEXTFILLCOLOR_ACTION: | |
| case META_TEXTLINECOLOR_ACTION: | |
| case META_TEXTALIGN_ACTION: | |
| case META_FONT_ACTION: | |
| case META_RASTEROP_ACTION: | |
| case META_REFPOINT_ACTION: | |
| case META_LAYOUTMODE_ACTION: | |
| // state-changing action - copy as-is | |
| aMtf.AddAction( pCurrAct->Clone() ); | |
| break; | |
| case META_GRADIENT_ACTION: | |
| case META_HATCH_ACTION: | |
| case META_EPS_ACTION: | |
| case META_COMMENT_ACTION: | |
| case META_POINT_ACTION: | |
| case META_PIXEL_ACTION: | |
| case META_LINE_ACTION: | |
| case META_RECT_ACTION: | |
| case META_ROUNDRECT_ACTION: | |
| case META_ELLIPSE_ACTION: | |
| case META_ARC_ACTION: | |
| case META_PIE_ACTION: | |
| case META_CHORD_ACTION: | |
| case META_POLYLINE_ACTION: | |
| case META_POLYGON_ACTION: | |
| case META_POLYPOLYGON_ACTION: | |
| case META_BMP_ACTION: | |
| case META_BMPSCALE_ACTION: | |
| case META_BMPSCALEPART_ACTION: | |
| case META_BMPEX_ACTION: | |
| case META_BMPEXSCALE_ACTION: | |
| case META_BMPEXSCALEPART_ACTION: | |
| case META_MASK_ACTION: | |
| case META_MASKSCALE_ACTION: | |
| case META_MASKSCALEPART_ACTION: | |
| case META_GRADIENTEX_ACTION: | |
| case META_WALLPAPER_ACTION: | |
| case META_TRANSPARENT_ACTION: | |
| case META_FLOATTRANSPARENT_ACTION: | |
| case META_TEXT_ACTION: | |
| case META_TEXTARRAY_ACTION: | |
| case META_TEXTLINE_ACTION: | |
| case META_TEXTRECT_ACTION: | |
| case META_STRETCHTEXT_ACTION: | |
| // output-generating action - only | |
| // copy, if we're within the | |
| // requested subset | |
| if( rSubset.mnSubsetBegin <= nCurrActionIndex && | |
| rSubset.mnSubsetEnd > nCurrActionIndex ) | |
| { | |
| aMtf.AddAction( pCurrAct->Clone() ); | |
| } | |
| break; | |
| default: | |
| OSL_ENSURE( false, | |
| "Unknown meta action type encountered" ); | |
| break; | |
| } | |
| } | |
| aVDev.DrawTransparent( aMtf, | |
| aEmptyPoint, | |
| aOutputSizePixel, | |
| *mpAlphaGradient ); | |
| } | |
| else | |
| { | |
| // no subsetting - render whole mtf | |
| aVDev.DrawTransparent( *mpGroupMtf, | |
| aEmptyPoint, | |
| aOutputSizePixel, | |
| *mpAlphaGradient ); | |
| } | |
| // update buffered bitmap and transformation | |
| BitmapSharedPtr aBmp( VCLFactory::getInstance().createBitmap( | |
| mpCanvas, | |
| aVDev.GetBitmapEx( | |
| aEmptyPoint, | |
| aBitmapSizePixel ) ) ); | |
| mxBufferBitmap = aBmp->getUNOBitmap(); | |
| maLastTransformation = aTotalTransform; | |
| maLastSubset = rSubset; | |
| } | |
| // determine target transformation (we can't simply pass | |
| // aTotalTransform as assembled above, since we must take | |
| // the canvas' view state as is, it might contain clipping | |
| // (which, in turn, is relative to the view | |
| // transformation)) | |
| // given that aTotalTransform is the identity | |
| // transformation, we could simply render our bitmap | |
| // as-is. Now, since the mxBufferBitmap content already | |
| // accounts for scale changes in the overall | |
| // transformation, we must factor this out | |
| // before. Generally, the transformation matrix should be | |
| // structured like this: | |
| // Translation*Rotation*Shear*Scale. Thus, to neutralize | |
| // the contained scaling, we've got to right-multiply with | |
| // the inverse. | |
| ::basegfx::B2ISize aBmpSize( | |
| ::basegfx::unotools::b2ISizeFromIntegerSize2D( mxBufferBitmap->getSize() ) ); | |
| ::basegfx::B2DHomMatrix aScaleCorrection; | |
| aScaleCorrection.scale( (double)maDstSize.getX() / aBmpSize.getX(), | |
| (double)maDstSize.getY() / aBmpSize.getY() ); | |
| aTransform = aTransform * aScaleCorrection; | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::setRenderStateTransform(aLocalState, aTransform); | |
| #ifdef SPECIAL_DEBUG | |
| aLocalState.Clip.clear(); | |
| aLocalState.DeviceColor = | |
| ::vcl::unotools::colorToDoubleSequence( | |
| ::Color( 0x80FF0000 ), | |
| mpCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace() ); | |
| if( maState.Clip.is() ) | |
| mpCanvas->getUNOCanvas()->fillPolyPolygon( maState.Clip, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| aLocalState.DeviceColor = maState.DeviceColor; | |
| #endif | |
| if( ::rtl::math::approxEqual(mnAlpha, 1.0) ) | |
| { | |
| // no further alpha changes necessary -> draw directly | |
| mpCanvas->getUNOCanvas()->drawBitmap( mxBufferBitmap, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| else | |
| { | |
| // add alpha modulation value to DeviceColor | |
| uno::Sequence<rendering::ARGBColor> aCols(1); | |
| aCols[0] = rendering::ARGBColor( mnAlpha, 1.0, 1.0, 1.0); | |
| aLocalState.DeviceColor = | |
| mpCanvas->getUNOCanvas()->getDevice()->getDeviceColorSpace()->convertFromARGB( | |
| aCols); | |
| mpCanvas->getUNOCanvas()->drawBitmapModulated( mxBufferBitmap, | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| return true; | |
| } | |
| // TODO(P3): The whole float transparency handling is a mess, | |
| // this should be refactored. What's more, the old idea of | |
| // having only internal 'metaactions', and not the original | |
| // GDIMetaFile now looks a lot less attractive. Try to move | |
| // into the direction of having a direct GDIMetaFile2XCanvas | |
| // renderer, and maybe a separate metafile XCanvas | |
| // implementation. | |
| bool TransparencyGroupAction::render( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| Subset aSubset; | |
| aSubset.mnSubsetBegin = 0; | |
| aSubset.mnSubsetEnd = -1; | |
| return render( rTransformation, aSubset ); | |
| } | |
| ::basegfx::B2DRange TransparencyGroupAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const | |
| { | |
| rendering::RenderState aLocalState( maState ); | |
| ::canvas::tools::prependToRenderState(aLocalState, rTransformation); | |
| return tools::calcDevicePixelBounds( | |
| ::basegfx::B2DRange( 0,0, | |
| maDstSize.getX(), | |
| maDstSize.getY() ), | |
| mpCanvas->getViewState(), | |
| aLocalState ); | |
| } | |
| ::basegfx::B2DRange TransparencyGroupAction::getBounds( const ::basegfx::B2DHomMatrix& rTransformation, | |
| const Subset& rSubset ) const | |
| { | |
| // TODO(F3): Currently, the bounds for | |
| // TransparencyGroupAction subsets equal those of the | |
| // full set, although this action is able to render | |
| // true subsets. | |
| // polygon only contains a single action, empty bounds | |
| // if subset requests different range | |
| if( rSubset.mnSubsetBegin != 0 || | |
| rSubset.mnSubsetEnd != 1 ) | |
| return ::basegfx::B2DRange(); | |
| return getBounds( rTransformation ); | |
| } | |
| sal_Int32 TransparencyGroupAction::getActionCount() const | |
| { | |
| return mpGroupMtf.get() ? mpGroupMtf->GetActionCount() : 0; | |
| } | |
| } | |
| ActionSharedPtr TransparencyGroupActionFactory::createTransparencyGroupAction( MtfAutoPtr& rGroupMtf, | |
| const Renderer::Parameters& rParms, | |
| const ::basegfx::B2DPoint& rDstPoint, | |
| const ::basegfx::B2DVector& rDstSize, | |
| double nAlpha, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) | |
| { | |
| return ActionSharedPtr( new TransparencyGroupAction(rGroupMtf, | |
| rParms, | |
| rDstPoint, | |
| rDstSize, | |
| nAlpha, | |
| rCanvas, | |
| rState ) ); | |
| } | |
| ActionSharedPtr TransparencyGroupActionFactory::createTransparencyGroupAction( MtfAutoPtr& rGroupMtf, | |
| GradientAutoPtr& rAlphaGradient, | |
| const Renderer::Parameters& rParms, | |
| const ::basegfx::B2DPoint& rDstPoint, | |
| const ::basegfx::B2DVector& rDstSize, | |
| const CanvasSharedPtr& rCanvas, | |
| const OutDevState& rState ) | |
| { | |
| return ActionSharedPtr( new TransparencyGroupAction(rGroupMtf, | |
| rAlphaGradient, | |
| rParms, | |
| rDstPoint, | |
| rDstSize, | |
| rCanvas, | |
| rState ) ); | |
| } | |
| } | |
| } |