canvas/source/directx/dx_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
  21 #include <ctype.h>
  22 #include <vcl/window.hxx>
  23 #include <vcl/canvastools.hxx>
  24 #include <canvas/debug.hxx>
  25 #include <canvas/verbosetrace.hxx>
  26 #include <canvas/canvastools.hxx>
  27 #include <tools/diagnose_ex.h>
  28
  29 #include <osl/mutex.hxx>
  30 #include <cppuhelper/compbase1.hxx>
  31
  32 #include <com/sun/star/lang/NoSupportException.hpp>
  33 #include <toolkit/helper/vclunohelper.hxx>
  34 #include <basegfx/tools/canvastools.hxx>
  35 #include "dx_linepolypolygon.hxx"
  36 #include "dx_spritecanvas.hxx"
  37 #include "dx_canvasbitmap.hxx"
  38 #include "dx_devicehelper.hxx"
  39 #include "dx_winstuff.hxx"
  40
  41 #include <vcl/sysdata.hxx>
  42 #include <vcl/outdev.hxx>
  43
  44 using namespace ::com::sun::star;
  45
  46 namespace dxcanvas
  47 {
  48     DeviceHelper::DeviceHelper() :
  49         mpDevice( NULL ),
  50         mnHDC(0),
  51         mpOutDev(0)
  52     {
  53     }
  54
  55     DeviceHelper::~DeviceHelper()
  56     {
  57     }
  58
  59     void DeviceHelper::init( HDC hdc, OutputDevice* pOutDev,
  60                              rendering::XGraphicDevice& rDevice )
  61     {
  62         mnHDC    = hdc;
  63         mpDevice = &rDevice;
  64         mpOutDev = pOutDev;
  65     }
  66
  67     void DeviceHelper::disposing()
  68     {
  69         // release all references
  70         mnHDC = 0;
  71         mpDevice = NULL;
  72         mpOutDev = 0;
  73     }
  74
  75     geometry::RealSize2D DeviceHelper::getPhysicalResolution()
  76     {
  77         if( !mpDevice )
  78             return ::canvas::tools::createInfiniteSize2D(); // we're disposed
  79
  80         HDC hDC = getHDC();
  81         ENSURE_OR_THROW( hDC,
  82                           "DeviceHelper::getPhysicalResolution(): cannot retrieve HDC from window" );
  83
  84         const int nHorzRes( GetDeviceCaps( hDC,
  85                                            LOGPIXELSX ) );
  86         const int nVertRes( GetDeviceCaps( hDC,
  87                                            LOGPIXELSY ) );
  88
  89         return geometry::RealSize2D( nHorzRes*25.4,
  90                                      nVertRes*25.4 );
  91     }
  92
  93     geometry::RealSize2D DeviceHelper::getPhysicalSize()
  94     {
  95         if( !mpDevice )
  96             return ::canvas::tools::createInfiniteSize2D(); // we're disposed
  97
  98         HDC hDC=getHDC();
  99         ENSURE_OR_THROW( hDC,
 100                           "DeviceHelper::getPhysicalSize(): cannot retrieve HDC from window" );
 101
 102         const int nHorzSize( GetDeviceCaps( hDC,
 103                                             HORZSIZE ) );
 104         const int nVertSize( GetDeviceCaps( hDC,
 105                                             VERTSIZE ) );
 106
 107         return geometry::RealSize2D( nHorzSize,
 108                                      nVertSize );
 109     }
 110
 111     uno::Reference< rendering::XLinePolyPolygon2D > DeviceHelper::createCompatibleLinePolyPolygon(
 112         const uno::Reference< rendering::XGraphicDevice >&              /*rDevice*/,
 113         const uno::Sequence< uno::Sequence< geometry::RealPoint2D > >&  points )
 114     {
 115         if( !mpDevice )
 116             return uno::Reference< rendering::XLinePolyPolygon2D >(); // we're disposed
 117
 118         return uno::Reference< rendering::XLinePolyPolygon2D >(
 119             new LinePolyPolygon(
 120                 ::basegfx::unotools::polyPolygonFromPoint2DSequenceSequence( points ) ) );
 121     }
 122
 123     uno::Reference< rendering::XBezierPolyPolygon2D > DeviceHelper::createCompatibleBezierPolyPolygon(
 124         const uno::Reference< rendering::XGraphicDevice >&                      /*rDevice*/,
 125         const uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > >&  points )
 126     {
 127         if( !mpDevice )
 128             return uno::Reference< rendering::XBezierPolyPolygon2D >(); // we're disposed
 129
 130         return uno::Reference< rendering::XBezierPolyPolygon2D >(
 131             new LinePolyPolygon(
 132                 ::basegfx::unotools::polyPolygonFromBezier2DSequenceSequence( points ) ) );
 133     }
 134
 135     uno::Reference< rendering::XBitmap > DeviceHelper::createCompatibleBitmap(
 136         const uno::Reference< rendering::XGraphicDevice >&  /*rDevice*/,
 137         const geometry::IntegerSize2D&                      size )
 138     {
 139         if( !mpDevice )
 140             return uno::Reference< rendering::XBitmap >(); // we're disposed
 141
 142         DXBitmapSharedPtr pBitmap(
 143             new DXBitmap(
 144                 ::basegfx::unotools::b2ISizeFromIntegerSize2D(size),
 145                 false));
 146
 147         // create a 24bit RGB system memory surface
 148         return uno::Reference< rendering::XBitmap >(new CanvasBitmap(pBitmap,mpDevice));
 149     }
 150
 151     uno::Reference< rendering::XVolatileBitmap > DeviceHelper::createVolatileBitmap(
 152         const uno::Reference< rendering::XGraphicDevice >&  /*rDevice*/,
 153         const geometry::IntegerSize2D&                      /*size*/ )
 154     {
 155         return uno::Reference< rendering::XVolatileBitmap >();
 156     }
 157
 158     uno::Reference< rendering::XBitmap > DeviceHelper::createCompatibleAlphaBitmap(
 159         const uno::Reference< rendering::XGraphicDevice >&  /*rDevice*/,
 160         const geometry::IntegerSize2D&                      size )
 161     {
 162         if( !mpDevice )
 163             return uno::Reference< rendering::XBitmap >(); // we're disposed
 164
 165         DXBitmapSharedPtr pBitmap(
 166             new DXBitmap(
 167                 ::basegfx::unotools::b2ISizeFromIntegerSize2D(size),
 168                 true));
 169
 170         // create a 32bit ARGB system memory surface
 171         return uno::Reference< rendering::XBitmap >(new CanvasBitmap(pBitmap,mpDevice));
 172     }
 173
 174     uno::Reference< rendering::XVolatileBitmap > DeviceHelper::createVolatileAlphaBitmap(
 175         const uno::Reference< rendering::XGraphicDevice >&  /*rDevice*/,
 176         const geometry::IntegerSize2D&                      /*size*/ )
 177     {
 178         return uno::Reference< rendering::XVolatileBitmap >();
 179     }
 180
 181     bool DeviceHelper::hasFullScreenMode()
 182     {
 183         return false;
 184     }
 185
 186     bool DeviceHelper::enterFullScreenMode( bool /*bEnter*/ )
 187     {
 188         return false;
 189     }
 190
 191     uno::Any DeviceHelper::isAccelerated() const
 192     {
 193         return ::com::sun::star::uno::makeAny(false);
 194     }
 195
 196     uno::Any DeviceHelper::getDeviceHandle() const
 197     {
 198         return uno::makeAny( reinterpret_cast< sal_Int64 >(mpOutDev.get()) );
 199     }
 200
 201     uno::Any DeviceHelper::getSurfaceHandle() const
 202     {
 203         // TODO(F1): expose DirectDraw object
 204         //return mpBackBuffer->getBitmap().get();
 205         return uno::Any();
 206     }
 207
 208     namespace
 209     {
 210         struct DeviceColorSpace: public rtl::StaticWithInit<uno::Reference<rendering::XColorSpace>,
 211                                                             DeviceColorSpace>
 212         {
 213             uno::Reference<rendering::XColorSpace> operator()()
 214             {
 215                 return vcl::unotools::createStandardColorSpace();
 216             }
 217         };
 218     }
 219
 220     uno::Reference<rendering::XColorSpace> DeviceHelper::getColorSpace() const
 221     {
 222         // always the same
 223         return DeviceColorSpace::get();
 224     }
 225 }
 226
 227 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */