/************************************************************** * * 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" #ifdef QUARTZ /************************************************************************ * Mac OS X/Quartz surface backend for OpenOffice.org Cairo Canvas * ************************************************************************/ #include #include #include #include #include "cairo_cairo.hxx" #if defined CAIRO_HAS_QUARTZ_SURFACE #include "cairo_quartz_cairo.hxx" namespace cairo { bool IsCairoWorking( OutputDevice* ) { // trivially true for Mac return true; } /** * QuartzSurface::Surface: Create generic Canvas surface using given Cairo Surface * * @param pSurface Cairo Surface * * This constructor only stores data, it does no processing. * It is used with e.g. cairo_image_surface_create_for_data() * and QuartzSurface::getSimilar() * * Set the mpSurface to the new surface or NULL **/ QuartzSurface::QuartzSurface( const CairoSurfaceSharedPtr& pSurface ) : mpView(NULL), mpSurface( pSurface ) { // Necessary, context is lost otherwise CGContextRetain( getCGContext() ); // == NULL for non-native surfaces } /** * QuartzSurface::Surface: Create Canvas surface from Window reference. * @param NSView * @param x horizontal location of the new surface * @param y vertical location of the new surface * @param width width of the new surface * @param height height of the new surface * * pSysData contains the platform native Window reference. * pSysData is used to create a surface on the Window * * Set the mpSurface to the new surface or NULL **/ QuartzSurface::QuartzSurface( NSView* pView, int x, int y, int width, int height ) : mpView(pView), mpSurface() { OSL_TRACE("Canvas::cairo::Surface(NSView*, x:%d, y:%d, w:%d, h:%d): New Surface for window", x, y, width, height); // on Mac OS X / Quartz we are not drawing directly to the screen, but via regular CGContextRef. // The actual drawing to NSView (i.e. screen) is done in QuartzSurface::flush() // HACK: currently initial size for windowsurface is 0x0, which is not possible for us. if (width == 0 || height == 0) { width = [mpView bounds].size.width; height = [mpView bounds].size.height; OSL_TRACE("Canvas::cairo::Surface(): BUG!! size is ZERO! fixing to %d x %d...", width, height); } // create a generic surface, NSView/Window is ARGB32. mpSurface.reset( cairo_quartz_surface_create(CAIRO_FORMAT_ARGB32, width, height), &cairo_surface_destroy); cairo_surface_set_device_offset( mpSurface.get(), x, y ); } /** * QuartzSurface::Surface: Create Canvas surface from CGContextRef. * @param CGContext Native graphics context * @param x horizontal location of the new surface * @param y vertical location of the new surface * @param width width of the new surface * @param height height of the new surface * * Set the mpSurface to the new surface or NULL **/ QuartzSurface::QuartzSurface( CGContextRef rContext, int x, int y, int width, int height ) : mpView(NULL), mpSurface() { OSL_TRACE("Canvas::cairo::Surface(CGContext:%p, x:%d, y:%d, w:%d, h:%d): New Surface.", rContext, x, y, width, height); // create surface based on CGContext // ensure kCGBitmapByteOrder32Host flag, otherwise Cairo breaks (we are practically always using CGBitmapContext) OSL_ASSERT ((CGBitmapContextGetBitsPerPixel(rContext) != 32) || (CGBitmapContextGetBitmapInfo(rContext) & kCGBitmapByteOrderMask) == kCGBitmapByteOrder32Host); mpSurface.reset(cairo_quartz_surface_create_for_cg_context(rContext, width, height), &cairo_surface_destroy); cairo_surface_set_device_offset( mpSurface.get(), x, y ); // Necessary, context is lost otherwise CGContextRetain(rContext); } /** * QuartzSurface::getCairo: Create Cairo (drawing object) for the Canvas surface * * @return new Cairo or NULL **/ CairoSharedPtr QuartzSurface::getCairo() const { if (mpSurface.get()){ return CairoSharedPtr( cairo_create(mpSurface.get()), &cairo_destroy ); } else { return CairoSharedPtr(); } } /** * QuartzSurface::getSimilar: Create new similar Canvas surface * @param aContent format of the new surface (cairo_content_t from cairo/src/cairo.h) * @param width width of the new surface * @param height height of the new surface * * Creates a new Canvas surface. This normally creates platform native surface, even though * generic function is used. * * Cairo surface from aContent (cairo_content_t) * * @return new surface or NULL **/ SurfaceSharedPtr QuartzSurface::getSimilar( Content aContent, int width, int height ) const { return SurfaceSharedPtr( new QuartzSurface( CairoSurfaceSharedPtr( cairo_surface_create_similar( mpSurface.get(), aContent, width, height ), &cairo_surface_destroy ))); } /** * QuartzSurface::Resize: Resizes the Canvas surface. * @param width new width of the surface * @param height new height of the surface * * Only used on X11. * * @return The new surface or NULL **/ void QuartzSurface::Resize( int width, int height ) { OSL_ENSURE(false,"not supposed to be called!"); } /** * QuartzSurface::flush: Draw the data to screen **/ void QuartzSurface::flush() const { // can only flush surfaces with NSView if( !mpView ) return; OSL_TRACE("Canvas::cairo::QuartzSurface::flush(): flush to NSView"); CGContextRef mrContext = getCGContext(); if (!mrContext) return; [mpView lockFocus]; /** * This code is using same screen update code as in VCL (esp. AquaSalGraphics::UpdateWindow() ) */ CGContextRef rViewContext = reinterpret_cast([[NSGraphicsContext currentContext] graphicsPort]); CGImageRef xImage = CGBitmapContextCreateImage(mrContext); CGContextDrawImage(rViewContext, CGRectMake( 0, 0, CGImageGetWidth(xImage), CGImageGetHeight(xImage)), xImage); CGImageRelease( xImage ); CGContextFlush( rViewContext ); [mpView unlockFocus]; } /** * QuartzSurface::getDepth: Get the color depth of the Canvas surface. * * @return color depth **/ int QuartzSurface::getDepth() const { if (mpSurface.get()) { switch (cairo_surface_get_content (mpSurface.get())) { case CAIRO_CONTENT_ALPHA: return 8; break; case CAIRO_CONTENT_COLOR: return 24; break; case CAIRO_CONTENT_COLOR_ALPHA: return 32; break; } } OSL_TRACE("Canvas::cairo::QuartzSurface::getDepth(): ERROR - depth unspecified!"); return -1; } /** * QuartzSurface::getCGContext: Get the native CGContextRef of the Canvas's cairo surface * * @return graphics context **/ CGContextRef QuartzSurface::getCGContext() const { if (mpSurface.get()) return cairo_quartz_surface_get_cg_context(mpSurface.get()); else return NULL; } /** * cairo::createVirtualDevice: Create a VCL virtual device for the CGContext in the cairo Surface * * @return The new virtual device **/ boost::shared_ptr QuartzSurface::createVirtualDevice() const { SystemGraphicsData aSystemGraphicsData; aSystemGraphicsData.nSize = sizeof(SystemGraphicsData); aSystemGraphicsData.rCGContext = getCGContext(); return boost::shared_ptr( new VirtualDevice( &aSystemGraphicsData, getDepth() )); } /** * cairo::createSurface: Create generic Canvas surface using given Cairo Surface * * @param rSurface Cairo Surface * * @return new Surface */ SurfaceSharedPtr createSurface( const CairoSurfaceSharedPtr& rSurface ) { return SurfaceSharedPtr(new QuartzSurface(rSurface)); } /** * cairo::createSurface: Create Canvas surface using given VCL Window or Virtualdevice * * @param rSurface Cairo Surface * * For VCL Window, use platform native system environment data (struct SystemEnvData in vcl/inc/sysdata.hxx) * For VCL Virtualdevice, use platform native system graphics data (struct SystemGraphicsData in vcl/inc/sysdata.hxx) * * @return new Surface */ SurfaceSharedPtr createSurface( const OutputDevice& rRefDevice, int x, int y, int width, int height ) { SurfaceSharedPtr surf; if( rRefDevice.GetOutDevType() == OUTDEV_WINDOW ) { const Window &rWindow = (const Window &) rRefDevice; const SystemEnvData* pSysData = GetSysData(&rWindow); if (pSysData) surf = SurfaceSharedPtr(new QuartzSurface(pSysData->pView, x, y, width, height)); } else if( rRefDevice.GetOutDevType() == OUTDEV_VIRDEV ) { SystemGraphicsData aSysData = ((const VirtualDevice&) rRefDevice).GetSystemGfxData(); if (aSysData.rCGContext) surf = SurfaceSharedPtr(new QuartzSurface(aSysData.rCGContext, x, y, width, height)); } return surf; } /** * cairo::createBitmapSurface: Create platfrom native Canvas surface from BitmapSystemData * @param OutputDevice (not used) * @param rData Platform native image data (struct BitmapSystemData in vcl/inc/bitmap.hxx) * @param rSize width and height of the new surface * * Create a surface based on image data on rData * * @return new surface or empty surface **/ SurfaceSharedPtr createBitmapSurface( const OutputDevice& /* rRefDevice */, const BitmapSystemData& rData, const Size& rSize ) { OSL_TRACE( "requested size: %d x %d available size: %d x %d", rSize.Width(), rSize.Height(), rData.mnWidth, rData.mnHeight ); if ( rData.mnWidth == rSize.Width() && rData.mnHeight == rSize.Height() ) { CGContextRef rContext = (CGContextRef)rData.rImageContext; OSL_TRACE("Canvas::cairo::createBitmapSurface(): New native image surface, context = %p.", rData.rImageContext); return SurfaceSharedPtr(new QuartzSurface(rContext, 0, 0, rData.mnWidth, rData.mnHeight)); } return SurfaceSharedPtr(); } } // namespace cairo #endif // CAIRO_HAS_QUARTZ_SURFACE #endif // QUARTZ