svx/source/unodraw/unomod.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 <sal/config.h>
  21
  22 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  23 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
  24 #include <com/sun/star/lang/NoSupportException.hpp>
  25 #include <com/sun/star/drawing/XShape.hpp>
  26 #include <vcl/svapp.hxx>
  27 #include <svl/itempool.hxx>
  28 #include <svtools/unoevent.hxx>
  29 #include <comphelper/sequence.hxx>
  30 #include <o3tl/string_view.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32
  33 #include <cppuhelper/implbase.hxx>
  34 #include <svx/unofill.hxx>
  35 #include <editeng/unonrule.hxx>
  36 #include <svtools/unoimap.hxx>
  37 #include <sfx2/event.hxx>
  38 #include <svx/fmmodel.hxx>
  39 #include <svx/fmpage.hxx>
  40 #include <svx/unoapi.hxx>
  41
  42 #include <svx/svdmodel.hxx>
  43 #include <svx/unoprov.hxx>
  44 #include <svx/unopage.hxx>
  45 #include <editeng/unofield.hxx>
  46 #include <svx/unomod.hxx>
  47 #include <svx/unomodel.hxx>
  48 #include <svx/svdobj.hxx>
  49 #include <svx/svdpage.hxx>
  50 #include <svx/SvxXTextColumns.hxx>
  51 #include <svx/unoshape.hxx>
  52 #include <svx/xmlgrhlp.hxx>
  53
  54 #include <com/sun/star/text/textfield/Type.hpp>
  55
  56 //-
  57
  58 using namespace ::com::sun::star;
  59
  60 //-
  61
  62 #define QUERYINT( xint ) \
  63     if( rType == cppu::UnoType<xint>::get() ) \
  64         aAny <<= uno::Reference< xint >(this)
  65
  66 //-
  67
  68 class SvxUnoDrawPagesAccess : public ::cppu::WeakImplHelper< css::drawing::XDrawPages, css::lang::XServiceInfo >
  69 {
  70 private:
  71     SvxUnoDrawingModel& mrModel;
  72
  73 public:
  74     explicit SvxUnoDrawPagesAccess( SvxUnoDrawingModel& rMyModel ) noexcept;
  75
  76     // XDrawPages
  77     virtual css::uno::Reference< css::drawing::XDrawPage > SAL_CALL insertNewByIndex( sal_Int32 nIndex ) override;
  78     virtual void SAL_CALL remove( const css::uno::Reference< css::drawing::XDrawPage >& xPage ) override;
  79
  80     // XIndexAccess
  81     virtual sal_Int32 SAL_CALL getCount() override ;
  82     virtual css::uno::Any SAL_CALL getByIndex( sal_Int32 Index ) override;
  83
  84     // XElementAccess
  85     virtual css::uno::Type SAL_CALL getElementType() override;
  86     virtual sal_Bool SAL_CALL hasElements() override;
  87
  88     // XServiceInfo
  89     virtual OUString SAL_CALL getImplementationName(  ) override;
  90     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
  91     virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
  92 };
  93 //-
  94
  95 static const SvEventDescription* ImplGetSupportedMacroItems()
  96 {
  97     static const SvEventDescription aMacroDescriptionsImpl[] =
  98     {
  99         { SvMacroItemId::OnMouseOver, "OnMouseOver" },
 100         { SvMacroItemId::OnMouseOut,  "OnMouseOut" },
 101         { SvMacroItemId::NONE, nullptr }
 102     };
 103
 104     return aMacroDescriptionsImpl;
 105 }
 106
 107 //-
 108
 109 /** fills the given EventObject from the given SdrHint.
 110     @returns
 111         true    if the SdrHint could be translated to an EventObject<br>
 112         false   if not
 113 */
 114 bool SvxUnoDrawMSFactory::createEvent( const SdrModel* pDoc, const SdrHint* pSdrHint, css::document::EventObject& aEvent )
 115 {
 116     const SdrObject* pObj = nullptr;
 117     const SdrPage* pPage = nullptr;
 118
 119     switch( pSdrHint->GetKind() )
 120     {
 121 //              case SdrHintKind::LayerChange:             // layer definition changed
 122 //              case SdrHintKind::LayerOrderChange:        // layer order changed (Insert/Remove/ChangePos)
 123 //              case HINT_LAYERSETCHG:          // layer set changed
 124 //              case HINT_LAYERSETORDERCHG:     // layer set order changed (Insert/Remove/ChangePos)
 125
 126 //      case HINT_PAGECHG:              // page changed
 127 //          aEvent.EventName = "PageModified";
 128 //          pPage = pSdrHint->GetPage();
 129 //          break;
 130         case SdrHintKind::PageOrderChange:         // draw or master page order changed (Insert/Remove/ChangePos)
 131             aEvent.EventName = "PageOrderModified";
 132             pPage = pSdrHint->GetPage();
 133             break;
 134         case SdrHintKind::ObjectChange:               // object changed
 135             aEvent.EventName = "ShapeModified";
 136             pObj = pSdrHint->GetObject();
 137             break;
 138         case SdrHintKind::ObjectInserted:          // add new draw object
 139             aEvent.EventName = "ShapeInserted";
 140             pObj = pSdrHint->GetObject();
 141             break;
 142         case SdrHintKind::ObjectRemoved:           // removed draw object from list
 143             aEvent.EventName = "ShapeRemoved";
 144             pObj = pSdrHint->GetObject();
 145             break;
 146 //                SdrHintKind::DefaultTabChange,   // default tab width changed
 147 //                SdrHintKind::SwitchToPage,    // #94278# UNDO/REDO at an object evtl. on another page
 148 //                HINT_OBJLISTCLEAR     // Is called before an SdrObjList will be cleared
 149         default:
 150             return false;
 151     }
 152
 153     if( pObj )
 154         aEvent.Source = const_cast<SdrObject*>(pObj)->getUnoShape();
 155     else if( pPage )
 156         aEvent.Source = const_cast<SdrPage*>(pPage)->getUnoPage();
 157     else
 158         aEvent.Source = const_cast<SdrModel*>(pDoc)->getUnoModel();
 159
 160     return true;
 161 }
 162
 163 namespace {
 164
 165 css::uno::Reference<css::uno::XInterface> create(
 166     OUString const & rServiceSpecifier, OUString const & referer)
 167 {
 168     if( rServiceSpecifier.startsWith("com.sun.star.drawing.") )
 169     {
 170         std::optional<SdrObjKind> nType = UHashMap::getId( rServiceSpecifier );
 171         if( nType )
 172         {
 173             SdrInventor nI = IsInventorE3D(*nType) ? SdrInventor::E3d : SdrInventor::Default;
 174
 175             return cppu::getXWeak(SvxDrawPage::CreateShapeByTypeAndInventor( *nType, nI, nullptr, nullptr, referer ).get());
 176         }
 177     }
 178     else if (rServiceSpecifier == "com.sun.star.document.ImportGraphicStorageHandler")
 179     {
 180         return cppu::getXWeak( SvXMLGraphicHelper::Create( SvXMLGraphicHelperMode::Read ).get() );
 181     }
 182     else if (rServiceSpecifier == "com.sun.star.text.TextColumns")
 183     {
 184         return SvxXTextColumns_createInstance();
 185     }
 186
 187     uno::Reference< uno::XInterface > xRet( SvxUnoDrawMSFactory::createTextField( rServiceSpecifier ) );
 188     if( !xRet.is() )
 189         throw lang::ServiceNotRegisteredException("unknown service: " + rServiceSpecifier);
 190
 191     return xRet;
 192 }
 193
 194 }
 195
 196 uno::Reference< uno::XInterface > SAL_CALL SvxUnoDrawMSFactory::createInstance( const OUString& rServiceSpecifier )
 197 {
 198     return create(rServiceSpecifier, "");
 199 }
 200
 201 uno::Reference< uno::XInterface > SvxUnoDrawMSFactory::createTextField( std::u16string_view ServiceSpecifier )
 202 {
 203     return SvxUnoTextCreateTextField( ServiceSpecifier );
 204 }
 205
 206 uno::Reference< uno::XInterface > SAL_CALL SvxUnoDrawMSFactory::createInstanceWithArguments( const OUString& ServiceSpecifier, const uno::Sequence< css::uno::Any >& Arguments )
 207 {
 208     OUString arg;
 209     if ((ServiceSpecifier == "com.sun.star.drawing.GraphicObjectShape"
 210          || ServiceSpecifier == "com.sun.star.drawing.AppletShape"
 211          || ServiceSpecifier == "com.sun.star.drawing.FrameShape"
 212          || ServiceSpecifier == "com.sun.star.drawing.OLE2Shape"
 213          || ServiceSpecifier == "com.sun.star.drawing.MediaShape"
 214          || ServiceSpecifier == "com.sun.star.drawing.PluginShape")
 215         && Arguments.getLength() == 1 && (Arguments[0] >>= arg))
 216     {
 217         return create(ServiceSpecifier, arg);
 218     }
 219     throw lang::NoSupportException();
 220 }
 221
 222 uno::Sequence< OUString > SAL_CALL SvxUnoDrawMSFactory::getAvailableServiceNames()
 223 {
 224     return UHashMap::getServiceNames();
 225 }
 226
 227 SdrModel& SvxUnoDrawingModel::getSdrModelFromUnoModel() const
 228 {
 229     OSL_ENSURE(mpDoc, "No SdrModel in UnoDrawingModel, should not happen");
 230     return *mpDoc;
 231 }
 232
 233 SvxUnoDrawingModel::SvxUnoDrawingModel(SdrModel* pDoc) noexcept
 234 :   SfxBaseModel(nullptr),
 235     mpDoc(pDoc)
 236 {
 237 }
 238
 239 SvxUnoDrawingModel::~SvxUnoDrawingModel() noexcept
 240 {
 241 }
 242
 243 uno::Any SAL_CALL SvxUnoDrawingModel::queryInterface( const uno::Type & rType )
 244 {
 245     uno::Any aAny;
 246
 247     QUERYINT(lang::XServiceInfo);
 248     else QUERYINT(lang::XMultiServiceFactory);
 249     else QUERYINT(drawing::XDrawPagesSupplier);
 250     else QUERYINT(css::ucb::XAnyCompareFactory);
 251     else
 252         return SfxBaseModel::queryInterface( rType );
 253
 254     return aAny;
 255 }
 256
 257 // XTypeProvider
 258 uno::Sequence< uno::Type > SAL_CALL SvxUnoDrawingModel::getTypes(  )
 259 {
 260     if( !maTypeSequence.hasElements() )
 261     {
 262         maTypeSequence = comphelper::concatSequences( SfxBaseModel::getTypes(),
 263             uno::Sequence {
 264                 cppu::UnoType<lang::XServiceInfo>::get(),
 265                 cppu::UnoType<lang::XMultiServiceFactory>::get(),
 266                 cppu::UnoType<drawing::XDrawPagesSupplier>::get(),
 267                 cppu::UnoType<css::ucb::XAnyCompareFactory>::get() });
 268     }
 269     return maTypeSequence;
 270 }
 271
 272 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoDrawingModel::getImplementationId(  )
 273 {
 274     return css::uno::Sequence<sal_Int8>();
 275 }
 276
 277 void SAL_CALL SvxUnoDrawingModel::lockControllers(  )
 278 {
 279     if( mpDoc )
 280         mpDoc->setLock(true);
 281 }
 282
 283 void SAL_CALL SvxUnoDrawingModel::unlockControllers(  )
 284 {
 285     if( mpDoc && mpDoc->isLocked() )
 286     {
 287         mpDoc->setLock(false);
 288     }
 289 }
 290
 291 sal_Bool SAL_CALL SvxUnoDrawingModel::hasControllersLocked(  )
 292 {
 293     return mpDoc && mpDoc->isLocked();
 294 }
 295
 296 // XDrawPagesSupplier
 297 uno::Reference< drawing::XDrawPages > SAL_CALL SvxUnoDrawingModel::getDrawPages()
 298 {
 299     ::SolarMutexGuard aGuard;
 300
 301     uno::Reference< drawing::XDrawPages >  xDrawPages( mxDrawPagesAccess );
 302
 303     if( !xDrawPages.is() )
 304         mxDrawPagesAccess = xDrawPages = new SvxUnoDrawPagesAccess(*this);
 305
 306     return xDrawPages;
 307 }
 308
 309 // XMultiServiceFactory ( SvxFmMSFactory )
 310 uno::Reference< uno::XInterface > SAL_CALL SvxUnoDrawingModel::createInstance( const OUString& aServiceSpecifier )
 311 {
 312     ::SolarMutexGuard aGuard;
 313
 314     if( aServiceSpecifier == "com.sun.star.drawing.DashTable" )
 315     {
 316         if( !mxDashTable.is() )
 317             mxDashTable = SvxUnoDashTable_createInstance( mpDoc );
 318         return mxDashTable;
 319     }
 320     if( aServiceSpecifier == "com.sun.star.drawing.GradientTable" )
 321     {
 322         if( !mxGradientTable.is() )
 323             mxGradientTable = SvxUnoGradientTable_createInstance( mpDoc );
 324         return mxGradientTable;
 325     }
 326     if( aServiceSpecifier == "com.sun.star.drawing.HatchTable" )
 327     {
 328         if( !mxHatchTable.is() )
 329             mxHatchTable = SvxUnoHatchTable_createInstance( mpDoc );
 330         return mxHatchTable;
 331     }
 332     if( aServiceSpecifier == "com.sun.star.drawing.BitmapTable" )
 333     {
 334         if( !mxBitmapTable.is() )
 335             mxBitmapTable = SvxUnoBitmapTable_createInstance( mpDoc );
 336         return mxBitmapTable;
 337     }
 338     if( aServiceSpecifier == "com.sun.star.drawing.TransparencyGradientTable" )
 339     {
 340         if( !mxTransGradientTable.is() )
 341             mxTransGradientTable = SvxUnoTransGradientTable_createInstance( mpDoc );
 342         return mxTransGradientTable;
 343     }
 344     if( aServiceSpecifier == "com.sun.star.drawing.MarkerTable" )
 345     {
 346         if( !mxMarkerTable.is() )
 347             mxMarkerTable = SvxUnoMarkerTable_createInstance( mpDoc );
 348         return mxMarkerTable;
 349     }
 350     if( aServiceSpecifier == "com.sun.star.text.NumberingRules" )
 351     {
 352         return uno::Reference< uno::XInterface >( SvxCreateNumRule( mpDoc ), uno::UNO_QUERY );
 353     }
 354
 355     if ( aServiceSpecifier == "com.sun.star.image.ImageMapRectangleObject" )
 356     {
 357         return SvUnoImageMapRectangleObject_createInstance( ImplGetSupportedMacroItems() );
 358     }
 359
 360     if ( aServiceSpecifier == "com.sun.star.image.ImageMapCircleObject" )
 361     {
 362         return SvUnoImageMapCircleObject_createInstance( ImplGetSupportedMacroItems() );
 363     }
 364
 365     if ( aServiceSpecifier == "com.sun.star.image.ImageMapPolygonObject" )
 366     {
 367         return SvUnoImageMapPolygonObject_createInstance( ImplGetSupportedMacroItems() );
 368     }
 369
 370     if( aServiceSpecifier == "com.sun.star.text.TextField.DateTime" )
 371     {
 372         return cppu::getXWeak(new SvxUnoTextField(text::textfield::Type::DATE));
 373     }
 374
 375     uno::Reference< uno::XInterface > xRet;
 376
 377     static constexpr OUString aPackagePrefix( u"com.sun.star.presentation."_ustr );
 378     if( aServiceSpecifier.startsWith( aPackagePrefix ) )
 379     {
 380         SvxShape* pShape = nullptr;
 381
 382         SdrObjKind nType = SdrObjKind::Text;
 383         std::u16string_view aTypeName = aServiceSpecifier.subView( aPackagePrefix.getLength() );
 384         // create a shape wrapper
 385         if( o3tl::starts_with(aTypeName, u"TitleTextShape") )
 386         {
 387             nType = SdrObjKind::Text;
 388         }
 389         else if( o3tl::starts_with(aTypeName, u"OutlinerShape" ) )
 390         {
 391             nType = SdrObjKind::Text;
 392         }
 393         else if( o3tl::starts_with(aTypeName, u"SubtitleShape" ) )
 394         {
 395             nType = SdrObjKind::Text;
 396         }
 397         else if( o3tl::starts_with(aTypeName, u"GraphicObjectShape" ) )
 398         {
 399             nType = SdrObjKind::Graphic;
 400         }
 401         else if( o3tl::starts_with(aTypeName, u"PageShape" ) )
 402         {
 403             nType = SdrObjKind::Page;
 404         }
 405         else if( o3tl::starts_with(aTypeName, u"OLE2Shape" ) )
 406         {
 407             nType = SdrObjKind::OLE2;
 408         }
 409         else if( o3tl::starts_with(aTypeName, u"ChartShape" ) )
 410         {
 411             nType = SdrObjKind::OLE2;
 412         }
 413         else if( o3tl::starts_with(aTypeName, u"OrgChartShape" ) )
 414         {
 415             nType = SdrObjKind::OLE2;
 416         }
 417         else if( o3tl::starts_with(aTypeName, u"NotesShape" ) )
 418         {
 419             nType = SdrObjKind::Text;
 420         }
 421         else if( o3tl::starts_with(aTypeName, u"HandoutShape" ) )
 422         {
 423             nType = SdrObjKind::Page;
 424         }
 425         else if( o3tl::starts_with(aTypeName, u"FooterShape" ) )
 426         {
 427             nType = SdrObjKind::Text;
 428         }
 429         else if( o3tl::starts_with(aTypeName, u"HeaderShape" ) )
 430         {
 431             nType = SdrObjKind::Text;
 432         }
 433         else if( o3tl::starts_with(aTypeName, u"SlideNumberShape" ) )
 434         {
 435             nType = SdrObjKind::Text;
 436         }
 437         else if( o3tl::starts_with(aTypeName, u"DateTimeShape" ) )
 438         {
 439             nType = SdrObjKind::Text;
 440         }
 441         else if( o3tl::starts_with(aTypeName, u"TableShape" ) )
 442         {
 443             nType = SdrObjKind::Table;
 444         }
 445         else
 446         {
 447             throw lang::ServiceNotRegisteredException();
 448         }
 449
 450         // create the API wrapper
 451         rtl::Reference<SvxShape> xNewShape = CreateSvxShapeByTypeAndInventor( nType, SdrInventor::Default, "" );
 452         pShape = xNewShape.get();
 453
 454         // set shape type
 455         if( pShape )
 456             pShape->SetShapeType(aServiceSpecifier);
 457
 458         xRet = cppu::getXWeak(pShape);
 459     }
 460     else
 461     {
 462         xRet = SvxFmMSFactory::createInstance( aServiceSpecifier );
 463     }
 464
 465     return xRet;
 466 }
 467
 468 uno::Sequence< OUString > SAL_CALL SvxUnoDrawingModel::getAvailableServiceNames()
 469 {
 470     const uno::Sequence< OUString > aSNS_ORG( SvxFmMSFactory::getAvailableServiceNames() );
 471
 472     uno::Sequence< OUString > aSNS{
 473         "com.sun.star.drawing.DashTable",
 474         "com.sun.star.drawing.GradientTable",
 475         "com.sun.star.drawing.HatchTable",
 476         "com.sun.star.drawing.BitmapTable",
 477         "com.sun.star.drawing.TransparencyGradientTable",
 478         "com.sun.star.drawing.MarkerTable",
 479         "com.sun.star.text.NumberingRules",
 480         "com.sun.star.image.ImageMapRectangleObject",
 481         "com.sun.star.image.ImageMapCircleObject",
 482         "com.sun.star.image.ImageMapPolygonObject",
 483
 484         "com.sun.star.presentation.TitleTextShape",
 485         "com.sun.star.presentation.OutlinerShape",
 486         "com.sun.star.presentation.SubtitleShape",
 487         "com.sun.star.presentation.GraphicObjectShape",
 488         "com.sun.star.presentation.ChartShape",
 489         "com.sun.star.presentation.PageShape",
 490         "com.sun.star.presentation.OLE2Shape",
 491         "com.sun.star.presentation.TableShape",
 492         "com.sun.star.presentation.OrgChartShape",
 493         "com.sun.star.presentation.NotesShape",
 494         "com.sun.star.presentation.HandoutShape"
 495     };
 496
 497     return comphelper::concatSequences( aSNS_ORG, aSNS );
 498 }
 499
 500 // lang::XServiceInfo
 501 OUString SAL_CALL SvxUnoDrawingModel::getImplementationName()
 502 {
 503     return "SvxUnoDrawingModel";
 504 }
 505
 506 sal_Bool SAL_CALL SvxUnoDrawingModel::supportsService( const OUString& ServiceName )
 507 {
 508     return cppu::supportsService( this, ServiceName );
 509 }
 510
 511 uno::Sequence< OUString > SAL_CALL SvxUnoDrawingModel::getSupportedServiceNames()
 512 {
 513     return { "com.sun.star.drawing.DrawingDocument" };
 514 }
 515
 516 // XAnyCompareFactory
 517 uno::Reference< css::ucb::XAnyCompare > SAL_CALL SvxUnoDrawingModel::createAnyCompareByName( const OUString& )
 518 {
 519     return SvxCreateNumRuleCompare();
 520 }
 521
 522 SvxUnoDrawPagesAccess::SvxUnoDrawPagesAccess( SvxUnoDrawingModel& rMyModel )  noexcept
 523 :   mrModel(rMyModel)
 524 {
 525 }
 526
 527 // XIndexAccess
 528 sal_Int32 SAL_CALL SvxUnoDrawPagesAccess::getCount()
 529 {
 530     ::SolarMutexGuard aGuard;
 531
 532     sal_Int32 nCount = 0;
 533
 534     if( mrModel.mpDoc )
 535         nCount = mrModel.mpDoc->GetPageCount();
 536
 537     return nCount;
 538 }
 539
 540 uno::Any SAL_CALL SvxUnoDrawPagesAccess::getByIndex( sal_Int32 Index )
 541 {
 542     ::SolarMutexGuard aGuard;
 543
 544     uno::Any aAny;
 545
 546     if( mrModel.mpDoc )
 547     {
 548         if( (Index < 0) || (Index >= mrModel.mpDoc->GetPageCount() ) )
 549             throw lang::IndexOutOfBoundsException();
 550
 551         SdrPage* pPage = mrModel.mpDoc->GetPage( static_cast<sal_uInt16>(Index) );
 552         if( pPage )
 553         {
 554             uno::Reference< uno::XInterface > xPage( pPage->mxUnoPage );
 555
 556             if( !xPage.is() )
 557             {
 558                 xPage = static_cast<drawing::XDrawPage*>(new SvxDrawPage( pPage ));
 559                 pPage->mxUnoPage = xPage;
 560             }
 561
 562             aAny <<= xPage;
 563         }
 564     }
 565     return aAny;
 566 }
 567
 568 // XElementAccess
 569 uno::Type SAL_CALL SvxUnoDrawPagesAccess::getElementType()
 570 {
 571     return cppu::UnoType<drawing::XDrawPage>::get();
 572 }
 573
 574 sal_Bool SAL_CALL SvxUnoDrawPagesAccess::hasElements()
 575 {
 576     return getCount() > 0;
 577 }
 578
 579 // XDrawPages
 580
 581 // create a new page with model at given position
 582 // and return corresponding SdDrawPage
 583 uno::Reference< drawing::XDrawPage > SAL_CALL SvxUnoDrawPagesAccess::insertNewByIndex( sal_Int32 nIndex )
 584 {
 585     ::SolarMutexGuard aGuard;
 586
 587     uno::Reference< drawing::XDrawPage > xDrawPage;
 588
 589     if( mrModel.mpDoc )
 590     {
 591         rtl::Reference<SdrPage> pPage;
 592
 593         if( auto pFormModel = dynamic_cast<FmFormModel*>( mrModel.mpDoc )  )
 594             pPage = new FmFormPage(*pFormModel);
 595         else
 596             pPage = new SdrPage(*mrModel.mpDoc);
 597
 598         mrModel.mpDoc->InsertPage( pPage.get(), static_cast<sal_uInt16>(nIndex) );
 599         xDrawPage.set( pPage->getUnoPage(), uno::UNO_QUERY );
 600     }
 601
 602     return xDrawPage;
 603 }
 604
 605 void SAL_CALL SvxUnoDrawPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
 606 {
 607     ::SolarMutexGuard aGuard;
 608
 609     sal_uInt16 nPageCount = mrModel.mpDoc->GetPageCount();
 610     if( nPageCount <= 1 )
 611         return;
 612
 613     // get pPage from xPage and get Id (nPos)
 614     SvxDrawPage* pSvxPage = comphelper::getFromUnoTunnel<SvxDrawPage>( xPage );
 615     if( pSvxPage )
 616     {
 617         SdrPage* pPage = pSvxPage->GetSdrPage();
 618         if(pPage)
 619         {
 620             sal_uInt16 nPage = pPage->GetPageNum();
 621             mrModel.mpDoc->DeletePage( nPage );
 622         }
 623     }
 624 }
 625
 626 // XServiceInfo
 627
 628 OUString SAL_CALL SvxUnoDrawPagesAccess::getImplementationName(  )
 629 {
 630     return "SvxUnoDrawPagesAccess";
 631 }
 632
 633 sal_Bool SAL_CALL SvxUnoDrawPagesAccess::supportsService( const OUString& ServiceName )
 634 {
 635     return cppu::supportsService(this, ServiceName);
 636 }
 637
 638 uno::Sequence< OUString > SAL_CALL SvxUnoDrawPagesAccess::getSupportedServiceNames(  )
 639 {
 640     return { "com.sun.star.drawing.DrawPages" };
 641 }
 642
 643 css::uno::Reference< css::container::XIndexReplace > SvxCreateNumRule(SdrModel* pModel)
 644 {
 645     const SvxNumRule* pDefaultRule = nullptr;
 646     if( pModel )
 647     {
 648         const SvxNumBulletItem* pItem = pModel->GetItemPool().GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET);
 649         if( pItem )
 650         {
 651             pDefaultRule = &pItem->GetNumRule();
 652         }
 653     }
 654
 655     if( pDefaultRule )
 656     {
 657         return SvxCreateNumRule( *pDefaultRule );
 658     }
 659     else
 660     {
 661         SvxNumRule aTempRule( SvxNumRuleFlags::NONE, 10, false );
 662         return SvxCreateNumRule( aTempRule );
 663     }
 664 }
 665
 666
 667 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */