vcl/source/graphic/UnoGraphicDescriptor.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 #include <graphic/UnoGraphicDescriptor.hxx>
  21
  22 #include <cppuhelper/weakagg.hxx>
  23 #include <unotools/ucbstreamhelper.hxx>
  24 #include <vcl/graphicfilter.hxx>
  25 #include <cppuhelper/supportsservice.hxx>
  26
  27 #include <com/sun/star/beans/PropertyAttribute.hpp>
  28 #include <com/sun/star/awt/Size.hpp>
  29 #include <com/sun/star/graphic/GraphicType.hpp>
  30 #include <com/sun/star/io/XInputStream.hpp>
  31
  32 #include <vcl/outdev.hxx>
  33 #include <vcl/graph.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <memory>
  36
  37 namespace {
  38
  39 enum class UnoGraphicProperty
  40 {
  41       GraphicType = 1
  42     , MimeType = 2
  43     , SizePixel = 3
  44     , Size100thMM = 4
  45     , BitsPerPixel = 5
  46     , Transparent = 6
  47     , Alpha = 7
  48     , Animated = 8
  49     , Linked = 9
  50     , OriginURL = 10
  51 };
  52
  53 }
  54
  55 using namespace ::com::sun::star;
  56
  57 namespace unographic {
  58
  59
  60 GraphicDescriptor::GraphicDescriptor() :
  61     ::comphelper::PropertySetHelper( createPropertySetInfo() ),
  62     mpGraphic( nullptr ),
  63     meType( GraphicType::NONE ),
  64     mnBitsPerPixel ( 0 ),
  65     mbTransparent ( false )
  66 {
  67 }
  68
  69 GraphicDescriptor::~GraphicDescriptor()
  70     noexcept
  71 {
  72 }
  73
  74 void GraphicDescriptor::init( const ::Graphic& rGraphic )
  75 {
  76     mpGraphic = &rGraphic;
  77 }
  78
  79 void GraphicDescriptor::init( const OUString& rURL )
  80 {
  81     std::unique_ptr<SvStream> pIStm(::utl::UcbStreamHelper::CreateStream( rURL, StreamMode::READ ));
  82
  83     if( pIStm )
  84         implCreate( *pIStm, &rURL );
  85 }
  86
  87 void GraphicDescriptor::init( const uno::Reference< io::XInputStream >& rxIStm, const OUString& rURL )
  88 {
  89     std::unique_ptr<SvStream> pIStm(::utl::UcbStreamHelper::CreateStream( rxIStm ));
  90
  91     if( pIStm )
  92         implCreate( *pIStm, &rURL );
  93 }
  94
  95 void GraphicDescriptor::implCreate( SvStream& rIStm, const OUString* pURL )
  96 {
  97     OUString aURL;
  98     if( pURL )
  99         aURL = *pURL;
 100     ::GraphicDescriptor aDescriptor( rIStm, &aURL );
 101
 102     mpGraphic = nullptr;
 103     maMimeType.clear();
 104     meType = GraphicType::NONE;
 105     mnBitsPerPixel = 0;
 106     mbTransparent = false;
 107
 108     if( !(aDescriptor.Detect( true ) && aDescriptor.GetFileFormat() != GraphicFileFormat::NOT) )
 109         return;
 110
 111     OUString aMimeType;
 112     sal_uInt8               cType = graphic::GraphicType::EMPTY;
 113
 114     switch( aDescriptor.GetFileFormat() )
 115     {
 116         case GraphicFileFormat::BMP: aMimeType = MIMETYPE_BMP; cType = graphic::GraphicType::PIXEL; break;
 117         case GraphicFileFormat::GIF: aMimeType = MIMETYPE_GIF; cType = graphic::GraphicType::PIXEL; break;
 118         case GraphicFileFormat::JPG: aMimeType = MIMETYPE_JPG; cType = graphic::GraphicType::PIXEL; break;
 119         case GraphicFileFormat::PCD: aMimeType = MIMETYPE_PCD; cType = graphic::GraphicType::PIXEL; break;
 120         case GraphicFileFormat::PCX: aMimeType = MIMETYPE_PCX; cType = graphic::GraphicType::PIXEL; break;
 121         case GraphicFileFormat::PNG: aMimeType = MIMETYPE_PNG; cType = graphic::GraphicType::PIXEL; break;
 122         case GraphicFileFormat::TIF: aMimeType = MIMETYPE_TIF; cType = graphic::GraphicType::PIXEL; break;
 123         case GraphicFileFormat::XBM: aMimeType = MIMETYPE_XBM; cType = graphic::GraphicType::PIXEL; break;
 124         case GraphicFileFormat::XPM: aMimeType = MIMETYPE_XPM; cType = graphic::GraphicType::PIXEL; break;
 125         case GraphicFileFormat::PBM: aMimeType = MIMETYPE_PBM; cType = graphic::GraphicType::PIXEL; break;
 126         case GraphicFileFormat::PGM: aMimeType = MIMETYPE_PGM; cType = graphic::GraphicType::PIXEL; break;
 127         case GraphicFileFormat::PPM: aMimeType = MIMETYPE_PPM; cType = graphic::GraphicType::PIXEL; break;
 128         case GraphicFileFormat::RAS: aMimeType = MIMETYPE_RAS; cType = graphic::GraphicType::PIXEL; break;
 129         case GraphicFileFormat::TGA: aMimeType = MIMETYPE_TGA; cType = graphic::GraphicType::PIXEL; break;
 130         case GraphicFileFormat::PSD: aMimeType = MIMETYPE_PSD; cType = graphic::GraphicType::PIXEL; break;
 131         case GraphicFileFormat::WEBP: aMimeType = MIMETYPE_WEBP; cType = graphic::GraphicType::PIXEL; break;
 132
 133         case GraphicFileFormat::EPS: aMimeType = MIMETYPE_EPS; cType = graphic::GraphicType::VECTOR; break;
 134         case GraphicFileFormat::DXF: aMimeType = MIMETYPE_DXF; cType = graphic::GraphicType::VECTOR; break;
 135         case GraphicFileFormat::MET: aMimeType = MIMETYPE_MET; cType = graphic::GraphicType::VECTOR; break;
 136         case GraphicFileFormat::PCT: aMimeType = MIMETYPE_PCT; cType = graphic::GraphicType::VECTOR; break;
 137         case GraphicFileFormat::SVM: aMimeType = MIMETYPE_SVM; cType = graphic::GraphicType::VECTOR; break;
 138         case GraphicFileFormat::WMF: aMimeType = MIMETYPE_WMF; cType = graphic::GraphicType::VECTOR; break;
 139         case GraphicFileFormat::WMZ: aMimeType = MIMETYPE_WMF; cType = graphic::GraphicType::VECTOR; break;
 140         case GraphicFileFormat::EMF: aMimeType = MIMETYPE_EMF; cType = graphic::GraphicType::VECTOR; break;
 141         case GraphicFileFormat::EMZ: aMimeType = MIMETYPE_EMF; cType = graphic::GraphicType::VECTOR; break;
 142         case GraphicFileFormat::SVG: aMimeType = MIMETYPE_SVG; cType = graphic::GraphicType::VECTOR; break;
 143         case GraphicFileFormat::SVGZ: aMimeType = MIMETYPE_SVG; cType = graphic::GraphicType::VECTOR; break;
 144
 145         default:
 146         break;
 147     }
 148
 149     if( graphic::GraphicType::EMPTY != cType )
 150     {
 151         meType = ( ( graphic::GraphicType::PIXEL == cType ) ? GraphicType::Bitmap : GraphicType::GdiMetafile );
 152         maMimeType = aMimeType;
 153         maSizePixel = aDescriptor.GetSizePixel();
 154         maSize100thMM = aDescriptor.GetSize_100TH_MM();
 155         mnBitsPerPixel = aDescriptor.GetBitsPerPixel();
 156         mbTransparent = ( graphic::GraphicType::VECTOR == cType );
 157     }
 158 }
 159
 160
 161 uno::Any SAL_CALL GraphicDescriptor::queryInterface( const uno::Type & rType )
 162 {
 163     uno::Any aAny;
 164
 165     if( rType == cppu::UnoType<lang::XServiceInfo>::get())
 166         aAny <<= uno::Reference< lang::XServiceInfo >(this);
 167     else if( rType == cppu::UnoType<lang::XTypeProvider>::get())
 168         aAny <<= uno::Reference< lang::XTypeProvider >(this);
 169     else if( rType == cppu::UnoType<beans::XPropertySet>::get())
 170         aAny <<= uno::Reference< beans::XPropertySet >(this);
 171     else if( rType == cppu::UnoType<beans::XPropertyState>::get())
 172         aAny <<= uno::Reference< beans::XPropertyState >(this);
 173     else if( rType == cppu::UnoType<beans::XMultiPropertySet>::get())
 174         aAny <<= uno::Reference< beans::XMultiPropertySet >(this);
 175     else
 176         aAny = OWeakObject::queryInterface( rType );
 177
 178     return aAny;
 179 }
 180
 181
 182 void SAL_CALL GraphicDescriptor::acquire()
 183     noexcept
 184 {
 185     OWeakObject::acquire();
 186 }
 187
 188
 189 void SAL_CALL GraphicDescriptor::release()
 190     noexcept
 191 {
 192     OWeakObject::release();
 193 }
 194
 195
 196 OUString SAL_CALL GraphicDescriptor::getImplementationName()
 197 {
 198     return u"com.sun.star.comp.graphic.GraphicDescriptor"_ustr;
 199 }
 200
 201 sal_Bool SAL_CALL GraphicDescriptor::supportsService( const OUString& ServiceName )
 202 {
 203     return cppu::supportsService(this, ServiceName);
 204 }
 205
 206
 207 uno::Sequence< OUString > SAL_CALL GraphicDescriptor::getSupportedServiceNames()
 208 {
 209     return { u"com.sun.star.graphic.GraphicDescriptor"_ustr };
 210 }
 211
 212
 213 uno::Sequence< uno::Type > SAL_CALL GraphicDescriptor::getTypes()
 214 {
 215     static const uno::Sequence< uno::Type > aTypes {
 216         cppu::UnoType<uno::XAggregation>::get(),
 217         cppu::UnoType<lang::XServiceInfo>::get(),
 218         cppu::UnoType<lang::XTypeProvider>::get(),
 219         cppu::UnoType<beans::XPropertySet>::get(),
 220         cppu::UnoType<beans::XPropertyState>::get(),
 221         cppu::UnoType<beans::XMultiPropertySet>::get() };
 222     return aTypes;
 223 }
 224
 225 uno::Sequence< sal_Int8 > SAL_CALL GraphicDescriptor::getImplementationId()
 226 {
 227     return css::uno::Sequence<sal_Int8>();
 228 }
 229
 230
 231 rtl::Reference<::comphelper::PropertySetInfo> GraphicDescriptor::createPropertySetInfo()
 232 {
 233     static ::comphelper::PropertyMapEntry const aEntries[] =
 234     {
 235         { u"GraphicType"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::GraphicType ), cppu::UnoType< sal_Int8 >::get(), beans::PropertyAttribute::READONLY, 0 },
 236         { u"MimeType"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::MimeType ), cppu::UnoType< OUString >::get(), beans::PropertyAttribute::READONLY, 0 },
 237         { u"SizePixel"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::SizePixel ), cppu::UnoType< awt::Size >::get(), beans::PropertyAttribute::READONLY, 0 },
 238         { u"Size100thMM"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::Size100thMM ), cppu::UnoType< awt::Size >::get(), beans::PropertyAttribute::READONLY, 0 },
 239         { u"BitsPerPixel"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::BitsPerPixel ), cppu::UnoType< sal_Int8 >::get(), beans::PropertyAttribute::READONLY, 0 },
 240         { u"Transparent"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::Transparent ), cppu::UnoType< sal_Bool >::get(), beans::PropertyAttribute::READONLY, 0 },
 241         { u"Alpha"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::Alpha ), cppu::UnoType< sal_Bool >::get(), beans::PropertyAttribute::READONLY, 0 },
 242         { u"Animated"_ustr, static_cast< sal_Int32 >( UnoGraphicProperty::Animated ), cppu::UnoType< sal_Bool >::get(), beans::PropertyAttribute::READONLY, 0 },
 243         { u"Linked"_ustr, sal_Int32(UnoGraphicProperty::Linked), cppu::UnoType<sal_Bool>::get(), beans::PropertyAttribute::READONLY, 0 },
 244         { u"OriginURL"_ustr, sal_Int32(UnoGraphicProperty::OriginURL), cppu::UnoType<OUString>::get(), beans::PropertyAttribute::READONLY, 0 },
 245     };
 246
 247     return rtl::Reference<::comphelper::PropertySetInfo>( new ::comphelper::PropertySetInfo(aEntries) );
 248 }
 249
 250
 251 void GraphicDescriptor::_setPropertyValues( const comphelper::PropertyMapEntry** /*ppEntries*/, const uno::Any* /*pValues*/ )
 252 {
 253     // we only have readonly attributes
 254 }
 255
 256
 257 void GraphicDescriptor::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, uno::Any* pValues )
 258 {
 259     SolarMutexGuard aGuard;
 260
 261     while( *ppEntries )
 262     {
 263         UnoGraphicProperty theProperty = static_cast< UnoGraphicProperty >( (*ppEntries)->mnHandle );
 264         switch( theProperty )
 265         {
 266             case UnoGraphicProperty::GraphicType:
 267             {
 268                 const GraphicType eType( mpGraphic ? mpGraphic->GetType() : meType );
 269
 270                 *pValues <<= ( eType == GraphicType::Bitmap ? graphic::GraphicType::PIXEL :
 271                                 ( eType == GraphicType::GdiMetafile ? graphic::GraphicType::VECTOR :
 272                                 graphic::GraphicType::EMPTY ) );
 273             }
 274             break;
 275
 276             case UnoGraphicProperty::MimeType:
 277             {
 278                 OUString aMimeType;
 279
 280                 if( mpGraphic )
 281                 {
 282                     if( mpGraphic->IsGfxLink() )
 283                     {
 284                         GfxLink aLink = mpGraphic->GetGfxLink();
 285                         switch (aLink.GetType())
 286                         {
 287                             case GfxLinkType::NativeGif: aMimeType = MIMETYPE_GIF; break;
 288
 289                             // #i15508# added BMP type for better exports (checked, works)
 290                             case GfxLinkType::NativeBmp: aMimeType = MIMETYPE_BMP; break;
 291
 292                             case GfxLinkType::NativeJpg: aMimeType = MIMETYPE_JPG; break;
 293                             case GfxLinkType::NativePng: aMimeType = MIMETYPE_PNG; break;
 294                             case GfxLinkType::NativeTif: aMimeType = MIMETYPE_TIF; break;
 295                             case GfxLinkType::NativeWmf: aMimeType = aLink.IsEMF() ? MIMETYPE_EMF : MIMETYPE_WMF; break;
 296                             case GfxLinkType::NativeMet: aMimeType = MIMETYPE_MET; break;
 297                             case GfxLinkType::NativePct: aMimeType = MIMETYPE_PCT; break;
 298                             case GfxLinkType::NativeWebp: aMimeType = MIMETYPE_WEBP; break;
 299
 300                             // added Svg mimetype support
 301                             case GfxLinkType::NativeSvg: aMimeType = MIMETYPE_SVG; break;
 302                             case GfxLinkType::NativePdf: aMimeType = MIMETYPE_PDF; break;
 303
 304                             default:
 305                             break;
 306                         }
 307                     }
 308
 309                     if( aMimeType.isEmpty() && ( mpGraphic->GetType() != GraphicType::NONE ) )
 310                         aMimeType = MIMETYPE_VCLGRAPHIC;
 311                 }
 312                 else
 313                     aMimeType = maMimeType;
 314
 315                 *pValues <<= aMimeType;
 316             }
 317             break;
 318
 319             case UnoGraphicProperty::SizePixel:
 320             {
 321                 awt::Size aAWTSize( 0, 0 );
 322
 323                 if( mpGraphic )
 324                 {
 325                     if( mpGraphic->GetType() == GraphicType::Bitmap )
 326                     {
 327                         const Size aSizePix( mpGraphic->GetSizePixel() );
 328                         aAWTSize = awt::Size( aSizePix.Width(), aSizePix.Height() );
 329                     }
 330                 }
 331                 else
 332                     aAWTSize = awt::Size( maSizePixel.Width(), maSizePixel.Height() );
 333
 334                 *pValues <<= aAWTSize;
 335             }
 336             break;
 337
 338             case UnoGraphicProperty::Size100thMM:
 339             {
 340                 awt::Size aAWTSize( 0, 0 );
 341
 342                 if( mpGraphic )
 343                 {
 344                     if( mpGraphic->GetPrefMapMode().GetMapUnit() != MapUnit::MapPixel )
 345                     {
 346                         const Size aSizeLog( OutputDevice::LogicToLogic(
 347                             mpGraphic->GetPrefSize(),
 348                             mpGraphic->GetPrefMapMode(),
 349                             MapMode(MapUnit::Map100thMM)) );
 350                         aAWTSize = awt::Size( aSizeLog.Width(), aSizeLog.Height() );
 351                     }
 352                 }
 353                 else
 354                     aAWTSize = awt::Size( maSize100thMM.Width(), maSize100thMM.Height() );
 355
 356                 *pValues <<= aAWTSize;
 357             }
 358             break;
 359
 360             case UnoGraphicProperty::BitsPerPixel:
 361             {
 362                 sal_uInt16 nBitsPerPixel = 0;
 363
 364                 if( mpGraphic )
 365                 {
 366                     if( mpGraphic->GetType() == GraphicType::Bitmap )
 367                     {
 368                         auto ePixelFormat = mpGraphic->GetBitmapEx().GetBitmap().getPixelFormat();
 369                         nBitsPerPixel = vcl::pixelFormatBitCount(ePixelFormat);
 370                     }
 371                 }
 372                 else
 373                     nBitsPerPixel = mnBitsPerPixel;
 374
 375                 *pValues <<= sal::static_int_cast< sal_Int8 >(nBitsPerPixel);
 376             }
 377             break;
 378
 379             case UnoGraphicProperty::Transparent:
 380             {
 381                 *pValues <<= mpGraphic ? mpGraphic->IsTransparent() : mbTransparent;
 382             }
 383             break;
 384
 385             case UnoGraphicProperty::Alpha:
 386             {
 387                 *pValues <<= mpGraphic && mpGraphic->IsAlpha();
 388             }
 389             break;
 390
 391             case UnoGraphicProperty::Animated:
 392             {
 393                 *pValues <<= mpGraphic && mpGraphic->IsAnimated();
 394             }
 395             break;
 396
 397             case UnoGraphicProperty::Linked:
 398             {
 399                 *pValues <<= mpGraphic && !mpGraphic->getOriginURL().isEmpty();
 400             }
 401             break;
 402
 403             case UnoGraphicProperty::OriginURL:
 404             {
 405                 OUString aOriginURL;
 406                 if (mpGraphic)
 407                     aOriginURL = mpGraphic->getOriginURL();
 408
 409                 *pValues <<= aOriginURL;
 410             }
 411             break;
 412         }
 413
 414         ++ppEntries;
 415         ++pValues;
 416     }
 417 }
 418
 419 }
 420
 421 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */