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