| /************************************************************** |
| * |
| * 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 <rtl/instance.hxx> |
| #include <osl/getglobalmutex.hxx> |
| #include <osl/diagnose.h> |
| #include <com/sun/star/rendering/InterpolationMode.hpp> |
| #include <vcl/window.hxx> |
| #include <vcl/graph.hxx> |
| #include <vcl/canvastools.hxx> |
| #include <basegfx/polygon/b2dpolypolygon.hxx> |
| |
| #include <cppcanvas/vclfactory.hxx> |
| |
| #include <implbitmapcanvas.hxx> |
| #include <implspritecanvas.hxx> |
| #include <implpolypolygon.hxx> |
| #include <implbitmap.hxx> |
| #include <implrenderer.hxx> |
| #include <impltext.hxx> |
| #include <implsprite.hxx> |
| |
| |
| using namespace ::com::sun::star; |
| |
| namespace cppcanvas |
| { |
| /* Singleton handling */ |
| struct InitInstance |
| { |
| VCLFactory* operator()() |
| { |
| return new VCLFactory(); |
| } |
| }; |
| |
| VCLFactory& VCLFactory::getInstance() |
| { |
| return *rtl_Instance< VCLFactory, InitInstance, ::osl::MutexGuard, |
| ::osl::GetGlobalMutex >::create( |
| InitInstance(), ::osl::GetGlobalMutex()); |
| } |
| |
| VCLFactory::VCLFactory() |
| { |
| } |
| |
| VCLFactory::~VCLFactory() |
| { |
| } |
| |
| BitmapCanvasSharedPtr VCLFactory::createCanvas( const ::Window& rVCLWindow ) |
| { |
| return BitmapCanvasSharedPtr( |
| new internal::ImplBitmapCanvas( |
| uno::Reference< rendering::XBitmapCanvas >( |
| rVCLWindow.GetCanvas(), |
| uno::UNO_QUERY) ) ); |
| } |
| |
| BitmapCanvasSharedPtr VCLFactory::createCanvas( const uno::Reference< rendering::XBitmapCanvas >& xCanvas ) |
| { |
| return BitmapCanvasSharedPtr( |
| new internal::ImplBitmapCanvas( xCanvas ) ); |
| } |
| |
| SpriteCanvasSharedPtr VCLFactory::createSpriteCanvas( const ::Window& rVCLWindow ) const |
| { |
| return SpriteCanvasSharedPtr( |
| new internal::ImplSpriteCanvas( |
| uno::Reference< rendering::XSpriteCanvas >( |
| rVCLWindow.GetSpriteCanvas(), |
| uno::UNO_QUERY) ) ); |
| } |
| |
| SpriteCanvasSharedPtr VCLFactory::createSpriteCanvas( const uno::Reference< rendering::XSpriteCanvas >& xCanvas ) const |
| { |
| return SpriteCanvasSharedPtr( |
| new internal::ImplSpriteCanvas( xCanvas ) ); |
| } |
| |
| SpriteCanvasSharedPtr VCLFactory::createFullscreenSpriteCanvas( const ::Window& rVCLWindow, |
| const Size& rFullscreenSize ) const |
| { |
| return SpriteCanvasSharedPtr( |
| new internal::ImplSpriteCanvas( |
| uno::Reference< rendering::XSpriteCanvas >( |
| rVCLWindow.GetFullscreenSpriteCanvas( rFullscreenSize ), |
| uno::UNO_QUERY) ) ); |
| } |
| |
| PolyPolygonSharedPtr VCLFactory::createPolyPolygon( const CanvasSharedPtr& rCanvas, |
| const ::Polygon& rPoly ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createPolyPolygon(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return PolyPolygonSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return PolyPolygonSharedPtr(); |
| |
| return PolyPolygonSharedPtr( |
| new internal::ImplPolyPolygon( rCanvas, |
| ::vcl::unotools::xPolyPolygonFromPolygon( |
| xCanvas->getDevice(), |
| rPoly) ) ); |
| } |
| |
| PolyPolygonSharedPtr VCLFactory::createPolyPolygon( const CanvasSharedPtr& rCanvas, |
| const ::PolyPolygon& rPolyPoly ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createPolyPolygon(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return PolyPolygonSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return PolyPolygonSharedPtr(); |
| |
| return PolyPolygonSharedPtr( |
| new internal::ImplPolyPolygon( rCanvas, |
| ::vcl::unotools::xPolyPolygonFromPolyPolygon( |
| xCanvas->getDevice(), |
| rPolyPoly) ) ); |
| } |
| |
| BitmapSharedPtr VCLFactory::createBitmap( const CanvasSharedPtr& rCanvas, |
| const ::Size& rSize ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createBitmap(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return BitmapSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return BitmapSharedPtr(); |
| |
| return BitmapSharedPtr( |
| new internal::ImplBitmap( rCanvas, |
| xCanvas->getDevice()->createCompatibleBitmap( |
| ::vcl::unotools::integerSize2DFromSize(rSize) ) ) ); |
| } |
| |
| BitmapSharedPtr VCLFactory::createAlphaBitmap( const CanvasSharedPtr& rCanvas, |
| const ::Size& rSize ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createBitmap(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return BitmapSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return BitmapSharedPtr(); |
| |
| return BitmapSharedPtr( |
| new internal::ImplBitmap( rCanvas, |
| xCanvas->getDevice()->createCompatibleAlphaBitmap( |
| ::vcl::unotools::integerSize2DFromSize(rSize) ) ) ); |
| } |
| |
| BitmapSharedPtr VCLFactory::createBitmap( const CanvasSharedPtr& rCanvas, |
| const ::Bitmap& rBitmap ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createBitmap(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return BitmapSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return BitmapSharedPtr(); |
| |
| return BitmapSharedPtr( new internal::ImplBitmap( rCanvas, |
| ::vcl::unotools::xBitmapFromBitmap( |
| xCanvas->getDevice(), |
| rBitmap) ) ); |
| } |
| |
| BitmapSharedPtr VCLFactory::createBitmap( const CanvasSharedPtr& rCanvas, |
| const ::BitmapEx& rBmpEx ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createBitmap(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return BitmapSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return BitmapSharedPtr(); |
| |
| return BitmapSharedPtr( new internal::ImplBitmap( rCanvas, |
| ::vcl::unotools::xBitmapFromBitmapEx( |
| xCanvas->getDevice(), |
| rBmpEx) ) ); |
| } |
| |
| RendererSharedPtr VCLFactory::createRenderer( const CanvasSharedPtr& rCanvas, |
| const ::Graphic& rGraphic, |
| const Renderer::Parameters& rParms ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createRenderer(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return RendererSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return RendererSharedPtr(); |
| |
| if( rGraphic.GetType() == GRAPHIC_GDIMETAFILE ) |
| return RendererSharedPtr( new internal::ImplRenderer( rCanvas, |
| rGraphic.GetGDIMetaFile(), |
| rParms ) ); |
| else |
| return RendererSharedPtr( new internal::ImplRenderer( rCanvas, |
| rGraphic.GetBitmapEx(), |
| rParms ) ); |
| } |
| |
| RendererSharedPtr VCLFactory::createRenderer( const CanvasSharedPtr& rCanvas, |
| const ::GDIMetaFile& rMtf, |
| const Renderer::Parameters& rParms ) const |
| { |
| return RendererSharedPtr( new internal::ImplRenderer( rCanvas, |
| rMtf, |
| rParms ) ); |
| } |
| |
| SpriteSharedPtr VCLFactory::createAnimatedSprite( const SpriteCanvasSharedPtr& rCanvas, const ::Animation& rAnim ) const |
| { |
| OSL_ENSURE( rCanvas.get() != NULL && |
| rCanvas->getUNOCanvas().is(), |
| "VCLFactory::createAnimatedSprite(): Invalid canvas" ); |
| |
| if( rCanvas.get() == NULL ) |
| return SpriteSharedPtr(); |
| |
| uno::Reference< rendering::XCanvas > xCanvas( rCanvas->getUNOCanvas() ); |
| if( !xCanvas.is() ) |
| return SpriteSharedPtr(); |
| |
| uno::Reference< rendering::XSpriteCanvas > xSpriteCanvas( rCanvas->getUNOSpriteCanvas() ); |
| if( !xSpriteCanvas.is() ) |
| return SpriteSharedPtr(); |
| |
| if( rAnim.IsEmpty() ) |
| return SpriteSharedPtr(); |
| |
| internal::ImplSpriteCanvas* pSpriteCanvas = dynamic_cast< internal::ImplSpriteCanvas* >( rCanvas.get() ); |
| if( !pSpriteCanvas ) |
| return SpriteSharedPtr(); |
| |
| const sal_uInt16 nBitmaps( rAnim.Count() ); |
| uno::Sequence< uno::Reference< rendering::XBitmap > > aBitmapSequence( nBitmaps ); |
| uno::Reference< rendering::XBitmap >* pBitmaps = aBitmapSequence.getArray(); |
| |
| unsigned int i; |
| BitmapEx aBmpEx; |
| BitmapEx aRestoreBuffer; |
| aBmpEx.SetSizePixel( rAnim.GetDisplaySizePixel() ); |
| aRestoreBuffer.SetSizePixel( rAnim.GetDisplaySizePixel() ); |
| aBmpEx.Erase( ::Color( 255, 0,0,0 ) ); // clear alpha channel |
| aRestoreBuffer = aBmpEx; |
| const Point aEmptyPoint; |
| |
| for( i=0; i<nBitmaps; ++i ) |
| { |
| const AnimationBitmap& rAnimBmp( rAnim.Get((sal_uInt16)i) ); |
| |
| // Handle dispose according to GIF spec: a |
| // DISPOSE_PREVIOUS does _not_ mean to revert to the |
| // previous frame, but to revert to the last frame with |
| // DISPOSE_NOT |
| |
| // dispose previous |
| if( rAnimBmp.eDisposal == DISPOSE_BACK ) |
| { |
| // simply clear bitmap to transparent |
| aBmpEx.Erase( ::Color( 255, 0,0,0 ) ); |
| } |
| else if( rAnimBmp.eDisposal == DISPOSE_PREVIOUS ) |
| { |
| // copy in last known full frame |
| aBmpEx = aRestoreBuffer; |
| } |
| // I have exactly _no_ idea what DISPOSE_FULL is supposed |
| // to do. It's apparently not set anywhere in our code |
| OSL_ENSURE( rAnimBmp.eDisposal!=DISPOSE_FULL, |
| "VCLFactory::createAnimatedSprite(): Somebody set the deprecated DISPOSE_FULL at the Animation" ); |
| |
| // update display |
| aBmpEx.CopyPixel( Rectangle( rAnimBmp.aPosPix, |
| rAnimBmp.aSizePix ), |
| Rectangle( aEmptyPoint, |
| rAnimBmp.aSizePix ), |
| &rAnimBmp.aBmpEx ); |
| |
| // store last DISPOSE_NOT frame, for later |
| // DISPOSE_PREVIOUS updates |
| if( rAnimBmp.eDisposal == DISPOSE_NOT ) |
| aRestoreBuffer = aBmpEx; |
| |
| pBitmaps[i] = ::vcl::unotools::xBitmapFromBitmapEx( |
| xCanvas->getDevice(), |
| aBmpEx); |
| } |
| |
| return pSpriteCanvas->createSpriteFromBitmaps( aBitmapSequence, |
| rendering::InterpolationMode::NEAREST_NEIGHBOR ); |
| } |
| |
| TextSharedPtr VCLFactory::createText( const CanvasSharedPtr& rCanvas, const ::rtl::OUString& rText ) const |
| { |
| return TextSharedPtr( new internal::ImplText( rCanvas, |
| rText ) ); |
| } |
| |
| } |
