/**************************************************************
*
* 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 <canvas/canvastools.hxx>
#include <tools/diagnose_ex.h>
#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 <cairo-win32.h>
#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<sal_Int64>( (BitmapEx*) NULL ) );
break;
}
case 1:
{
#ifdef CAIRO_HAS_XLIB_SURFACE
X11Surface* pXlibSurface=dynamic_cast<X11Surface*>(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<QuartzSurface*>(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<X11Surface*>(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<QuartzSurface*>(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;
}
}