svx/source/unodraw/unoshap4.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 <com/sun/star/util/XModifiable.hpp>
  21 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  22 #include <com/sun/star/embed/XLinkageSupport.hpp>
  23 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
  24 #include <com/sun/star/embed/Aspects.hpp>
  25 #include <com/sun/star/task/XInteractionHandler.hpp>
  26 #include <com/sun/star/ucb/CommandFailedException.hpp>
  27 #include <com/sun/star/ucb/ContentCreationException.hpp>
  28
  29 #include <svx/svdoole2.hxx>
  30 #include <svx/svdomedia.hxx>
  31 #include <svx/svdpool.hxx>
  32 #include <comphelper/classids.hxx>
  33 #include <comphelper/embeddedobjectcontainer.hxx>
  34 #include <comphelper/propertysequence.hxx>
  35 #include <comphelper/propertyvalue.hxx>
  36 #include <cppuhelper/exc_hlp.hxx>
  37
  38 #include <toolkit/helper/vclunohelper.hxx>
  39
  40 #include <sot/exchange.hxx>
  41
  42 #include <svx/svdmodel.hxx>
  43 #include "shapeimpl.hxx"
  44
  45 #include <svx/unoshprp.hxx>
  46
  47 #include <utility>
  48 #include <vcl/gdimtf.hxx>
  49 #include <vcl/wmf.hxx>
  50 #include <svtools/embedhlp.hxx>
  51 #include <sal/log.hxx>
  52 #include <tools/debug.hxx>
  53 #include <tools/globname.hxx>
  54 #include <tools/stream.hxx>
  55
  56 #include <config_features.h>
  57
  58
  59 using namespace ::cppu;
  60 using namespace ::com::sun::star;
  61 using namespace ::com::sun::star::uno;
  62 using namespace ::com::sun::star::lang;
  63 using namespace ::com::sun::star::container;
  64 using namespace ::com::sun::star::beans;
  65
  66
  67 SvxOle2Shape::SvxOle2Shape(SdrObject* pObject, OUString referer)
  68     : SvxShapeText(pObject, getSvxMapProvider().GetMap(SVXMAP_OLE2),
  69                 getSvxMapProvider().GetPropertySet(SVXMAP_OLE2,SdrObject::GetGlobalDrawObjectItemPool()))
  70     , referer_(std::move(referer))
  71 {
  72 }
  73
  74 SvxOle2Shape::SvxOle2Shape(SdrObject* pObject, OUString referer, std::span<const SfxItemPropertyMapEntry> pPropertyMap, const SvxItemPropertySet* pPropertySet)
  75     : SvxShapeText(pObject, pPropertyMap, pPropertySet)
  76     , referer_(std::move(referer))
  77 {
  78 }
  79
  80 SvxOle2Shape::~SvxOle2Shape() noexcept
  81 {
  82 }
  83
  84 //XPropertySet
  85 bool SvxOle2Shape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
  86 {
  87     switch( pProperty->nWID )
  88     {
  89     case OWN_ATTR_OLE_VISAREA:
  90     {
  91         // TODO/LATER: seems to make no sense for iconified object
  92
  93         awt::Rectangle aVisArea;
  94         if( !(rValue >>= aVisArea))
  95             break;
  96         if( auto pOle2Obj = dynamic_cast<SdrOle2Obj* >(GetSdrObject()) )
  97         {
  98             Size aTmp( aVisArea.X + aVisArea.Width, aVisArea.Y + aVisArea.Height );
  99             uno::Reference < embed::XEmbeddedObject > xObj = pOle2Obj->GetObjRef();
 100             if( xObj.is() )
 101             {
 102                 try
 103                 {
 104                     // the API handles with MapUnit::Map100thMM map mode
 105                     MapUnit aObjUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( embed::Aspects::MSOLE_CONTENT ) );
 106                     aTmp = OutputDevice::LogicToLogic(aTmp, MapMode(MapUnit::Map100thMM), MapMode(aObjUnit));
 107                     xObj->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, awt::Size( aTmp.Width(), aTmp.Height() ) );
 108                 }
 109                 catch( uno::Exception& )
 110                 {
 111                     OSL_FAIL( "Couldn't set the visual area for the object!" );
 112                 }
 113             }
 114
 115             return true;
 116         }
 117         break;
 118     }
 119     case OWN_ATTR_OLE_ASPECT:
 120     {
 121         sal_Int64 nAspect = 0;
 122         if( rValue >>= nAspect )
 123         {
 124             static_cast<SdrOle2Obj*>(GetSdrObject())->SetAspect( nAspect );
 125             return true;
 126         }
 127         break;
 128     }
 129     case OWN_ATTR_CLSID:
 130     {
 131         OUString aCLSID;
 132         if( rValue >>= aCLSID )
 133         {
 134             // init an OLE object with a global name
 135             SvGlobalName aClassName;
 136             if( aClassName.MakeId( aCLSID ) )
 137             {
 138                 if( createObject( aClassName ) )
 139                     return true;
 140             }
 141         }
 142         break;
 143     }
 144     case OWN_ATTR_THUMBNAIL:
 145     {
 146         uno::Reference< graphic::XGraphic > xGraphic( rValue, uno::UNO_QUERY );
 147         if( xGraphic.is() )
 148         {
 149             const Graphic aGraphic(xGraphic);
 150             static_cast<SdrOle2Obj*>(GetSdrObject())->SetGraphic(aGraphic);
 151             return true;
 152         }
 153         break;
 154     }
 155     case OWN_ATTR_VALUE_GRAPHIC:
 156     {
 157         uno::Reference< graphic::XGraphic > xGraphic( rValue, uno::UNO_QUERY );
 158         if( xGraphic.is() )
 159         {
 160             SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
 161             if( pOle )
 162             {
 163                 GraphicObject aGrafObj( xGraphic );
 164                 const Graphic& aGraphic( aGrafObj.GetGraphic() );
 165                 pOle->SetGraphicToObj( aGraphic );
 166             }
 167             return true;
 168         }
 169         break;
 170     }
 171     case OWN_ATTR_PERSISTNAME:
 172     {
 173         OUString aPersistName;
 174         if( rValue >>= aPersistName )
 175         {
 176             SdrOle2Obj *pOle;
 177 #if OSL_DEBUG_LEVEL > 0
 178             pOle = dynamic_cast<SdrOle2Obj*>(GetSdrObject());
 179             assert(pOle);
 180 #else
 181             pOle = static_cast<SdrOle2Obj*>(GetSdrObject());
 182 #endif
 183             pOle->SetPersistName( aPersistName, this );
 184             return true;
 185         }
 186         break;
 187     }
 188     case OWN_ATTR_OLE_LINKURL:
 189     {
 190         OUString aLinkURL;
 191         if( rValue >>= aLinkURL )
 192         {
 193             createLink( aLinkURL );
 194             return true;
 195         }
 196         break;
 197     }
 198     default:
 199         return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
 200     }
 201
 202     throw IllegalArgumentException();
 203 }
 204
 205 bool SvxOle2Shape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
 206 {
 207     switch( pProperty->nWID )
 208     {
 209     case OWN_ATTR_CLSID:
 210     {
 211         OUString aCLSID;
 212         GetClassName_Impl(aCLSID);
 213         rValue <<= aCLSID;
 214         break;
 215     }
 216
 217     case OWN_ATTR_INTERNAL_OLE:
 218     {
 219         OUString sCLSID;
 220         rValue <<= SotExchange::IsInternal( GetClassName_Impl(sCLSID) );
 221         break;
 222     }
 223
 224     case OWN_ATTR_METAFILE:
 225     {
 226         SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>(GetSdrObject());
 227         if( pObj )
 228         {
 229             const Graphic* pGraphic = pObj->GetGraphic();
 230             if( pGraphic )
 231             {
 232                 bool bIsWMF = false;
 233                 if ( pGraphic->IsGfxLink() )
 234                 {
 235                     GfxLink aLnk = pGraphic->GetGfxLink();
 236                     if ( aLnk.GetType() == GfxLinkType::NativeWmf )
 237                     {
 238                         bIsWMF = true;
 239                         uno::Sequence<sal_Int8> aSeq(reinterpret_cast<sal_Int8 const *>(aLnk.GetData()), static_cast<sal_Int32>(aLnk.GetDataSize()));
 240                         rValue <<= aSeq;
 241                     }
 242                 }
 243                 if ( !bIsWMF )
 244                 {
 245                     // #i119735# just use GetGDIMetaFile, it will create a buffered version of contained bitmap now automatically
 246                     GDIMetaFile aMtf(pObj->GetGraphic()->GetGDIMetaFile());
 247                     SvMemoryStream aDestStrm( 65535, 65535 );
 248                     ConvertGDIMetaFileToWMF( aMtf, aDestStrm, nullptr, false );
 249                     const uno::Sequence<sal_Int8> aSeq(
 250                         static_cast< const sal_Int8* >(aDestStrm.GetData()),
 251                         aDestStrm.GetEndOfData());
 252                     rValue <<= aSeq;
 253                 }
 254             }
 255         }
 256         else
 257         {
 258             rValue = GetBitmap( true );
 259         }
 260         break;
 261     }
 262
 263     case OWN_ATTR_OLE_VISAREA:
 264     {
 265         awt::Rectangle aVisArea;
 266         if( dynamic_cast<const SdrOle2Obj* >(GetSdrObject()) != nullptr)
 267         {
 268             MapMode aMapMode( MapUnit::Map100thMM ); // the API uses this map mode
 269             Size aTmp = static_cast<SdrOle2Obj*>(GetSdrObject())->GetOrigObjSize( &aMapMode ); // get the size in the requested map mode
 270             aVisArea = awt::Rectangle( 0, 0, aTmp.Width(), aTmp.Height() );
 271         }
 272
 273         rValue <<= aVisArea;
 274         break;
 275     }
 276
 277     case OWN_ATTR_OLESIZE:
 278     {
 279         Size aTmp( static_cast<SdrOle2Obj*>(GetSdrObject())->GetOrigObjSize() );
 280         rValue <<= awt::Size( aTmp.Width(), aTmp.Height() );
 281         break;
 282     }
 283
 284     case OWN_ATTR_OLE_ASPECT:
 285     {
 286         rValue <<= static_cast<SdrOle2Obj*>(GetSdrObject())->GetAspect();
 287         break;
 288     }
 289
 290     case OWN_ATTR_OLEMODEL:
 291     case OWN_ATTR_OLE_EMBEDDED_OBJECT:
 292     case OWN_ATTR_OLE_EMBEDDED_OBJECT_NONEWCLIENT:
 293     {
 294         SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>( GetSdrObject() );
 295         if( pObj )
 296         {
 297             uno::Reference < embed::XEmbeddedObject > xObj( pObj->GetObjRef() );
 298             if ( xObj.is()
 299               && ( pProperty->nWID == OWN_ATTR_OLE_EMBEDDED_OBJECT || pProperty->nWID == OWN_ATTR_OLE_EMBEDDED_OBJECT_NONEWCLIENT || svt::EmbeddedObjectRef::TryRunningState( xObj ) ) )
 300             {
 301                 // Discussed with CL fue to the before GetPaintingPageView
 302                 // usage. Removed it, former fallback is used now
 303                 if ( pProperty->nWID == OWN_ATTR_OLEMODEL || pProperty->nWID == OWN_ATTR_OLE_EMBEDDED_OBJECT )
 304                 {
 305                     const bool bSuccess(pObj->AddOwnLightClient());
 306                     SAL_WARN_IF(!bSuccess, "svx.svdraw", "An object without client is provided!");
 307                 }
 308
 309                 if ( pProperty->nWID == OWN_ATTR_OLEMODEL )
 310                     rValue <<= pObj->GetObjRef()->getComponent();
 311                 else
 312                     rValue <<= xObj;
 313             }
 314         }
 315         break;
 316     }
 317
 318     case OWN_ATTR_VALUE_GRAPHIC:
 319     {
 320         uno::Reference< graphic::XGraphic > xGraphic;
 321         const Graphic* pGraphic = static_cast<SdrOle2Obj*>( GetSdrObject() )->GetGraphic();
 322         if( pGraphic )
 323             xGraphic = pGraphic->GetXGraphic();
 324         rValue <<= xGraphic;
 325         break;
 326     }
 327
 328     case OWN_ATTR_THUMBNAIL:
 329     {
 330         uno::Reference< graphic::XGraphic > xGraphic;
 331         const Graphic* pGraphic = static_cast<SdrOle2Obj*>( GetSdrObject() )->GetGraphic();
 332         if( pGraphic )
 333             xGraphic = pGraphic->GetXGraphic();
 334         rValue <<= xGraphic;
 335         break;
 336     }
 337     case OWN_ATTR_PERSISTNAME:
 338     {
 339         OUString    aPersistName;
 340         SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
 341
 342         if( pOle )
 343         {
 344             aPersistName = pOle->GetPersistName();
 345             if( !aPersistName.isEmpty() )
 346             {
 347                 ::comphelper::IEmbeddedHelper* pPersist(GetSdrObject()->getSdrModelFromSdrObject().GetPersist());
 348                 if( (nullptr == pPersist) || !pPersist->getEmbeddedObjectContainer().HasEmbeddedObject( pOle->GetPersistName() ) )
 349                     aPersistName.clear();
 350             }
 351         }
 352
 353         rValue <<= aPersistName;
 354         break;
 355     }
 356     case OWN_ATTR_OLE_LINKURL:
 357     {
 358         OUString    aLinkURL;
 359         SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
 360
 361         if( pOle )
 362         {
 363             uno::Reference< embed::XLinkageSupport > xLink( pOle->GetObjRef(), uno::UNO_QUERY );
 364             if ( xLink.is() && xLink->isLink() )
 365                 aLinkURL = xLink->getLinkURL();
 366         }
 367
 368         rValue <<= aLinkURL;
 369         break;
 370     }
 371     default:
 372         return SvxShapeText::getPropertyValueImpl( rName, pProperty, rValue );
 373     }
 374
 375     return true;
 376 }
 377
 378 bool SvxOle2Shape::createObject( const SvGlobalName &aClassName )
 379 {
 380     DBG_TESTSOLARMUTEX();
 381
 382     SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
 383     if ( !pOle2Obj || !pOle2Obj->IsEmpty() )
 384         return false;
 385
 386     // create storage and inplace object
 387     ::comphelper::IEmbeddedHelper*     pPersist = GetSdrObject()->getSdrModelFromSdrObject().GetPersist();
 388     OUString              aPersistName;
 389     OUString            aTmpStr;
 390     if( SvxShape::getPropertyValue( UNO_NAME_OLE2_PERSISTNAME ) >>= aTmpStr )
 391         aPersistName = aTmpStr;
 392
 393     uno::Sequence<beans::PropertyValue> objArgs( comphelper::InitPropertySequence({
 394             { "DefaultParentBaseURL", Any(pPersist->getDocumentBaseURL()) }
 395         }));
 396     //TODO/LATER: how to cope with creation failure?!
 397     uno::Reference<embed::XEmbeddedObject> xObj(
 398         pPersist->getEmbeddedObjectContainer().CreateEmbeddedObject(
 399             aClassName.GetByteSequence(), objArgs, aPersistName));
 400     if( xObj.is() )
 401     {
 402         tools::Rectangle aRect = pOle2Obj->GetLogicRect();
 403         if ( aRect.GetWidth() == 101 && aRect.GetHeight() == 101 )
 404         {
 405             // TODO/LATER: is it possible that this method is used to create an iconified object?
 406             // default size
 407             try
 408             {
 409                 awt::Size aSz = xObj->getVisualAreaSize( pOle2Obj->GetAspect() );
 410                 aRect.SetSize( Size( aSz.Width, aSz.Height ) );
 411             }
 412             catch( embed::NoVisualAreaSizeException& )
 413             {}
 414             pOle2Obj->SetLogicRect( aRect );
 415         }
 416         else
 417         {
 418             awt::Size aSz;
 419             Size aSize = aRect.GetSize();
 420             aSz.Width = aSize.Width();
 421             aSz.Height = aSize.Height();
 422             if (aSz.Width != 0 || aSz.Height != 0)
 423             {
 424                 //HACK: can aSz legally be empty?
 425                 xObj->setVisualAreaSize(  pOle2Obj->GetAspect(), aSz );
 426             }
 427         }
 428
 429         // connect the object after the visual area is set
 430         aTmpStr = aPersistName;
 431         SvxShape::setPropertyValue( UNO_NAME_OLE2_PERSISTNAME, Any( aTmpStr ) );
 432
 433         // the object is inserted during setting of PersistName property usually
 434         if( pOle2Obj->IsEmpty() )
 435             pOle2Obj->SetObjRef( xObj );
 436     }
 437
 438     return xObj.is();
 439 }
 440
 441 void SvxOle2Shape::createLink( const OUString& aLinkURL )
 442 {
 443     DBG_TESTSOLARMUTEX();
 444
 445     SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
 446     if ( !pOle2Obj || !pOle2Obj->IsEmpty() )
 447         return;
 448
 449     OUString aPersistName;
 450
 451     ::comphelper::IEmbeddedHelper* pPersist = GetSdrObject()->getSdrModelFromSdrObject().GetPersist();
 452
 453     uno::Sequence< beans::PropertyValue > aMediaDescr{
 454         comphelper::makePropertyValue("URL", aLinkURL),
 455         comphelper::makePropertyValue("Referer", referer_)
 456     };
 457
 458     uno::Reference< task::XInteractionHandler > xInteraction = pPersist->getInteractionHandler();
 459     if ( xInteraction.is() )
 460     {
 461         aMediaDescr.realloc( 3 );
 462         auto pMediaDescr = aMediaDescr.getArray();
 463         pMediaDescr[2].Name = "InteractionHandler";
 464         pMediaDescr[2].Value <<= xInteraction;
 465     }
 466
 467     //TODO/LATER: how to cope with creation failure?!
 468     uno::Reference< embed::XEmbeddedObject > xObj =
 469             pPersist->getEmbeddedObjectContainer().InsertEmbeddedLink( aMediaDescr , aPersistName );
 470
 471     if( !xObj.is() )
 472         return;
 473
 474     tools::Rectangle aRect = pOle2Obj->GetLogicRect();
 475     if ( aRect.GetWidth() == 101 && aRect.GetHeight() == 101 )
 476     {
 477         // default size
 478         try
 479         {
 480             awt::Size aSz = xObj->getVisualAreaSize( pOle2Obj->GetAspect() );
 481             aRect.SetSize( Size( aSz.Width, aSz.Height ) );
 482         }
 483         catch (const uno::Exception&)
 484         {}
 485         pOle2Obj->SetLogicRect( aRect );
 486     }
 487     else
 488     {
 489         awt::Size aSz;
 490         Size aSize = pOle2Obj->GetLogicRect().GetSize();
 491         aSz.Width = aSize.Width();
 492         aSz.Height = aSize.Height();
 493         xObj->setVisualAreaSize(  pOle2Obj->GetAspect(), aSz );
 494     }
 495
 496     // connect the object after the visual area is set
 497     SvxShape::setPropertyValue( UNO_NAME_OLE2_PERSISTNAME, uno::Any( aPersistName ) );
 498
 499     // the object is inserted during setting of PersistName property usually
 500     if ( pOle2Obj->IsEmpty() )
 501         pOle2Obj->SetObjRef( xObj );
 502 }
 503
 504 void SvxOle2Shape::resetModifiedState()
 505 {
 506     SdrObject* pObject = GetSdrObject();
 507     ::comphelper::IEmbeddedHelper* pPersist = pObject ? pObject->getSdrModelFromSdrObject().GetPersist() : nullptr;
 508     if( pPersist && !pPersist->isEnableSetModified() )
 509     {
 510         SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >(pObject);
 511         if( pOle && !pOle->IsEmpty() )
 512         {
 513             uno::Reference < util::XModifiable > xMod( pOle->GetObjRef(), uno::UNO_QUERY );
 514             if( xMod.is() )
 515                 // TODO/MBA: what's this?!
 516                 xMod->setModified( false );
 517         }
 518     }
 519 }
 520
 521 SvGlobalName SvxOle2Shape::GetClassName_Impl(OUString& rHexCLSID)
 522 {
 523     DBG_TESTSOLARMUTEX();
 524     SvGlobalName aClassName;
 525     SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
 526
 527     if( pOle2Obj )
 528     {
 529         rHexCLSID.clear();
 530
 531         if( pOle2Obj->IsEmpty() )
 532         {
 533             ::comphelper::IEmbeddedHelper* pPersist = GetSdrObject()->getSdrModelFromSdrObject().GetPersist();
 534             if( pPersist )
 535             {
 536                 uno::Reference < embed::XEmbeddedObject > xObj =
 537                         pPersist->getEmbeddedObjectContainer().GetEmbeddedObject( pOle2Obj->GetPersistName() );
 538                 if ( xObj.is() )
 539                 {
 540                     aClassName = SvGlobalName( xObj->getClassID() );
 541                     rHexCLSID = aClassName.GetHexName();
 542                 }
 543             }
 544         }
 545
 546         if (rHexCLSID.isEmpty())
 547         {
 548             const uno::Reference < embed::XEmbeddedObject >& xObj( pOle2Obj->GetObjRef() );
 549             if ( xObj.is() )
 550             {
 551                 aClassName = SvGlobalName( xObj->getClassID() );
 552                 rHexCLSID = aClassName.GetHexName();
 553             }
 554         }
 555     }
 556
 557     return aClassName;
 558 }
 559
 560 OUString SvxOle2Shape::GetAndClearInitialFrameURL()
 561 {
 562     return OUString();
 563 }
 564
 565 SvxAppletShape::SvxAppletShape(SdrObject* pObject, OUString referer)
 566     : SvxOle2Shape(pObject, std::move(referer), getSvxMapProvider().GetMap(SVXMAP_APPLET), getSvxMapProvider().GetPropertySet(SVXMAP_APPLET, SdrObject::GetGlobalDrawObjectItemPool()))
 567 {
 568     SetShapeType( "com.sun.star.drawing.AppletShape" );
 569 }
 570
 571 SvxAppletShape::~SvxAppletShape() noexcept
 572 {
 573 }
 574
 575 void SvxAppletShape::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
 576 {
 577     SvxShape::Create( pNewObj, pNewPage );
 578     const SvGlobalName aAppletClassId( SO3_APPLET_CLASSID );
 579     createObject(aAppletClassId);
 580     SetShapeType( "com.sun.star.drawing.AppletShape" );
 581 }
 582
 583 void SAL_CALL SvxAppletShape::setPropertyValue( const OUString& aPropertyName, const css::uno::Any& rValue )
 584 {
 585     SvxShape::setPropertyValue( aPropertyName, rValue );
 586     resetModifiedState();
 587 }
 588
 589 void SAL_CALL SvxAppletShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& rValues )
 590 {
 591     SvxShape::setPropertyValues( aPropertyNames, rValues );
 592     resetModifiedState();
 593 }
 594
 595 bool SvxAppletShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
 596 {
 597     if( (pProperty->nWID >= OWN_ATTR_APPLET_DOCBASE) && (pProperty->nWID <= OWN_ATTR_APPLET_ISSCRIPT) )
 598     {
 599         if ( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
 600         {
 601             uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
 602             if( xSet.is() )
 603             {
 604                 // allow exceptions to pass through
 605                 xSet->setPropertyValue( rName, rValue );
 606             }
 607         }
 608         return true;
 609     }
 610     else
 611     {
 612         return SvxOle2Shape::setPropertyValueImpl( rName, pProperty, rValue );
 613     }
 614 }
 615
 616 bool SvxAppletShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
 617 {
 618     if( (pProperty->nWID >= OWN_ATTR_APPLET_DOCBASE) && (pProperty->nWID <= OWN_ATTR_APPLET_ISSCRIPT) )
 619     {
 620         if ( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
 621         {
 622             uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
 623             if( xSet.is() )
 624             {
 625                 rValue = xSet->getPropertyValue( rName );
 626             }
 627         }
 628         return true;
 629     }
 630     else
 631     {
 632         return SvxOle2Shape::getPropertyValueImpl( rName, pProperty, rValue );
 633     }
 634 }
 635
 636 SvxPluginShape::SvxPluginShape(SdrObject* pObject, OUString referer)
 637     : SvxOle2Shape(pObject, std::move(referer), getSvxMapProvider().GetMap(SVXMAP_PLUGIN), getSvxMapProvider().GetPropertySet(SVXMAP_PLUGIN, SdrObject::GetGlobalDrawObjectItemPool()))
 638 {
 639     SetShapeType( "com.sun.star.drawing.PluginShape" );
 640 }
 641
 642 SvxPluginShape::~SvxPluginShape() noexcept
 643 {
 644 }
 645
 646 void SvxPluginShape::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
 647 {
 648     SvxShape::Create( pNewObj, pNewPage );
 649     const SvGlobalName aPluginClassId( SO3_PLUGIN_CLASSID );
 650     createObject(aPluginClassId);
 651     SetShapeType( "com.sun.star.drawing.PluginShape" );
 652 }
 653
 654 void SAL_CALL SvxPluginShape::setPropertyValue( const OUString& aPropertyName, const css::uno::Any& rValue )
 655 {
 656     SvxShape::setPropertyValue( aPropertyName, rValue );
 657     resetModifiedState();
 658 }
 659
 660 void SAL_CALL SvxPluginShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& rValues )
 661 {
 662     SvxShape::setPropertyValues( aPropertyNames, rValues );
 663     resetModifiedState();
 664 }
 665
 666 bool SvxPluginShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
 667 {
 668     if( (pProperty->nWID >= OWN_ATTR_PLUGIN_MIMETYPE) && (pProperty->nWID <= OWN_ATTR_PLUGIN_COMMANDS) )
 669     {
 670         if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
 671         {
 672             uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
 673             if( xSet.is() )
 674             {
 675                 // allow exceptions to pass through
 676                 xSet->setPropertyValue( rName, rValue );
 677             }
 678         }
 679         return true;
 680     }
 681     else
 682     {
 683         return SvxOle2Shape::setPropertyValueImpl( rName, pProperty, rValue );
 684     }
 685 }
 686
 687 bool SvxPluginShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
 688 {
 689     if( (pProperty->nWID >= OWN_ATTR_PLUGIN_MIMETYPE) && (pProperty->nWID <= OWN_ATTR_PLUGIN_COMMANDS) )
 690     {
 691         if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
 692         {
 693             uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
 694             if( xSet.is() )
 695             {
 696                 rValue = xSet->getPropertyValue( rName );
 697             }
 698         }
 699         return true;
 700     }
 701     else
 702     {
 703         return SvxOle2Shape::getPropertyValueImpl( rName, pProperty, rValue );
 704     }
 705 }
 706
 707 SvxFrameShape::SvxFrameShape(SdrObject* pObject, OUString referer)
 708     : SvxOle2Shape(pObject, std::move(referer), getSvxMapProvider().GetMap(SVXMAP_FRAME), getSvxMapProvider().GetPropertySet(SVXMAP_FRAME, SdrObject::GetGlobalDrawObjectItemPool()))
 709 {
 710     SetShapeType( "com.sun.star.drawing.FrameShape" );
 711 }
 712
 713 SvxFrameShape::~SvxFrameShape() noexcept
 714 {
 715 }
 716
 717 OUString SvxFrameShape::GetAndClearInitialFrameURL()
 718 {
 719     OUString sRet(m_sInitialFrameURL);
 720     m_sInitialFrameURL.clear();
 721     return sRet;
 722 }
 723
 724 void SvxFrameShape::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
 725 {
 726     uno::Reference<beans::XPropertySet> xSet(static_cast<OWeakObject *>(this), uno::UNO_QUERY);
 727     if (xSet)
 728         xSet->getPropertyValue("FrameURL") >>= m_sInitialFrameURL;
 729
 730     SvxShape::Create( pNewObj, pNewPage );
 731     const SvGlobalName aIFrameClassId( SO3_IFRAME_CLASSID );
 732     createObject(aIFrameClassId);
 733     SetShapeType( "com.sun.star.drawing.FrameShape" );
 734 }
 735
 736 void SAL_CALL SvxFrameShape::setPropertyValue( const OUString& aPropertyName, const css::uno::Any& rValue )
 737 {
 738     SvxShape::setPropertyValue( aPropertyName, rValue );
 739     resetModifiedState();
 740 }
 741
 742 void SAL_CALL SvxFrameShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& rValues )
 743 {
 744     SvxShape::setPropertyValues( aPropertyNames, rValues );
 745     resetModifiedState();
 746 }
 747
 748 bool SvxFrameShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
 749 {
 750     if( (pProperty->nWID >= OWN_ATTR_FRAME_URL) && (pProperty->nWID <= OWN_ATTR_FRAME_MARGIN_HEIGHT) )
 751     {
 752         if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
 753         {
 754             uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
 755             if( xSet.is() )
 756             {
 757                 // allow exceptions to pass through
 758                 xSet->setPropertyValue( rName, rValue );
 759             }
 760         }
 761         return true;
 762     }
 763     else
 764     {
 765         return SvxOle2Shape::setPropertyValueImpl( rName, pProperty, rValue );
 766     }
 767 }
 768
 769 bool SvxFrameShape::getPropertyValueImpl(const OUString& rName, const SfxItemPropertyMapEntry* pProperty,
 770     css::uno::Any& rValue)
 771 {
 772     if( (pProperty->nWID >= OWN_ATTR_FRAME_URL) && (pProperty->nWID <= OWN_ATTR_FRAME_MARGIN_HEIGHT) )
 773     {
 774         if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
 775         {
 776             uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
 777             if( xSet.is() )
 778             {
 779                 rValue = xSet->getPropertyValue( rName );
 780             }
 781         }
 782         return true;
 783     }
 784     else
 785     {
 786         return SvxOle2Shape::getPropertyValueImpl( rName, pProperty, rValue );
 787     }
 788 }
 789
 790 SvxMediaShape::SvxMediaShape(SdrObject* pObj, OUString referer)
 791 :   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_MEDIA), getSvxMapProvider().GetPropertySet(SVXMAP_MEDIA, SdrObject::GetGlobalDrawObjectItemPool()) ),
 792     referer_(std::move(referer))
 793 {
 794     SetShapeType( "com.sun.star.drawing.MediaShape" );
 795 }
 796
 797
 798 SvxMediaShape::~SvxMediaShape() noexcept
 799 {
 800 }
 801
 802
 803 bool SvxMediaShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, const css::uno::Any& rValue )
 804 {
 805     if( ((pProperty->nWID >= OWN_ATTR_MEDIA_URL) && (pProperty->nWID <= OWN_ATTR_MEDIA_ZOOM))
 806         || (pProperty->nWID == OWN_ATTR_MEDIA_STREAM)
 807         || (pProperty->nWID == OWN_ATTR_MEDIA_MIMETYPE)
 808         || (pProperty->nWID == OWN_ATTR_VALUE_GRAPHIC)
 809         || (pProperty->nWID == SDRATTR_GRAFCROP))
 810     {
 811 #if HAVE_FEATURE_AVMEDIA
 812         SdrMediaObj* pMedia = static_cast< SdrMediaObj* >( GetSdrObject() );
 813         ::avmedia::MediaItem aItem;
 814         bool bOk = false;
 815 #endif
 816
 817         switch( pProperty->nWID )
 818         {
 819         case OWN_ATTR_MEDIA_URL:
 820 #if HAVE_FEATURE_AVMEDIA
 821         {
 822             OUString aURL;
 823             if( rValue >>= aURL )
 824             {
 825                 bOk = true;
 826                 aItem.setURL( aURL, "", referer_ );
 827             }
 828         }
 829 #endif
 830         break;
 831
 832         case OWN_ATTR_MEDIA_LOOP:
 833 #if HAVE_FEATURE_AVMEDIA
 834         {
 835             bool bLoop;
 836
 837             if( rValue >>= bLoop )
 838             {
 839                 bOk = true;
 840                 aItem.setLoop( bLoop );
 841             }
 842         }
 843 #endif
 844         break;
 845
 846         case OWN_ATTR_MEDIA_MUTE:
 847 #if HAVE_FEATURE_AVMEDIA
 848         {
 849             bool bMute;
 850
 851             if( rValue >>= bMute )
 852             {
 853                 bOk = true;
 854                 aItem.setMute( bMute );
 855             }
 856         }
 857 #endif
 858         break;
 859
 860         case OWN_ATTR_MEDIA_VOLUMEDB:
 861 #if HAVE_FEATURE_AVMEDIA
 862         {
 863             sal_Int16 nVolumeDB = sal_Int16();
 864
 865             if( rValue >>= nVolumeDB )
 866             {
 867                 bOk = true;
 868                 aItem.setVolumeDB( nVolumeDB );
 869             }
 870         }
 871 #endif
 872         break;
 873
 874         case OWN_ATTR_MEDIA_ZOOM:
 875 #if HAVE_FEATURE_AVMEDIA
 876         {
 877             css::media::ZoomLevel eLevel;
 878
 879             if( rValue >>= eLevel )
 880             {
 881                 bOk = true;
 882                 aItem.setZoom( eLevel );
 883             }
 884         }
 885 #endif
 886         break;
 887
 888         case OWN_ATTR_MEDIA_MIMETYPE:
 889 #if HAVE_FEATURE_AVMEDIA
 890         {
 891             OUString sMimeType;
 892             if( rValue >>= sMimeType )
 893             {
 894                 bOk = true;
 895                 aItem.setMimeType( sMimeType );
 896             }
 897         }
 898 #endif
 899         break;
 900
 901         case OWN_ATTR_VALUE_GRAPHIC:
 902 #if HAVE_FEATURE_AVMEDIA
 903         {
 904             uno::Reference<graphic::XGraphic> xGraphic(rValue, uno::UNO_QUERY);
 905             if (xGraphic.is())
 906             {
 907                 bOk = true;
 908                 aItem.setGraphic(Graphic(xGraphic));
 909             }
 910         }
 911 #endif
 912         break;
 913
 914         case SDRATTR_GRAFCROP:
 915 #if HAVE_FEATURE_AVMEDIA
 916         {
 917             text::GraphicCrop aCrop;
 918             if (rValue >>= aCrop)
 919             {
 920                 bOk = true;
 921                 aItem.setCrop(aCrop);
 922             }
 923         }
 924 #endif
 925         break;
 926
 927         case OWN_ATTR_MEDIA_STREAM:
 928 #if HAVE_FEATURE_AVMEDIA
 929             try
 930             {
 931                 uno::Reference<io::XInputStream> xStream;
 932                 if (rValue >>= xStream)
 933                 {
 934                     pMedia->SetInputStream(xStream);
 935                 }
 936             }
 937             catch (const css::ucb::ContentCreationException&)
 938             {
 939                 css::uno::Any exc = cppu::getCaughtException();
 940                 throw css::lang::WrappedTargetException(
 941                         "ContentCreationException Setting InputStream!",
 942                         getXWeak(),
 943                         exc);
 944             }
 945             catch (const css::ucb::CommandFailedException&)
 946             {
 947                 css::uno::Any anyEx = cppu::getCaughtException();
 948                 throw css::lang::WrappedTargetException(
 949                         "CommandFailedException Setting InputStream!",
 950                         getXWeak(),
 951                         anyEx);
 952             }
 953 #endif
 954         break;
 955
 956         default:
 957             OSL_FAIL("SvxMediaShape::setPropertyValueImpl(), unknown argument!");
 958         }
 959
 960 #if HAVE_FEATURE_AVMEDIA
 961         if( bOk )
 962         {
 963             pMedia->setMediaProperties( aItem );
 964             return true;
 965         }
 966 #endif
 967     }
 968     else
 969     {
 970         return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
 971     }
 972
 973     throw IllegalArgumentException();
 974 }
 975
 976
 977 bool SvxMediaShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertyMapEntry* pProperty, css::uno::Any& rValue )
 978 {
 979     if (   ((pProperty->nWID >= OWN_ATTR_MEDIA_URL) &&
 980             (pProperty->nWID <= OWN_ATTR_MEDIA_ZOOM))
 981         || (pProperty->nWID == OWN_ATTR_MEDIA_STREAM)
 982         || (pProperty->nWID == OWN_ATTR_MEDIA_TEMPFILEURL)
 983         || (pProperty->nWID == OWN_ATTR_MEDIA_MIMETYPE)
 984         || (pProperty->nWID == OWN_ATTR_FALLBACK_GRAPHIC)
 985         || (pProperty->nWID == OWN_ATTR_VALUE_GRAPHIC)
 986         || (pProperty->nWID == SDRATTR_GRAFCROP))
 987     {
 988         SdrMediaObj* pMedia = static_cast< SdrMediaObj* >( GetSdrObject() );
 989 #if HAVE_FEATURE_AVMEDIA
 990         const ::avmedia::MediaItem aItem( pMedia->getMediaProperties() );
 991 #endif
 992
 993         switch( pProperty->nWID )
 994         {
 995             case OWN_ATTR_MEDIA_URL:
 996 #if HAVE_FEATURE_AVMEDIA
 997                 rValue <<= aItem.getURL();
 998 #endif
 999                 break;
1000
1001             case OWN_ATTR_MEDIA_LOOP:
1002 #if HAVE_FEATURE_AVMEDIA
1003                 rValue <<= aItem.isLoop();
1004 #endif
1005                 break;
1006
1007             case OWN_ATTR_MEDIA_MUTE:
1008 #if HAVE_FEATURE_AVMEDIA
1009                 rValue <<= aItem.isMute();
1010 #endif
1011                 break;
1012
1013             case OWN_ATTR_MEDIA_VOLUMEDB:
1014 #if HAVE_FEATURE_AVMEDIA
1015                 rValue <<= aItem.getVolumeDB();
1016 #endif
1017                 break;
1018
1019             case OWN_ATTR_MEDIA_ZOOM:
1020 #if HAVE_FEATURE_AVMEDIA
1021                 rValue <<= aItem.getZoom();
1022 #endif
1023                 break;
1024
1025             case OWN_ATTR_MEDIA_STREAM:
1026                 try
1027                 {
1028                     rValue <<= pMedia->GetInputStream();
1029                 }
1030                 catch (const css::ucb::ContentCreationException&)
1031                 {
1032                     css::uno::Any anyEx = cppu::getCaughtException();
1033                     throw css::lang::WrappedTargetException(
1034                             "ContentCreationException Getting InputStream!",
1035                             getXWeak(), anyEx );
1036                 }
1037                 catch (const css::ucb::CommandFailedException&)
1038                 {
1039                     css::uno::Any anyEx = cppu::getCaughtException();
1040                     throw css::lang::WrappedTargetException(
1041                             "CommandFailedException Getting InputStream!",
1042                             getXWeak(), anyEx );
1043                 }
1044
1045                 break;
1046
1047             case OWN_ATTR_MEDIA_TEMPFILEURL:
1048 #if HAVE_FEATURE_AVMEDIA
1049                 rValue <<= aItem.getTempURL();
1050 #endif
1051                 break;
1052
1053             case OWN_ATTR_MEDIA_MIMETYPE:
1054 #if HAVE_FEATURE_AVMEDIA
1055                 rValue <<= aItem.getMimeType();
1056 #endif
1057                 break;
1058
1059             case OWN_ATTR_VALUE_GRAPHIC:
1060 #if HAVE_FEATURE_AVMEDIA
1061             {
1062                 Graphic aGraphic = aItem.getGraphic();
1063                 if (!aGraphic.IsNone())
1064                 {
1065                     rValue <<= aGraphic.GetXGraphic();
1066                 }
1067             }
1068 #endif
1069             break;
1070
1071             case SDRATTR_GRAFCROP:
1072 #if HAVE_FEATURE_AVMEDIA
1073             {
1074                 text::GraphicCrop aCrop = aItem.getCrop();
1075                 rValue <<= aCrop;
1076             }
1077 #endif
1078             break;
1079
1080             case OWN_ATTR_FALLBACK_GRAPHIC:
1081                 rValue <<= pMedia->getSnapshot();
1082                 break;
1083
1084             default:
1085                 OSL_FAIL("SvxMediaShape::getPropertyValueImpl(), unknown property!");
1086         }
1087         return true;
1088     }
1089     else
1090     {
1091         return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
1092     }
1093 }
1094
1095 bool SvxMediaShape::getPropertyStateImpl(const SfxItemPropertyMapEntry* pProperty,
1096                                          css::beans::PropertyState& rState)
1097 {
1098 #if HAVE_FEATURE_AVMEDIA
1099     if (pProperty->nWID == SDRATTR_GRAFCROP)
1100     {
1101         auto pMedia = static_cast<SdrMediaObj*>(GetSdrObject());
1102         const avmedia::MediaItem& rItem = pMedia->getMediaProperties();
1103         const text::GraphicCrop& rCrop = rItem.getCrop();
1104         if (rCrop.Bottom > 0 || rCrop.Left > 0 || rCrop.Right > 0 || rCrop.Top > 0)
1105         {
1106             // The media has a crop, expose it to UNO-based export filters.
1107             rState = beans::PropertyState_DIRECT_VALUE;
1108         }
1109         else
1110         {
1111             rState = beans::PropertyState_AMBIGUOUS_VALUE;
1112         }
1113         return true;
1114     }
1115 #endif
1116
1117     return SvxShape::getPropertyStateImpl(pProperty, rState);
1118 }
1119
1120 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */