goodies/source/unographic/renderer.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: renderer.cxx,v $
  10  * $Revision: 1.6 $
  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_goodies.hxx"
  33
  34 #ifndef _COM_SUN_STAR_BEANS_PROPERTYSTATE_HDL_
  35 #include <com/sun/star/beans/PropertyState.hpp>
  36 #endif
  37 #ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HDL_
  38 #include <com/sun/star/beans/PropertyAttribute.hpp>
  39 #endif
  40 #ifndef _COM_SUN_STAR_AWT_RECTANGLE_HDL_
  41 #include <com/sun/star/awt/Rectangle.hpp>
  42 #endif
  43 #include <rtl/uuid.h>
  44 #include <vos/mutex.hxx>
  45 #ifndef _SV_SVAPP_HXX_
  46 #include <vcl/svapp.hxx>
  47 #endif
  48
  49 #include <toolkit/helper/vclunohelper.hxx>
  50 #include <comphelper/propertysetinfo.hxx>
  51 #include <svtools/itemprop.hxx>
  52 #include "grfmgr.hxx"
  53 #include "graphic.hxx"
  54 #include "renderer.hxx"
  55
  56 #define UNOGRAPHIC_DEVICE                       1
  57 #define UNOGRAPHIC_DESTINATIONRECT      2
  58 #define UNOGRAPHIC_RENDERDATA           3
  59
  60 using namespace ::com::sun::star;
  61
  62 namespace unographic {
  63
  64 // ---------------------
  65 // - GraphicRendererVCL -
  66 // ---------------------
  67
  68 GraphicRendererVCL::GraphicRendererVCL() :
  69     ::comphelper::PropertySetHelper( createPropertySetInfo() ),
  70     mpOutDev( NULL )
  71 {
  72 }
  73
  74 // ------------------------------------------------------------------------------
  75
  76 GraphicRendererVCL::~GraphicRendererVCL()
  77     throw()
  78 {
  79 }
  80
  81 // ------------------------------------------------------------------------------
  82
  83 ::rtl::OUString GraphicRendererVCL::getImplementationName_Static()
  84     throw()
  85 {
  86     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.graphic.GraphicRendererVCL" ) );
  87 }
  88
  89 // ------------------------------------------------------------------------------
  90
  91 uno::Sequence< ::rtl::OUString > GraphicRendererVCL::getSupportedServiceNames_Static()
  92     throw(      )
  93 {
  94     uno::Sequence< ::rtl::OUString > aSeq( 1 );
  95
  96     aSeq.getArray()[ 0 ] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.graphic.GraphicRendererVCL" ) );
  97
  98     return aSeq;
  99 }
 100
 101 // ------------------------------------------------------------------------------
 102
 103 uno::Any SAL_CALL GraphicRendererVCL::queryAggregation( const uno::Type & rType )
 104     throw( uno::RuntimeException )
 105 {
 106     uno::Any aAny;
 107
 108     if( rType == ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0) )
 109         aAny <<= uno::Reference< lang::XServiceInfo >(this);
 110     else if( rType == ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0) )
 111         aAny <<= uno::Reference< lang::XTypeProvider >(this);
 112     else if( rType == ::getCppuType((const uno::Reference< beans::XPropertySet >*)0) )
 113         aAny <<= uno::Reference< beans::XPropertySet >(this);
 114     else if( rType == ::getCppuType((const uno::Reference< beans::XPropertyState >*)0) )
 115         aAny <<= uno::Reference< beans::XPropertyState >(this);
 116     else if( rType == ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0) )
 117         aAny <<= uno::Reference< beans::XMultiPropertySet >(this);
 118     else if( rType == ::getCppuType((const uno::Reference< graphic::XGraphicRenderer >*)0) )
 119         aAny <<= uno::Reference< graphic::XGraphicRenderer >(this);
 120     else
 121         aAny <<= OWeakAggObject::queryAggregation( rType );
 122
 123     return aAny;
 124 }
 125
 126 // ------------------------------------------------------------------------------
 127
 128 uno::Any SAL_CALL GraphicRendererVCL::queryInterface( const uno::Type & rType )
 129     throw( uno::RuntimeException )
 130 {
 131     return OWeakAggObject::queryInterface( rType );
 132 }
 133
 134 // ------------------------------------------------------------------------------
 135
 136 void SAL_CALL GraphicRendererVCL::acquire()
 137     throw()
 138 {
 139     OWeakAggObject::acquire();
 140 }
 141
 142 // ------------------------------------------------------------------------------
 143
 144 void SAL_CALL GraphicRendererVCL::release()
 145     throw()
 146 {
 147     OWeakAggObject::release();
 148 }
 149
 150 // ------------------------------------------------------------------------------
 151
 152 ::rtl::OUString SAL_CALL GraphicRendererVCL::getImplementationName()
 153     throw( uno::RuntimeException )
 154 {
 155     return getImplementationName_Static();
 156 }
 157
 158 // ------------------------------------------------------------------------------
 159
 160 sal_Bool SAL_CALL GraphicRendererVCL::supportsService( const rtl::OUString& ServiceName )
 161     throw( uno::RuntimeException )
 162 {
 163     uno::Sequence< ::rtl::OUString >    aSNL( getSupportedServiceNames() );
 164     const ::rtl::OUString*                              pArray = aSNL.getConstArray();
 165
 166     for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 167         if( pArray[i] == ServiceName )
 168             return true;
 169
 170     return false;
 171 }
 172
 173 // ------------------------------------------------------------------------------
 174
 175 uno::Sequence< rtl::OUString > SAL_CALL GraphicRendererVCL::getSupportedServiceNames()
 176     throw( uno::RuntimeException )
 177 {
 178     return getSupportedServiceNames_Static();
 179 }
 180
 181 // ------------------------------------------------------------------------------
 182
 183 uno::Sequence< uno::Type > SAL_CALL GraphicRendererVCL::getTypes()
 184     throw( uno::RuntimeException )
 185 {
 186     uno::Sequence< uno::Type >  aTypes( 7 );
 187     uno::Type*                                  pTypes = aTypes.getArray();
 188
 189     *pTypes++ = ::getCppuType((const uno::Reference< uno::XAggregation>*)0);
 190     *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo>*)0);
 191     *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider>*)0);
 192     *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet>*)0);
 193     *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState>*)0);
 194     *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet>*)0);
 195     *pTypes++ = ::getCppuType((const uno::Reference< graphic::XGraphicRenderer>*)0);
 196
 197     return aTypes;
 198 }
 199
 200 // ------------------------------------------------------------------------------
 201
 202 uno::Sequence< sal_Int8 > SAL_CALL GraphicRendererVCL::getImplementationId()
 203     throw( uno::RuntimeException )
 204 {
 205     vos::OGuard                                                 aGuard( Application::GetSolarMutex() );
 206     static uno::Sequence< sal_Int8 >    aId;
 207
 208     if( aId.getLength() == 0 )
 209     {
 210         aId.realloc( 16 );
 211         rtl_createUuid( reinterpret_cast< sal_uInt8* >( aId.getArray() ), 0, sal_True );
 212     }
 213
 214     return aId;
 215 }
 216
 217 // ------------------------------------------------------------------------------
 218
 219 ::comphelper::PropertySetInfo* GraphicRendererVCL::createPropertySetInfo()
 220 {
 221     vos::OGuard                                         aGuard( Application::GetSolarMutex() );
 222     ::comphelper::PropertySetInfo*      pRet = new ::comphelper::PropertySetInfo();
 223
 224     static ::comphelper::PropertyMapEntry aEntries[] =
 225     {
 226         { MAP_CHAR_LEN( "Device" ), UNOGRAPHIC_DEVICE, &::getCppuType( (const uno::Any*)(0)), 0, 0 },
 227         { MAP_CHAR_LEN( "DestinationRect" ), UNOGRAPHIC_DESTINATIONRECT, &::getCppuType( (const awt::Rectangle*)(0)), 0, 0 },
 228         { MAP_CHAR_LEN( "RenderData" ), UNOGRAPHIC_RENDERDATA,  &::getCppuType( (const uno::Any*)(0)), 0, 0 },
 229
 230         { 0,0,0,0,0,0 }
 231     };
 232
 233     pRet->acquire();
 234     pRet->add( aEntries );
 235
 236     return pRet;
 237 }
 238
 239 // ------------------------------------------------------------------------------
 240
 241 void GraphicRendererVCL::_setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const uno::Any* pValues )
 242     throw( beans::UnknownPropertyException,
 243            beans::PropertyVetoException,
 244            lang::IllegalArgumentException,
 245               lang::WrappedTargetException )
 246 {
 247     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 248
 249     while( *ppEntries )
 250     {
 251         switch( (*ppEntries)->mnHandle )
 252         {
 253             case( UNOGRAPHIC_DEVICE ):
 254             {
 255                 uno::Reference< awt::XDevice > xDevice;
 256
 257                 if( ( *pValues >>= xDevice ) && xDevice.is() )
 258                 {
 259                     mxDevice = xDevice;
 260                     mpOutDev = VCLUnoHelper::GetOutputDevice( xDevice );
 261                 }
 262                 else
 263                 {
 264                     mxDevice.clear();
 265                     mpOutDev = NULL;
 266                 }
 267             }
 268             break;
 269
 270             case( UNOGRAPHIC_DESTINATIONRECT ):
 271             {
 272                 awt::Rectangle aAWTRect;
 273
 274                 if( *pValues >>= aAWTRect )
 275                 {
 276                     maDestRect = Rectangle( Point( aAWTRect.X, aAWTRect.Y ),
 277                                             Size( aAWTRect.Width, aAWTRect.Height ) );
 278                 }
 279             }
 280             break;
 281
 282             case( UNOGRAPHIC_RENDERDATA ):
 283             {
 284                 *pValues >>= maRenderData;
 285             }
 286             break;
 287         }
 288
 289         ++ppEntries;
 290         ++pValues;
 291     }
 292 }
 293
 294 // ------------------------------------------------------------------------------
 295
 296 void GraphicRendererVCL::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, uno::Any* pValues )
 297     throw( beans::UnknownPropertyException, lang::WrappedTargetException )
 298 {
 299     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 300
 301     while( *ppEntries )
 302     {
 303         switch( (*ppEntries)->mnHandle )
 304         {
 305             case( UNOGRAPHIC_DEVICE ):
 306             {
 307                 if( mxDevice.is() )
 308                     *pValues <<= mxDevice;
 309             }
 310             break;
 311
 312             case( UNOGRAPHIC_DESTINATIONRECT ):
 313             {
 314                 const awt::Rectangle aAWTRect( maDestRect.Left(), maDestRect.Top(),
 315                                                maDestRect.GetWidth(), maDestRect.GetHeight() );
 316
 317                 *pValues <<= aAWTRect;
 318             }
 319             break;
 320
 321             case( UNOGRAPHIC_RENDERDATA ):
 322             {
 323                 *pValues <<= maRenderData;
 324             }
 325             break;
 326         }
 327
 328         ++ppEntries;
 329         ++pValues;
 330     }
 331 }
 332
 333 // ------------------------------------------------------------------------------
 334
 335 void SAL_CALL GraphicRendererVCL::render( const uno::Reference< graphic::XGraphic >& rxGraphic )
 336     throw (uno::RuntimeException)
 337 {
 338     if( mpOutDev && mxDevice.is() && rxGraphic.is() )
 339     {
 340         const uno::Reference< XInterface >      xIFace( rxGraphic, uno::UNO_QUERY );
 341         const ::Graphic*                                        pGraphic = ::unographic::Graphic::getImplementation( xIFace );
 342
 343         if( pGraphic )
 344         {
 345             GraphicObject aGraphicObject( *pGraphic );
 346             aGraphicObject.Draw( mpOutDev, maDestRect.TopLeft(), maDestRect.GetSize() );
 347         }
 348     }
 349 }
 350
 351 }