goodies/source/unographic/descriptor.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: descriptor.cxx,v $
  10  * $Revision: 1.10 $
  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 #include "descriptor.hxx"
  35
  36 #include <rtl/uuid.h>
  37 #include <vos/mutex.hxx>
  38 #include <unotools/ucbstreamhelper.hxx>
  39 #include <svtools/filter.hxx>
  40 #include <svtools/itemprop.hxx>
  41
  42 #ifndef _COM_SUN_STAR_BEANS_PROPERTYSTATE_HDL_
  43 #include <com/sun/star/beans/PropertyState.hpp>
  44 #endif
  45 #ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HDL_
  46 #include <com/sun/star/beans/PropertyAttribute.hpp>
  47 #endif
  48 #ifndef _COM_SUN_STAR_AWT_SIZE_HDL_
  49 #include <com/sun/star/awt/Size.hpp>
  50 #endif
  51 #ifndef _COM_SUN_STAR_GRAPHIC_GRAPHICTYPE_HDL_
  52 #include <com/sun/star/graphic/GraphicType.hpp>
  53 #endif
  54 #include "vcl/graph.hxx"
  55 #include "vcl/svapp.hxx"
  56
  57 #define UNOGRAPHIC_GRAPHICTYPE  1
  58 #define UNOGRAPHIC_MIMETYPE             2
  59 #define UNOGRAPHIC_SIZEPIXEL    3
  60 #define UNOGRAPHIC_SIZE100THMM  4
  61 #define UNOGRAPHIC_BITSPERPIXEL 5
  62 #define UNOGRAPHIC_TRANSPARENT  6
  63 #define UNOGRAPHIC_ALPHA                7
  64 #define UNOGRAPHIC_ANIMATED             8
  65
  66 using namespace ::com::sun::star;
  67
  68 namespace unographic {
  69
  70 // ---------------------
  71 // - GraphicDescriptor -
  72 // ---------------------
  73
  74 GraphicDescriptor::GraphicDescriptor() :
  75     ::comphelper::PropertySetHelper( createPropertySetInfo(), SAL_NO_ACQUIRE ),
  76     mpGraphic( NULL ),
  77     meType( GRAPHIC_NONE ),
  78     mnBitsPerPixel ( 0 ),
  79     mbTransparent ( false ),
  80     mbAlpha( false ),
  81     mbAnimated( false )
  82 {
  83 }
  84
  85 // ------------------------------------------------------------------------------
  86
  87 GraphicDescriptor::~GraphicDescriptor()
  88     throw()
  89 {
  90 }
  91
  92 // ------------------------------------------------------------------------------
  93
  94 void GraphicDescriptor::init( const ::Graphic& rGraphic )
  95     throw()
  96 {
  97     mpGraphic = &rGraphic;
  98 }
  99
 100 // ------------------------------------------------------------------------------
 101
 102 void GraphicDescriptor::init( const ::rtl::OUString& rURL )
 103     throw()
 104 {
 105     SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( rURL, STREAM_READ );
 106
 107     if( pIStm )
 108     {
 109         implCreate( *pIStm, &rURL );
 110         delete pIStm;
 111     }
 112 }
 113
 114 // ------------------------------------------------------------------------------
 115
 116 void GraphicDescriptor::init( const uno::Reference< io::XInputStream >& rxIStm, const ::rtl::OUString& rURL )
 117     throw()
 118 {
 119     SvStream* pIStm = ::utl::UcbStreamHelper::CreateStream( rxIStm );
 120
 121     if( pIStm )
 122     {
 123         implCreate( *pIStm, &rURL );
 124         delete pIStm;
 125     }
 126 }
 127
 128 // ------------------------------------------------------------------------------
 129
 130 bool GraphicDescriptor::isValid() const
 131 {
 132     return( mpGraphic ? ( mpGraphic->GetType() != GRAPHIC_NONE ) : ( meType != GRAPHIC_NONE ) );
 133 }
 134
 135 // ------------------------------------------------------------------------------
 136
 137 void GraphicDescriptor::implCreate( SvStream& rIStm, const ::rtl::OUString* pURL )
 138 {
 139     String aURL;
 140     if( pURL )
 141         aURL = *pURL;
 142     ::GraphicDescriptor aDescriptor( rIStm, &aURL );
 143
 144     mpGraphic = NULL;
 145     maMimeType = ::rtl::OUString();
 146     meType = GRAPHIC_NONE;
 147     mnBitsPerPixel = 0;
 148     mbTransparent = false;
 149
 150     if( aDescriptor.Detect( true ) && aDescriptor.GetFileFormat() != GFF_NOT )
 151     {
 152         const char*                     pMimeType = NULL;
 153         sal_uInt8                               cType = graphic::GraphicType::EMPTY;
 154
 155         switch( aDescriptor.GetFileFormat() )
 156         {
 157             case( GFF_BMP ): pMimeType = MIMETYPE_BMP; cType = graphic::GraphicType::PIXEL; break;
 158             case( GFF_GIF ): pMimeType = MIMETYPE_GIF; cType = graphic::GraphicType::PIXEL; break;
 159             case( GFF_JPG ): pMimeType = MIMETYPE_JPG; cType = graphic::GraphicType::PIXEL; break;
 160             case( GFF_PCD ): pMimeType = MIMETYPE_PCD; cType = graphic::GraphicType::PIXEL; break;
 161             case( GFF_PCX ): pMimeType = MIMETYPE_PCX; cType = graphic::GraphicType::PIXEL; break;
 162             case( GFF_PNG ): pMimeType = MIMETYPE_PNG; cType = graphic::GraphicType::PIXEL; break;
 163             case( GFF_TIF ): pMimeType = MIMETYPE_TIF; cType = graphic::GraphicType::PIXEL; break;
 164             case( GFF_XBM ): pMimeType = MIMETYPE_XBM; cType = graphic::GraphicType::PIXEL; break;
 165             case( GFF_XPM ): pMimeType = MIMETYPE_XPM; cType = graphic::GraphicType::PIXEL; break;
 166             case( GFF_PBM ): pMimeType = MIMETYPE_PBM; cType = graphic::GraphicType::PIXEL; break;
 167             case( GFF_PGM ): pMimeType = MIMETYPE_PGM; cType = graphic::GraphicType::PIXEL; break;
 168             case( GFF_PPM ): pMimeType = MIMETYPE_PPM; cType = graphic::GraphicType::PIXEL; break;
 169             case( GFF_RAS ): pMimeType = MIMETYPE_RAS; cType = graphic::GraphicType::PIXEL; break;
 170             case( GFF_TGA ): pMimeType = MIMETYPE_TGA; cType = graphic::GraphicType::PIXEL; break;
 171             case( GFF_PSD ): pMimeType = MIMETYPE_PSD; cType = graphic::GraphicType::PIXEL; break;
 172
 173             case( GFF_EPS ): pMimeType = MIMETYPE_EPS; cType = graphic::GraphicType::VECTOR; break;
 174             case( GFF_DXF ): pMimeType = MIMETYPE_DXF; cType = graphic::GraphicType::VECTOR; break;
 175             case( GFF_MET ): pMimeType = MIMETYPE_MET; cType = graphic::GraphicType::VECTOR; break;
 176             case( GFF_PCT ): pMimeType = MIMETYPE_PCT; cType = graphic::GraphicType::VECTOR; break;
 177             case( GFF_SGF ): pMimeType = MIMETYPE_SGF; cType = graphic::GraphicType::VECTOR; break;
 178             case( GFF_SVM ): pMimeType = MIMETYPE_SVM; cType = graphic::GraphicType::VECTOR; break;
 179             case( GFF_WMF ): pMimeType = MIMETYPE_WMF; cType = graphic::GraphicType::VECTOR; break;
 180             case( GFF_SGV ): pMimeType = MIMETYPE_SGV; cType = graphic::GraphicType::VECTOR; break;
 181             case( GFF_EMF ): pMimeType = MIMETYPE_EMF; cType = graphic::GraphicType::VECTOR; break;
 182
 183             default:
 184             break;
 185         }
 186
 187         if( graphic::GraphicType::EMPTY != cType )
 188         {
 189             meType = ( ( graphic::GraphicType::PIXEL == cType ) ? GRAPHIC_BITMAP : GRAPHIC_GDIMETAFILE );
 190             maMimeType = String( pMimeType, RTL_TEXTENCODING_ASCII_US );
 191             maSizePixel = aDescriptor.GetSizePixel();
 192             maSize100thMM = aDescriptor.GetSize_100TH_MM();
 193             mnBitsPerPixel = aDescriptor.GetBitsPerPixel();
 194             mbTransparent = ( graphic::GraphicType::VECTOR == cType );
 195             mbAlpha = mbAnimated = false;
 196         }
 197     }
 198 }
 199
 200 // ------------------------------------------------------------------------------
 201
 202 ::rtl::OUString GraphicDescriptor::getImplementationName_Static()
 203     throw()
 204 {
 205     return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.graphic.GraphicDescriptor" ) );
 206 }
 207
 208 // ------------------------------------------------------------------------------
 209
 210 uno::Sequence< ::rtl::OUString > GraphicDescriptor::getSupportedServiceNames_Static()
 211     throw(      )
 212 {
 213     uno::Sequence< ::rtl::OUString > aSeq( 1 );
 214
 215     aSeq.getArray()[ 0 ] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.graphic.GraphicDescriptor" ) );
 216
 217     return aSeq;
 218 }
 219
 220 // ------------------------------------------------------------------------------
 221
 222 uno::Any SAL_CALL GraphicDescriptor::queryAggregation( const uno::Type & rType )
 223     throw( uno::RuntimeException )
 224 {
 225     uno::Any aAny;
 226
 227     if( rType == ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0) )
 228         aAny <<= uno::Reference< lang::XServiceInfo >(this);
 229     else if( rType == ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0) )
 230         aAny <<= uno::Reference< lang::XTypeProvider >(this);
 231     else if( rType == ::getCppuType((const uno::Reference< beans::XPropertySet >*)0) )
 232         aAny <<= uno::Reference< beans::XPropertySet >(this);
 233     else if( rType == ::getCppuType((const uno::Reference< beans::XPropertyState >*)0) )
 234         aAny <<= uno::Reference< beans::XPropertyState >(this);
 235     else if( rType == ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0) )
 236         aAny <<= uno::Reference< beans::XMultiPropertySet >(this);
 237     else
 238         aAny <<= OWeakAggObject::queryAggregation( rType );
 239
 240     return aAny;
 241 }
 242
 243 // ------------------------------------------------------------------------------
 244
 245 uno::Any SAL_CALL GraphicDescriptor::queryInterface( const uno::Type & rType )
 246     throw( uno::RuntimeException )
 247 {
 248     return OWeakAggObject::queryInterface( rType );
 249 }
 250
 251 // ------------------------------------------------------------------------------
 252
 253 void SAL_CALL GraphicDescriptor::acquire()
 254     throw()
 255 {
 256     OWeakAggObject::acquire();
 257 }
 258
 259 // ------------------------------------------------------------------------------
 260
 261 void SAL_CALL GraphicDescriptor::release()
 262     throw()
 263 {
 264     OWeakAggObject::release();
 265 }
 266
 267 // ------------------------------------------------------------------------------
 268
 269 ::rtl::OUString SAL_CALL GraphicDescriptor::getImplementationName()
 270     throw( uno::RuntimeException )
 271 {
 272     return getImplementationName_Static();
 273 }
 274
 275 // ------------------------------------------------------------------------------
 276
 277 sal_Bool SAL_CALL GraphicDescriptor::supportsService( const rtl::OUString& ServiceName )
 278     throw( uno::RuntimeException )
 279 {
 280     uno::Sequence< ::rtl::OUString >    aSNL( getSupportedServiceNames() );
 281     const ::rtl::OUString*                              pArray = aSNL.getConstArray();
 282
 283     for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 284         if( pArray[i] == ServiceName )
 285             return true;
 286
 287     return false;
 288 }
 289
 290 // ------------------------------------------------------------------------------
 291
 292 uno::Sequence< rtl::OUString > SAL_CALL GraphicDescriptor::getSupportedServiceNames()
 293     throw( uno::RuntimeException )
 294 {
 295     return getSupportedServiceNames_Static();
 296 }
 297
 298 // ------------------------------------------------------------------------------
 299
 300 uno::Sequence< uno::Type > SAL_CALL GraphicDescriptor::getTypes()
 301     throw( uno::RuntimeException )
 302 {
 303     uno::Sequence< uno::Type >  aTypes( 6 );
 304     uno::Type*                                  pTypes = aTypes.getArray();
 305
 306     *pTypes++ = ::getCppuType((const uno::Reference< uno::XAggregation>*)0);
 307     *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo>*)0);
 308     *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider>*)0);
 309     *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet>*)0);
 310     *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState>*)0);
 311     *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet>*)0);
 312
 313     return aTypes;
 314 }
 315
 316 // ------------------------------------------------------------------------------
 317
 318 uno::Sequence< sal_Int8 > SAL_CALL GraphicDescriptor::getImplementationId()
 319     throw( uno::RuntimeException )
 320 {
 321     vos::OGuard                                                 aGuard( Application::GetSolarMutex() );
 322     static uno::Sequence< sal_Int8 >    aId;
 323
 324     if( aId.getLength() == 0 )
 325     {
 326         aId.realloc( 16 );
 327         rtl_createUuid( reinterpret_cast< sal_uInt8* >( aId.getArray() ), 0, sal_True );
 328     }
 329
 330     return aId;
 331 }
 332
 333 // ------------------------------------------------------------------------------
 334
 335 ::comphelper::PropertySetInfo* GraphicDescriptor::createPropertySetInfo()
 336 {
 337     vos::OGuard                                         aGuard( Application::GetSolarMutex() );
 338     ::comphelper::PropertySetInfo*      pRet = new ::comphelper::PropertySetInfo();
 339
 340     static ::comphelper::PropertyMapEntry aEntries[] =
 341     {
 342         { MAP_CHAR_LEN( "GraphicType" ), UNOGRAPHIC_GRAPHICTYPE, &::getCppuType( (const sal_Int8*)(0)), beans::PropertyAttribute::READONLY, 0 },
 343         { MAP_CHAR_LEN( "MimeType" ), UNOGRAPHIC_MIMETYPE, &::getCppuType( (const ::rtl::OUString*)(0)), beans::PropertyAttribute::READONLY, 0 },
 344         { MAP_CHAR_LEN( "SizePixel" ), UNOGRAPHIC_SIZEPIXEL, &::getCppuType( (const awt::Size*)(0)), beans::PropertyAttribute::READONLY, 0 },
 345         { MAP_CHAR_LEN( "Size100thMM" ), UNOGRAPHIC_SIZE100THMM,        &::getCppuType( (const awt::Size*)(0)), beans::PropertyAttribute::READONLY, 0 },
 346         { MAP_CHAR_LEN( "BitsPerPixel" ), UNOGRAPHIC_BITSPERPIXEL, &::getCppuType( (const sal_uInt8*)(0)), beans::PropertyAttribute::READONLY, 0 },
 347         { MAP_CHAR_LEN( "Transparent" ), UNOGRAPHIC_TRANSPARENT, &::getCppuType( (const sal_Bool*)(0)), beans::PropertyAttribute::READONLY, 0 },
 348         { MAP_CHAR_LEN( "Alpha" ), UNOGRAPHIC_ALPHA, &::getCppuType( (const sal_Bool*)(0)), beans::PropertyAttribute::READONLY, 0 },
 349         { MAP_CHAR_LEN( "Animated" ), UNOGRAPHIC_ANIMATED, &::getCppuType( (const sal_Bool*)(0)), beans::PropertyAttribute::READONLY, 0 },
 350
 351         { 0,0,0,0,0,0 }
 352     };
 353
 354     pRet->acquire();
 355     pRet->add( aEntries );
 356
 357     return pRet;
 358 }
 359
 360 // ------------------------------------------------------------------------------
 361
 362 void GraphicDescriptor::_setPropertyValues( const comphelper::PropertyMapEntry** /*ppEntries*/, const uno::Any* /*pValues*/ )
 363     throw( beans::UnknownPropertyException,
 364            beans::PropertyVetoException,
 365            lang::IllegalArgumentException,
 366               lang::WrappedTargetException )
 367 {
 368     // we only have readonly attributes
 369 }
 370
 371 // ------------------------------------------------------------------------------
 372
 373 void GraphicDescriptor::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, uno::Any* pValues )
 374     throw( beans::UnknownPropertyException, lang::WrappedTargetException )
 375 {
 376     ::vos::OGuard aGuard( Application::GetSolarMutex() );
 377
 378     while( *ppEntries )
 379     {
 380         switch( (*ppEntries)->mnHandle )
 381         {
 382             case( UNOGRAPHIC_GRAPHICTYPE ):
 383             {
 384                 const GraphicType eType( mpGraphic ? mpGraphic->GetType() : meType );
 385
 386                 *pValues <<= ( ( eType == GRAPHIC_BITMAP ? graphic::GraphicType::PIXEL :
 387                                 ( eType == GRAPHIC_GDIMETAFILE ? graphic::GraphicType::VECTOR :
 388                                 graphic::GraphicType::EMPTY ) ) );
 389             }
 390             break;
 391
 392             case( UNOGRAPHIC_MIMETYPE ):
 393             {
 394                 ::rtl::OUString aMimeType;
 395
 396                 if( mpGraphic )
 397                 {
 398                     if( mpGraphic->IsLink() )
 399                     {
 400                         const char* pMimeType;
 401
 402                         switch( const_cast< Graphic* >( mpGraphic )->GetLink().GetType() )
 403                         {
 404                             case( GFX_LINK_TYPE_NATIVE_GIF ): pMimeType = MIMETYPE_GIF; break;
 405                             case( GFX_LINK_TYPE_NATIVE_JPG ): pMimeType = MIMETYPE_JPG; break;
 406                             case( GFX_LINK_TYPE_NATIVE_PNG ): pMimeType = MIMETYPE_PNG; break;
 407                             case( GFX_LINK_TYPE_NATIVE_WMF ): pMimeType = MIMETYPE_WMF; break;
 408                             case( GFX_LINK_TYPE_NATIVE_MET ): pMimeType = MIMETYPE_MET; break;
 409                             case( GFX_LINK_TYPE_NATIVE_PCT ): pMimeType = MIMETYPE_PCT ; break;
 410
 411                             default:
 412                                 pMimeType = NULL;
 413                             break;
 414                         }
 415
 416                         if( pMimeType )
 417                             aMimeType = ::rtl::OUString::createFromAscii( pMimeType );
 418                     }
 419
 420                     if( !aMimeType.getLength() && ( mpGraphic->GetType() != GRAPHIC_NONE ) )
 421                         aMimeType = ::rtl::OUString::createFromAscii( MIMETYPE_VCLGRAPHIC );
 422                 }
 423                 else
 424                     aMimeType = maMimeType;
 425
 426                  *pValues <<= aMimeType;
 427             }
 428             break;
 429
 430             case( UNOGRAPHIC_SIZEPIXEL ):
 431             {
 432                 awt::Size aAWTSize( 0, 0 );
 433
 434                 if( mpGraphic )
 435                 {
 436                     if( mpGraphic->GetType() == GRAPHIC_BITMAP )
 437                     {
 438                         const Size aSizePix( mpGraphic->GetBitmapEx().GetSizePixel() );
 439                         aAWTSize = awt::Size( aSizePix.Width(), aSizePix.Height() );
 440                     }
 441                 }
 442                 else
 443                     aAWTSize = awt::Size( maSizePixel.Width(), maSizePixel.Height() );
 444
 445                 *pValues <<= aAWTSize;
 446             }
 447             break;
 448
 449             case( UNOGRAPHIC_SIZE100THMM ):
 450             {
 451                 awt::Size aAWTSize( 0, 0 );
 452
 453                 if( mpGraphic )
 454                 {
 455                     if( mpGraphic->GetPrefMapMode().GetMapUnit() != MAP_PIXEL )
 456                     {
 457                         const Size aSizeLog( OutputDevice::LogicToLogic( mpGraphic->GetPrefSize(), mpGraphic->GetPrefMapMode(), MAP_100TH_MM ) );
 458                         aAWTSize = awt::Size( aSizeLog.Width(), aSizeLog.Height() );
 459                     }
 460                 }
 461                 else
 462                     aAWTSize = awt::Size( maSize100thMM.Width(), maSize100thMM.Height() );
 463
 464                 *pValues <<= aAWTSize;
 465             }
 466             break;
 467
 468             case( UNOGRAPHIC_BITSPERPIXEL ):
 469             {
 470                 USHORT nBitsPerPixel = 0;
 471
 472                 if( mpGraphic )
 473                 {
 474                     if( mpGraphic->GetType() == GRAPHIC_BITMAP )
 475                         nBitsPerPixel = mpGraphic->GetBitmapEx().GetBitmap().GetBitCount();
 476                 }
 477                 else
 478                     nBitsPerPixel = mnBitsPerPixel;
 479
 480                 *pValues <<= sal::static_int_cast< sal_Int8 >(nBitsPerPixel);
 481             }
 482             break;
 483
 484             case( UNOGRAPHIC_TRANSPARENT ):
 485             {
 486                 *pValues <<= static_cast< sal_Bool >( mpGraphic ? mpGraphic->IsTransparent() : mbTransparent );
 487             }
 488             break;
 489
 490             case( UNOGRAPHIC_ALPHA ):
 491             {
 492                 *pValues <<= static_cast< sal_Bool >( mpGraphic ? mpGraphic->IsAlpha() : mbAlpha );
 493             }
 494             break;
 495
 496             case( UNOGRAPHIC_ANIMATED ):
 497             {
 498                 *pValues <<= static_cast< sal_Bool >( mpGraphic ? mpGraphic->IsAnimated() : mbAnimated );
 499             }
 500             break;
 501         }
 502
 503         ++ppEntries;
 504         ++pValues;
 505     }
 506 }
 507
 508 }