svtools/source/graphic/renderer.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 <com/sun/star/awt/Rectangle.hpp>
  22 #include <com/sun/star/awt/XDevice.hpp>
  23 #include <com/sun/star/graphic/XGraphic.hpp>
  24 #include <com/sun/star/graphic/XGraphicRenderer.hpp>
  25 #include <com/sun/star/lang/XServiceInfo.hpp>
  26 #include <com/sun/star/uno/XComponentContext.hpp>
  27 #include <tools/gen.hxx>
  28 #include <vcl/svapp.hxx>
  29 #include <toolkit/helper/vclunohelper.hxx>
  30 #include <comphelper/propertysethelper.hxx>
  31 #include <comphelper/propertysetinfo.hxx>
  32 #include <cppuhelper/supportsservice.hxx>
  33 #include <rtl/ref.hxx>
  34 #include <vcl/GraphicObject.hxx>
  35 #include <vcl/outdev.hxx>
  36
  37 #define UNOGRAPHIC_DEVICE           1
  38 #define UNOGRAPHIC_DESTINATIONRECT  2
  39 #define UNOGRAPHIC_RENDERDATA       3
  40
  41 using namespace ::com::sun::star;
  42
  43 namespace {
  44
  45 class GraphicRendererVCL : public ::cppu::OWeakObject,
  46                            public css::lang::XServiceInfo,
  47                            public css::lang::XTypeProvider,
  48                            public ::comphelper::PropertySetHelper,
  49                            public css::graphic::XGraphicRenderer
  50 {
  51     static rtl::Reference<::comphelper::PropertySetInfo> createPropertySetInfo();
  52
  53 public:
  54
  55     GraphicRendererVCL();
  56
  57     // XInterface
  58     virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override;
  59     virtual void SAL_CALL acquire() noexcept override;
  60     virtual void SAL_CALL release() noexcept override;
  61
  62     // XServiceInfo
  63     virtual OUString SAL_CALL getImplementationName() override;
  64     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
  65     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
  66
  67     // XTypeProvider
  68     virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes(  ) override;
  69     virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId(  ) override;
  70
  71     // PropertySetHelper
  72     virtual void _setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const css::uno::Any* pValues ) override;
  73     virtual void _getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, css::uno::Any* pValue ) override;
  74
  75     // XGraphicRenderer
  76     virtual void SAL_CALL render( const css::uno::Reference< css::graphic::XGraphic >& Graphic ) override;
  77
  78 private:
  79
  80     css::uno::Reference< css::awt::XDevice > mxDevice;
  81
  82     VclPtr<OutputDevice>        mpOutDev;
  83     tools::Rectangle                   maDestRect;
  84     css::uno::Any               maRenderData;
  85 };
  86
  87 GraphicRendererVCL::GraphicRendererVCL() :
  88     ::comphelper::PropertySetHelper( createPropertySetInfo() ),
  89     mpOutDev( nullptr )
  90 {
  91 }
  92
  93 uno::Any SAL_CALL GraphicRendererVCL::queryInterface( const uno::Type & rType )
  94 {
  95     uno::Any aAny;
  96
  97     if( rType == cppu::UnoType<lang::XServiceInfo>::get())
  98         aAny <<= uno::Reference< lang::XServiceInfo >(this);
  99     else if( rType == cppu::UnoType<lang::XTypeProvider>::get())
 100         aAny <<= uno::Reference< lang::XTypeProvider >(this);
 101     else if( rType == cppu::UnoType<beans::XPropertySet>::get())
 102         aAny <<= uno::Reference< beans::XPropertySet >(this);
 103     else if( rType == cppu::UnoType<beans::XPropertyState>::get())
 104         aAny <<= uno::Reference< beans::XPropertyState >(this);
 105     else if( rType == cppu::UnoType<beans::XMultiPropertySet>::get())
 106         aAny <<= uno::Reference< beans::XMultiPropertySet >(this);
 107     else if( rType == cppu::UnoType<graphic::XGraphicRenderer>::get())
 108         aAny <<= uno::Reference< graphic::XGraphicRenderer >(this);
 109     else
 110         aAny = OWeakObject::queryInterface( rType );
 111
 112     return aAny;
 113 }
 114
 115
 116 void SAL_CALL GraphicRendererVCL::acquire()
 117     noexcept
 118 {
 119     OWeakObject::acquire();
 120 }
 121
 122
 123 void SAL_CALL GraphicRendererVCL::release()
 124     noexcept
 125 {
 126     OWeakObject::release();
 127 }
 128
 129
 130 OUString SAL_CALL GraphicRendererVCL::getImplementationName()
 131 {
 132     return u"com.sun.star.comp.graphic.GraphicRendererVCL"_ustr;
 133 }
 134
 135 sal_Bool SAL_CALL GraphicRendererVCL::supportsService( const OUString& ServiceName )
 136 {
 137     return cppu::supportsService(this, ServiceName);
 138 }
 139
 140
 141 uno::Sequence< OUString > SAL_CALL GraphicRendererVCL::getSupportedServiceNames()
 142 {
 143     return { u"com.sun.star.graphic.GraphicRendererVCL"_ustr };
 144 }
 145
 146
 147 uno::Sequence< uno::Type > SAL_CALL GraphicRendererVCL::getTypes()
 148 {
 149     static const uno::Sequence< uno::Type >  aTypes {
 150         cppu::UnoType<lang::XServiceInfo>::get(),
 151         cppu::UnoType<lang::XTypeProvider>::get(),
 152         cppu::UnoType<beans::XPropertySet>::get(),
 153         cppu::UnoType<beans::XPropertyState>::get(),
 154         cppu::UnoType<beans::XMultiPropertySet>::get(),
 155         cppu::UnoType<graphic::XGraphicRenderer>::get() };
 156     return aTypes;
 157 }
 158
 159 uno::Sequence< sal_Int8 > SAL_CALL GraphicRendererVCL::getImplementationId()
 160 {
 161     return css::uno::Sequence<sal_Int8>();
 162 }
 163
 164
 165 rtl::Reference<::comphelper::PropertySetInfo> GraphicRendererVCL::createPropertySetInfo()
 166 {
 167     static ::comphelper::PropertyMapEntry const aEntries[] =
 168     {
 169         { u"Device"_ustr, UNOGRAPHIC_DEVICE, cppu::UnoType<uno::Any>::get(), 0, 0 },
 170         { u"DestinationRect"_ustr, UNOGRAPHIC_DESTINATIONRECT, cppu::UnoType<awt::Rectangle>::get(), 0, 0 },
 171         { u"RenderData"_ustr, UNOGRAPHIC_RENDERDATA, cppu::UnoType<uno::Any>::get(), 0, 0 },
 172     };
 173
 174     return rtl::Reference<::comphelper::PropertySetInfo>( new ::comphelper::PropertySetInfo(aEntries) );
 175 }
 176
 177
 178 void GraphicRendererVCL::_setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const uno::Any* pValues )
 179 {
 180     SolarMutexGuard aGuard;
 181
 182     while( *ppEntries )
 183     {
 184         switch( (*ppEntries)->mnHandle )
 185         {
 186             case UNOGRAPHIC_DEVICE:
 187             {
 188                 uno::Reference< awt::XDevice > xDevice;
 189
 190                 if( ( *pValues >>= xDevice ) && xDevice.is() )
 191                 {
 192                     mxDevice = xDevice;
 193                     mpOutDev = VCLUnoHelper::GetOutputDevice( xDevice );
 194                 }
 195                 else
 196                 {
 197                     mxDevice.clear();
 198                     mpOutDev = nullptr;
 199                 }
 200             }
 201             break;
 202
 203             case UNOGRAPHIC_DESTINATIONRECT:
 204             {
 205                 awt::Rectangle aAWTRect;
 206
 207                 if( *pValues >>= aAWTRect )
 208                 {
 209                     maDestRect = tools::Rectangle( Point( aAWTRect.X, aAWTRect.Y ),
 210                                             Size( aAWTRect.Width, aAWTRect.Height ) );
 211                 }
 212             }
 213             break;
 214
 215             case UNOGRAPHIC_RENDERDATA:
 216             {
 217                  maRenderData = *pValues;
 218             }
 219             break;
 220         }
 221
 222         ++ppEntries;
 223         ++pValues;
 224     }
 225 }
 226
 227
 228 void GraphicRendererVCL::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, uno::Any* pValues )
 229 {
 230     SolarMutexGuard aGuard;
 231
 232     while( *ppEntries )
 233     {
 234         switch( (*ppEntries)->mnHandle )
 235         {
 236             case UNOGRAPHIC_DEVICE:
 237             {
 238                 if( mxDevice.is() )
 239                     *pValues <<= mxDevice;
 240             }
 241             break;
 242
 243             case UNOGRAPHIC_DESTINATIONRECT:
 244             {
 245                 const awt::Rectangle aAWTRect( maDestRect.Left(), maDestRect.Top(),
 246                                                maDestRect.GetWidth(), maDestRect.GetHeight() );
 247
 248                 *pValues <<= aAWTRect;
 249             }
 250             break;
 251
 252             case UNOGRAPHIC_RENDERDATA:
 253             {
 254                 *pValues = maRenderData;
 255             }
 256             break;
 257         }
 258
 259         ++ppEntries;
 260         ++pValues;
 261     }
 262 }
 263
 264 void SAL_CALL GraphicRendererVCL::render( const uno::Reference< graphic::XGraphic >& rxGraphic )
 265 {
 266     if( mpOutDev && mxDevice.is() && rxGraphic.is() )
 267     {
 268         Graphic aGraphic(rxGraphic);
 269         if (!aGraphic.IsNone())
 270         {
 271             GraphicObject aGraphicObject(std::move(aGraphic));
 272             aGraphicObject.Draw(*mpOutDev, maDestRect.TopLeft(), maDestRect.GetSize());
 273         }
 274     }
 275 }
 276
 277 }
 278
 279 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 280 com_sun_star_comp_graphic_GraphicRendererVCL_get_implementation(
 281     css::uno::XComponentContext *,
 282     css::uno::Sequence<css::uno::Any> const &)
 283 {
 284     return cppu::acquire(new GraphicRendererVCL);
 285 }
 286
 287 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */