/************************************************************** * * 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 #include #include #include "cairo_canvasbitmap.hxx" #ifdef CAIRO_HAS_XLIB_SURFACE # include "cairo_xlib_cairo.hxx" #elif defined CAIRO_HAS_QUARTZ_SURFACE # include "cairo_quartz_cairo.hxx" #elif defined CAIRO_HAS_WIN32_SURFACE # include "cairo_win32_cairo.hxx" # include #else # error Native API needed. #endif using namespace ::cairo; using namespace ::com::sun::star; #ifdef CAIRO_HAS_WIN32_SURFACE namespace { HBITMAP surface2HBitmap( const SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize ) { // cant seem to retrieve HBITMAP from cairo. copy content then HDC hScreenDC=GetDC(NULL); HBITMAP hBmpBitmap = CreateCompatibleBitmap( hScreenDC, rSize.getX(), rSize.getY() ); HDC hBmpDC = CreateCompatibleDC( 0 ); HBITMAP hBmpOld = (HBITMAP) SelectObject( hBmpDC, hBmpBitmap ); BitBlt( hBmpDC, 0, 0, rSize.getX(), rSize.getX(), cairo_win32_surface_get_dc(rSurface->getCairoSurface().get()), 0, 0, SRCCOPY ); SelectObject( hBmpDC, hBmpOld ); DeleteDC( hBmpDC ); return hBmpBitmap; } } #endif namespace cairocanvas { CanvasBitmap::CanvasBitmap( const ::basegfx::B2ISize& rSize, const SurfaceProviderRef& rSurfaceProvider, rendering::XGraphicDevice* pDevice, bool bHasAlpha ) : mpSurfaceProvider( rSurfaceProvider ), mpBufferSurface(), mpBufferCairo(), maSize(rSize), mbHasAlpha(bHasAlpha) { ENSURE_OR_THROW( mpSurfaceProvider.is(), "CanvasBitmap::CanvasBitmap(): Invalid surface or device" ); OSL_TRACE( "bitmap size: %dx%d", rSize.getX(), rSize.getY() ); mpBufferSurface = mpSurfaceProvider->createSurface( rSize, bHasAlpha ? CAIRO_CONTENT_COLOR_ALPHA : CAIRO_CONTENT_COLOR ); mpBufferCairo = mpBufferSurface->getCairo(); maCanvasHelper.init( rSize, *mpSurfaceProvider, pDevice ); maCanvasHelper.setSurface( mpBufferSurface, bHasAlpha ); // clear bitmap to 100% transparent maCanvasHelper.clear(); } void SAL_CALL CanvasBitmap::disposing() { mpSurfaceProvider.clear(); mpBufferCairo.reset(); mpBufferSurface.reset(); // forward to parent CanvasBitmap_Base::disposing(); } SurfaceSharedPtr CanvasBitmap::getSurface() { return mpBufferSurface; } SurfaceSharedPtr CanvasBitmap::createSurface( const ::basegfx::B2ISize& rSize, Content aContent ) { return mpSurfaceProvider->createSurface(rSize,aContent); } SurfaceSharedPtr CanvasBitmap::createSurface( ::Bitmap& rBitmap ) { return mpSurfaceProvider->createSurface(rBitmap); } SurfaceSharedPtr CanvasBitmap::changeSurface( bool, bool ) { // non-modifiable surface here return SurfaceSharedPtr(); } OutputDevice* CanvasBitmap::getOutputDevice() { return mpSurfaceProvider->getOutputDevice(); } bool CanvasBitmap::repaint( const SurfaceSharedPtr& pSurface, const rendering::ViewState& viewState, const rendering::RenderState& renderState ) { return maCanvasHelper.repaint( pSurface, viewState, renderState ); } uno::Any SAL_CALL CanvasBitmap::getFastPropertyValue( sal_Int32 nHandle ) throw (uno::RuntimeException) { uno::Any aRV( sal_Int32(0) ); // 0 ... get BitmapEx // 1 ... get Pixbuf with bitmap RGB content // 2 ... get Pixbuf with bitmap alpha mask switch( nHandle ) { case 0: { aRV = uno::Any( reinterpret_cast( (BitmapEx*) NULL ) ); break; } case 1: { #ifdef CAIRO_HAS_XLIB_SURFACE X11Surface* pXlibSurface=dynamic_cast(mpBufferSurface.get()); OSL_ASSERT(pXlibSurface); uno::Sequence< uno::Any > args( 3 ); args[0] = uno::Any( false ); // do not call XFreePixmap on it args[1] = uno::Any( pXlibSurface->getPixmap()->mhDrawable ); args[2] = uno::Any( sal_Int32( pXlibSurface->getDepth() ) ); aRV = uno::Any( args ); #elif defined CAIRO_HAS_QUARTZ_SURFACE QuartzSurface* pQuartzSurface = dynamic_cast(mpBufferSurface.get()); OSL_ASSERT(pQuartzSurface); uno::Sequence< uno::Any > args( 1 ); args[0] = uno::Any( sal_IntPtr (pQuartzSurface->getCGContext()) ); aRV = uno::Any( args ); #elif defined CAIRO_HAS_WIN32_SURFACE // TODO(F2): check whether under all circumstances, // the alpha channel is ignored here. uno::Sequence< uno::Any > args( 1 ); args[1] = uno::Any( sal_Int64(surface2HBitmap(mpBufferSurface,maSize)) ); aRV = uno::Any( args ); // caller frees the bitmap #else # error Please define fast prop retrieval for your platform! #endif break; } case 2: { #ifdef CAIRO_HAS_XLIB_SURFACE uno::Sequence< uno::Any > args( 3 ); SurfaceSharedPtr pAlphaSurface = mpSurfaceProvider->createSurface( maSize, CAIRO_CONTENT_COLOR ); CairoSharedPtr pAlphaCairo = pAlphaSurface->getCairo(); X11Surface* pXlibSurface=dynamic_cast(pAlphaSurface.get()); OSL_ASSERT(pXlibSurface); // create RGB image (levels of gray) of alpha channel of original picture cairo_set_source_rgba( pAlphaCairo.get(), 1, 1, 1, 1 ); cairo_set_operator( pAlphaCairo.get(), CAIRO_OPERATOR_SOURCE ); cairo_paint( pAlphaCairo.get() ); cairo_set_source_surface( pAlphaCairo.get(), mpBufferSurface->getCairoSurface().get(), 0, 0 ); cairo_set_operator( pAlphaCairo.get(), CAIRO_OPERATOR_XOR ); cairo_paint( pAlphaCairo.get() ); pAlphaCairo.reset(); X11PixmapSharedPtr pPixmap = pXlibSurface->getPixmap(); args[0] = uno::Any( true ); args[1] = ::com::sun::star::uno::Any( pPixmap->mhDrawable ); args[2] = ::com::sun::star::uno::Any( sal_Int32( pXlibSurface->getDepth () ) ); pPixmap->clear(); // caller takes ownership of pixmap // return pixmap and alphachannel pixmap - it will be used in BitmapEx aRV = uno::Any( args ); #elif defined CAIRO_HAS_QUARTZ_SURFACE SurfaceSharedPtr pAlphaSurface = mpSurfaceProvider->createSurface( maSize, CAIRO_CONTENT_COLOR ); CairoSharedPtr pAlphaCairo = pAlphaSurface->getCairo(); QuartzSurface* pQuartzSurface=dynamic_cast(pAlphaSurface.get()); OSL_ASSERT(pQuartzSurface); // create RGB image (levels of gray) of alpha channel of original picture cairo_set_source_rgba( pAlphaCairo.get(), 1, 1, 1, 1 ); cairo_set_operator( pAlphaCairo.get(), CAIRO_OPERATOR_SOURCE ); cairo_paint( pAlphaCairo.get() ); cairo_set_source_surface( pAlphaCairo.get(), mpBufferSurface->getCairoSurface().get(), 0, 0 ); cairo_set_operator( pAlphaCairo.get(), CAIRO_OPERATOR_XOR ); cairo_paint( pAlphaCairo.get() ); pAlphaCairo.reset(); uno::Sequence< uno::Any > args( 1 ); args[0] = uno::Any( sal_IntPtr (pQuartzSurface->getCGContext()) ); // return ??? and alphachannel ??? - it will be used in BitmapEx aRV = uno::Any( args ); #elif defined CAIRO_HAS_WIN32_SURFACE SurfaceSharedPtr pAlphaSurface = mpSurfaceProvider->createSurface( maSize, CAIRO_CONTENT_COLOR ); CairoSharedPtr pAlphaCairo = pAlphaSurface->getCairo(); // create RGB image (levels of gray) of alpha channel of original picture cairo_set_source_rgba( pAlphaCairo.get(), 1, 1, 1, 1 ); cairo_set_operator( pAlphaCairo.get(), CAIRO_OPERATOR_SOURCE ); cairo_paint( pAlphaCairo.get() ); cairo_set_source_surface( pAlphaCairo.get(), mpBufferSurface->getCairoSurface().get(), 0, 0 ); cairo_set_operator( pAlphaCairo.get(), CAIRO_OPERATOR_XOR ); cairo_paint( pAlphaCairo.get() ); pAlphaCairo.reset(); // cant seem to retrieve HBITMAP from cairo. copy content then uno::Sequence< uno::Any > args( 1 ); args[1] = uno::Any( sal_Int64(surface2HBitmap(pAlphaSurface,maSize)) ); aRV = uno::Any( args ); // caller frees the bitmap #else # error Please define fast prop retrieval for your platform! #endif break; } } return aRV; } #define IMPLEMENTATION_NAME "CairoCanvas.CanvasBitmap" #define SERVICE_NAME "com.sun.star.rendering.CanvasBitmap" ::rtl::OUString SAL_CALL CanvasBitmap::getImplementationName( ) throw (uno::RuntimeException) { return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( IMPLEMENTATION_NAME ) ); } sal_Bool SAL_CALL CanvasBitmap::supportsService( const ::rtl::OUString& ServiceName ) throw (uno::RuntimeException) { return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( SERVICE_NAME ) ); } uno::Sequence< ::rtl::OUString > SAL_CALL CanvasBitmap::getSupportedServiceNames( ) throw (uno::RuntimeException) { uno::Sequence< ::rtl::OUString > aRet(1); aRet[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( SERVICE_NAME ) ); return aRet; } }