svx/source/unodraw/unopage.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 <config_features.h>
  21
  22 #include <com/sun/star/document/EventObject.hpp>
  23 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  24 #include <com/sun/star/lang/DisposedException.hpp>
  25 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  26 #include <o3tl/safeint.hxx>
  27 #include <osl/mutex.hxx>
  28 #include <comphelper/classids.hxx>
  29 #include <comphelper/embeddedobjectcontainer.hxx>
  30 #include <comphelper/sequence.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32
  33 #include <svx/fmpage.hxx>
  34 #include <svx/svdpool.hxx>
  35 #include <svx/svdobj.hxx>
  36 #include <svx/svdoole2.hxx>
  37 #include <svx/svdpage.hxx>
  38 #include <svx/svdmodel.hxx>
  39 #include <svx/strings.hrc>
  40 #include <svx/svdview.hxx>
  41 #include <svx/svdpagv.hxx>
  42 #include <svx/svdundo.hxx>
  43 #include <svx/unopage.hxx>
  44 #include "shapeimpl.hxx"
  45 #include <svx/unodraw/SvxTableShape.hxx>
  46 #include <svx/dialmgr.hxx>
  47 #include <svx/svdobjkind.hxx>
  48 #include <svx/unoprov.hxx>
  49 #include <svx/unoapi.hxx>
  50 #include <extrud3d.hxx>
  51 #include <svx/lathe3d.hxx>
  52 #include <svx/scene3d.hxx>
  53 #include <vcl/svapp.hxx>
  54 #include <comphelper/diagnose_ex.hxx>
  55 #include <tools/globname.hxx>
  56 #include <sal/log.hxx>
  57 #include <fmobj.hxx>
  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::drawing;
  65
  66 UNO3_GETIMPLEMENTATION_IMPL( SvxDrawPage );
  67
  68 SvxDrawPage::SvxDrawPage(SdrPage* pInPage) // TTTT should be reference
  69 :    mpPage(pInPage)
  70     ,mpModel(&pInPage->getSdrModelFromSdrPage())  // register at broadcaster
  71     ,mpView(new SdrView(pInPage->getSdrModelFromSdrPage())) // create (hidden) view
  72 {
  73     mpView->SetDesignMode();
  74 }
  75
  76 SvxDrawPage::~SvxDrawPage() noexcept
  77 {
  78     if( !m_bDisposed )
  79     {
  80         assert(!"SvxDrawPage must be disposed!");
  81         acquire();
  82         dispose();
  83     }
  84 }
  85
  86 // XComponent
  87 void SvxDrawPage::disposing() noexcept
  88 {
  89     if( mpModel )
  90     {
  91         mpModel = nullptr;
  92     }
  93
  94     mpView.reset();
  95     mpPage = nullptr;
  96 }
  97
  98 // XComponent
  99 void SvxDrawPage::dispose()
 100 {
 101     SolarMutexGuard aSolarGuard;
 102
 103     // An frequently programming error is to release the last
 104     // reference to this object in the disposing message.
 105     // Make it robust, hold a self Reference.
 106     uno::Reference< lang::XComponent > xSelf( this );
 107
 108     // Guard dispose against multiple threading
 109     // Remark: It is an error to call dispose more than once
 110     {
 111         std::unique_lock aGuard( m_aMutex );
 112         if( m_bDisposed )
 113             return;
 114         m_bDisposed = true;
 115     }
 116
 117     // Create an event with this as sender
 118     css::document::EventObject aEvt;
 119     aEvt.Source.set(uno::Reference<uno::XInterface>::query( static_cast<lang::XComponent *>(this) ));
 120     // inform all listeners to release this object
 121     // The listener container are automatically cleared
 122     {
 123         std::unique_lock aGuard( m_aMutex );
 124         maEventListeners.disposeAndClear( aGuard, aEvt );
 125     }
 126     // notify subclasses to do their dispose
 127     disposing();
 128 }
 129
 130 void SAL_CALL SvxDrawPage::addEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener )
 131 {
 132     std::unique_lock aGuard( m_aMutex );
 133
 134     if( mpModel == nullptr )
 135         throw lang::DisposedException();
 136
 137     maEventListeners.addInterface( aGuard, aListener );
 138 }
 139
 140 void SAL_CALL SvxDrawPage::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener )
 141 {
 142     std::unique_lock aGuard( m_aMutex );
 143
 144     if( mpModel == nullptr )
 145         throw lang::DisposedException();
 146
 147     maEventListeners.removeInterface( aGuard, aListener );
 148 }
 149
 150 void SAL_CALL SvxDrawPage::add( const uno::Reference< drawing::XShape >& xShape )
 151 {
 152     SolarMutexGuard aGuard;
 153
 154     if ( ( mpModel == nullptr ) || ( mpPage == nullptr ) )
 155         throw lang::DisposedException();
 156
 157     SvxShape* pShape = comphelper::getFromUnoTunnel<SvxShape>( xShape );
 158
 159     if( nullptr == pShape )
 160     {
 161         assert(false && "adding a non-SvxShape to a page?");
 162         return;
 163     }
 164
 165     rtl::Reference<SdrObject> pObj = pShape->GetSdrObject();
 166     bool bNeededToClone(false);
 167
 168     if(pObj && &pObj->getSdrModelFromSdrObject() != &mpPage->getSdrModelFromSdrPage())
 169     {
 170         // TTTT UNO API tries to add an existing SvxShape to this SvxDrawPage,
 171         // but these use different SdrModels. It was possible before to completely
 172         // 'change' a SdrObject to another SdrModel (including dangerous MigrateItemPool
 173         // stuff), but is no longer. We need to Clone the SdrObject to the target model
 174         // and ::Create a new SvxShape (set SdrObject there, take over values, ...)
 175         rtl::Reference<SdrObject> pClonedSdrShape(pObj->CloneSdrObject(mpPage->getSdrModelFromSdrPage()));
 176         pObj->setUnoShape(nullptr);
 177         pClonedSdrShape->setUnoShape(pShape);
 178         // pShape->InvalidateSdrObject();
 179         // pShape->Create(pClonedSdrShape, this);
 180         pObj = std::move(pClonedSdrShape);
 181         bNeededToClone = true;
 182     }
 183
 184     if(!pObj)
 185     {
 186         pObj = CreateSdrObject( xShape );
 187         ENSURE_OR_RETURN_VOID( pObj != nullptr, "SvxDrawPage::add: no SdrObject was created!" );
 188     }
 189     else if ( !pObj->IsInserted() )
 190     {
 191         mpPage->InsertObject( pObj.get() );
 192
 193         if(bNeededToClone)
 194         {
 195             // TTTT Unfortunately in SdrObject::SetPage (see there) the
 196             // xShape/UnoShape at the newly cloned SDrObject is *removed* again,
 197             // so re-set it here, the caller *may need it* (e.g. Writer)
 198             uno::Reference< drawing::XShape > xShapeCheck(pObj->getWeakUnoShape());
 199
 200             if( !xShapeCheck.is() )
 201             {
 202                 pObj->setUnoShape(pShape);
 203             }
 204         }
 205     }
 206
 207     pShape->Create( pObj.get(), this );
 208     OSL_ENSURE( pShape->GetSdrObject() == pObj.get(), "SvxDrawPage::add: shape does not know about its newly created SdrObject!" );
 209
 210     if ( !pObj->IsInserted() )
 211     {
 212         mpPage->InsertObject( pObj.get() );
 213     }
 214
 215     mpModel->SetChanged();
 216 }
 217
 218 void SAL_CALL SvxDrawPage::addTop( const uno::Reference< drawing::XShape >& xShape )
 219 {
 220     add(xShape);
 221 }
 222
 223 void SAL_CALL SvxDrawPage::addBottom( const uno::Reference< drawing::XShape >& xShape )
 224 {
 225     SolarMutexGuard aGuard;
 226
 227     if ( ( mpModel == nullptr ) || ( mpPage == nullptr ) )
 228         throw lang::DisposedException();
 229
 230     SvxShape* pShape = comphelper::getFromUnoTunnel<SvxShape>( xShape );
 231
 232     if( nullptr == pShape )
 233     {
 234         assert(false && "adding a non-SvxShape to a page?");
 235         return;
 236     }
 237
 238     rtl::Reference<SdrObject> pObj = pShape->GetSdrObject();
 239
 240     if(!pObj)
 241     {
 242         pObj = CreateSdrObject( xShape, true );
 243         ENSURE_OR_RETURN_VOID( pObj != nullptr, "SvxDrawPage::add: no SdrObject was created!" );
 244     }
 245     else if ( !pObj->IsInserted() )
 246     {
 247         mpPage->InsertObject( pObj.get(), 0 );
 248     }
 249
 250     pShape->Create( pObj.get(), this );
 251     OSL_ENSURE( pShape->GetSdrObject() == pObj.get(), "SvxDrawPage::add: shape does not know about its newly created SdrObject!" );
 252
 253     if ( !pObj->IsInserted() )
 254     {
 255         mpPage->InsertObject( pObj.get(), 0 );
 256     }
 257
 258     mpModel->SetChanged();
 259 }
 260
 261 void SAL_CALL SvxDrawPage::remove( const Reference< drawing::XShape >& xShape )
 262 {
 263     SolarMutexGuard aGuard;
 264
 265     if( (mpModel == nullptr) || (mpPage == nullptr) )
 266         throw lang::DisposedException();
 267
 268     SdrObject* pObj = SdrObject::getSdrObjectFromXShape( xShape );
 269     if (!pObj)
 270         return;
 271
 272     // remove SdrObject from page
 273     const size_t nCount = mpPage->GetObjCount();
 274     for( size_t nNum = 0; nNum < nCount; ++nNum )
 275     {
 276         if(mpPage->GetObj(nNum) == pObj)
 277         {
 278             const bool bUndoEnabled = mpModel->IsUndoEnabled();
 279
 280             if (bUndoEnabled)
 281             {
 282                 mpModel->BegUndo(SvxResId(STR_EditDelete),
 283                     pObj->TakeObjNameSingul(), SdrRepeatFunc::Delete);
 284
 285                 mpModel->AddUndo(mpModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj));
 286             }
 287
 288             OSL_VERIFY( mpPage->RemoveObject( nNum ) == pObj );
 289
 290             if (bUndoEnabled)
 291                 mpModel->EndUndo();
 292
 293             break;
 294         }
 295     }
 296
 297     mpModel->SetChanged();
 298 }
 299
 300 void SvxDrawPage::sort( const css::uno::Sequence< sal_Int32 >& sortOrder )
 301 {
 302     SolarMutexGuard aGuard;
 303
 304     if ((mpModel == nullptr) || (mpPage == nullptr))
 305         throw lang::DisposedException();
 306
 307     auto newOrder = comphelper::sequenceToContainer<std::vector<sal_Int32>>(sortOrder);
 308     mpPage->sort(newOrder);
 309 }
 310
 311 // css::container::XIndexAccess
 312 sal_Int32 SAL_CALL SvxDrawPage::getCount()
 313 {
 314     SolarMutexGuard aGuard;
 315
 316     if( (mpModel == nullptr) || (mpPage == nullptr) )
 317         throw lang::DisposedException();
 318
 319     return static_cast<sal_Int32>( mpPage->GetObjCount() );
 320 }
 321
 322 uno::Any SAL_CALL SvxDrawPage::getByIndex( sal_Int32 Index )
 323 {
 324     SolarMutexGuard aGuard;
 325
 326     if( (mpModel == nullptr) || (mpPage == nullptr) )
 327         throw lang::DisposedException(u"Model or Page was already disposed!"_ustr);
 328
 329     if ( Index < 0 || o3tl::make_unsigned(Index) >= mpPage->GetObjCount() )
 330         throw lang::IndexOutOfBoundsException("Index (" + OUString::number(Index)
 331                                               + ") needs to be a positive integer smaller than the shape count ("
 332                                               + OUString::number(mpPage->GetObjCount()) + ")!");
 333
 334     SdrObject* pObj = mpPage->GetObj( Index );
 335     if( pObj == nullptr )
 336         throw uno::RuntimeException("Runtime exception thrown while getting a ref to the SdrObject at index: "
 337                                     + OUString::number(Index));
 338
 339
 340     return Any(Reference< drawing::XShape >( pObj->getUnoShape(), uno::UNO_QUERY ));
 341 }
 342
 343 // css::container::XElementAccess
 344 uno::Type SAL_CALL SvxDrawPage::getElementType()
 345 {
 346     return cppu::UnoType<drawing::XShape>::get();
 347 }
 348
 349 sal_Bool SAL_CALL SvxDrawPage::hasElements()
 350 {
 351     SolarMutexGuard aGuard;
 352
 353     if( (mpModel == nullptr) || (mpPage == nullptr) )
 354         throw lang::DisposedException();
 355
 356     return mpPage->GetObjCount()>0;
 357 }
 358
 359 namespace
 360 {
 361     void lcl_markSdrObjectOfShape( const Reference< drawing::XShape >& _rxShape, SdrView& _rView, SdrPageView& _rPageView )
 362     {
 363         SdrObject* pObj = SdrObject::getSdrObjectFromXShape( _rxShape );
 364         if ( !pObj )
 365             return;
 366
 367         _rView.MarkObj( pObj, &_rPageView );
 368     }
 369 }
 370
 371 // ATTENTION: SelectObjectsInView selects the css::drawing::Shapes
 372 // only in the given SdrPageView. It hasn't to be the visible SdrPageView.
 373 void SvxDrawPage::SelectObjectsInView( const Reference< drawing::XShapes > & aShapes, SdrPageView* pPageView ) noexcept
 374 {
 375     SAL_WARN_IF(!pPageView, "svx", "SdrPageView is NULL!");
 376     SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
 377
 378     if(pPageView==nullptr || mpView==nullptr)
 379         return;
 380
 381     mpView->UnmarkAllObj( pPageView );
 382
 383     tools::Long nCount = aShapes->getCount();
 384     for( tools::Long i = 0; i < nCount; i++ )
 385     {
 386         uno::Any aAny( aShapes->getByIndex(i) );
 387         Reference< drawing::XShape > xShape;
 388         if( aAny >>= xShape )
 389             lcl_markSdrObjectOfShape( xShape, *mpView, *pPageView );
 390     }
 391 }
 392
 393 // ATTENTION: SelectObjectInView selects the shape only in the given SdrPageView.
 394 // It hasn't to be the visible SdrPageView.
 395 void SvxDrawPage::SelectObjectInView( const Reference< drawing::XShape > & xShape, SdrPageView* pPageView ) noexcept
 396 {
 397     SAL_WARN_IF(!pPageView, "svx", "SdrPageView is NULL!");
 398     SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
 399
 400     if(pPageView!=nullptr && mpView != nullptr)
 401     {
 402         mpView->UnmarkAllObj( pPageView );
 403         lcl_markSdrObjectOfShape( xShape, *mpView, *pPageView );
 404     }
 405 }
 406
 407 Reference< drawing::XShapeGroup > SAL_CALL SvxDrawPage::group( const Reference< drawing::XShapes >& xShapes )
 408 {
 409     SolarMutexGuard aGuard;
 410
 411     if( (mpModel == nullptr) || (mpPage == nullptr) )
 412         throw lang::DisposedException();
 413
 414     SAL_WARN_IF(!mpPage , "svx", "SdrPage is NULL!");
 415     SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
 416
 417     Reference< css::drawing::XShapeGroup >  xShapeGroup;
 418     if(mpPage==nullptr||mpView==nullptr||!xShapes.is())
 419         return xShapeGroup;
 420
 421     SdrPageView* pPageView = mpView->ShowSdrPage( mpPage );
 422
 423     SelectObjectsInView( xShapes, pPageView );
 424
 425     mpView->GroupMarked();
 426
 427     mpView->AdjustMarkHdl();
 428     const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
 429     if( rMarkList.GetMarkCount() == 1 )
 430     {
 431         SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 432         if( pObj )
 433              xShapeGroup.set( pObj->getUnoShape(), UNO_QUERY );
 434     }
 435
 436     mpView->HideSdrPage();
 437
 438     if( mpModel )
 439         mpModel->SetChanged();
 440
 441     return xShapeGroup;
 442 }
 443
 444 void SAL_CALL SvxDrawPage::ungroup( const Reference< drawing::XShapeGroup >& aGroup )
 445 {
 446     SolarMutexGuard aGuard;
 447
 448     if( (mpModel == nullptr) || (mpPage == nullptr) )
 449         throw lang::DisposedException();
 450
 451     SAL_WARN_IF(!mpPage, "svx", "SdrPage is NULL!");
 452     SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
 453
 454     if(mpPage==nullptr||mpView==nullptr||!aGroup.is())
 455         return;
 456
 457     SdrPageView* pPageView = mpView->ShowSdrPage( mpPage );
 458
 459     SelectObjectInView( aGroup, pPageView );
 460     mpView->UnGroupMarked();
 461
 462     mpView->HideSdrPage();
 463
 464     if( mpModel )
 465         mpModel->SetChanged();
 466 }
 467
 468 rtl::Reference<SdrObject> SvxDrawPage::CreateSdrObject_(const Reference< drawing::XShape > & xShape)
 469 {
 470     OUString aShapeType( xShape->getShapeType() );
 471
 472     if  (   aShapeType == "com.sun.star.drawing.ShapeControl"   // compatibility
 473         ||  aShapeType == "com.sun.star.drawing.ControlShape"
 474         )
 475     {
 476         return new FmFormObj(GetSdrPage()->getSdrModelFromSdrPage());
 477     }
 478
 479     SdrObjKind nType = SdrObjKind::NONE;
 480     SdrInventor nInventor;
 481
 482     GetTypeAndInventor( nType, nInventor, xShape->getShapeType() );
 483     if (nType == SdrObjKind::NONE)
 484         return nullptr;
 485
 486     awt::Size aSize = xShape->getSize();
 487     aSize.Width += 1;
 488     aSize.Height += 1;
 489     awt::Point aPos = xShape->getPosition();
 490     tools::Rectangle aRect( Point( aPos.X, aPos.Y ), Size( aSize.Width, aSize.Height ) );
 491
 492     rtl::Reference<SdrObject> pNewObj = SdrObjFactory::MakeNewObject(
 493         *mpModel,
 494         nInventor,
 495         nType,
 496         &aRect);
 497
 498     if (!pNewObj)
 499         return nullptr;
 500
 501     if( nType == SdrObjKind::E3D_Scene )
 502     {
 503         auto pScene = static_cast<E3dScene* >(pNewObj.get());
 504         // initialise scene
 505
 506         double fW = static_cast<double>(aSize.Width);
 507         double fH = static_cast<double>(aSize.Height);
 508
 509         Camera3D aCam(pScene->GetCamera());
 510         aCam.SetAutoAdjustProjection(false);
 511         aCam.SetViewWindow(- fW / 2, - fH / 2, fW, fH);
 512         basegfx::B3DPoint aLookAt;
 513         basegfx::B3DPoint aCamPos(0.0, 0.0, 10000.0);
 514         aCam.SetPosAndLookAt(aCamPos, aLookAt);
 515         aCam.SetFocalLength(100.0);
 516         pScene->SetCamera(aCam);
 517
 518         pScene->SetBoundAndSnapRectsDirty();
 519     }
 520     else if(nType == SdrObjKind::E3D_Extrusion)
 521     {
 522         auto pObj = static_cast<E3dExtrudeObj* >(pNewObj.get());
 523         basegfx::B2DPolygon aNewPolygon;
 524         aNewPolygon.append(basegfx::B2DPoint(0.0, 0.0));
 525         aNewPolygon.append(basegfx::B2DPoint(0.0, 1.0));
 526         aNewPolygon.append(basegfx::B2DPoint(1.0, 0.0));
 527         aNewPolygon.setClosed(true);
 528         pObj->SetExtrudePolygon(basegfx::B2DPolyPolygon(aNewPolygon));
 529
 530         // #107245# pObj->SetExtrudeCharacterMode(sal_True);
 531         pObj->SetMergedItem(Svx3DCharacterModeItem(true));
 532     }
 533     else if(nType == SdrObjKind::E3D_Lathe)
 534     {
 535         auto pLatheObj = static_cast<E3dLatheObj* >(pNewObj.get());
 536         basegfx::B2DPolygon aNewPolygon;
 537         aNewPolygon.append(basegfx::B2DPoint(0.0, 0.0));
 538         aNewPolygon.append(basegfx::B2DPoint(0.0, 1.0));
 539         aNewPolygon.append(basegfx::B2DPoint(1.0, 0.0));
 540         aNewPolygon.setClosed(true);
 541         pLatheObj->SetPolyPoly2D(basegfx::B2DPolyPolygon(aNewPolygon));
 542
 543         // #107245# pObj->SetLatheCharacterMode(sal_True);
 544         pLatheObj->SetMergedItem(Svx3DCharacterModeItem(true));
 545     }
 546
 547     return pNewObj;
 548 }
 549
 550 void SvxDrawPage::GetTypeAndInventor( SdrObjKind& rType, SdrInventor& rInventor, const OUString& aName ) noexcept
 551 {
 552     std::optional<SdrObjKind> nTempType = UHashMap::getId( aName );
 553
 554     if( !nTempType )
 555     {
 556         if( aName == "com.sun.star.drawing.TableShape" ||
 557             aName == "com.sun.star.presentation.TableShape" )
 558         {
 559             rInventor = SdrInventor::Default;
 560             rType = SdrObjKind::Table;
 561         }
 562 #if HAVE_FEATURE_AVMEDIA
 563         else if ( aName == "com.sun.star.presentation.MediaShape" )
 564         {
 565             rInventor = SdrInventor::Default;
 566             rType = SdrObjKind::Media;
 567         }
 568 #endif
 569     }
 570     else if( IsInventorE3D(*nTempType) )
 571     {
 572         rInventor = SdrInventor::E3d;
 573         rType = *nTempType;
 574     }
 575     else
 576     {
 577         rInventor = SdrInventor::Default;
 578         rType = *nTempType;
 579
 580         switch( rType )
 581         {
 582             case SdrObjKind::OLEPluginFrame:
 583             case SdrObjKind::OLE2Plugin:
 584             case SdrObjKind::OLE2Applet:
 585                 rType = SdrObjKind::OLE2;
 586                 break;
 587             default:
 588                 break;
 589         }
 590     }
 591 }
 592
 593 rtl::Reference<SvxShape> SvxDrawPage::CreateShapeByTypeAndInventor( SdrObjKind nType, SdrInventor nInventor, SdrObject *pObj, SvxDrawPage *mpPage, OUString const & referer )
 594 {
 595     rtl::Reference<SvxShape> pRet;
 596
 597     switch( nInventor )
 598     {
 599         case SdrInventor::FmForm:
 600         {
 601             return new SvxShapeControl( pObj );
 602         }
 603         case SdrInventor::E3d:
 604         {
 605             switch( nType )
 606             {
 607                 case SdrObjKind::E3D_Scene :
 608                     pRet = new Svx3DSceneObject( pObj, mpPage );
 609                     break;
 610                 case SdrObjKind::E3D_Cube :
 611                     pRet = new Svx3DCubeObject( pObj );
 612                     break;
 613                 case SdrObjKind::E3D_Sphere :
 614                     pRet = new Svx3DSphereObject( pObj );
 615                     break;
 616                 case SdrObjKind::E3D_Lathe :
 617                     pRet = new Svx3DLatheObject( pObj );
 618                     break;
 619                 case SdrObjKind::E3D_Extrusion :
 620                     pRet = new Svx3DExtrudeObject( pObj );
 621                     break;
 622                 case SdrObjKind::E3D_Polygon :
 623                     pRet = new Svx3DPolygonObject( pObj );
 624                     break;
 625                 default: // unknown 3D-object on page
 626                     assert(false && "the IsInventor3D function must be wrong");
 627                     pRet = new SvxShape( pObj );
 628                     break;
 629             }
 630             break;
 631         }
 632         case SdrInventor::Default:
 633         {
 634             switch( nType )
 635             {
 636                 case SdrObjKind::Group:
 637                     pRet = new SvxShapeGroup( pObj, mpPage );
 638                     break;
 639                 case SdrObjKind::Line:
 640                     pRet = new SvxShapePolyPolygon( pObj );
 641                     break;
 642                 case SdrObjKind::Rectangle:
 643                 case SdrObjKind::Annotation:
 644                     pRet = new SvxShapeRect( pObj );
 645                     break;
 646                 case SdrObjKind::CircleOrEllipse:
 647                 case SdrObjKind::CircleSection:
 648                 case SdrObjKind::CircleArc:
 649                 case SdrObjKind::CircleCut:
 650                     pRet = new SvxShapeCircle( pObj );
 651                     break;
 652                 case SdrObjKind::Polygon:
 653                     pRet = new SvxShapePolyPolygon( pObj );
 654                     break;
 655                 case SdrObjKind::PolyLine:
 656                     pRet = new SvxShapePolyPolygon( pObj );
 657                     break;
 658                 case SdrObjKind::PathLine:
 659                     pRet = new SvxShapePolyPolygon( pObj );
 660                     break;
 661                 case SdrObjKind::PathFill:
 662                     pRet = new SvxShapePolyPolygon( pObj );
 663                     break;
 664                 case SdrObjKind::FreehandLine:
 665                     pRet = new SvxShapePolyPolygon( pObj );
 666                     break;
 667                 case SdrObjKind::FreehandFill:
 668                     pRet = new SvxShapePolyPolygon( pObj );
 669                     break;
 670                 case SdrObjKind::Caption:
 671                     pRet = new SvxShapeCaption( pObj );
 672                     break;
 673                 case SdrObjKind::TitleText:
 674                 case SdrObjKind::OutlineText:
 675                 case SdrObjKind::Text:
 676                     pRet = new SvxShapeText( pObj );
 677                     break;
 678                 case SdrObjKind::Graphic:
 679                     pRet = new SvxGraphicObject( pObj );
 680                     break;
 681                 case SdrObjKind::OLEPluginFrame:
 682                     pRet = new SvxFrameShape( pObj, referer );
 683                     break;
 684                 case SdrObjKind::OLE2Applet:
 685                     pRet = new SvxAppletShape( pObj, referer );
 686                     break;
 687                 case SdrObjKind::OLE2Plugin:
 688                     pRet = new SvxPluginShape( pObj, referer );
 689                     break;
 690                  case SdrObjKind::OLE2:
 691                      {
 692                         if( pObj && !pObj->IsEmptyPresObj() && mpPage )
 693                         {
 694                             SdrPage* pSdrPage = mpPage->GetSdrPage();
 695                             if( pSdrPage )
 696                             {
 697                                 SdrModel& rSdrModel(pSdrPage->getSdrModelFromSdrPage());
 698                                 ::comphelper::IEmbeddedHelper *pPersist = rSdrModel.GetPersist();
 699
 700                                 if( pPersist )
 701                                 {
 702                                     uno::Reference < embed::XEmbeddedObject > xObject = pPersist->getEmbeddedObjectContainer().
 703                                             GetEmbeddedObject( static_cast< SdrOle2Obj* >( pObj )->GetPersistName() );
 704
 705                                     // TODO CL->KA: Why is this not working anymore?
 706                                     if( xObject.is() )
 707                                     {
 708                                         SvGlobalName aClassId( xObject->getClassID() );
 709
 710                                         const SvGlobalName aAppletClassId( SO3_APPLET_CLASSID );
 711                                         const SvGlobalName aPluginClassId( SO3_PLUGIN_CLASSID );
 712                                         const SvGlobalName aIFrameClassId( SO3_IFRAME_CLASSID );
 713
 714                                         if( aPluginClassId == aClassId )
 715                                         {
 716                                             pRet = new SvxPluginShape( pObj, referer );
 717                                             nType = SdrObjKind::OLE2Plugin;
 718                                         }
 719                                         else if( aAppletClassId == aClassId )
 720                                         {
 721                                             pRet = new SvxAppletShape( pObj, referer );
 722                                             nType = SdrObjKind::OLE2Applet;
 723                                         }
 724                                         else if( aIFrameClassId == aClassId )
 725                                         {
 726                                             pRet = new SvxFrameShape( pObj, referer );
 727                                             nType = SdrObjKind::OLEPluginFrame;
 728                                         }
 729                                     }
 730                                 }
 731                             }
 732                         }
 733                         if( pRet == nullptr )
 734                         {
 735                             SvxUnoPropertyMapProvider& rSvxMapProvider = getSvxMapProvider();
 736                             pRet = new SvxOle2Shape( pObj, referer, rSvxMapProvider.GetMap(SVXMAP_OLE2),  rSvxMapProvider.GetPropertySet(SVXMAP_OLE2, SdrObject::GetGlobalDrawObjectItemPool()) );
 737                         }
 738                      }
 739                     break;
 740                 case SdrObjKind::Edge:
 741                     pRet = new SvxShapeConnector( pObj );
 742                     break;
 743                 case SdrObjKind::PathPoly:
 744                     pRet = new SvxShapePolyPolygon( pObj );
 745                     break;
 746                 case SdrObjKind::PathPolyLine:
 747                     pRet = new SvxShapePolyPolygon( pObj );
 748                     break;
 749                 case SdrObjKind::Page:
 750                 {
 751                     SvxUnoPropertyMapProvider& rSvxMapProvider = getSvxMapProvider();
 752                     pRet = new SvxShape( pObj, rSvxMapProvider.GetMap(SVXMAP_PAGE),  rSvxMapProvider.GetPropertySet(SVXMAP_PAGE, SdrObject::GetGlobalDrawObjectItemPool()) );
 753                 }
 754                     break;
 755                 case SdrObjKind::Measure:
 756                     pRet = new SvxShapeDimensioning( pObj );
 757                     break;
 758                 case SdrObjKind::UNO:
 759                     pRet = new SvxShapeControl( pObj );
 760                     break;
 761                 case SdrObjKind::CustomShape:
 762                     pRet = new SvxCustomShape( pObj );
 763                     break;
 764                 case SdrObjKind::Media:
 765                     pRet = new SvxMediaShape( pObj, referer );
 766                     break;
 767                 case SdrObjKind::Table:
 768                     pRet = new SvxTableShape( pObj );
 769                     break;
 770                 default: // unknown 2D-object on page
 771                     assert(false && "Not implemented Starone-Shape created");
 772                     pRet = new SvxShapeText( pObj );
 773                     break;
 774             }
 775             break;
 776         }
 777         default: // unknown inventor
 778         {
 779             assert(false && "Unknown Inventor in SvxDrawPage::CreateShape()");
 780             break;
 781         }
 782     }
 783
 784     if(pRet)
 785     {
 786         SdrObjKind nObjId = nType;
 787
 788         switch(nObjId)
 789         {
 790         case SdrObjKind::CircleCut:          // segment of circle
 791         case SdrObjKind::CircleArc:          // arc of circle
 792         case SdrObjKind::CircleSection:          // sector
 793             nObjId = SdrObjKind::CircleOrEllipse;
 794             break;
 795
 796         case SdrObjKind::TitleText:
 797         case SdrObjKind::OutlineText:
 798             nObjId = SdrObjKind::Text;
 799             break;
 800         default: ;
 801         }
 802
 803         pRet->setShapeKind(nObjId);
 804     }
 805
 806     return pRet;
 807 }
 808
 809 Reference< drawing::XShape >  SvxDrawPage::CreateShape( SdrObject *pObj ) const
 810 {
 811     Reference< drawing::XShape > xShape( CreateShapeByTypeAndInventor(pObj->GetObjIdentifier(),
 812                                               pObj->GetObjInventor(),
 813                                               pObj,
 814                                               const_cast<SvxDrawPage*>(this)));
 815     return xShape;
 816 }
 817
 818 rtl::Reference<SdrObject> SvxDrawPage::CreateSdrObject( const Reference< drawing::XShape > & xShape, bool bBeginning ) noexcept
 819 {
 820     rtl::Reference<SdrObject> pObj = CreateSdrObject_( xShape );
 821     if( pObj)
 822     {
 823         if ( !pObj->IsInserted() && !pObj->IsDoNotInsertIntoPageAutomatically() )
 824         {
 825             if(bBeginning)
 826                 mpPage->InsertObject( pObj.get(), 0 );
 827             else
 828                 mpPage->InsertObject( pObj.get() );
 829         }
 830     }
 831
 832     return pObj;
 833 }
 834
 835 // css::lang::XServiceInfo
 836 OUString SAL_CALL SvxDrawPage::getImplementationName()
 837 {
 838     return u"SvxDrawPage"_ustr;
 839 }
 840
 841 sal_Bool SAL_CALL SvxDrawPage::supportsService( const OUString& ServiceName )
 842 {
 843     return cppu::supportsService( this, ServiceName );
 844 }
 845
 846 uno::Sequence< OUString > SAL_CALL SvxDrawPage::getSupportedServiceNames()
 847 {
 848     uno::Sequence<OUString> aSeq { u"com.sun.star.drawing.ShapeCollection"_ustr };
 849     return aSeq;
 850 }
 851
 852 rtl::Reference<SvxShape> CreateSvxShapeByTypeAndInventor(SdrObjKind nType, SdrInventor nInventor, OUString const & referer)
 853 {
 854     return SvxDrawPage::CreateShapeByTypeAndInventor( nType, nInventor, nullptr, nullptr, referer );
 855 }
 856
 857 /** returns a StarOffice API wrapper for the given SdrPage */
 858 uno::Reference< drawing::XDrawPage > GetXDrawPageForSdrPage( SdrPage* pPage ) noexcept
 859 {
 860     if(pPage)
 861     {
 862         uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
 863
 864         return xDrawPage;
 865     }
 866
 867     return uno::Reference< drawing::XDrawPage >();
 868 }
 869
 870 /** returns the SdrObject from the given StarOffice API wrapper */
 871 SdrPage* GetSdrPageFromXDrawPage( const uno::Reference< drawing::XDrawPage >& xDrawPage ) noexcept
 872 {
 873     if(xDrawPage.is())
 874     {
 875         SvxDrawPage* pDrawPage = comphelper::getFromUnoTunnel<SvxDrawPage>( xDrawPage );
 876
 877         if(pDrawPage)
 878         {
 879             return pDrawPage->GetSdrPage();
 880         }
 881         assert(false && "non-SvxDrawPage?");
 882     }
 883
 884     return nullptr;
 885 }
 886
 887 // helper that returns true if the given XShape is member of the given
 888 // XDrawPage or it's MasterPage (aka associated)
 889 bool IsXShapeAssociatedWithXDrawPage(
 890     const css::uno::Reference<css::drawing::XShape>& rxShape,
 891     const css::uno::Reference< css::drawing::XDrawPage >& rxDrawPage) noexcept
 892 {
 893     if (!rxShape)
 894         return false;
 895
 896     if (!rxDrawPage)
 897         return false;
 898
 899     const SdrObject* pSdrObject(SdrObject::getSdrObjectFromXShape(rxShape));
 900     if (nullptr == pSdrObject)
 901         return false;
 902
 903     SdrPage* pSdrPage(GetSdrPageFromXDrawPage(rxDrawPage));
 904     if (nullptr == pSdrPage)
 905         return false;
 906
 907     const SdrPage* pPageFromObj(pSdrObject->getSdrPageFromSdrObject());
 908     if (nullptr == pPageFromObj)
 909         return false;
 910
 911     if (pSdrPage == pPageFromObj)
 912         // given XShape is member of given XDrawPage
 913         return true;
 914
 915     if (pSdrPage->TRG_HasMasterPage())
 916         if (&pSdrPage->TRG_GetMasterPage() == pPageFromObj)
 917             // given XShape is member of MasterPage of given XDrawPage
 918             return true;
 919
 920     return false;
 921 }
 922
 923 // XFormsSupplier
 924 css::uno::Reference< css::container::XNameContainer > SAL_CALL SvxDrawPage::getForms()
 925 {
 926     SolarMutexGuard g;
 927
 928     css::uno::Reference< css::container::XNameContainer >  xForms;
 929
 930     FmFormPage *pFmPage = dynamic_cast<FmFormPage*>( GetSdrPage()  );
 931     if( pFmPage )
 932         xForms.set( pFmPage->GetForms(), css::uno::UNO_QUERY_THROW );
 933
 934     return xForms;
 935 }
 936
 937 // XFormsSupplier2
 938 sal_Bool SAL_CALL SvxDrawPage::hasForms()
 939 {
 940     SolarMutexGuard g;
 941
 942     bool bHas = false;
 943     FmFormPage* pFormPage = dynamic_cast<FmFormPage*>( GetSdrPage()  );
 944     if ( pFormPage )
 945         bHas = pFormPage->GetForms( false ).is();
 946     return bHas;
 947 }
 948
 949 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */