canvas/source/vcl/devicehelper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <canvas/debug.hxx>
  21 #include <tools/diagnose_ex.h>
  22 #include <canvas/canvastools.hxx>
  23 #include <rtl/instance.hxx>
  24 #include <toolkit/helper/vclunohelper.hxx>
  25 #include <vcl/canvastools.hxx>
  26 #include <basegfx/tools/canvastools.hxx>
  27 #include <basegfx/tools/unopolypolygon.hxx>
  28 #include <vcl/dibtools.hxx>
  29
  30 #include "devicehelper.hxx"
  31 #include "spritecanvas.hxx"
  32 #include "spritecanvashelper.hxx"
  33 #include "canvasbitmap.hxx"
  34
  35 using namespace ::com::sun::star;
  36
  37 namespace vclcanvas
  38 {
  39     DeviceHelper::DeviceHelper() :
  40         mpOutDev()
  41     {}
  42
  43     void DeviceHelper::init( const OutDevProviderSharedPtr& rOutDev )
  44     {
  45         mpOutDev = rOutDev;
  46     }
  47
  48     geometry::RealSize2D DeviceHelper::getPhysicalResolution()
  49     {
  50         if( !mpOutDev )
  51             return ::canvas::tools::createInfiniteSize2D(); // we're disposed
  52
  53         // Map a one-by-one millimeter box to pixel
  54         OutputDevice& rOutDev = mpOutDev->getOutDev();
  55         const MapMode aOldMapMode( rOutDev.GetMapMode() );
  56         rOutDev.SetMapMode( MapMode(MAP_MM) );
  57         const Size aPixelSize( rOutDev.LogicToPixel(Size(1,1)) );
  58         rOutDev.SetMapMode( aOldMapMode );
  59
  60         return vcl::unotools::size2DFromSize( aPixelSize );
  61     }
  62
  63     geometry::RealSize2D DeviceHelper::getPhysicalSize()
  64     {
  65         if( !mpOutDev )
  66             return ::canvas::tools::createInfiniteSize2D(); // we're disposed
  67
  68         // Map the pixel dimensions of the output window to millimeter
  69         OutputDevice& rOutDev = mpOutDev->getOutDev();
  70         const MapMode aOldMapMode( rOutDev.GetMapMode() );
  71         rOutDev.SetMapMode( MapMode(MAP_MM) );
  72         const Size aLogSize( rOutDev.PixelToLogic(rOutDev.GetOutputSizePixel()) );
  73         rOutDev.SetMapMode( aOldMapMode );
  74
  75         return vcl::unotools::size2DFromSize( aLogSize );
  76     }
  77
  78     uno::Reference< rendering::XLinePolyPolygon2D > DeviceHelper::createCompatibleLinePolyPolygon(
  79         const uno::Reference< rendering::XGraphicDevice >&              ,
  80         const uno::Sequence< uno::Sequence< geometry::RealPoint2D > >&  points )
  81     {
  82         uno::Reference< rendering::XLinePolyPolygon2D > xPoly;
  83         if( !mpOutDev )
  84             return xPoly; // we're disposed
  85
  86         xPoly.set( new ::basegfx::unotools::UnoPolyPolygon(
  87                        ::basegfx::unotools::polyPolygonFromPoint2DSequenceSequence( points ) ) );
  88         // vcl only handles even_odd polygons
  89         xPoly->setFillRule(rendering::FillRule_EVEN_ODD);
  90
  91         return xPoly;
  92     }
  93
  94     uno::Reference< rendering::XBezierPolyPolygon2D > DeviceHelper::createCompatibleBezierPolyPolygon(
  95         const uno::Reference< rendering::XGraphicDevice >&                      ,
  96         const uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > >&  points )
  97     {
  98         uno::Reference< rendering::XBezierPolyPolygon2D > xPoly;
  99         if( !mpOutDev )
 100             return xPoly; // we're disposed
 101
 102         xPoly.set( new ::basegfx::unotools::UnoPolyPolygon(
 103                        ::basegfx::unotools::polyPolygonFromBezier2DSequenceSequence( points ) ) );
 104         // vcl only handles even_odd polygons
 105         xPoly->setFillRule(rendering::FillRule_EVEN_ODD);
 106
 107         return xPoly;
 108     }
 109
 110     uno::Reference< rendering::XBitmap > DeviceHelper::createCompatibleBitmap(
 111         const uno::Reference< rendering::XGraphicDevice >& rDevice,
 112         const geometry::IntegerSize2D&                     size )
 113     {
 114         if( !mpOutDev )
 115             return uno::Reference< rendering::XBitmap >(); // we're disposed
 116
 117         return uno::Reference< rendering::XBitmap >(
 118             new CanvasBitmap( vcl::unotools::sizeFromIntegerSize2D(size),
 119                               false,
 120                               *rDevice.get(),
 121                               mpOutDev ) );
 122     }
 123
 124     uno::Reference< rendering::XVolatileBitmap > DeviceHelper::createVolatileBitmap(
 125         const uno::Reference< rendering::XGraphicDevice >&  ,
 126         const geometry::IntegerSize2D&                       )
 127     {
 128         return uno::Reference< rendering::XVolatileBitmap >();
 129     }
 130
 131     uno::Reference< rendering::XBitmap > DeviceHelper::createCompatibleAlphaBitmap(
 132         const uno::Reference< rendering::XGraphicDevice >& rDevice,
 133         const geometry::IntegerSize2D&                     size )
 134     {
 135         if( !mpOutDev )
 136             return uno::Reference< rendering::XBitmap >(); // we're disposed
 137
 138         return uno::Reference< rendering::XBitmap >(
 139             new CanvasBitmap( vcl::unotools::sizeFromIntegerSize2D(size),
 140                               true,
 141                               *rDevice.get(),
 142                               mpOutDev ) );
 143     }
 144
 145     uno::Reference< rendering::XVolatileBitmap > DeviceHelper::createVolatileAlphaBitmap(
 146         const uno::Reference< rendering::XGraphicDevice >&  ,
 147         const geometry::IntegerSize2D&                       )
 148     {
 149         return uno::Reference< rendering::XVolatileBitmap >();
 150     }
 151
 152     bool DeviceHelper::enterFullScreenMode( bool bEnter )
 153     {
 154         (void)bEnter;
 155         return false;
 156     }
 157
 158     void DeviceHelper::disposing()
 159     {
 160         // release all references
 161         mpOutDev.reset();
 162     }
 163
 164     uno::Any DeviceHelper::isAccelerated() const
 165     {
 166         return ::com::sun::star::uno::makeAny(false);
 167     }
 168
 169     uno::Any DeviceHelper::getDeviceHandle() const
 170     {
 171         if( !mpOutDev )
 172             return uno::Any();
 173
 174         return uno::makeAny(
 175             reinterpret_cast< sal_Int64 >(&mpOutDev->getOutDev()) );
 176     }
 177
 178     uno::Any DeviceHelper::getSurfaceHandle() const
 179     {
 180         return getDeviceHandle();
 181     }
 182
 183     namespace
 184     {
 185         struct DeviceColorSpace: public rtl::StaticWithInit<uno::Reference<rendering::XColorSpace>,
 186                                                             DeviceColorSpace>
 187         {
 188             uno::Reference<rendering::XColorSpace> operator()()
 189             {
 190                 uno::Reference< rendering::XColorSpace > xColorSpace( canvas::tools::getStdColorSpace(), uno::UNO_QUERY );
 191                 assert( xColorSpace.is() );
 192                 return xColorSpace;
 193             }
 194         };
 195     }
 196
 197     uno::Reference<rendering::XColorSpace> DeviceHelper::getColorSpace() const
 198     {
 199         // always the same
 200         return DeviceColorSpace::get();
 201     }
 202
 203     void DeviceHelper::dumpScreenContent() const
 204     {
 205         static sal_Int32 nFilePostfixCount(0);
 206
 207         if( mpOutDev )
 208         {
 209             OUString aFilename = "dbg_frontbuffer" + OUString::number(nFilePostfixCount) + ".bmp";
 210
 211             SvFileStream aStream( aFilename, STREAM_STD_READWRITE );
 212
 213             const ::Point aEmptyPoint;
 214             OutputDevice& rOutDev = mpOutDev->getOutDev();
 215             bool bOldMap( rOutDev.IsMapModeEnabled() );
 216             rOutDev.EnableMapMode( false );
 217             WriteDIB(rOutDev.GetBitmap(aEmptyPoint, rOutDev.GetOutputSizePixel()), aStream, false, true);
 218             rOutDev.EnableMapMode( bOldMap );
 219
 220             ++nFilePostfixCount;
 221         }
 222     }
 223
 224 }
 225
 226 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */