canvas/source/vcl/devicehelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: devicehelper.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_canvas.hxx"
  33
  34 #include <canvas/debug.hxx>
  35 #include <tools/diagnose_ex.h>
  36 #include <canvas/canvastools.hxx>
  37
  38 #include <rtl/instance.hxx>
  39 #include <toolkit/helper/vclunohelper.hxx>
  40 #include <vcl/canvastools.hxx>
  41 #include <basegfx/tools/canvastools.hxx>
  42 #include <basegfx/tools/unopolypolygon.hxx>
  43
  44 #include "devicehelper.hxx"
  45 #include "spritecanvas.hxx"
  46 #include "spritecanvashelper.hxx"
  47 #include "canvasbitmap.hxx"
  48
  49
  50 using namespace ::com::sun::star;
  51
  52 namespace vclcanvas
  53 {
  54     DeviceHelper::DeviceHelper() :
  55         mpOutDev()
  56     {}
  57
  58     void DeviceHelper::init( const OutDevProviderSharedPtr& rOutDev )
  59     {
  60         mpOutDev = rOutDev;
  61     }
  62
  63     geometry::RealSize2D DeviceHelper::getPhysicalResolution()
  64     {
  65         if( !mpOutDev )
  66             return ::canvas::tools::createInfiniteSize2D(); // we're disposed
  67
  68         // Map a one-by-one millimeter box to pixel
  69         OutputDevice& rOutDev = mpOutDev->getOutDev();
  70         const MapMode aOldMapMode( rOutDev.GetMapMode() );
  71         rOutDev.SetMapMode( MapMode(MAP_MM) );
  72         const Size aPixelSize( rOutDev.LogicToPixel(Size(1,1)) );
  73         rOutDev.SetMapMode( aOldMapMode );
  74
  75         return ::vcl::unotools::size2DFromSize( aPixelSize );
  76     }
  77
  78     geometry::RealSize2D DeviceHelper::getPhysicalSize()
  79     {
  80         if( !mpOutDev )
  81             return ::canvas::tools::createInfiniteSize2D(); // we're disposed
  82
  83         // Map the pixel dimensions of the output window to millimeter
  84         OutputDevice& rOutDev = mpOutDev->getOutDev();
  85         const MapMode aOldMapMode( rOutDev.GetMapMode() );
  86         rOutDev.SetMapMode( MapMode(MAP_MM) );
  87         const Size aLogSize( rOutDev.PixelToLogic(rOutDev.GetOutputSizePixel()) );
  88         rOutDev.SetMapMode( aOldMapMode );
  89
  90         return ::vcl::unotools::size2DFromSize( aLogSize );
  91     }
  92
  93     uno::Reference< rendering::XLinePolyPolygon2D > DeviceHelper::createCompatibleLinePolyPolygon(
  94         const uno::Reference< rendering::XGraphicDevice >&                              ,
  95         const uno::Sequence< uno::Sequence< geometry::RealPoint2D > >&  points )
  96     {
  97         uno::Reference< rendering::XLinePolyPolygon2D > xPoly;
  98         if( !mpOutDev )
  99             return xPoly; // we're disposed
 100
 101         xPoly.set( new ::basegfx::unotools::UnoPolyPolygon(
 102                        ::basegfx::unotools::polyPolygonFromPoint2DSequenceSequence( points ) ) );
 103         // vcl only handles even_odd polygons
 104         xPoly->setFillRule(rendering::FillRule_EVEN_ODD);
 105
 106         return xPoly;
 107     }
 108
 109     uno::Reference< rendering::XBezierPolyPolygon2D > DeviceHelper::createCompatibleBezierPolyPolygon(
 110         const uno::Reference< rendering::XGraphicDevice >&                                              ,
 111         const uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > >&  points )
 112     {
 113         uno::Reference< rendering::XBezierPolyPolygon2D > xPoly;
 114         if( !mpOutDev )
 115             return xPoly; // we're disposed
 116
 117         xPoly.set( new ::basegfx::unotools::UnoPolyPolygon(
 118                        ::basegfx::unotools::polyPolygonFromBezier2DSequenceSequence( points ) ) );
 119         // vcl only handles even_odd polygons
 120         xPoly->setFillRule(rendering::FillRule_EVEN_ODD);
 121
 122         return xPoly;
 123     }
 124
 125     uno::Reference< rendering::XBitmap > DeviceHelper::createCompatibleBitmap(
 126         const uno::Reference< rendering::XGraphicDevice >& rDevice,
 127         const geometry::IntegerSize2D&                                     size )
 128     {
 129         if( !mpOutDev )
 130             return uno::Reference< rendering::XBitmap >(); // we're disposed
 131
 132         return uno::Reference< rendering::XBitmap >(
 133             new CanvasBitmap( ::vcl::unotools::sizeFromIntegerSize2D(size),
 134                               false,
 135                               *rDevice.get(),
 136                               mpOutDev ) );
 137     }
 138
 139     uno::Reference< rendering::XVolatileBitmap > DeviceHelper::createVolatileBitmap(
 140         const uno::Reference< rendering::XGraphicDevice >&      ,
 141         const geometry::IntegerSize2D&                                           )
 142     {
 143         return uno::Reference< rendering::XVolatileBitmap >();
 144     }
 145
 146     uno::Reference< rendering::XBitmap > DeviceHelper::createCompatibleAlphaBitmap(
 147         const uno::Reference< rendering::XGraphicDevice >& rDevice,
 148         const geometry::IntegerSize2D&                     size )
 149     {
 150         if( !mpOutDev )
 151             return uno::Reference< rendering::XBitmap >(); // we're disposed
 152
 153         return uno::Reference< rendering::XBitmap >(
 154             new CanvasBitmap( ::vcl::unotools::sizeFromIntegerSize2D(size),
 155                               true,
 156                               *rDevice.get(),
 157                               mpOutDev ) );
 158     }
 159
 160     uno::Reference< rendering::XVolatileBitmap > DeviceHelper::createVolatileAlphaBitmap(
 161         const uno::Reference< rendering::XGraphicDevice >&      ,
 162         const geometry::IntegerSize2D&                                           )
 163     {
 164         return uno::Reference< rendering::XVolatileBitmap >();
 165     }
 166
 167     sal_Bool DeviceHelper::hasFullScreenMode()
 168     {
 169         return false;
 170     }
 171
 172     sal_Bool DeviceHelper::enterFullScreenMode( sal_Bool bEnter )
 173     {
 174         (void)bEnter;
 175         return false;
 176     }
 177
 178     void DeviceHelper::disposing()
 179     {
 180         // release all references
 181         mpOutDev.reset();
 182     }
 183
 184     uno::Any DeviceHelper::isAccelerated() const
 185     {
 186         return ::com::sun::star::uno::makeAny(false);
 187     }
 188
 189     uno::Any DeviceHelper::getDeviceHandle() const
 190     {
 191         if( !mpOutDev )
 192             return uno::Any();
 193
 194         return uno::makeAny(
 195             reinterpret_cast< sal_Int64 >(&mpOutDev->getOutDev()) );
 196     }
 197
 198     uno::Any DeviceHelper::getSurfaceHandle() const
 199     {
 200         return getDeviceHandle();
 201     }
 202
 203     namespace
 204     {
 205         struct DeviceColorSpace: public rtl::StaticWithInit<uno::Reference<rendering::XColorSpace>,
 206                                                             DeviceColorSpace>
 207         {
 208             uno::Reference<rendering::XColorSpace> operator()()
 209             {
 210                 return vcl::unotools::createStandardColorSpace();
 211             }
 212         };
 213     }
 214
 215     uno::Reference<rendering::XColorSpace> DeviceHelper::getColorSpace() const
 216     {
 217         // always the same
 218         return DeviceColorSpace::get();
 219     }
 220
 221     void DeviceHelper::dumpScreenContent() const
 222     {
 223         static sal_uInt32 nFilePostfixCount(0);
 224
 225         if( mpOutDev )
 226         {
 227             String aFilename( String::CreateFromAscii("dbg_frontbuffer") );
 228             aFilename += String::CreateFromInt32(nFilePostfixCount);
 229             aFilename += String::CreateFromAscii(".bmp");
 230
 231             SvFileStream aStream( aFilename, STREAM_STD_READWRITE );
 232
 233             const ::Point aEmptyPoint;
 234             OutputDevice& rOutDev = mpOutDev->getOutDev();
 235             bool bOldMap( rOutDev.IsMapModeEnabled() );
 236             rOutDev.EnableMapMode( FALSE );
 237             aStream << rOutDev.GetBitmap(aEmptyPoint,
 238                                          rOutDev.GetOutputSizePixel());
 239             rOutDev.EnableMapMode( bOldMap );
 240
 241             ++nFilePostfixCount;
 242         }
 243     }
 244
 245 }