sd/source/ui/view/drviews2.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 <avmedia/mediaplayer.hxx>
  23
  24 #include <basic/sberrors.hxx>
  25 #include <basic/sbstar.hxx>
  26
  27 #include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
  28 #include <com/sun/star/drawing/XDrawPages.hpp>
  29 #include <com/sun/star/lang/XInitialization.hpp>
  30 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
  31 #include <com/sun/star/ui/dialogs/XSLTFilterDialog.hpp>
  32 #include <com/sun/star/frame/XDispatchProvider.hpp>
  33 #include <com/sun/star/util/URLTransformer.hpp>
  34 #include <com/sun/star/util/XURLTransformer.hpp>
  35 #include <com/sun/star/scanner/XScannerManager2.hpp>
  36 #include <com/sun/star/document/XDocumentProperties.hpp>
  37
  38 #include <comphelper/processfactory.hxx>
  39 #include <comphelper/propertysequence.hxx>
  40 #include <comphelper/scopeguard.hxx>
  41 #include <comphelper/lok.hxx>
  42
  43 #include <editeng/contouritem.hxx>
  44 #include <editeng/editdata.hxx>
  45 #include <editeng/eeitem.hxx>
  46 #include <editeng/flditem.hxx>
  47 #include <editeng/section.hxx>
  48 #include <editeng/editobj.hxx>
  49 #include <editeng/CustomPropertyField.hxx>
  50 #include <editeng/urlfieldhelper.hxx>
  51
  52 #include <sal/log.hxx>
  53
  54 #include <sfx2/bindings.hxx>
  55 #include <sfx2/dispatch.hxx>
  56 #include <sfx2/docfile.hxx>
  57 #include <sfx2/msgpool.hxx>
  58 #include <sfx2/msg.hxx>
  59 #include <sfx2/request.hxx>
  60 #include <sfx2/viewfrm.hxx>
  61 #include <sfx2/zoomitem.hxx>
  62
  63 #include <svx/compressgraphicdialog.hxx>
  64 #include <svx/ClassificationDialog.hxx>
  65 #include <svx/ClassificationCommon.hxx>
  66 #include <svx/bmpmask.hxx>
  67 #include <svx/extedit.hxx>
  68 #include <svx/extrusionbar.hxx>
  69 #include <svx/f3dchild.hxx>
  70 #include <svx/fontwork.hxx>
  71 #include <svx/fontworkbar.hxx>
  72 #include <svx/graphichelper.hxx>
  73 #include <svx/hlnkitem.hxx>
  74 #include <svx/imapdlg.hxx>
  75 #include <svx/sdtagitm.hxx>
  76 #include <svx/svdograf.hxx>
  77 #include <svx/svdoole2.hxx>
  78 #include <svx/svdpagv.hxx>
  79 #include <svx/svdundo.hxx>
  80 #include <svx/svxdlg.hxx>
  81 #include <svx/svxids.hrc>
  82 #include <svx/sdtfsitm.hxx>
  83 #include <svx/sdmetitm.hxx>
  84 #include <svx/zoomslideritem.hxx>
  85 #include <svx/xflclit.hxx>
  86 #include <svx/xlnwtit.hxx>
  87 #include <svx/chrtitem.hxx>
  88 #include <svx/xlnclit.hxx>
  89 #include <svx/xflgrit.hxx>
  90 #include <svx/xfillit0.hxx>
  91
  92 #include <comphelper/diagnose_ex.hxx>
  93 #include <tools/UnitConversion.hxx>
  94
  95 #include <unotools/useroptions.hxx>
  96
  97 #include <vcl/abstdlg.hxx>
  98 #include <vcl/graph.hxx>
  99 #include <vcl/svapp.hxx>
 100 #include <vcl/unohelp2.hxx>
 101 #include <vcl/weld.hxx>
 102
 103 #include <editeng/cmapitem.hxx>
 104 #include <editeng/escapementitem.hxx>
 105 #include <editeng/kernitem.hxx>
 106 #include <editeng/wghtitem.hxx>
 107 #include <editeng/postitem.hxx>
 108 #include <editeng/udlnitem.hxx>
 109 #include <editeng/crossedoutitem.hxx>
 110 #include <editeng/shdditem.hxx>
 111 #include <editeng/numitem.hxx>
 112 #include <svx/svdobj.hxx>
 113 #include <svx/SvxColorChildWindow.hxx>
 114 #include <editeng/outlobj.hxx>
 115 #include <editeng/flstitem.hxx>
 116 #include <editeng/fontitem.hxx>
 117 #include <editeng/fhgtitem.hxx>
 118 #include <editeng/colritem.hxx>
 119
 120 #include <svl/poolitem.hxx>
 121 #include <svl/style.hxx>
 122 #include <svl/whiter.hxx>
 123
 124 #include <app.hrc>
 125 #include <strings.hrc>
 126
 127 #include <AnimationChildWindow.hxx>
 128 #include <DrawDocShell.hxx>
 129 #include <DrawViewShell.hxx>
 130 #include <LayerTabBar.hxx>
 131 #include <Outliner.hxx>
 132 #include <ViewShellHint.hxx>
 133 #include <ViewShellImplementation.hxx>
 134 #include <Window.hxx>
 135 #include <drawdoc.hxx>
 136 #include <drawview.hxx>
 137 #include <fuarea.hxx>
 138 #include <fubullet.hxx>
 139 #include <fuchar.hxx>
 140 #include <fucushow.hxx>
 141 #include <fuconnct.hxx>
 142 #include <fucopy.hxx>
 143 #include <fudspord.hxx>
 144 #include <fuexecuteinteraction.hxx>
 145 #include <fuexpand.hxx>
 146 #include <fuinsert.hxx>
 147 #include <fuinsfil.hxx>
 148 #include <fuline.hxx>
 149 #include <fulinend.hxx>
 150 #include <fulink.hxx>
 151 #include <fumeasur.hxx>
 152 #include <fumorph.hxx>
 153 #include <fuoaprms.hxx>
 154 #include <fuolbull.hxx>
 155 #include <fupage.hxx>
 156 #include <fuparagr.hxx>
 157 #include <fuprlout.hxx>
 158 #include <fuscale.hxx>
 159 #include <fusel.hxx>
 160 #include <fusldlg.hxx>
 161 #include <fusnapln.hxx>
 162 #include <fusumry.hxx>
 163 #include <futempl.hxx>
 164 #include <futhes.hxx>
 165 #include <futransf.hxx>
 166 #include <futxtatt.hxx>
 167 #include <fuvect.hxx>
 168 #include <futext.hxx>
 169 #include <helpids.h>
 170 #include <sdabstdlg.hxx>
 171 #include <sdattr.hxx>
 172 #include <sdpage.hxx>
 173 #include <sdresid.hxx>
 174 #include <unokywds.hxx>
 175 #include <slideshow.hxx>
 176 #include <stlsheet.hxx>
 177 #include <undolayer.hxx>
 178 #include <sfx2/sidebar/Sidebar.hxx>
 179 #include <sfx2/classificationhelper.hxx>
 180 #include <sdmod.hxx>
 181 #include <model/SlsPageDescriptor.hxx>
 182 #include <model/SlsPageEnumerationProvider.hxx>
 183 #include <SlideSorter.hxx>
 184 #include <view/SlideSorterView.hxx>
 185 #include <SlideSorterViewShell.hxx>
 186 #include <controller/SlideSorterController.hxx>
 187 #include <controller/SlsPageSelector.hxx>
 188 #include <tools/GraphicSizeCheck.hxx>
 189
 190 #include <theme/ThemeColorChanger.hxx>
 191 #include <svx/dialog/ThemeDialog.hxx>
 192 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
 193
 194 #include <ViewShellBase.hxx>
 195 #include <memory>
 196
 197 #include <sfx2/newstyle.hxx>
 198 #include <SelectLayerDlg.hxx>
 199 #include <unomodel.hxx>
 200
 201 using namespace ::com::sun::star;
 202 using namespace ::com::sun::star::uno;
 203
 204 #define MIN_ACTIONS_FOR_DIALOG  5000    ///< if there are more meta objects, we show a dialog during the break up
 205
 206 namespace sd {
 207
 208 namespace {
 209
 210 const SvxFieldItem* findField(editeng::Section const & rSection)
 211 {
 212     for (SfxPoolItem const * pPool: rSection.maAttributes)
 213     {
 214         if (pPool->Which() == EE_FEATURE_FIELD)
 215             return static_cast<const SvxFieldItem*>(pPool);
 216     }
 217     return nullptr;
 218 }
 219
 220 bool hasCustomPropertyField(std::vector<editeng::Section> const & aSections, std::u16string_view rName)
 221 {
 222     for (editeng::Section const & rSection : aSections)
 223     {
 224         const SvxFieldItem* pFieldItem = findField(rSection);
 225         if (pFieldItem)
 226         {
 227             const editeng::CustomPropertyField* pCustomPropertyField = dynamic_cast<const editeng::CustomPropertyField*>(pFieldItem->GetField());
 228             if (pCustomPropertyField && pCustomPropertyField->GetName() == rName)
 229                 return true;
 230         }
 231     }
 232     return false;
 233 }
 234
 235 OUString getWeightString(SfxItemSet const & rItemSet)
 236 {
 237     OUString sWeightString = u"NORMAL"_ustr;
 238
 239     if (const SfxPoolItem* pItem = rItemSet.GetItem(EE_CHAR_WEIGHT, false))
 240     {
 241         const SvxWeightItem* pWeightItem = dynamic_cast<const SvxWeightItem*>(pItem);
 242         if (pWeightItem && pWeightItem->GetWeight() == WEIGHT_BOLD)
 243             sWeightString = "BOLD";
 244     }
 245     return sWeightString;
 246 }
 247
 248 class ClassificationCommon
 249 {
 250 protected:
 251     sd::DrawViewShell& m_rDrawViewShell;
 252     uno::Reference<document::XDocumentProperties> m_xDocumentProperties;
 253     uno::Reference<beans::XPropertyContainer> m_xPropertyContainer;
 254     sfx::ClassificationKeyCreator m_aKeyCreator;
 255 public:
 256     ClassificationCommon(sd::DrawViewShell& rDrawViewShell, const css::uno::Reference<css::document::XDocumentProperties>& rDocProps)
 257         : m_rDrawViewShell(rDrawViewShell)
 258         , m_xDocumentProperties(rDocProps)
 259         , m_xPropertyContainer(m_xDocumentProperties->getUserDefinedProperties())
 260         , m_aKeyCreator(SfxClassificationHelper::getPolicyType())
 261     {}
 262 };
 263
 264 class ClassificationCollector : public ClassificationCommon
 265 {
 266 private:
 267     std::vector<svx::ClassificationResult> m_aResults;
 268
 269     void iterateSectionsAndCollect(std::vector<editeng::Section> const & rSections, EditTextObject const & rEditText)
 270     {
 271         sal_Int32 nCurrentParagraph = -1;
 272         OUString sBlank;
 273
 274         for (editeng::Section const & rSection : rSections)
 275         {
 276             // Insert new paragraph if needed
 277             while (nCurrentParagraph < rSection.mnParagraph)
 278             {
 279                 nCurrentParagraph++;
 280                 // Get Weight of current paragraph
 281                 OUString sWeightProperty = getWeightString(rEditText.GetParaAttribs(nCurrentParagraph));
 282                 // Insert new paragraph into collection
 283                 m_aResults.emplace_back(svx::ClassificationType::PARAGRAPH, sWeightProperty, sBlank, sBlank);
 284             }
 285
 286             const SvxFieldItem* pFieldItem = findField(rSection);
 287             const editeng::CustomPropertyField* pCustomPropertyField = pFieldItem ?
 288                 dynamic_cast<const editeng::CustomPropertyField*>(pFieldItem->GetField()) :
 289                 nullptr;
 290             if (pCustomPropertyField)
 291             {
 292                 const OUString& aKey = pCustomPropertyField->GetName();
 293                 if (m_aKeyCreator.isMarkingTextKey(aKey))
 294                 {
 295                     m_aResults.emplace_back(svx::ClassificationType::TEXT,
 296                                            svx::classification::getProperty(m_xPropertyContainer, aKey),
 297                                            sBlank, sBlank);
 298                 }
 299                 else if (m_aKeyCreator.isCategoryNameKey(aKey) || m_aKeyCreator.isCategoryIdentifierKey(aKey))
 300                 {
 301                     m_aResults.emplace_back(svx::ClassificationType::CATEGORY,
 302                                            svx::classification::getProperty(m_xPropertyContainer, aKey),
 303                                            sBlank, sBlank);
 304                 }
 305                 else if (m_aKeyCreator.isMarkingKey(aKey))
 306                 {
 307                     m_aResults.emplace_back(svx::ClassificationType::MARKING,
 308                                            svx::classification::getProperty(m_xPropertyContainer, aKey),
 309                                            sBlank, sBlank);
 310                 }
 311                 else if (m_aKeyCreator.isIntellectualPropertyPartKey(aKey))
 312                 {
 313                     m_aResults.emplace_back(svx::ClassificationType::INTELLECTUAL_PROPERTY_PART,
 314                                            svx::classification::getProperty(m_xPropertyContainer, aKey),
 315                                            sBlank, sBlank);
 316                 }
 317             }
 318         }
 319     }
 320
 321 public:
 322     ClassificationCollector(sd::DrawViewShell & rDrawViewShell, const css::uno::Reference<css::document::XDocumentProperties>& rDocProps)
 323         : ClassificationCommon(rDrawViewShell, rDocProps)
 324     {}
 325
 326     std::vector<svx::ClassificationResult> const & getResults() const
 327     {
 328         return m_aResults;
 329     }
 330
 331     void collect()
 332     {
 333         // Set to MASTER mode
 334         EditMode eOldMode = m_rDrawViewShell.GetEditMode();
 335         if (eOldMode != EditMode::MasterPage)
 336             m_rDrawViewShell.ChangeEditMode(EditMode::MasterPage, false);
 337
 338         // Scoped guard to revert to the previous mode
 339         comphelper::ScopeGuard const aGuard([this, eOldMode] () {
 340             m_rDrawViewShell.ChangeEditMode(eOldMode, false);
 341         });
 342
 343         const sal_uInt16 nCount = m_rDrawViewShell.GetDoc()->GetMasterSdPageCount(PageKind::Standard);
 344
 345         for (sal_uInt16 nPageIndex = 0; nPageIndex < nCount; ++nPageIndex)
 346         {
 347             SdPage* pMasterPage = m_rDrawViewShell.GetDoc()->GetMasterSdPage(nPageIndex, PageKind::Standard);
 348             for (const rtl::Reference<SdrObject>& pObject : *pMasterPage)
 349             {
 350                 SdrRectObj* pRectObject = dynamic_cast<SdrRectObj*>(pObject.get());
 351                 if (pRectObject && pRectObject->GetTextKind() == SdrObjKind::Text)
 352                 {
 353                     OutlinerParaObject* pOutlinerParagraphObject = pRectObject->GetOutlinerParaObject();
 354                     if (pOutlinerParagraphObject)
 355                     {
 356                         const EditTextObject& rEditText = pOutlinerParagraphObject->GetTextObject();
 357                         std::vector<editeng::Section> aSections;
 358                         rEditText.GetAllSections(aSections);
 359
 360                         // Search for a custom property field that has the classification category identifier key
 361                         if (hasCustomPropertyField(aSections, m_aKeyCreator.makeCategoryNameKey()))
 362                         {
 363                             iterateSectionsAndCollect(aSections, rEditText);
 364                             return;
 365                         }
 366                     }
 367                 }
 368             }
 369         }
 370     }
 371 };
 372
 373 class ClassificationInserter : public ClassificationCommon
 374 {
 375 private:
 376     /// Delete the previous existing classification object(s) - if they exist
 377     void deleteExistingObjects()
 378     {
 379         OUString sKey = m_aKeyCreator.makeCategoryNameKey();
 380
 381         const sal_uInt16 nCount = m_rDrawViewShell.GetDoc()->GetMasterSdPageCount(PageKind::Standard);
 382
 383         for (sal_uInt16 nPageIndex = 0; nPageIndex < nCount; ++nPageIndex)
 384         {
 385             SdPage* pMasterPage = m_rDrawViewShell.GetDoc()->GetMasterSdPage(nPageIndex, PageKind::Standard);
 386             for (const rtl::Reference<SdrObject>& pObject : *pMasterPage)
 387             {
 388                 SdrRectObj* pRectObject = dynamic_cast<SdrRectObj*>(pObject.get());
 389                 if (pRectObject && pRectObject->GetTextKind() == SdrObjKind::Text)
 390                 {
 391                     OutlinerParaObject* pOutlinerParagraphObject = pRectObject->GetOutlinerParaObject();
 392                     if (pOutlinerParagraphObject)
 393                     {
 394                         const EditTextObject& rEditText = pOutlinerParagraphObject->GetTextObject();
 395                         std::vector<editeng::Section> aSections;
 396                         rEditText.GetAllSections(aSections);
 397
 398                         if (hasCustomPropertyField(aSections, sKey))
 399                         {
 400                             pMasterPage->RemoveObject(pRectObject->GetOrdNum());
 401                         }
 402                     }
 403                 }
 404             }
 405         }
 406     }
 407
 408     void fillTheOutliner(Outliner* pOutliner, std::vector<svx::ClassificationResult> const & rResults)
 409     {
 410         sal_Int32 nParagraph = -1;
 411         for (svx::ClassificationResult const & rResult : rResults)
 412         {
 413
 414             ESelection aPosition(nParagraph, EE_TEXTPOS_MAX);
 415
 416             switch (rResult.meType)
 417             {
 418                 case svx::ClassificationType::TEXT:
 419                 {
 420                     OUString sKey = m_aKeyCreator.makeNumberedTextKey();
 421                     svx::classification::addOrInsertDocumentProperty(m_xPropertyContainer, sKey, rResult.msName);
 422                     pOutliner->QuickInsertField(SvxFieldItem(editeng::CustomPropertyField(sKey, rResult.msName), EE_FEATURE_FIELD), aPosition);
 423                 }
 424                 break;
 425
 426                 case svx::ClassificationType::CATEGORY:
 427                 {
 428                     OUString sKey = m_aKeyCreator.makeCategoryNameKey();
 429                     pOutliner->QuickInsertField(SvxFieldItem(editeng::CustomPropertyField(sKey, rResult.msName), EE_FEATURE_FIELD), aPosition);
 430                 }
 431                 break;
 432
 433                 case svx::ClassificationType::MARKING:
 434                 {
 435                     OUString sKey = m_aKeyCreator.makeNumberedMarkingKey();
 436                     svx::classification::addOrInsertDocumentProperty(m_xPropertyContainer, sKey, rResult.msName);
 437                     pOutliner->QuickInsertField(SvxFieldItem(editeng::CustomPropertyField(sKey, rResult.msName), EE_FEATURE_FIELD), aPosition);
 438                 }
 439                 break;
 440
 441                 case svx::ClassificationType::INTELLECTUAL_PROPERTY_PART:
 442                 {
 443                     OUString sKey = m_aKeyCreator.makeNumberedIntellectualPropertyPartKey();
 444                     svx::classification::addOrInsertDocumentProperty(m_xPropertyContainer, sKey, rResult.msName);
 445                     pOutliner->QuickInsertField(SvxFieldItem(editeng::CustomPropertyField(sKey, rResult.msName), EE_FEATURE_FIELD), aPosition);
 446                 }
 447                 break;
 448
 449                 case svx::ClassificationType::PARAGRAPH:
 450                 {
 451                     nParagraph++;
 452                     pOutliner->Insert(u""_ustr);
 453
 454                     SfxItemSetFixed<EE_ITEMS_START, EE_ITEMS_END> aItemSet(m_rDrawViewShell.GetDoc()->GetPool());
 455
 456                     if (rResult.msName == "BOLD")
 457                         aItemSet.Put(SvxWeightItem(WEIGHT_BOLD, EE_CHAR_WEIGHT));
 458                     else
 459                         aItemSet.Put(SvxWeightItem(WEIGHT_NORMAL, EE_CHAR_WEIGHT));
 460
 461                     SvxNumRule aDefaultNumRule(SvxNumRuleFlags::NONE, 0, false);
 462                     aItemSet.Put(SvxNumBulletItem(std::move(aDefaultNumRule), EE_PARA_NUMBULLET));
 463
 464                     pOutliner->SetParaAttribs(nParagraph, aItemSet);
 465                 }
 466                 break;
 467
 468                 default:
 469                 break;
 470             }
 471         }
 472     }
 473
 474 public:
 475     ClassificationInserter(sd::DrawViewShell & rDrawViewShell, const css::uno::Reference<css::document::XDocumentProperties>& rDocProps)
 476         : ClassificationCommon(rDrawViewShell, rDocProps)
 477     {
 478     }
 479
 480     void insert(std::vector<svx::ClassificationResult> const & rResults)
 481     {
 482         // Set to MASTER mode
 483         EditMode eOldMode = m_rDrawViewShell.GetEditMode();
 484         if (eOldMode != EditMode::MasterPage)
 485             m_rDrawViewShell.ChangeEditMode(EditMode::MasterPage, false);
 486
 487         // Scoped guard to revert the mode
 488         comphelper::ScopeGuard const aGuard([this, eOldMode] () {
 489             m_rDrawViewShell.ChangeEditMode(eOldMode, false);
 490         });
 491
 492         // Delete the previous existing object - if exists
 493         deleteExistingObjects();
 494
 495         // Clear properties
 496         svx::classification::removeAllProperties(m_xPropertyContainer);
 497
 498         SfxClassificationHelper aHelper(m_xDocumentProperties);
 499
 500         // Apply properties from the BA policy
 501         for (svx::ClassificationResult const & rResult : rResults)
 502         {
 503             if (rResult.meType == svx::ClassificationType::CATEGORY)
 504                 aHelper.SetBACName(rResult.msName, SfxClassificationHelper::getPolicyType());
 505         }
 506
 507         // Insert full text as document property
 508         svx::classification::insertFullTextualRepresentationAsDocumentProperty(m_xPropertyContainer, m_aKeyCreator, rResults);
 509
 510         // Create the outliner from the
 511         Outliner* pOutliner = m_rDrawViewShell.GetDoc()->GetInternalOutliner();
 512         OutlinerMode eOutlinerMode = pOutliner->GetOutlinerMode();
 513
 514         comphelper::ScopeGuard const aOutlinerGuard([pOutliner, eOutlinerMode] () {
 515             pOutliner->Init(eOutlinerMode);
 516         });
 517
 518         pOutliner->Init(OutlinerMode::TextObject);
 519
 520         // Fill the outliner with the text from classification result
 521         fillTheOutliner(pOutliner, rResults);
 522
 523         // Calculate to outliner text size
 524         pOutliner->UpdateFields();
 525         pOutliner->SetUpdateLayout(true);
 526         Size aTextSize(pOutliner->CalcTextSize());
 527         pOutliner->SetUpdateLayout(false);
 528
 529         // Create objects, apply the outliner and add them (objects) to all master pages
 530         const sal_uInt16 nCount = m_rDrawViewShell.GetDoc()->GetMasterSdPageCount(PageKind::Standard);
 531
 532         for (sal_uInt16 nPageIndex = 0; nPageIndex < nCount; ++nPageIndex)
 533         {
 534             SdPage* pMasterPage = m_rDrawViewShell.GetDoc()->GetMasterSdPage(nPageIndex, PageKind::Standard);
 535             if (!pMasterPage)
 536                 continue;
 537
 538             rtl::Reference<SdrRectObj> pObject = new SdrRectObj(
 539                 *m_rDrawViewShell.GetDoc(), // TTTT should be reference
 540                 SdrObjKind::Text);
 541             pObject->SetMergedItem(makeSdrTextAutoGrowWidthItem(true));
 542             pObject->SetOutlinerParaObject(pOutliner->CreateParaObject());
 543             pMasterPage->InsertObject(pObject.get());
 544
 545             // Calculate position
 546             ::tools::Rectangle aRectangle(Point(), pMasterPage->GetSize());
 547             Point aPosition(aRectangle.Center().X(), aRectangle.Bottom());
 548
 549             aPosition.AdjustX( -(aTextSize.Width() / 2) );
 550             aPosition.AdjustY( -(aTextSize.Height()) );
 551
 552             pObject->SetLogicRect(::tools::Rectangle(aPosition, aTextSize));
 553         }
 554     }
 555 };
 556
 557     void lcl_convertStringArguments(const std::unique_ptr<SfxItemSet>& pArgs)
 558     {
 559         const SfxPoolItem* pItem = nullptr;
 560
 561         if (SfxItemState::SET == pArgs->GetItemState(SID_ATTR_LINE_WIDTH_ARG, false, &pItem))
 562         {
 563             double fValue = static_cast<const SvxDoubleItem*>(pItem)->GetValue();
 564             // FIXME: different units...
 565             int nPow = 100;
 566             int nValue = fValue * nPow;
 567
 568             XLineWidthItem aItem(nValue);
 569             pArgs->Put(aItem);
 570         }
 571         if (SfxItemState::SET == pArgs->GetItemState(SID_FILL_GRADIENT_JSON, false, &pItem))
 572         {
 573             const SfxStringItem* pJSON = static_cast<const SfxStringItem*>(pItem);
 574             if (pJSON)
 575             {
 576                 basegfx::BGradient aGradient = basegfx::BGradient::fromJSON(pJSON->GetValue());
 577                 XFillGradientItem aItem(aGradient);
 578                 pArgs->Put(aItem);
 579             }
 580         }
 581     }
 582 }
 583
 584 /**
 585  * SfxRequests for temporary actions
 586  */
 587
 588 void DrawViewShell::FuTemporary(SfxRequest& rReq)
 589 {
 590     // during a native slide show nothing gets executed!
 591     if(SlideShow::IsRunning( GetViewShellBase() )
 592         && !SlideShow::IsInteractiveSlideshow( &GetViewShellBase() ) // IASS
 593         && (rReq.GetSlot() != SID_NAVIGATOR))
 594         return;
 595
 596     DBG_ASSERT( mpDrawView, "sd::DrawViewShell::FuTemporary(), no draw view!" );
 597     if( !mpDrawView )
 598         return;
 599
 600     CheckLineTo (rReq);
 601
 602     DeactivateCurrentFunction();
 603
 604     sal_uInt16 nSId = rReq.GetSlot();
 605     const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
 606
 607     switch ( nSId )
 608     {
 609         case SID_OUTLINE_TEXT_AUTOFIT:
 610         {
 611             SfxUndoManager* pUndoManager = GetDocSh()->GetUndoManager();
 612             if( rMarkList.GetMarkCount() == 1 )
 613             {
 614                 pUndoManager->EnterListAction(u""_ustr, u""_ustr, 0, GetViewShellBase().GetViewShellId());
 615                 mpDrawView->BegUndo();
 616
 617                 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 618                 bool bSet = pObj->GetMergedItemSet().GetItem<SdrTextFitToSizeTypeItem>(SDRATTR_TEXT_FITTOSIZE)->GetValue() != drawing::TextFitToSizeType_NONE;
 619
 620                 mpDrawView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoAttrObject(*pObj));
 621
 622                 if (!bSet)
 623                 {
 624                     //If we are turning on AutoFit we have to turn these off if already on
 625                     if (pObj->GetMergedItemSet().GetItem<SdrOnOffItem>(SDRATTR_TEXT_AUTOGROWHEIGHT)->GetValue())
 626                         pObj->SetMergedItem(makeSdrTextAutoGrowHeightItem(false));
 627                     if (pObj->GetMergedItemSet().GetItem<SdrOnOffItem>(SDRATTR_TEXT_AUTOGROWWIDTH)->GetValue())
 628                         pObj->SetMergedItem(makeSdrTextAutoGrowWidthItem(false));
 629                 }
 630
 631                 pObj->SetMergedItem(SdrTextFitToSizeTypeItem(bSet ? drawing::TextFitToSizeType_NONE : drawing::TextFitToSizeType_AUTOFIT));
 632
 633                 mpDrawView->EndUndo();
 634                 pUndoManager->LeaveListAction();
 635             }
 636             Cancel();
 637             rReq.Done();
 638         }
 639         break;
 640
 641         // area and line attributes: shall have
 642         // an own Execute method (like StateMethode)
 643         case SID_ATTR_FILL_STYLE:
 644         case SID_ATTR_FILL_COLOR:
 645         case SID_ATTR_FILL_GRADIENT:
 646         case SID_ATTR_FILL_HATCH:
 647         case SID_ATTR_FILL_BITMAP:
 648         case SID_ATTR_FILL_SHADOW:
 649         case SID_ATTR_SHADOW_COLOR:
 650         case SID_ATTR_SHADOW_TRANSPARENCE:
 651         case SID_ATTR_SHADOW_BLUR:
 652         case SID_ATTR_SHADOW_XDISTANCE:
 653         case SID_ATTR_SHADOW_YDISTANCE:
 654         case SID_ATTR_FILL_USE_SLIDE_BACKGROUND:
 655         case SID_ATTR_FILL_TRANSPARENCE:
 656         case SID_ATTR_FILL_FLOATTRANSPARENCE:
 657
 658         case SID_ATTR_LINE_STYLE:
 659         case SID_ATTR_LINE_DASH:
 660         case SID_ATTR_LINE_WIDTH:
 661         case SID_ATTR_LINE_COLOR:
 662         case SID_ATTR_LINEEND_STYLE:
 663         case SID_ATTR_LINE_START:
 664         case SID_ATTR_LINE_END:
 665         case SID_ATTR_LINE_TRANSPARENCE:
 666         case SID_ATTR_LINE_JOINT:
 667         case SID_ATTR_LINE_CAP:
 668
 669         case SID_ATTR_TEXT_FITTOSIZE:
 670         {
 671             if( rReq.GetArgs() )
 672             {
 673                 std::unique_ptr<SfxItemSet> pNewArgs = rReq.GetArgs()->Clone();
 674                 if (nSId == SID_ATTR_FILL_COLOR)
 675                 {
 676                     const XFillStyleItem aXFillStyleItem;
 677                     pNewArgs->Put(aXFillStyleItem);
 678                 }
 679                 lcl_convertStringArguments(pNewArgs);
 680                 mpDrawView->SetAttributes(*pNewArgs);
 681                 rReq.Done();
 682             }
 683             else
 684             {
 685                 switch( rReq.GetSlot() )
 686                 {
 687                     case SID_ATTR_FILL_SHADOW:
 688                     case SID_ATTR_SHADOW_COLOR:
 689                     case SID_ATTR_SHADOW_TRANSPARENCE:
 690                     case SID_ATTR_SHADOW_BLUR:
 691                     case SID_ATTR_SHADOW_XDISTANCE:
 692                     case SID_ATTR_SHADOW_YDISTANCE:
 693                     case SID_ATTR_FILL_STYLE:
 694                     case SID_ATTR_FILL_COLOR:
 695                     case SID_ATTR_FILL_GRADIENT:
 696                     case SID_ATTR_FILL_HATCH:
 697                     case SID_ATTR_FILL_BITMAP:
 698                     case SID_ATTR_FILL_USE_SLIDE_BACKGROUND:
 699                     case SID_ATTR_FILL_TRANSPARENCE:
 700                     case SID_ATTR_FILL_FLOATTRANSPARENCE:
 701                         GetViewFrame()->GetDispatcher()->Execute( SID_ATTRIBUTES_AREA, SfxCallMode::ASYNCHRON );
 702                         break;
 703                     case SID_ATTR_LINE_STYLE:
 704                     case SID_ATTR_LINE_DASH:
 705                     case SID_ATTR_LINE_WIDTH:
 706                     case SID_ATTR_LINE_COLOR:
 707                     case SID_ATTR_LINE_TRANSPARENCE:
 708                     case SID_ATTR_LINE_JOINT:
 709                     case SID_ATTR_LINE_CAP:
 710                         GetViewFrame()->GetDispatcher()->Execute( SID_ATTRIBUTES_LINE, SfxCallMode::ASYNCHRON );
 711                         break;
 712                     case SID_ATTR_TEXT_FITTOSIZE:
 713                         GetViewFrame()->GetDispatcher()->Execute( SID_TEXTATTR_DLG, SfxCallMode::ASYNCHRON );
 714                         break;
 715                 }
 716             }
 717             Cancel();
 718         }
 719         break;
 720
 721         case SID_HYPHENATION:
 722         {
 723             const SfxBoolItem* pItem = rReq.GetArg<SfxBoolItem>(SID_HYPHENATION);
 724
 725             if( pItem )
 726             {
 727                 SfxItemSetFixed<EE_PARA_HYPHENATE, EE_PARA_HYPHENATE> aSet( GetPool() );
 728                 bool bValue = pItem->GetValue();
 729                 aSet.Put( SfxBoolItem( EE_PARA_HYPHENATE, bValue ) );
 730                 mpDrawView->SetAttributes( aSet );
 731             }
 732             else // only for testing purpose
 733             {
 734                 OSL_FAIL(" no value for hyphenation!");
 735                 SfxItemSetFixed<EE_PARA_HYPHENATE, EE_PARA_HYPHENATE> aSet( GetPool() );
 736                 aSet.Put( SfxBoolItem( EE_PARA_HYPHENATE, true ) );
 737                 mpDrawView->SetAttributes( aSet );
 738             }
 739             rReq.Done();
 740             Cancel();
 741         }
 742         break;
 743
 744         case SID_INSERTPAGE:
 745         case SID_INSERTPAGE_QUICK:
 746         {
 747             SdPage* pNewPage = CreateOrDuplicatePage (rReq, mePageKind, GetActualPage());
 748             Cancel();
 749             if(HasCurrentFunction(SID_BEZIER_EDIT) )
 750                 GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
 751             if (pNewPage != nullptr)
 752                 SwitchPage((pNewPage->GetPageNum()-1)/2);
 753             rReq.Done ();
 754         }
 755         break;
 756
 757         case SID_DUPLICATE_PAGE:
 758         {
 759             auto slideSorter = sd::slidesorter::SlideSorterViewShell::GetSlideSorter(GetViewShellBase());
 760             SdPage* pNewPage = nullptr;
 761             if(slideSorter)
 762                 DuplicateSelectedSlides(rReq);
 763             else
 764                 pNewPage = CreateOrDuplicatePage (rReq, mePageKind, GetActualPage());
 765             Cancel();
 766             if(HasCurrentFunction(SID_BEZIER_EDIT) )
 767                 GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
 768             if(!slideSorter && pNewPage != nullptr)
 769                 SwitchPage((pNewPage->GetPageNum()-1)/2);
 770             rReq.Done();
 771         }
 772         break;
 773
 774         case SID_INSERT_MASTER_PAGE:
 775         {
 776             // Use the API to create a new page.
 777             rtl::Reference<SdXImpressDocument> xMasterPagesSupplier (
 778                 GetDoc()->getUnoModel());
 779             if (xMasterPagesSupplier.is())
 780             {
 781                 Reference<drawing::XDrawPages> xMasterPages (
 782                     xMasterPagesSupplier->getMasterPages());
 783                 if (xMasterPages.is())
 784                 {
 785                     sal_uInt16 nIndex = GetCurPagePos() + 1;
 786                     xMasterPages->insertNewByIndex (nIndex);
 787
 788                     // Create shapes for the default layout.
 789                     SdPage* pMasterPage = GetDoc()->GetMasterSdPage(
 790                         nIndex, PageKind::Standard);
 791                     pMasterPage->CreateTitleAndLayout (true,true);
 792                 }
 793             }
 794
 795             Cancel();
 796             if(HasCurrentFunction(SID_BEZIER_EDIT))
 797                 GetViewFrame()->GetDispatcher()->Execute(
 798                     SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
 799             rReq.Done ();
 800         }
 801         break;
 802
 803         case SID_MODIFYPAGE:
 804         {
 805             if (mePageKind==PageKind::Standard || mePageKind==PageKind::Notes ||
 806                 (mePageKind==PageKind::Handout && meEditMode==EditMode::MasterPage) )
 807             {
 808                 if ( mpDrawView->IsTextEdit() )
 809                 {
 810                     mpDrawView->SdrEndTextEdit();
 811                 }
 812                 sal_uInt16 nPage = maTabControl->GetCurPagePos();
 813                 mpActualPage = GetDoc()->GetSdPage(nPage, mePageKind);
 814                 ::sd::ViewShell::mpImpl->ProcessModifyPageSlot (
 815                     rReq,
 816                     mpActualPage,
 817                     mePageKind);
 818             }
 819
 820             Cancel();
 821             rReq.Done ();
 822         }
 823         break;
 824
 825         case SID_ASSIGN_LAYOUT:
 826         {
 827             if (mePageKind==PageKind::Standard || mePageKind==PageKind::Notes || (mePageKind==PageKind::Handout && meEditMode==EditMode::MasterPage))
 828             {
 829                 if ( mpDrawView->IsTextEdit() )
 830                     mpDrawView->SdrEndTextEdit();
 831
 832                 ::sd::ViewShell::mpImpl->AssignLayout(rReq, mePageKind);
 833             }
 834             Cancel();
 835             rReq.Done ();
 836         }
 837         break;
 838
 839         case SID_RENAMEPAGE:
 840         case SID_RENAME_MASTER_PAGE:
 841         {
 842             if (mePageKind==PageKind::Standard || mePageKind==PageKind::Notes )
 843             {
 844                 if ( mpDrawView->IsTextEdit() )
 845                 {
 846                     mpDrawView->SdrEndTextEdit();
 847                 }
 848
 849                 sal_uInt16 nPage = maTabControl->GetCurPagePos();
 850                 SdPage* pCurrentPage = ( GetEditMode() == EditMode::Page )
 851                     ? GetDoc()->GetSdPage( nPage, GetPageKind() )
 852                     : GetDoc()->GetMasterSdPage( nPage, GetPageKind() );
 853
 854                 OUString aTitle = SdResId(STR_TITLE_RENAMESLIDE);
 855                 OUString aDescr = SdResId(STR_DESC_RENAMESLIDE);
 856                 const OUString& aPageName = pCurrentPage->GetName();
 857
 858                 if(rReq.GetArgs())
 859                 {
 860                     OUString aName = rReq.GetArgs()->GetItem<const SfxStringItem>(SID_RENAMEPAGE)->GetValue();
 861
 862                     bool bResult = RenameSlide( maTabControl->GetPageId(nPage), aName );
 863                     DBG_ASSERT( bResult, "Couldn't rename slide" );
 864                 }
 865                 else
 866                 {
 867                     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 868                     ScopedVclPtr<AbstractSvxNameDialog> aNameDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aPageName, aDescr));
 869                     aNameDlg->SetText( aTitle );
 870                     aNameDlg->SetCheckNameHdl( LINK( this, DrawViewShell, RenameSlideHdl ) );
 871                     aNameDlg->SetEditHelpId( HID_SD_NAMEDIALOG_PAGE );
 872
 873                     if( aNameDlg->Execute() == RET_OK )
 874                     {
 875                         OUString aNewName = aNameDlg->GetName();
 876                         if (aNewName != aPageName)
 877                         {
 878                             bool bResult = RenameSlide( maTabControl->GetPageId(nPage), aNewName );
 879                             DBG_ASSERT( bResult, "Couldn't rename slide" );
 880                         }
 881                     }
 882                 }
 883             }
 884             Cancel();
 885             rReq.Ignore();
 886         }
 887         break;
 888
 889         case SID_RENAMEPAGE_QUICK:
 890         {
 891             if (mePageKind==PageKind::Standard || mePageKind==PageKind::Notes )
 892             {
 893                 if ( mpDrawView->IsTextEdit() )
 894                 {
 895                     mpDrawView->SdrEndTextEdit();
 896                 }
 897
 898                 maTabControl->StartEditMode( maTabControl->GetCurPageId() );
 899             }
 900
 901             Cancel();
 902             rReq.Ignore ();
 903         }
 904         break;
 905
 906         case SID_PAGESIZE :  // either this (no menu entries or something else!)
 907         {
 908             const SfxItemSet *pArgs = rReq.GetArgs ();
 909
 910             if (pArgs && pArgs->Count () == 3)
 911             {
 912                 const SfxUInt32Item* pWidth = rReq.GetArg<SfxUInt32Item>(ID_VAL_PAGEWIDTH);
 913                 const SfxUInt32Item* pHeight = rReq.GetArg<SfxUInt32Item>(ID_VAL_PAGEHEIGHT);
 914                 const SfxBoolItem* pScaleAll = rReq.GetArg<SfxBoolItem>(ID_VAL_SCALEOBJECTS);
 915
 916                 Size aSize (pWidth->GetValue (), pHeight->GetValue ());
 917
 918                 SetupPage (aSize, 0, 0, 0, 0, true, false, pScaleAll->GetValue ());
 919                 rReq.Ignore ();
 920                 break;
 921             }
 922 #if HAVE_FEATURE_SCRIPTING
 923             StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
 924 #endif
 925             rReq.Ignore ();
 926             break;
 927         }
 928
 929         case SID_PAGEMARGIN :  // or this (no menu entries or something else!)
 930         {
 931             const SfxItemSet *pArgs = rReq.GetArgs ();
 932
 933             if (pArgs && pArgs->Count () == 5)
 934             {
 935                 const SfxUInt32Item* pLeft = rReq.GetArg<SfxUInt32Item>(ID_VAL_PAGELEFT);
 936                 const SfxUInt32Item* pRight = rReq.GetArg<SfxUInt32Item>(ID_VAL_PAGERIGHT);
 937                 const SfxUInt32Item* pUpper = rReq.GetArg<SfxUInt32Item>(ID_VAL_PAGETOP);
 938                 const SfxUInt32Item* pLower = rReq.GetArg<SfxUInt32Item>(ID_VAL_PAGEBOTTOM);
 939                 const SfxBoolItem* pScaleAll = rReq.GetArg<SfxBoolItem>(ID_VAL_SCALEOBJECTS);
 940
 941                 Size aEmptySize (0, 0);
 942
 943                 SetupPage (aEmptySize, pLeft->GetValue (), pRight->GetValue (),
 944                            pUpper->GetValue (), pLower->GetValue (),
 945                            false, true, pScaleAll->GetValue ());
 946                 rReq.Ignore ();
 947                 break;
 948             }
 949 #if HAVE_FEATURE_SCRIPTING
 950             StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
 951 #endif
 952             rReq.Ignore ();
 953             break;
 954         }
 955
 956         case SID_ATTR_ZOOMSLIDER:
 957         {
 958             const SfxItemSet* pArgs = rReq.GetArgs();
 959
 960             const SfxUInt16Item* pScale = (pArgs && pArgs->Count () == 1) ?
 961                 rReq.GetArg(SID_ATTR_ZOOMSLIDER) : nullptr;
 962             if (pScale && CHECK_RANGE (5, pScale->GetValue (), 3000))
 963             {
 964                 SetZoom (pScale->GetValue ());
 965
 966                 SfxBindings& rBindings = GetViewFrame()->GetBindings();
 967                 rBindings.Invalidate( SID_ATTR_ZOOM );
 968                 rBindings.Invalidate( SID_ZOOM_IN );
 969                 rBindings.Invalidate( SID_ZOOM_OUT );
 970                 rBindings.Invalidate( SID_ATTR_ZOOMSLIDER );
 971
 972             }
 973
 974             Cancel();
 975             rReq.Done ();
 976             break;
 977         }
 978
 979         case SID_ATTR_ZOOM:
 980         {
 981             const SfxItemSet* pArgs = rReq.GetArgs();
 982             mbZoomOnPage = false;
 983
 984             if ( pArgs )
 985             {
 986                 SvxZoomType eZT = pArgs->Get( SID_ATTR_ZOOM ).GetType();
 987                 switch( eZT )
 988                 {
 989                     case SvxZoomType::PERCENT:
 990                         SetZoom( static_cast<::tools::Long>( pArgs->Get( SID_ATTR_ZOOM ).GetValue()) );
 991                         break;
 992
 993                     case SvxZoomType::OPTIMAL:
 994                         GetViewFrame()->GetDispatcher()->Execute( SID_SIZE_ALL,
 995                                     SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
 996                         break;
 997
 998                     case SvxZoomType::PAGEWIDTH:
 999                         GetViewFrame()->GetDispatcher()->Execute( SID_SIZE_PAGE_WIDTH,
1000                                     SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
1001                         break;
1002
1003                     case SvxZoomType::WHOLEPAGE:
1004                         GetViewFrame()->GetDispatcher()->Execute( SID_SIZE_PAGE,
1005                                     SfxCallMode::ASYNCHRON | SfxCallMode::RECORD );
1006                         break;
1007                     case SvxZoomType::PAGEWIDTH_NOBORDER:
1008                         OSL_FAIL("sd::DrawViewShell::FuTemporary(), SvxZoomType::PAGEWIDTH_NOBORDER not handled!" );
1009                         break;
1010                 }
1011                 rReq.Ignore ();
1012             }
1013             else
1014             {
1015                 // open zoom dialog
1016                 SetCurrentFunction( FuScale::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1017             }
1018             Cancel();
1019         }
1020         break;
1021
1022         case SID_CHANGEBEZIER:
1023         case SID_CHANGEPOLYGON:
1024             if ( mpDrawView->IsTextEdit() )
1025             {
1026                 mpDrawView->SdrEndTextEdit();
1027                 GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
1028             }
1029
1030             if ( mpDrawView->IsPresObjSelected() )
1031             {
1032                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
1033                                                               VclMessageType::Info, VclButtonsType::Ok,
1034                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
1035                 xInfoBox->run();
1036             }
1037             else
1038             {
1039                 if( rReq.GetSlot() == SID_CHANGEBEZIER )
1040                 {
1041                     weld::WaitObject aWait(GetFrameWeld());
1042                     mpDrawView->ConvertMarkedToPathObj(false);
1043                 }
1044                 else
1045                 {
1046                     if( mpDrawView->IsVectorizeAllowed() )
1047                     {
1048                         SetCurrentFunction( FuVectorize::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1049                     }
1050                     else
1051                     {
1052                         weld::WaitObject aWait(GetFrameWeld());
1053                         mpDrawView->ConvertMarkedToPolyObj();
1054                     }
1055                 }
1056
1057                 Invalidate(SID_CHANGEBEZIER);
1058                 Invalidate(SID_CHANGEPOLYGON);
1059             }
1060             Cancel();
1061
1062             if( HasCurrentFunction(SID_BEZIER_EDIT) )
1063             {   // where applicable, activate right edit action
1064                 GetViewFrame()->GetDispatcher()->Execute(SID_SWITCH_POINTEDIT,
1065                                         SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
1066             }
1067             rReq.Ignore ();
1068             break;
1069
1070         case SID_CONVERT_TO_CONTOUR:
1071             if ( mpDrawView->IsTextEdit() )
1072             {
1073                 mpDrawView->SdrEndTextEdit();
1074                 GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
1075             }
1076
1077             if ( mpDrawView->IsPresObjSelected() )
1078             {
1079                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
1080                                                               VclMessageType::Info, VclButtonsType::Ok,
1081                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
1082                 xInfoBox->run();
1083             }
1084             else
1085             {
1086                 weld::WaitObject aWait(GetFrameWeld());
1087                 mpDrawView->ConvertMarkedToPathObj(true);
1088
1089                 Invalidate(SID_CONVERT_TO_CONTOUR);
1090             }
1091             Cancel();
1092
1093             rReq.Ignore ();
1094             break;
1095
1096         case SID_CONVERT_TO_METAFILE:
1097         case SID_CONVERT_TO_BITMAP:
1098         {
1099             // End text edit mode when it is active because the metafile or
1100             // bitmap that will be created does not support it.
1101             if ( mpDrawView->IsTextEdit() )
1102             {
1103                 mpDrawView->SdrEndTextEdit();
1104                 GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
1105             }
1106
1107             if ( mpDrawView->IsPresObjSelected(true,true,true) )
1108             {
1109                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
1110                                                               VclMessageType::Info, VclButtonsType::Ok,
1111                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
1112                 xInfoBox->run();
1113             }
1114             else
1115             {
1116                 weld::WaitObject aWait(GetFrameWeld());
1117
1118                 // create SdrGrafObj from metafile/bitmap
1119                 Graphic aGraphic;
1120                 switch (nSId)
1121                 {
1122                     case SID_CONVERT_TO_METAFILE:
1123                     {
1124                         // switch on undo for the next operations
1125                         mpDrawView->BegUndo(SdResId(STR_UNDO_CONVERT_TO_METAFILE));
1126                         GDIMetaFile aMetaFile(mpDrawView->GetMarkedObjMetaFile());
1127                         aGraphic = Graphic(aMetaFile);
1128                     }
1129                     break;
1130                     case SID_CONVERT_TO_BITMAP:
1131                     {
1132                         // Disable spelling during conversion
1133                         bool bOnlineSpell = GetDoc()->GetOnlineSpell();
1134                         GetDoc()->SetOnlineSpell(false);
1135
1136                         // switch on undo for the next operations
1137                         mpDrawView->BegUndo(SdResId(STR_UNDO_CONVERT_TO_BITMAP));
1138                         aGraphic = Graphic(mpDrawView->GetMarkedObjBitmapEx());
1139                         // Restore online spelling
1140                         GetDoc()->SetOnlineSpell(bOnlineSpell);
1141                     }
1142                     break;
1143                 }
1144
1145                 // create new object
1146                 rtl::Reference<SdrGrafObj> pGraphicObj = new SdrGrafObj(
1147                     *GetDoc(),
1148                     aGraphic);
1149
1150                 // get some necessary info and ensure it
1151                 const size_t nMarkCount(rMarkList.GetMarkCount());
1152                 SdrPageView* pPageView = mpDrawView->GetSdrPageView();
1153                 OSL_ENSURE(nMarkCount, "DrawViewShell::FuTemporary: SID_CONVERT_TO_BITMAP with empty selection (!)");
1154                 OSL_ENSURE(pPageView, "DrawViewShell::FuTemporary: SID_CONVERT_TO_BITMAP without SdrPageView (!)");
1155
1156                 // fit rectangle of new graphic object to selection's mark rect
1157                 ::tools::Rectangle aAllMarkedRect;
1158                 rMarkList.TakeBoundRect(pPageView, aAllMarkedRect);
1159                 pGraphicObj->SetLogicRect(aAllMarkedRect);
1160
1161                 // #i71540# to keep the order, it is necessary to replace the lowest object
1162                 // of the selection with the new object. This also means that with multi
1163                 // selection, all other objects need to be deleted first
1164                 SdrMark* pFirstMark = rMarkList.GetMark(0);
1165                 SdrObject* pReplacementCandidate = pFirstMark->GetMarkedSdrObj();
1166
1167                 if(nMarkCount > 1)
1168                 {
1169                     // take first object out of selection
1170                     mpDrawView->MarkObj(pReplacementCandidate, pPageView, true, true);
1171
1172                     // clear remaining selection
1173                     mpDrawView->DeleteMarkedObj();
1174                 }
1175
1176                 // #i124816# copy layer from lowest object which gets replaced
1177                 pGraphicObj->SetLayer(pReplacementCandidate->GetLayer());
1178
1179                 // now replace lowest object with new one
1180                 mpDrawView->ReplaceObjectAtView(pReplacementCandidate, *pPageView, pGraphicObj.get());
1181
1182                 // switch off undo
1183                 mpDrawView->EndUndo();
1184             }
1185         }
1186
1187         Cancel();
1188
1189         rReq.Done ();
1190         break;
1191
1192         case SID_REMOVE_HYPERLINK:
1193         {
1194             if (mpDrawView->IsTextEdit())
1195             {
1196                 OutlinerView* pOutView = mpDrawView->GetTextEditOutlinerView();
1197                 if (pOutView)
1198                     URLFieldHelper::RemoveURLField(pOutView->GetEditView());
1199             }
1200         }
1201         Cancel();
1202         rReq.Done ();
1203         break;
1204
1205         case SID_SET_DEFAULT:
1206         {
1207             std::optional<SfxItemSet> pSet;
1208
1209             if (mpDrawView->IsTextEdit())
1210             {
1211                 pSet.emplace( GetPool(), svl::Items<EE_ITEMS_START, EE_ITEMS_END> );
1212                 mpDrawView->SetAttributes( *pSet, true );
1213             }
1214             else
1215             {
1216                 const size_t nCount = rMarkList.GetMarkCount();
1217
1218                 // For every presentation object a SfxItemSet of hard attributes
1219                 // and the UserCall is stored in this list. This is because
1220                 // at the following mpDrawView->SetAttributes( *pSet, sal_True )
1221                 // they get lost and have to be restored.
1222                 std::vector<std::pair<std::unique_ptr<SfxItemSet>,SdrObjUserCall*> > aAttrList;
1223                 SdPage* pPresPage = static_cast<SdPage*>( mpDrawView->GetSdrPageView()->GetPage() );
1224
1225                 for ( size_t i = 0; i < nCount; ++i )
1226                 {
1227                     SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1228
1229                     if( pPresPage->IsPresObj( pObj ) )
1230                     {
1231                         auto pNewSet = std::make_unique<SfxItemSetFixed<SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT>>( GetDoc()->GetPool() );
1232                         pNewSet->Put(pObj->GetMergedItemSet());
1233                         aAttrList.emplace_back(std::move(pNewSet), pObj->GetUserCall());
1234                     }
1235                 }
1236
1237                 pSet.emplace( GetPool() );
1238                 mpDrawView->SetAttributes( *pSet, true );
1239
1240                 sal_uLong j = 0;
1241
1242                 for ( size_t i = 0; i < nCount; ++i )
1243                 {
1244                     SfxStyleSheet* pSheet = nullptr;
1245                     SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1246
1247                     if (pObj->GetObjIdentifier() == SdrObjKind::TitleText)
1248                     {
1249                         pSheet = mpActualPage->GetStyleSheetForPresObj(PresObjKind::Title);
1250                         if (pSheet)
1251                             pObj->SetStyleSheet(pSheet, false);
1252                     }
1253                     else if(pObj->GetObjIdentifier() == SdrObjKind::OutlineText)
1254                     {
1255                         for (sal_uInt16 nLevel = 1; nLevel < 10; nLevel++)
1256                         {
1257                             pSheet = mpActualPage->GetStyleSheetForPresObj( PresObjKind::Outline );
1258                             DBG_ASSERT(pSheet, "Template for outline object not found");
1259                             if (pSheet)
1260                             {
1261                                 pObj->StartListening(*pSheet);
1262
1263                                 if( nLevel == 1 )
1264                                     // text frame listens on StyleSheet of level1
1265                                     pObj->NbcSetStyleSheet(pSheet, false);
1266                             }
1267                         }
1268                     }
1269
1270                     if( pPresPage->IsPresObj( pObj ) )
1271                     {
1272                         std::pair<std::unique_ptr<SfxItemSet>,SdrObjUserCall*> &rAttr = aAttrList[j++];
1273
1274                         std::unique_ptr<SfxItemSet> & pNewSet(rAttr.first);
1275                         SdrObjUserCall* pUserCall = rAttr.second;
1276
1277                         if ( pNewSet && pNewSet->GetItemState( SDRATTR_TEXT_MINFRAMEHEIGHT ) == SfxItemState::SET )
1278                         {
1279                             pObj->SetMergedItem(pNewSet->Get(SDRATTR_TEXT_MINFRAMEHEIGHT));
1280                         }
1281
1282                         if ( pNewSet && pNewSet->GetItemState( SDRATTR_TEXT_AUTOGROWHEIGHT ) == SfxItemState::SET )
1283                         {
1284                             pObj->SetMergedItem(pNewSet->Get(SDRATTR_TEXT_AUTOGROWHEIGHT));
1285                         }
1286
1287                         if( pUserCall )
1288                             pObj->SetUserCall( pUserCall );
1289                     }
1290                 }
1291             }
1292
1293             pSet.reset();
1294             Cancel();
1295         }
1296         break;
1297
1298         case SID_DELETE_SNAPITEM:
1299         {
1300             SdrPageView* pPV;
1301             Point   aMPos = GetActiveWindow()->PixelToLogic( maMousePos );
1302             sal_uInt16  nHitLog = static_cast<sal_uInt16>(GetActiveWindow()->PixelToLogic( Size(
1303                 FuPoor::HITPIX, 0 ) ).Width());
1304             sal_uInt16  nHelpLine;
1305
1306             if( mpDrawView->PickHelpLine( aMPos, nHitLog, *GetActiveWindow()->GetOutDev(), nHelpLine, pPV) )
1307             {
1308                 pPV->DeleteHelpLine( nHelpLine );
1309             }
1310             Cancel();
1311             rReq.Ignore ();
1312         }
1313         break;
1314
1315         case SID_DELETE_PAGE:
1316         case SID_DELETE_MASTER_PAGE:
1317             DeleteActualPage();
1318             Cancel();
1319             rReq.Ignore ();
1320         break;
1321
1322         case SID_DELETE_LAYER:
1323             DeleteActualLayer();
1324             Cancel();
1325             rReq.Ignore ();
1326         break;
1327
1328         case SID_ORIGINAL_SIZE:
1329             mpDrawView->SetMarkedOriginalSize();
1330             Cancel();
1331             rReq.Done();
1332         break;
1333
1334         case SID_DRAW_FONTWORK:
1335         case SID_DRAW_FONTWORK_VERTICAL:
1336         {
1337             svx::FontworkBar::execute(*mpView, rReq, GetViewFrame()->GetBindings());       // SJ: can be removed  (I think)
1338             Cancel();
1339             rReq.Done();
1340         }
1341         break;
1342
1343         case SID_SAVE_GRAPHIC:
1344         {
1345             if( rMarkList.GetMarkCount() == 1 )
1346             {
1347                 if (const SdrGrafObj* pObj = dynamic_cast<const SdrGrafObj*>(rMarkList.GetMark(0)->GetMarkedSdrObj()))
1348                     if (pObj->GetGraphicType() == GraphicType::Bitmap || pObj->GetGraphicType() == GraphicType::GdiMetafile)
1349                     {
1350                         weld::Window* pFrame = GetFrameWeld();
1351                         GraphicAttr aGraphicAttr = pObj->GetGraphicAttr();
1352                         short nState = RET_CANCEL;
1353                         if (aGraphicAttr != GraphicAttr()) // the image has been modified
1354                         {
1355                             if (pFrame)
1356                             {
1357                                 nState = GraphicHelper::HasToSaveTransformedImage(pFrame);
1358                             }
1359                         }
1360                         else
1361                         {
1362                             nState = RET_NO;
1363                         }
1364
1365                         if (nState == RET_YES)
1366                         {
1367                             GraphicHelper::ExportGraphic(pFrame, pObj->GetTransformedGraphic(), u""_ustr);
1368                         }
1369                         else if (nState == RET_NO)
1370                         {
1371                             const GraphicObject& aGraphicObject(pObj->GetGraphicObject());
1372                             GraphicHelper::ExportGraphic(pFrame, aGraphicObject.GetGraphic(), u""_ustr);
1373                         }
1374                     }
1375             }
1376             Cancel();
1377             rReq.Ignore();
1378         }
1379         break;
1380
1381         case SID_EXTERNAL_EDIT:
1382         {
1383             if( rMarkList.GetMarkCount() == 1 )
1384             {
1385                 SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
1386                 if( auto pGraphicObj = dynamic_cast<SdrGrafObj*>( pObj ) )
1387                     if( pGraphicObj->GetGraphicType() == GraphicType::Bitmap )
1388                     {
1389                         GraphicObject aGraphicObject( pGraphicObj->GetGraphicObject() );
1390                         m_ExternalEdits.push_back(
1391                             std::make_unique<SdrExternalToolEdit>(
1392                                 mpDrawView.get(), pGraphicObj));
1393                         m_ExternalEdits.back()->Edit( &aGraphicObject );
1394                     }
1395             }
1396             Cancel();
1397             rReq.Ignore();
1398         }
1399         break;
1400
1401         case SID_COMPRESS_GRAPHIC:
1402         {
1403             if( rMarkList.GetMarkCount() == 1 )
1404             {
1405                 SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
1406
1407                 if( auto pGraphicObj = dynamic_cast<SdrGrafObj*>( pObj ) )
1408                     if( pGraphicObj->GetGraphicType() == GraphicType::Bitmap )
1409                     {
1410                         CompressGraphicsDialog dialog(GetFrameWeld(), pGraphicObj, GetViewFrame()->GetBindings() );
1411                         if (dialog.run() == RET_OK)
1412                         {
1413                             rtl::Reference<SdrGrafObj> pNewObject = dialog.GetCompressedSdrGrafObj();
1414                             SdrPageView* pPageView = mpDrawView->GetSdrPageView();
1415                             OUString aUndoString = rMarkList.GetMarkDescription() + " Compress";
1416                             mpDrawView->BegUndo( aUndoString );
1417                             mpDrawView->ReplaceObjectAtView( pObj, *pPageView, pNewObject.get() );
1418                             mpDrawView->EndUndo();
1419                         }
1420                     }
1421             }
1422             Cancel();
1423             rReq.Ignore();
1424         }
1425         break;
1426
1427         case SID_GRAPHIC_SIZE_CHECK:
1428         {
1429             sd::GraphicSizeCheckGUIResult aResult(GetDoc());
1430             svx::GenericCheckDialog aDialog(GetFrameWeld(), aResult);
1431             aDialog.run();
1432
1433             Cancel();
1434             rReq.Ignore();
1435         }
1436         break;
1437
1438         case SID_ATTRIBUTES_LINE:  // BASIC
1439         {
1440             SetCurrentFunction( FuLine::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1441             if (rReq.GetArgs())
1442                 Cancel();
1443         }
1444         break;
1445
1446         case SID_ATTRIBUTES_AREA:  // BASIC
1447         {
1448             SetCurrentFunction( FuArea::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1449             if (rReq.GetArgs())
1450                 Cancel();
1451         }
1452         break;
1453
1454         case SID_ATTR_TRANSFORM:
1455         {
1456             SetCurrentFunction( FuTransform::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1457             // tdf#138963 conditions tested for here must be the same as those
1458             // of the early returns from FuTransform::DoExecute
1459             if (rReq.GetArgs() || rMarkList.GetMarkCount() == 0)
1460             {
1461                 Invalidate(SID_RULER_OBJECT);
1462                 Cancel();
1463             }
1464         }
1465         break;
1466         case SID_MOVE_SHAPE_HANDLE:
1467         {
1468             const SfxItemSet *pArgs = rReq.GetArgs ();
1469             if (pArgs && pArgs->Count () >= 3)
1470             {
1471                 const SfxUInt32Item* handleNumItem = rReq.GetArg<SfxUInt32Item>(FN_PARAM_1);
1472                 const SfxUInt32Item* newPosXTwips = rReq.GetArg<SfxUInt32Item>(FN_PARAM_2);
1473                 const SfxUInt32Item* newPosYTwips = rReq.GetArg<SfxUInt32Item>(FN_PARAM_3);
1474                 const SfxInt32Item* OrdNum = rReq.GetArg<SfxInt32Item>(FN_PARAM_4);
1475
1476                 const sal_uInt32 handleNum = handleNumItem->GetValue();
1477                 const ::tools::Long newPosX = convertTwipToMm100(newPosXTwips->GetValue());
1478                 const ::tools::Long newPosY = convertTwipToMm100(newPosYTwips->GetValue());
1479
1480                 mpDrawView->MoveShapeHandle(handleNum, Point(newPosX, newPosY), OrdNum ? OrdNum->GetValue() : -1);
1481                 Cancel();
1482             }
1483             break;
1484         }
1485         case SID_CHAR_DLG_EFFECT:
1486         case SID_CHAR_DLG:  // BASIC
1487         {
1488             SetCurrentFunction( FuChar::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1489             Cancel();
1490         }
1491         break;
1492
1493         case SID_PARA_DLG:
1494         {
1495             SetCurrentFunction( FuParagraph::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1496             Cancel();
1497         }
1498         break;
1499
1500         case FN_NUM_BULLET_ON:
1501         {
1502             // The value (sal_uInt16)0xFFFF means set bullet on/off.
1503             SfxUInt16Item aItem(FN_SVX_SET_BULLET, sal_uInt16(0xFFFF));
1504             GetViewFrame()->GetDispatcher()->ExecuteList(FN_SVX_SET_BULLET,
1505                     SfxCallMode::RECORD, { &aItem });
1506         }
1507         break;
1508
1509         case FN_NUM_NUMBERING_ON:
1510         {
1511             // The value (sal_uInt16)0xFFFF means set bullet on/off.
1512             SfxUInt16Item aItem(FN_SVX_SET_NUMBER, sal_uInt16(0xFFFF));
1513             GetViewFrame()->GetDispatcher()->ExecuteList(FN_SVX_SET_NUMBER,
1514                     SfxCallMode::RECORD, { &aItem });
1515         }
1516         break;
1517
1518         case SID_OUTLINE_BULLET:
1519         case FN_SVX_SET_BULLET:
1520         case FN_SVX_SET_NUMBER:
1521         {
1522             SetCurrentFunction( FuBulletAndPosition::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1523             Cancel();
1524         }
1525         break;
1526
1527         case FN_INSERT_SOFT_HYPHEN:
1528         case FN_INSERT_HARDHYPHEN:
1529         case FN_INSERT_HARD_SPACE:
1530         case FN_INSERT_NNBSP:
1531         case SID_INSERT_RLM :
1532         case SID_INSERT_LRM :
1533         case SID_INSERT_WJ :
1534         case SID_INSERT_ZWSP:
1535         case SID_CHARMAP:
1536         {
1537             SetCurrentFunction( FuBullet::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1538             Cancel();
1539         }
1540         break;
1541
1542         case SID_PRESENTATION_LAYOUT:
1543         {
1544             SetCurrentFunction( FuPresentationLayout::Create(this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq) );
1545             Cancel();
1546         }
1547         break;
1548
1549         case SID_PASTE_SPECIAL:
1550         {
1551             SetCurrentFunction( FuInsertClipboard::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1552             Cancel();
1553             rReq.Ignore ();
1554         }
1555         break;
1556
1557         case SID_CHANGE_PICTURE:
1558         case SID_INSERT_GRAPHIC:
1559         {
1560             SetCurrentFunction( FuInsertGraphic::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq,
1561                                                          nSId == SID_CHANGE_PICTURE ) );
1562             Cancel();
1563             rReq.Ignore ();
1564         }
1565         break;
1566
1567         case SID_INSERT_AVMEDIA:
1568         {
1569             SetCurrentFunction( FuInsertAVMedia::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1570
1571             Cancel();
1572             rReq.Ignore ();
1573         }
1574         break;
1575
1576         case SID_INSERT_OBJECT:
1577         case SID_INSERT_FLOATINGFRAME:
1578         case SID_INSERT_MATH:
1579         case SID_INSERT_DIAGRAM:
1580         case SID_ATTR_TABLE:
1581         {
1582             SetCurrentFunction( FuInsertOLE::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1583             // Set the selection tool as the old one. This in particular important for the
1584             // zoom function, in which clicking without dragging zooms as well, and that
1585             // makes exiting the object editing mode impossible.
1586             if (dynamic_cast<FuSelection*>( GetOldFunction().get() ) == nullptr)
1587                 SetOldFunction( FuSelection::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1588             Cancel();
1589             rReq.Ignore ();
1590         }
1591         break;
1592         case SID_CLASSIFICATION_APPLY:
1593         {
1594             const SfxItemSet* pArgs = rReq.GetArgs();
1595             const SfxPoolItem* pItem = nullptr;
1596             if (pArgs && pArgs->GetItemState(nSId, false, &pItem) == SfxItemState::SET)
1597             {
1598                 const OUString& rName = static_cast<const SfxStringItem*>(pItem)->GetValue();
1599                 auto eType = SfxClassificationPolicyType::IntellectualProperty;
1600                 if (pArgs->GetItemState(SID_TYPE_NAME, false, &pItem) == SfxItemState::SET)
1601                 {
1602                     const OUString& rType = static_cast<const SfxStringItem*>(pItem)->GetValue();
1603                     eType = SfxClassificationHelper::stringToPolicyType(rType);
1604                 }
1605                 if (SfxViewFrame* pViewFrame = GetViewFrame())
1606                 {
1607                     if (SfxObjectShell* pObjectShell = pViewFrame->GetObjectShell())
1608                     {
1609                         SfxClassificationHelper aHelper(pObjectShell->getDocProperties());
1610                         aHelper.SetBACName(rName, eType);
1611                     }
1612                 }
1613             }
1614             else
1615                 SAL_WARN("sd.ui", "missing parameter for SID_CLASSIFICATION_APPLY");
1616
1617             Cancel();
1618             rReq.Ignore();
1619         }
1620         break;
1621
1622         case SID_CLASSIFICATION_DIALOG:
1623         {
1624             if (SfxObjectShell* pObjShell = SfxObjectShell::Current())
1625             {
1626                 css::uno::Reference<css::document::XDocumentProperties> xDocProps(pObjShell->getDocProperties());
1627                 auto xDialog = std::make_shared<svx::ClassificationDialog>(GetFrameWeld(), xDocProps, false, [](){} );
1628                 ClassificationCollector aCollector(*this, xDocProps);
1629                 aCollector.collect();
1630
1631                 xDialog->setupValues(std::vector(aCollector.getResults()));
1632
1633                 if (RET_OK == xDialog->run())
1634                 {
1635                     ClassificationInserter aInserter(*this, xDocProps);
1636                     aInserter.insert(xDialog->getResult());
1637                 }
1638                 xDialog.reset();
1639             }
1640
1641             Cancel();
1642             rReq.Ignore();
1643         }
1644         break;
1645
1646         case SID_COPYOBJECTS:
1647         {
1648             if ( mpDrawView->IsPresObjSelected(false) )
1649             {
1650                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
1651                                                               VclMessageType::Info, VclButtonsType::Ok,
1652                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
1653                 xInfoBox->run();
1654             }
1655             else
1656             {
1657                 if ( mpDrawView->IsTextEdit() )
1658                 {
1659                     mpDrawView->SdrEndTextEdit();
1660                 }
1661
1662                 SetCurrentFunction( FuCopy::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1663             }
1664             Cancel();
1665             rReq.Ignore ();
1666         }
1667         break;
1668
1669         case SID_INSERTFILE:  // BASIC
1670         {
1671             Broadcast (ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START));
1672             SetCurrentFunction( FuInsertFile::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1673             Broadcast (ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END));
1674             Cancel();
1675             rReq.Done ();
1676         }
1677         break;
1678
1679         case SID_SELECT_BACKGROUND:
1680         case SID_SAVE_BACKGROUND:
1681         case SID_ATTR_PAGE_SIZE:
1682         case SID_ATTR_PAGE:
1683         case SID_PAGESETUP:  // BASIC ??
1684         {
1685             SetCurrentFunction( FuPage::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1686             Cancel();
1687             rReq.Ignore (); // we generate independent macros !!
1688         }
1689         break;
1690
1691         case SID_BEFORE_OBJ:
1692         case SID_BEHIND_OBJ:
1693         {
1694             SetCurrentFunction( FuDisplayOrder::Create(this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq) );
1695             rReq.Done();
1696             // finishes itself, no Cancel() needed!
1697         }
1698         break;
1699
1700         case SID_REVERSE_ORDER:   // BASIC
1701         {
1702             mpDrawView->ReverseOrderOfMarked();
1703             Cancel();
1704             rReq.Done ();
1705         }
1706         break;
1707
1708         case SID_ANIMATION_EFFECTS:
1709         {
1710             SetCurrentFunction( FuObjectAnimationParameters::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq) );
1711             Cancel();
1712         }
1713         break;
1714
1715         case SID_EXECUTE_ANIMATION_EFFECT:
1716         {
1717             SetCurrentFunction(FuExecuteInteraction::Create(this, GetActiveWindow(),
1718                                                             mpDrawView.get(), GetDoc(), rReq));
1719             Cancel();
1720         }
1721         break;
1722
1723         case SID_LINEEND_POLYGON:
1724         {
1725             SetCurrentFunction( FuLineEnd::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1726             Cancel();
1727         }
1728         break;
1729
1730         case SID_CAPTUREPOINT:
1731             // negative value to signal call from menu
1732             maMousePos = Point(-1,-1);
1733             [[fallthrough]];
1734         case SID_SET_SNAPITEM:
1735         {
1736             SetCurrentFunction( FuSnapLine::Create(this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq) );
1737             Cancel();
1738         }
1739         break;
1740
1741         case SID_MANAGE_LINKS:
1742         {
1743             SetCurrentFunction( FuLink::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1744             Cancel();
1745             rReq.Ignore ();
1746         }
1747         break;
1748
1749         case SID_THESAURUS:
1750         {
1751             SetCurrentFunction( FuThesaurus::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1752             Cancel();
1753             rReq.Ignore ();
1754         }
1755         break;
1756
1757         case SID_TEXTATTR_DLG:
1758         {
1759             if (mpDrawView->IsTextEdit())
1760                 mpDrawView->SdrEndTextEdit();
1761             SetCurrentFunction( FuTextAttrDlg::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1762             Cancel();
1763             rReq.Ignore ();
1764         }
1765         break;
1766
1767         case SID_MEASURE_DLG:
1768         {
1769             SetCurrentFunction( FuMeasureDlg::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1770             Cancel();
1771             rReq.Ignore ();
1772         }
1773         break;
1774
1775         case SID_CONNECTION_DLG:
1776         {
1777             SetCurrentFunction( FuConnectionDlg::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1778             Cancel();
1779             rReq.Done();
1780         }
1781         break;
1782
1783         case SID_CONNECTION_NEW_ROUTING:
1784         {
1785             SfxItemSetFixed<SDRATTR_EDGELINE1DELTA, SDRATTR_EDGELINE3DELTA> aDefAttr( GetPool() );
1786             GetView()->SetAttributes( aDefAttr, true ); // (ReplaceAll)
1787
1788             Cancel();
1789             rReq.Done();
1790         }
1791         break;
1792
1793         case SID_TWAIN_SELECT:
1794         {
1795             if( mxScannerManager.is() )
1796             {
1797                 try
1798                 {
1799                     const css::uno::Sequence< css::scanner::ScannerContext >
1800                         aContexts( mxScannerManager->getAvailableScanners() );
1801
1802                     if( aContexts.hasElements() )
1803                     {
1804                         css::scanner::ScannerContext aContext( aContexts.getConstArray()[ 0 ] );
1805
1806                         Reference<lang::XInitialization> xInit(mxScannerManager, UNO_QUERY);
1807                         if (xInit.is())
1808                         {
1809                             //  initialize dialog
1810                             weld::Window* pWindow = rReq.GetFrameWeld();
1811                             uno::Sequence<uno::Any> aSeq(comphelper::InitAnyPropertySequence(
1812                             {
1813                                 {"ParentWindow", pWindow ? uno::Any(pWindow->GetXWindow()) : uno::Any(Reference<awt::XWindow>())}
1814                             }));
1815                             xInit->initialize( aSeq );
1816                         }
1817
1818                         mxScannerManager->configureScannerAndScan( aContext, mxScannerListener );
1819                     }
1820                 }
1821                 catch(...)
1822                 {
1823                 }
1824             }
1825
1826             Cancel();
1827             rReq.Done();
1828         }
1829         break;
1830
1831         case SID_TWAIN_TRANSFER:
1832         {
1833             bool bDone = false;
1834
1835             if( mxScannerManager.is() )
1836             {
1837                 try
1838                 {
1839                     const css::uno::Sequence< css::scanner::ScannerContext > aContexts( mxScannerManager->getAvailableScanners() );
1840
1841                     if( aContexts.hasElements() )
1842                     {
1843                         mxScannerManager->startScan( aContexts.getConstArray()[ 0 ], mxScannerListener );
1844                         bDone = true;
1845                     }
1846                 }
1847                 catch( ... )
1848                 {
1849                 }
1850             }
1851
1852             if( !bDone )
1853             {
1854                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
1855                                                               VclMessageType::Info, VclButtonsType::Ok,
1856 #ifndef UNX
1857                                                               SdResId(STR_TWAIN_NO_SOURCE)
1858 #else
1859                                                               SdResId(STR_TWAIN_NO_SOURCE_UNX)
1860 #endif
1861                                                               ));
1862                 xInfoBox->run();
1863
1864             }
1865             else
1866             {
1867                 SfxBindings& rBindings = GetViewFrame()->GetBindings();
1868                 rBindings.Invalidate( SID_TWAIN_SELECT );
1869                 rBindings.Invalidate( SID_TWAIN_TRANSFER );
1870             }
1871
1872             Cancel();
1873             rReq.Done();
1874         }
1875         break;
1876
1877         case SID_POLYGON_MORPHING:
1878         {
1879             SetCurrentFunction( FuMorph::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
1880             Cancel();
1881         }
1882         break;
1883
1884         case SID_INSERTLAYER:
1885         {
1886             if ( mpDrawView->IsTextEdit() )
1887             {
1888                 mpDrawView->SdrEndTextEdit();
1889             }
1890
1891             SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
1892             sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
1893             sal_uInt16 nLayer = nLayerCnt - 2 + 1;
1894             OUString aLayerName = SdResId(STR_LAYER) + OUString::number(nLayer);
1895             OUString aLayerTitle, aLayerDesc;
1896             bool bIsVisible = false;
1897             bool bIsLocked = false;
1898             bool bIsPrintable = false;
1899
1900             const SfxItemSet* pArgs = rReq.GetArgs();
1901
1902             if (! pArgs)
1903             {
1904                 SfxItemSetFixed<ATTR_LAYER_START, ATTR_LAYER_END> aNewAttr( GetDoc()->GetPool() );
1905
1906                 aNewAttr.Put( makeSdAttrLayerName( aLayerName ) );
1907                 aNewAttr.Put( makeSdAttrLayerTitle() );
1908                 aNewAttr.Put( makeSdAttrLayerDesc() );
1909                 aNewAttr.Put( makeSdAttrLayerVisible() );
1910                 aNewAttr.Put( makeSdAttrLayerPrintable() );
1911                 aNewAttr.Put( makeSdAttrLayerLocked() );
1912                 aNewAttr.Put( makeSdAttrLayerThisPage() );
1913
1914                 SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
1915                 vcl::Window* pWin = GetActiveWindow();
1916                 ScopedVclPtr<AbstractSdInsertLayerDlg> pDlg( pFact->CreateSdInsertLayerDlg(pWin ? pWin->GetFrameWeld() : nullptr, aNewAttr, true, SdResId(STR_INSERTLAYER)) );
1917                 pDlg->SetHelpId( SdModule::get()->GetSlotPool()->GetSlot( SID_INSERTLAYER )->GetCommand() );
1918
1919                 // test for already existing names
1920                 bool bLoop = true;
1921                 while( bLoop && pDlg->Execute() == RET_OK )
1922                 {
1923                     pDlg->GetAttr( aNewAttr );
1924                     aLayerName   = aNewAttr.Get(ATTR_LAYER_NAME).GetValue ();
1925
1926                     if( rLayerAdmin.GetLayer( aLayerName )
1927                         || aLayerName.isEmpty()
1928                         || LayerTabBar::IsLocalizedNameOfStandardLayer( aLayerName) )
1929                     {
1930                         // name already exists
1931                         std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(GetFrameWeld(),
1932                                                                    VclMessageType::Warning, VclButtonsType::Ok,
1933                                                                    SdResId(STR_WARN_NAME_DUPLICATE)));
1934                         xWarn->run();
1935                     }
1936                     else
1937                         bLoop = false;
1938                 }
1939                 if( bLoop ) // was canceled
1940                 {
1941                     pDlg.disposeAndClear();
1942                     Cancel();
1943                     rReq.Ignore ();
1944                     break;
1945                 }
1946                 else
1947                 {
1948                     aLayerTitle  = aNewAttr.Get(ATTR_LAYER_TITLE).GetValue();
1949                     aLayerDesc   = aNewAttr.Get(ATTR_LAYER_DESC).GetValue ();
1950                     bIsVisible   = static_cast<const SfxBoolItem &>( aNewAttr.Get (ATTR_LAYER_VISIBLE)).GetValue ();
1951                     bIsLocked    = static_cast<const SfxBoolItem &>( aNewAttr.Get (ATTR_LAYER_LOCKED)).GetValue () ;
1952                     bIsPrintable = static_cast<const SfxBoolItem &>( aNewAttr.Get (ATTR_LAYER_PRINTABLE)).GetValue () ;
1953                 }
1954             }
1955             else if (pArgs->Count () != 4)
1956             {
1957 #if HAVE_FEATURE_SCRIPTING
1958                  StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
1959 #endif
1960                  Cancel();
1961                  rReq.Ignore ();
1962                  break;
1963             }
1964             else
1965             {
1966                  const SfxStringItem* pLayerName = rReq.GetArg<SfxStringItem>(ID_VAL_LAYERNAME);
1967                  const SfxBoolItem* pIsVisible = rReq.GetArg<SfxBoolItem>(ID_VAL_ISVISIBLE);
1968                  const SfxBoolItem* pIsLocked = rReq.GetArg<SfxBoolItem>(ID_VAL_ISLOCKED);
1969                  const SfxBoolItem* pIsPrintable = rReq.GetArg<SfxBoolItem>(ID_VAL_ISPRINTABLE);
1970
1971                  aLayerName   = pLayerName->GetValue ();
1972                  bIsVisible   = pIsVisible->GetValue ();
1973                  bIsLocked    = pIsLocked->GetValue ();
1974                  bIsPrintable = pIsPrintable->GetValue ();
1975             }
1976
1977             OUString aPrevLayer = mpDrawView->GetActiveLayer();
1978             SdrLayer* pLayer;
1979             sal_uInt16 nPrevLayer = 0;
1980             nLayerCnt = rLayerAdmin.GetLayerCount();
1981
1982             for ( nLayer = 0; nLayer < nLayerCnt; nLayer++ )
1983             {
1984                 pLayer = rLayerAdmin.GetLayer(nLayer);
1985                 OUString aName = pLayer->GetName();
1986
1987                 if ( aPrevLayer == aName )
1988                 {
1989                     nPrevLayer = std::max(nLayer, sal_uInt16(4));
1990                 }
1991             }
1992
1993             mpDrawView->InsertNewLayer(aLayerName, nPrevLayer + 1);
1994             pLayer = rLayerAdmin.GetLayer(aLayerName);
1995             if( pLayer )
1996             {
1997                 pLayer->SetTitle( aLayerTitle );
1998                 pLayer->SetDescription( aLayerDesc );
1999             }
2000
2001             mpDrawView->SetLayerVisible( aLayerName, bIsVisible );
2002             mpDrawView->SetLayerLocked( aLayerName, bIsLocked);
2003             mpDrawView->SetLayerPrintable(aLayerName, bIsPrintable);
2004
2005             mpDrawView->SetActiveLayer(aLayerName);
2006
2007             ResetActualLayer();
2008
2009             GetDoc()->SetChanged();
2010
2011             GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHLAYER,
2012                     SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
2013
2014             Cancel();
2015             rReq.Done ();
2016         }
2017         break;
2018
2019         case SID_MODIFYLAYER:
2020         {
2021             if(!GetLayerTabControl()) // #i87182#
2022             {
2023                 OSL_ENSURE(false, "No LayerTabBar (!)");
2024                 Cancel();
2025                 rReq.Ignore();
2026                 break;
2027             }
2028
2029             if ( mpDrawView->IsTextEdit() )
2030             {
2031                 mpDrawView->SdrEndTextEdit();
2032             }
2033
2034             SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
2035             sal_uInt16 nCurPage = GetLayerTabControl()->GetCurPageId();
2036             OUString aLayerName = GetLayerTabControl()->GetLayerName(nCurPage);
2037             SdrLayer* pLayer = rLayerAdmin.GetLayer(aLayerName);
2038
2039             OUString aLayerTitle = pLayer->GetTitle();
2040             OUString aLayerDesc = pLayer->GetDescription();
2041
2042             OUString aOldLayerName(aLayerName);
2043             OUString aOldLayerTitle(aLayerTitle);
2044             OUString aOldLayerDesc(aLayerDesc);
2045
2046             bool bIsVisible, bIsLocked, bIsPrintable;
2047             bool bOldIsVisible = bIsVisible = mpDrawView->IsLayerVisible(aLayerName);
2048             bool bOldIsLocked = bIsLocked = mpDrawView->IsLayerLocked(aLayerName);
2049             bool bOldIsPrintable = bIsPrintable = mpDrawView->IsLayerPrintable(aLayerName);
2050
2051             const SfxItemSet* pArgs = rReq.GetArgs();
2052             // is it allowed to delete the layer?
2053             bool bDelete = !( LayerTabBar::IsRealNameOfStandardLayer(aLayerName) );
2054
2055             if (! pArgs)
2056             {
2057                 SfxItemSetFixed<ATTR_LAYER_START, ATTR_LAYER_END> aNewAttr( GetDoc()->GetPool() );
2058
2059                 aNewAttr.Put( makeSdAttrLayerName( aLayerName ) );
2060                 aNewAttr.Put( makeSdAttrLayerTitle( aLayerTitle ) );
2061                 aNewAttr.Put( makeSdAttrLayerDesc( aLayerDesc ) );
2062                 aNewAttr.Put( makeSdAttrLayerVisible( bIsVisible ) );
2063                 aNewAttr.Put( makeSdAttrLayerLocked( bIsLocked ) );
2064                 aNewAttr.Put( makeSdAttrLayerPrintable( bIsPrintable ) );
2065                 aNewAttr.Put( makeSdAttrLayerThisPage() );
2066
2067                 SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
2068                 vcl::Window* pWin = GetActiveWindow();
2069                 ScopedVclPtr<AbstractSdInsertLayerDlg> pDlg( pFact->CreateSdInsertLayerDlg(pWin ? pWin->GetFrameWeld() : nullptr, aNewAttr, bDelete, SdResId(STR_MODIFYLAYER)) );
2070                 pDlg->SetHelpId( SdModule::get()->GetSlotPool()->GetSlot( SID_MODIFYLAYER )->GetCommand() );
2071
2072                 // test for already existing names
2073                 bool    bLoop = true;
2074                 sal_uInt16  nRet = 0;
2075                 while( bLoop )
2076                 {
2077                     nRet = pDlg->Execute();
2078                     if (nRet != RET_OK)
2079                         break;
2080                     pDlg->GetAttr( aNewAttr );
2081                     aLayerName   = aNewAttr.Get(ATTR_LAYER_NAME).GetValue ();
2082                     if (bDelete)
2083                     {
2084                         if( (rLayerAdmin.GetLayer( aLayerName ) && aLayerName != aOldLayerName)
2085                             || LayerTabBar::IsRealNameOfStandardLayer(aLayerName)
2086                             || LayerTabBar::IsLocalizedNameOfStandardLayer(aLayerName)
2087                             || aLayerName.isEmpty() )
2088                         {
2089                             // name already exists
2090                             std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(GetFrameWeld(),
2091                                                                    VclMessageType::Warning, VclButtonsType::Ok,
2092                                                                    SdResId(STR_WARN_NAME_DUPLICATE)));
2093                             xWarn->run();
2094                         }
2095                         else
2096                             bLoop = false;
2097                     }
2098                     else
2099                         bLoop = false; // altering name is already disabled in the dialog itself
2100                 }
2101                 switch (nRet)
2102                 {
2103                     case RET_OK :
2104                         aLayerTitle  = aNewAttr.Get(ATTR_LAYER_TITLE).GetValue ();
2105                         aLayerDesc   = aNewAttr.Get(ATTR_LAYER_DESC).GetValue ();
2106                         bIsVisible   = static_cast<const SfxBoolItem &>( aNewAttr.Get (ATTR_LAYER_VISIBLE)).GetValue ();
2107                         bIsLocked    = static_cast<const SfxBoolItem &>( aNewAttr.Get (ATTR_LAYER_LOCKED)).GetValue ();
2108                         bIsPrintable = static_cast<const SfxBoolItem &>( aNewAttr.Get (ATTR_LAYER_PRINTABLE)).GetValue ();
2109                         break;
2110
2111                     default :
2112                         pDlg.disposeAndClear();
2113                         rReq.Ignore ();
2114                         Cancel ();
2115                         return;
2116                 }
2117             }
2118             else if (pArgs->Count () == 4)
2119             {
2120                 const SfxStringItem* pLayerName = rReq.GetArg<SfxStringItem>(ID_VAL_LAYERNAME);
2121                 const SfxBoolItem* pIsVisible = rReq.GetArg<SfxBoolItem>(ID_VAL_ISVISIBLE);
2122                 const SfxBoolItem* pIsLocked = rReq.GetArg<SfxBoolItem>(ID_VAL_ISLOCKED);
2123                 const SfxBoolItem* pIsPrintable = rReq.GetArg<SfxBoolItem>(ID_VAL_ISPRINTABLE);
2124
2125                 aLayerName   = pLayerName->GetValue ();
2126                 bIsVisible   = pIsVisible->GetValue ();
2127                 bIsLocked    = pIsLocked->GetValue ();
2128                 bIsPrintable = pIsPrintable->GetValue ();
2129             }
2130             else
2131             {
2132 #if HAVE_FEATURE_SCRIPTING
2133                 StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
2134 #endif
2135                 Cancel ();
2136                 rReq.Ignore ();
2137                 break;
2138             }
2139
2140             SfxUndoManager* pManager = GetDoc()->GetDocSh()->GetUndoManager();
2141             std::unique_ptr<SdLayerModifyUndoAction> pAction( new SdLayerModifyUndoAction(
2142                 GetDoc(),
2143                 pLayer,
2144                 // old values
2145                 aOldLayerName,
2146                 aOldLayerTitle,
2147                 aOldLayerDesc,
2148                 bOldIsVisible,
2149                 bOldIsLocked,
2150                 bOldIsPrintable,
2151                 // new values
2152                 aLayerName,
2153                 aLayerTitle,
2154                 aLayerDesc,
2155                 bIsVisible,
2156                 bIsLocked,
2157                 bIsPrintable
2158                 ) );
2159             pManager->AddUndoAction( std::move(pAction) );
2160
2161             ModifyLayer( pLayer, aLayerName, aLayerTitle, aLayerDesc, bIsVisible, bIsLocked, bIsPrintable );
2162
2163             Cancel();
2164             rReq.Done ();
2165         }
2166         break;
2167
2168         case SID_TOGGLELAYERVISIBILITY:
2169         {
2170             // tdf#113439; duplicates LayerTabBar::MouseButtonDown()
2171             sal_uInt16 aTabId = GetLayerTabControl()->GetCurPageId();
2172             OUString aName( GetLayerTabControl()->GetLayerName(aTabId) );
2173
2174             SdrPageView* pPV = mpDrawView->GetSdrPageView();
2175             bool bVisible = !pPV->IsLayerVisible(aName);
2176
2177             pPV->SetLayerVisible(aName, bVisible);
2178
2179             ResetActualLayer();
2180             GetDoc()->SetChanged();
2181
2182             Cancel();
2183             rReq.Ignore ();
2184         }
2185         break;
2186
2187         case SID_RENAMELAYER:
2188         {
2189             if ( mpDrawView->IsTextEdit() )
2190             {
2191                 mpDrawView->SdrEndTextEdit();
2192             }
2193
2194             if(GetLayerTabControl()) // #i87182#
2195             {
2196                 GetLayerTabControl()->StartEditMode(GetLayerTabControl()->GetCurPageId());
2197             }
2198             else
2199             {
2200                 OSL_ENSURE(false, "No LayerTabBar (!)");
2201             }
2202
2203             Cancel();
2204             rReq.Ignore ();
2205         }
2206         break;
2207
2208         case SID_EDIT_HYPERLINK :
2209         {
2210             // Ensure the field is selected first
2211             OutlinerView* pOutView = mpDrawView->GetTextEditOutlinerView();
2212             if (pOutView)
2213                 pOutView->SelectFieldAtCursor();
2214
2215             GetViewFrame()->GetDispatcher()->Execute( SID_HYPERLINK_DIALOG );
2216
2217             Cancel();
2218             rReq.Done ();
2219         }
2220         break;
2221
2222         case SID_OPEN_HYPERLINK:
2223         {
2224             OutlinerView* pOutView = mpDrawView->GetTextEditOutlinerView();
2225             if ( pOutView )
2226             {
2227                 const SvxFieldItem* pFieldItem
2228                     = pOutView->GetFieldAtSelection(/*AlsoCheckBeforeCursor=*/true);
2229                 const SvxFieldData* pField = pFieldItem ? pFieldItem->GetField() : nullptr;
2230                 if( auto pURLField = dynamic_cast< const SvxURLField *>( pField ) )
2231                 {
2232                     SfxStringItem aUrl( SID_FILE_NAME, pURLField->GetURL() );
2233                     SfxStringItem aTarget( SID_TARGETNAME, pURLField->GetTargetFrame() );
2234
2235                     OUString aReferName;
2236                     SfxViewFrame* pFrame = GetViewFrame();
2237                     SfxMedium* pMed = pFrame->GetObjectShell()->GetMedium();
2238                     if (pMed)
2239                         aReferName = pMed->GetName();
2240
2241                     SfxFrameItem aFrm( SID_DOCFRAME, pFrame );
2242                     SfxStringItem aReferer( SID_REFERER, aReferName );
2243
2244                     SfxBoolItem aNewView( SID_OPEN_NEW_VIEW, false );
2245                     SfxBoolItem aBrowsing( SID_BROWSE, true );
2246
2247                     if (SfxViewFrame* pViewFrm = SfxViewFrame::Current())
2248                     {
2249                         pViewFrm->GetDispatcher()->ExecuteList(SID_OPENDOC,
2250                             SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
2251                             { &aUrl, &aTarget, &aFrm, &aReferer,
2252                                 &aNewView, &aBrowsing });
2253                     }
2254                 }
2255             }
2256             Cancel();
2257             rReq.Done ();
2258         }
2259         break;
2260
2261         case SID_COPY_HYPERLINK_LOCATION:
2262         {
2263             OutlinerView* pOutView = mpDrawView->GetTextEditOutlinerView();
2264             if ( pOutView )
2265             {
2266                 const SvxFieldItem* pFieldItem
2267                     = pOutView->GetFieldAtSelection(/*AlsoCheckBeforeCursor=*/true);
2268                 const SvxFieldData* pField = pFieldItem ? pFieldItem->GetField() : nullptr;
2269                 if (const SvxURLField* pURLField = dynamic_cast<const SvxURLField*>(pField))
2270                 {
2271                     uno::Reference<datatransfer::clipboard::XClipboard> xClipboard
2272                         = pOutView->GetWindow()->GetClipboard();
2273
2274                     vcl::unohelper::TextDataObject::CopyStringTo(pURLField->GetURL(), xClipboard, SfxViewShell::Current());
2275                 }
2276             }
2277
2278             Cancel();
2279             rReq.Done ();
2280         }
2281         break;
2282
2283         case SID_HYPERLINK_SETLINK:
2284         {
2285             const SfxItemSet* pReqArgs = rReq.GetArgs();
2286
2287             if (pReqArgs)
2288             {
2289                 const SvxHyperlinkItem* pHLItem =
2290                     &pReqArgs->Get(SID_HYPERLINK_SETLINK);
2291
2292                 if (pHLItem->GetInsertMode() == HLINK_FIELD)
2293                 {
2294                     InsertURLField(pHLItem->GetURL(), pHLItem->GetName(),
2295                                    pHLItem->GetTargetFrame());
2296                 }
2297                 else if (pHLItem->GetInsertMode() == HLINK_BUTTON)
2298                 {
2299                     InsertURLButton(pHLItem->GetURL(), pHLItem->GetName(),
2300                                     pHLItem->GetTargetFrame(), nullptr);
2301                 }
2302                 else if (pHLItem->GetInsertMode() == HLINK_DEFAULT)
2303                 {
2304                     OutlinerView* pOlView = mpDrawView->GetTextEditOutlinerView();
2305
2306                     if (pOlView || comphelper::LibreOfficeKit::isActive())
2307                     {
2308                         InsertURLField(pHLItem->GetURL(), pHLItem->GetName(),
2309                                        pHLItem->GetTargetFrame());
2310                     }
2311                     else
2312                     {
2313                         InsertURLButton(pHLItem->GetURL(), pHLItem->GetName(),
2314                                         pHLItem->GetTargetFrame(), nullptr);
2315                     }
2316                 }
2317             }
2318
2319             Cancel();
2320             rReq.Ignore ();
2321         }
2322         break;
2323
2324         case SID_HIDE_LAST_LEVEL:
2325         {
2326             ESelection aSel;
2327             // fdo#78151 editing a PresObjKind::Outline in a master page ?
2328             ::Outliner* pOL = GetOutlinerForMasterPageOutlineTextObj(aSel);
2329             if (pOL)
2330             {
2331                 //we are on the last paragraph
2332                 aSel.Adjust();
2333                 if (aSel.end.nPara == pOL->GetParagraphCount() - 1)
2334                 {
2335                     sal_uInt16 nDepth = pOL->GetDepth(aSel.end.nPara);
2336                     //there exists a previous numbering level
2337                     if (nDepth != sal_uInt16(-1) && nDepth > 0)
2338                     {
2339                         Paragraph* pPara = pOL->GetParagraph(aSel.end.nPara);
2340                         pOL->Remove(pPara, 1);
2341                     }
2342                 }
2343             }
2344             Cancel();
2345             rReq.Done ();
2346         }
2347         break;
2348
2349         case SID_SHOW_NEXT_LEVEL:
2350         {
2351             const TranslateId STR_PRESOBJ_MPOUTLINE_ARY[]
2352             {
2353                 STR_PRESOBJ_MPOUTLINE,
2354                 STR_PRESOBJ_MPOUTLLAYER2,
2355                 STR_PRESOBJ_MPOUTLLAYER3,
2356                 STR_PRESOBJ_MPOUTLLAYER4,
2357                 STR_PRESOBJ_MPOUTLLAYER5,
2358                 STR_PRESOBJ_MPOUTLLAYER6,
2359                 STR_PRESOBJ_MPOUTLLAYER7,
2360                 STR_PRESOBJ_MPNOTESTITLE,
2361                 STR_PRESOBJ_MPNOTESTEXT,
2362                 STR_PRESOBJ_NOTESTEXT
2363             };
2364
2365             ESelection aSel;
2366             // fdo#78151 editing a PresObjKind::Outline in a master page ?
2367             ::Outliner* pOL = GetOutlinerForMasterPageOutlineTextObj(aSel);
2368             if (pOL)
2369             {
2370                 //we are on the last paragraph
2371                 aSel.Adjust();
2372                 if (aSel.end.nPara == pOL->GetParagraphCount() - 1)
2373                 {
2374                     sal_uInt16 nDepth = pOL->GetDepth(aSel.end.nPara);
2375                     //there exists a previous numbering level
2376                     if (nDepth < 8)
2377                     {
2378                         sal_uInt16 nNewDepth = nDepth+1;
2379                         pOL->Insert(SdResId(STR_PRESOBJ_MPOUTLINE_ARY[nNewDepth]), EE_PARA_MAX, nNewDepth);
2380                     }
2381                 }
2382             }
2383             Cancel();
2384             rReq.Done ();
2385         }
2386         break;
2387
2388         case SID_INSERT_FLD_DATE_FIX:
2389         case SID_INSERT_FLD_DATE_VAR:
2390         case SID_INSERT_FLD_TIME_FIX:
2391         case SID_INSERT_FLD_TIME_VAR:
2392         case SID_INSERT_FLD_AUTHOR:
2393         case SID_INSERT_FLD_PAGE:
2394         case SID_INSERT_FLD_PAGE_TITLE:
2395         case SID_INSERT_FLD_PAGES:
2396         case SID_INSERT_FLD_FILE:
2397         {
2398             sal_uInt16 nMul = 1;
2399             std::unique_ptr<SvxFieldItem> pFieldItem;
2400
2401             switch( nSId )
2402             {
2403                 case SID_INSERT_FLD_DATE_FIX:
2404                     pFieldItem.reset(new SvxFieldItem(
2405                         SvxDateField( Date( Date::SYSTEM ), SvxDateType::Fix ), EE_FEATURE_FIELD ));
2406                 break;
2407
2408                 case SID_INSERT_FLD_DATE_VAR:
2409                     pFieldItem.reset(new SvxFieldItem( SvxDateField(), EE_FEATURE_FIELD ));
2410                 break;
2411
2412                 case SID_INSERT_FLD_TIME_FIX:
2413                     pFieldItem.reset(new SvxFieldItem(
2414                         SvxExtTimeField( ::tools::Time( ::tools::Time::SYSTEM ), SvxTimeType::Fix ), EE_FEATURE_FIELD ));
2415                 break;
2416
2417                 case SID_INSERT_FLD_TIME_VAR:
2418                     pFieldItem.reset(new SvxFieldItem( SvxExtTimeField(), EE_FEATURE_FIELD ));
2419                 break;
2420
2421                 case SID_INSERT_FLD_AUTHOR:
2422                 {
2423                     SvtUserOptions aUserOptions;
2424                     pFieldItem.reset(new SvxFieldItem(
2425                             SvxAuthorField(
2426                                 aUserOptions.GetFirstName(), aUserOptions.GetLastName(), aUserOptions.GetID() ), EE_FEATURE_FIELD ));
2427                 }
2428                 break;
2429
2430                 case SID_INSERT_FLD_PAGE:
2431                 {
2432                     pFieldItem.reset(new SvxFieldItem( SvxPageField(), EE_FEATURE_FIELD ));
2433                     nMul = 3;
2434                 }
2435                 break;
2436
2437                 case SID_INSERT_FLD_PAGE_TITLE:
2438                 {
2439                     pFieldItem.reset(new SvxFieldItem( SvxPageTitleField(), EE_FEATURE_FIELD));
2440                     nMul = 3;
2441                 }
2442                 break;
2443
2444                 case SID_INSERT_FLD_PAGES:
2445                 {
2446                     pFieldItem.reset(new SvxFieldItem( SvxPagesField(), EE_FEATURE_FIELD ));
2447                     nMul = 3;
2448                 }
2449                 break;
2450
2451                 case SID_INSERT_FLD_FILE:
2452                 {
2453                     OUString aName;
2454                     if( GetDocSh()->HasName() )
2455                         aName = GetDocSh()->GetMedium()->GetName();
2456                     pFieldItem.reset(new SvxFieldItem( SvxExtFileField( aName ), EE_FEATURE_FIELD ));
2457                 }
2458                 break;
2459             }
2460
2461             OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView();
2462
2463             if( pOLV )
2464             {
2465                 const SvxFieldItem* pOldFldItem = pOLV->GetFieldAtSelection();
2466
2467                 if( pOldFldItem && ( nullptr != dynamic_cast< const SvxURLField *>( pOldFldItem->GetField() ) ||
2468                                     nullptr != dynamic_cast< const SvxDateField *>( pOldFldItem->GetField() ) ||
2469                                     nullptr != dynamic_cast< const SvxTimeField *>( pOldFldItem->GetField() ) ||
2470                                     nullptr != dynamic_cast< const SvxExtTimeField *>( pOldFldItem->GetField() ) ||
2471                                     nullptr != dynamic_cast< const SvxExtFileField *>( pOldFldItem->GetField() ) ||
2472                                     nullptr != dynamic_cast< const SvxAuthorField *>( pOldFldItem->GetField() ) ||
2473                                     nullptr != dynamic_cast< const SvxPageField *>( pOldFldItem->GetField() ) ) )
2474                 {
2475                     // select field, then it will be deleted when inserting
2476                     ESelection aSel = pOLV->GetSelection();
2477                     if (aSel.start.nIndex == aSel.end.nIndex)
2478                         aSel.end.nIndex++;
2479                     pOLV->SetSelection( aSel );
2480                 }
2481
2482                 if( pFieldItem )
2483                     pOLV->InsertField( *pFieldItem );
2484             }
2485             else
2486             {
2487                 Outliner* pOutl = GetDoc()->GetInternalOutliner();
2488                 pOutl->Init( OutlinerMode::TextObject );
2489                 OutlinerMode nOutlMode = pOutl->GetOutlinerMode();
2490                 pOutl->SetStyleSheet( 0, nullptr );
2491                 pOutl->QuickInsertField( *pFieldItem, ESelection() );
2492                 std::optional<OutlinerParaObject> pOutlParaObject = pOutl->CreateParaObject();
2493
2494                 rtl::Reference<SdrRectObj> pRectObj = new SdrRectObj(
2495                     *GetDoc(),
2496                     SdrObjKind::Text);
2497                 pRectObj->SetMergedItem(makeSdrTextAutoGrowWidthItem(true));
2498
2499                 pOutl->UpdateFields();
2500                 pOutl->SetUpdateLayout( true );
2501                 Size aSize( pOutl->CalcTextSize() );
2502                 aSize.setWidth( aSize.Width() * nMul );
2503                 pOutl->SetUpdateLayout( false );
2504
2505                 Point aPos;
2506                 ::tools::Rectangle aRect( aPos, GetActiveWindow()->GetOutputSizePixel() );
2507                 aPos = aRect.Center();
2508                 aPos = GetActiveWindow()->PixelToLogic(aPos);
2509                 aPos.AdjustX( -(aSize.Width() / 2) );
2510                 aPos.AdjustY( -(aSize.Height() / 2) );
2511
2512                 ::tools::Rectangle aLogicRect(aPos, aSize);
2513                 pRectObj->SetLogicRect(aLogicRect);
2514                 pRectObj->SetOutlinerParaObject( std::move(pOutlParaObject) );
2515                 mpDrawView->InsertObjectAtView(pRectObj.get(), *mpDrawView->GetSdrPageView());
2516                 pOutl->Init( nOutlMode );
2517             }
2518
2519             pFieldItem.reset();
2520
2521             Cancel();
2522             rReq.Ignore ();
2523         }
2524         break;
2525
2526         case SID_MODIFY_FIELD:
2527         {
2528             OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView();
2529
2530             if( pOLV )
2531             {
2532                 const SvxFieldItem* pFldItem = pOLV->GetFieldAtSelection();
2533
2534                 if( pFldItem && (nullptr != dynamic_cast< const SvxDateField *>( pFldItem->GetField() ) ||
2535                                  nullptr != dynamic_cast< const SvxAuthorField *>( pFldItem->GetField() ) ||
2536                                  nullptr != dynamic_cast< const SvxExtFileField *>( pFldItem->GetField() ) ||
2537                                  nullptr != dynamic_cast< const SvxExtTimeField *>( pFldItem->GetField() ) ) )
2538                 {
2539                     // Dialog...
2540                     SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
2541                     vcl::Window* pWin = GetActiveWindow();
2542                     ScopedVclPtr<AbstractSdModifyFieldDlg> pDlg( pFact->CreateSdModifyFieldDlg(pWin ? pWin->GetFrameWeld() : nullptr, pFldItem->GetField(), pOLV->GetAttribs() ) );
2543                     if( pDlg->Execute() == RET_OK )
2544                     {
2545                         // To make a correct SetAttribs() call at the utlinerView
2546                         // it is necessary to split the actions here
2547                         std::unique_ptr<SvxFieldData> pField(pDlg->GetField());
2548                         ESelection aSel = pOLV->GetSelection();
2549                         bool bSelectionWasModified(false);
2550
2551                         if( pField )
2552                         {
2553                             SvxFieldItem aFieldItem( *pField, EE_FEATURE_FIELD );
2554
2555                             if (aSel.start.nIndex == aSel.end.nIndex)
2556                             {
2557                                 bSelectionWasModified = true;
2558                                 aSel.end.nIndex++;
2559                                 pOLV->SetSelection( aSel );
2560                             }
2561
2562                             pOLV->InsertField( aFieldItem );
2563
2564                             // select again for eventual SetAttribs call
2565                             pOLV->SetSelection( aSel );
2566                         }
2567
2568                         SfxItemSet aSet( pDlg->GetItemSet() );
2569
2570                         if( aSet.Count() )
2571                         {
2572                             pOLV->SetAttribs( aSet );
2573
2574                             ::Outliner* pOutliner = pOLV->GetOutliner();
2575                             if( pOutliner )
2576                                 pOutliner->UpdateFields();
2577                         }
2578
2579                         if(pField)
2580                         {
2581                             // restore selection to original
2582                             if(bSelectionWasModified)
2583                             {
2584                                 aSel.end.nIndex--;
2585                                 pOLV->SetSelection( aSel );
2586                             }
2587                         }
2588                     }
2589                 }
2590             }
2591
2592             Cancel();
2593             rReq.Ignore ();
2594         }
2595         break;
2596
2597         case SID_OPEN_XML_FILTERSETTINGS:
2598         {
2599             try
2600             {
2601                 css::uno::Reference < css::ui::dialogs::XExecutableDialog > xDialog = css::ui::dialogs::XSLTFilterDialog::create( ::comphelper::getProcessComponentContext() );
2602                 xDialog->execute();
2603             }
2604             catch( css::uno::RuntimeException& )
2605             {
2606                 DBG_UNHANDLED_EXCEPTION("sd.view");
2607             }
2608
2609             Cancel();
2610             rReq.Ignore ();
2611         }
2612         break;
2613
2614         case SID_GROUP:  // BASIC
2615         {
2616             if ( mpDrawView->IsPresObjSelected( true, true, true ) )
2617             {
2618                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2619                                                               VclMessageType::Info, VclButtonsType::Ok,
2620                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2621                 xInfoBox->run();
2622             }
2623             else
2624             {
2625                 mpDrawView->GroupMarked();
2626             }
2627             Cancel();
2628             rReq.Done ();
2629         }
2630         break;
2631
2632         case SID_UNGROUP:  // BASIC
2633         {
2634             mpDrawView->UnGroupMarked();
2635             Cancel();
2636             rReq.Done ();
2637         }
2638         break;
2639
2640         case SID_NAME_GROUP:
2641         {
2642             // only allow for single object selection since the name of an object needs
2643             // to be unique
2644             if(1 == rMarkList.GetMarkCount())
2645             {
2646                 // #i68101#
2647                 rtl::Reference<SdrObject> pSelected = rMarkList.GetMark(0)->GetMarkedSdrObj();
2648                 OSL_ENSURE(pSelected, "DrawViewShell::FuTemp03: nMarkCount, but no object (!)");
2649                 OUString aName(pSelected->GetName());
2650
2651                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
2652                 VclPtr<AbstractSvxObjectNameDialog> pDlg(pFact->CreateSvxObjectNameDialog(GetFrameWeld(), aName));
2653
2654                 pDlg->SetCheckNameHdl(LINK(this, DrawViewShell, NameObjectHdl));
2655
2656                 pDlg->StartExecuteAsync(
2657                     [this, pDlg, pSelected] (sal_Int32 nResult)->void
2658                     {
2659                         if (nResult == RET_OK)
2660                         {
2661                             pSelected->SetName(pDlg->GetName());
2662
2663                             SdPage* pPage = GetActualPage();
2664                             if (pPage)
2665                                 pPage->notifyObjectRenamed(pSelected.get());
2666                         }
2667                         pDlg->disposeOnce();
2668                         SfxBindings& rBindings = GetViewFrame()->GetBindings();
2669                         rBindings.Invalidate( SID_NAVIGATOR_STATE, true );
2670                         rBindings.Invalidate( SID_CONTEXT );
2671                     }
2672                 );
2673             }
2674
2675             Cancel();
2676             rReq.Ignore();
2677             break;
2678         }
2679
2680         // #i68101#
2681         case SID_OBJECT_TITLE_DESCRIPTION:
2682         {
2683             if(1 == rMarkList.GetMarkCount())
2684             {
2685                 rtl::Reference<SdrObject> pSelected = rMarkList.GetMark(0)->GetMarkedSdrObj();
2686                 OSL_ENSURE(pSelected, "DrawViewShell::FuTemp03: nMarkCount, but no object (!)");
2687                 OUString aTitle(pSelected->GetTitle());
2688                 OUString aDescription(pSelected->GetDescription());
2689                 bool isDecorative(pSelected->IsDecorative());
2690
2691                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
2692                 VclPtr<AbstractSvxObjectTitleDescDialog> pDlg(pFact->CreateSvxObjectTitleDescDialog(
2693                             GetFrameWeld(), aTitle, aDescription, isDecorative));
2694
2695                 pDlg->StartExecuteAsync(
2696                     [this, pDlg, pSelected] (sal_Int32 nResult)->void
2697                     {
2698                         if (nResult == RET_OK)
2699                         {
2700                             pSelected->SetTitle(pDlg->GetTitle());
2701                             pSelected->SetDescription(pDlg->GetDescription());
2702                             pSelected->SetDecorative(pDlg->IsDecorative());
2703                         }
2704                         pDlg->disposeOnce();
2705                         SfxBindings& rBindings = GetViewFrame()->GetBindings();
2706                         rBindings.Invalidate( SID_NAVIGATOR_STATE, true );
2707                         rBindings.Invalidate( SID_CONTEXT );
2708                     }
2709                 );
2710             }
2711
2712             Cancel();
2713             rReq.Ignore();
2714             break;
2715         }
2716
2717         case SID_SETLAYER:
2718         {
2719             const size_t nMarkCount = rMarkList.GetMarkCount();
2720             if (nMarkCount >= 1 && mpLayerTabBar)
2721             {
2722                 SdSelectLayerDlg aDlg(GetFrameWeld());
2723
2724                 weld::TreeView& rTreeView = aDlg.GetTreeView();
2725                 auto nPageCount = mpLayerTabBar->GetPageCount();
2726                 for (auto i = 0; i < nPageCount; i++)
2727                     rTreeView.append_text(LayerTabBar::convertToLocalizedName(
2728                                         mpLayerTabBar->GetLayerName(mpLayerTabBar->GetPageId(i))));
2729                 rTreeView.select(0);
2730
2731                 if (aDlg.run() == RET_OK && rTreeView.get_selected_index() != -1)
2732                 {
2733                     SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
2734                     SdrLayerID aSdrLayerId = rLayerAdmin.GetLayerID(mpLayerTabBar->GetLayerName(
2735                                         mpLayerTabBar->GetPageId(rTreeView.get_selected_index())));
2736                     for (size_t i = 0; i < nMarkCount; ++i)
2737                     {
2738                         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
2739                         pObj->SetLayer(aSdrLayerId);
2740                     }
2741                 }
2742             }
2743             Cancel();
2744             rReq.Ignore();
2745             break;
2746         }
2747
2748         case SID_ENTER_GROUP:  // BASIC
2749         {
2750             mpDrawView->EnterMarkedGroup();
2751             Cancel();
2752             rReq.Done ();
2753         }
2754         break;
2755
2756         case SID_LEAVE_GROUP:  // BASIC
2757         {
2758             mpDrawView->LeaveOneGroup();
2759             Cancel();
2760             rReq.Done ();
2761         }
2762         break;
2763
2764         case SID_LEAVE_ALL_GROUPS:  // BASIC
2765         {
2766             mpDrawView->LeaveAllGroup();
2767             Cancel();
2768             rReq.Done ();
2769         }
2770         break;
2771
2772         case SID_TEXT_COMBINE:  // BASIC
2773         {
2774             // End text edit to avoid conflicts
2775             if(mpDrawView->IsTextEdit())
2776                 mpDrawView->SdrEndTextEdit();
2777
2778             if ( mpDrawView->IsPresObjSelected() )
2779             {
2780                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2781                                                               VclMessageType::Info, VclButtonsType::Ok,
2782                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2783                 xInfoBox->run();
2784             }
2785             else
2786             {
2787                 weld::WaitObject aWait(GetFrameWeld());
2788                 mpDrawView->CombineMarkedTextObjects();
2789             }
2790             Cancel();
2791             rReq.Done ();
2792         }
2793         break;
2794
2795         case SID_COMBINE:  // BASIC
2796         {
2797             // End text edit to avoid conflicts
2798             if(mpDrawView->IsTextEdit())
2799                 mpDrawView->SdrEndTextEdit();
2800
2801             if ( mpDrawView->IsPresObjSelected() )
2802             {
2803                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2804                                                               VclMessageType::Info, VclButtonsType::Ok,
2805                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2806                 xInfoBox->run();
2807             }
2808             else
2809             {
2810                 weld::WaitObject aWait(GetFrameWeld());
2811                 mpDrawView->CombineMarkedObjects(false);
2812             }
2813             Cancel();
2814             rReq.Done ();
2815         }
2816         break;
2817
2818         case SID_DISTRIBUTE_HLEFT:
2819         case SID_DISTRIBUTE_HCENTER:
2820         case SID_DISTRIBUTE_HDISTANCE:
2821         case SID_DISTRIBUTE_HRIGHT:
2822         case SID_DISTRIBUTE_VTOP:
2823         case SID_DISTRIBUTE_VCENTER:
2824         case SID_DISTRIBUTE_VDISTANCE:
2825         case SID_DISTRIBUTE_VBOTTOM:
2826         {
2827             if ( mpDrawView->IsPresObjSelected() )
2828             {
2829                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2830                                                               VclMessageType::Info, VclButtonsType::Ok,
2831                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2832                 xInfoBox->run();
2833             }
2834             else
2835             {
2836                 mpDrawView->DistributeMarkedObjects(nSId);
2837             }
2838             Cancel();
2839             rReq.Done ();
2840         }
2841         break;
2842         case SID_POLY_MERGE:
2843         {
2844             // End text edit to avoid conflicts
2845             if(mpDrawView->IsTextEdit())
2846                 mpDrawView->SdrEndTextEdit();
2847
2848             if ( mpDrawView->IsPresObjSelected() )
2849             {
2850                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2851                                                               VclMessageType::Info, VclButtonsType::Ok,
2852                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2853                 xInfoBox->run();
2854             }
2855             else
2856             {
2857                 weld::WaitObject aWait(GetFrameWeld());
2858                 mpDrawView->MergeMarkedObjects(SdrMergeMode::Merge);
2859             }
2860             Cancel();
2861             rReq.Done ();
2862         }
2863         break;
2864
2865         case SID_POLY_SUBSTRACT:
2866         {
2867             // End text edit to avoid conflicts
2868             if(mpDrawView->IsTextEdit())
2869                 mpDrawView->SdrEndTextEdit();
2870
2871             if ( mpDrawView->IsPresObjSelected() )
2872             {
2873                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2874                                                               VclMessageType::Info, VclButtonsType::Ok,
2875                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2876                 xInfoBox->run();
2877             }
2878             else
2879             {
2880                 weld::WaitObject aWait(GetFrameWeld());
2881                 mpDrawView->MergeMarkedObjects(SdrMergeMode::Subtract);
2882             }
2883             Cancel();
2884             rReq.Done ();
2885         }
2886         break;
2887
2888         case SID_POLY_INTERSECT:
2889         {
2890             // End text edit to avoid conflicts
2891             if(mpDrawView->IsTextEdit())
2892                 mpDrawView->SdrEndTextEdit();
2893
2894             if ( mpDrawView->IsPresObjSelected() )
2895             {
2896                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2897                                                               VclMessageType::Info, VclButtonsType::Ok,
2898                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2899                 xInfoBox->run();
2900             }
2901             else
2902             {
2903                 weld::WaitObject aWait(GetFrameWeld());
2904                 mpDrawView->MergeMarkedObjects(SdrMergeMode::Intersect);
2905             }
2906             Cancel();
2907             rReq.Done ();
2908         }
2909         break;
2910
2911         case SID_EQUALIZEWIDTH:
2912         case SID_EQUALIZEHEIGHT:
2913         {
2914             // End text edit to avoid conflicts
2915             if(mpDrawView->IsTextEdit())
2916                 mpDrawView->SdrEndTextEdit();
2917
2918             mpDrawView->EqualizeMarkedObjects(nSId == SID_EQUALIZEWIDTH);
2919             Cancel();
2920             rReq.Done ();
2921         }
2922         break;
2923
2924         case SID_DISMANTLE:  // BASIC
2925         {
2926             if ( mpDrawView->IsDismantlePossible() )
2927             {
2928                 weld::WaitObject aWait(GetFrameWeld());
2929                 mpDrawView->DismantleMarkedObjects();
2930             }
2931             Cancel();
2932             rReq.Done ();
2933         }
2934         break;
2935
2936         case SID_CONNECT:  // BASIC
2937         {
2938             if ( mpDrawView->IsPresObjSelected() )
2939             {
2940                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
2941                                                               VclMessageType::Info, VclButtonsType::Ok,
2942                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
2943                 xInfoBox->run();
2944             }
2945             else
2946             {
2947                 weld::WaitObject aWait(GetFrameWeld());
2948                 mpDrawView->CombineMarkedObjects();
2949             }
2950             Cancel();
2951             rReq.Done ();
2952         }
2953         break;
2954
2955         case SID_BREAK:  // BASIC
2956         {
2957             if ( mpDrawView->IsTextEdit() )
2958             {
2959                 mpDrawView->SdrEndTextEdit();
2960             }
2961
2962             if ( mpDrawView->IsBreak3DObjPossible() )
2963             {
2964                 weld::WaitObject aWait(GetFrameWeld());
2965                 mpDrawView->Break3DObj();
2966             }
2967             else if ( mpDrawView->IsDismantlePossible(true) )
2968             {
2969                 weld::WaitObject aWait(GetFrameWeld());
2970                 mpDrawView->DismantleMarkedObjects(true);
2971             }
2972             else if ( mpDrawView->IsImportMtfPossible() )
2973             {
2974                 weld::WaitObject aWait(GetFrameWeld());
2975                 const size_t nCnt=rMarkList.GetMarkCount();
2976
2977                 // determine the sum of meta objects of all selected meta files
2978                 sal_uLong nCount = 0;
2979                 for(size_t nm=0; nm<nCnt; ++nm)
2980                 {
2981                     SdrMark*     pM=rMarkList.GetMark(nm);
2982                     SdrObject*   pObj=pM->GetMarkedSdrObj();
2983                     SdrGrafObj*  pGraf= dynamic_cast< SdrGrafObj *>( pObj );
2984                     SdrOle2Obj*  pOle2= dynamic_cast< SdrOle2Obj *>( pObj );
2985
2986                     if (pGraf != nullptr)
2987                     {
2988                         if (pGraf->HasGDIMetaFile())
2989                         {
2990                             nCount += pGraf->GetGraphic().GetGDIMetaFile().GetActionSize();
2991                         }
2992                         else if (pGraf->isEmbeddedVectorGraphicData())
2993                         {
2994                             nCount += pGraf->getMetafileFromEmbeddedVectorGraphicData().GetActionSize();
2995                         }
2996                     }
2997
2998                     if (pOle2)
2999                         if (const Graphic* pGraphic = pOle2->GetGraphic())
3000                             nCount += pGraphic->GetGDIMetaFile().GetActionSize();
3001                 }
3002
3003                 // decide with the sum of all meta objects if we should show a dialog
3004                 if(nCount < MIN_ACTIONS_FOR_DIALOG)
3005                 {
3006                     // nope, no dialog
3007                     mpDrawView->DoImportMarkedMtf();
3008                 }
3009                 else
3010                 {
3011                     SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
3012                     ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateBreakDlg(GetFrameWeld(), mpDrawView.get(), GetDocSh(), nCount, static_cast<sal_uLong>(nCnt) ));
3013                     pDlg->Execute();
3014                 }
3015             }
3016
3017             Cancel();
3018             rReq.Done ();
3019         }
3020         break;
3021
3022         case SID_CONVERT_TO_3D:
3023         {
3024             if ( mpDrawView->IsPresObjSelected() )
3025             {
3026                 std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
3027                                                               VclMessageType::Info, VclButtonsType::Ok,
3028                                                               SdResId(STR_ACTION_NOTPOSSIBLE)));
3029                 xInfoBox->run();
3030             }
3031             else
3032             {
3033                 if (mpDrawView->IsConvertTo3DObjPossible())
3034                 {
3035                     if (mpDrawView->IsTextEdit())
3036                     {
3037                         mpDrawView->SdrEndTextEdit();
3038                     }
3039
3040                     weld::WaitObject aWait(GetFrameWeld());
3041                     mpDrawView->ConvertMarkedObjTo3D();
3042                 }
3043             }
3044
3045             Cancel();
3046             rReq.Done();
3047         }
3048         break;
3049
3050         case SID_FRAME_TO_TOP:  // BASIC
3051         {
3052             mpDrawView->PutMarkedToTop();
3053             Cancel();
3054             rReq.Done ();
3055         }
3056         break;
3057
3058         case SID_MOREFRONT:  // BASIC
3059         case SID_FRAME_UP:  // BASIC
3060         {
3061             mpDrawView->MovMarkedToTop();
3062             Cancel();
3063             rReq.Done ();
3064         }
3065         break;
3066
3067         case SID_MOREBACK:  // BASIC
3068         case SID_FRAME_DOWN:  // BASIC
3069         {
3070             mpDrawView->MovMarkedToBtm();
3071             Cancel();
3072             rReq.Done ();
3073         }
3074         break;
3075
3076         case SID_FRAME_TO_BOTTOM:   // BASIC
3077         {
3078             mpDrawView->PutMarkedToBtm();
3079             Cancel();
3080             rReq.Done ();
3081         }
3082         break;
3083
3084         case SID_HORIZONTAL:  // BASIC
3085         case SID_FLIP_HORIZONTAL:
3086         {
3087             mpDrawView->MirrorAllMarkedHorizontal();
3088             Cancel();
3089             rReq.Done ();
3090         }
3091         break;
3092
3093         case SID_VERTICAL:  // BASIC
3094         case SID_FLIP_VERTICAL:
3095         {
3096             mpDrawView->MirrorAllMarkedVertical();
3097             Cancel();
3098             rReq.Done ();
3099         }
3100         break;
3101
3102         case SID_OBJECT_ALIGN_LEFT:  // BASIC
3103         {
3104             mpDrawView->AlignMarkedObjects(SdrHorAlign::Left, SdrVertAlign::NONE);
3105             Cancel();
3106             rReq.Done ();
3107         }
3108         break;
3109
3110         case SID_OBJECT_ALIGN_CENTER:  // BASIC
3111         {
3112             mpDrawView->AlignMarkedObjects(SdrHorAlign::Center, SdrVertAlign::NONE);
3113             Cancel();
3114             rReq.Done ();
3115         }
3116         break;
3117
3118         case SID_OBJECT_ALIGN_RIGHT:  // BASIC
3119         {
3120             mpDrawView->AlignMarkedObjects(SdrHorAlign::Right, SdrVertAlign::NONE);
3121             Cancel();
3122             rReq.Done ();
3123         }
3124         break;
3125
3126         case SID_OBJECT_ALIGN_UP:  // BASIC
3127         {
3128             mpDrawView->AlignMarkedObjects(SdrHorAlign::NONE, SdrVertAlign::Top);
3129             Cancel();
3130             rReq.Done ();
3131         }
3132         break;
3133
3134         case SID_OBJECT_ALIGN_MIDDLE:  // BASIC
3135         {
3136             mpDrawView->AlignMarkedObjects(SdrHorAlign::NONE, SdrVertAlign::Center);
3137             Cancel();
3138             rReq.Done ();
3139         }
3140         break;
3141
3142         case SID_ALIGN_PAGE:
3143         {
3144             mpDrawView->AlignMarkedObjects(SdrHorAlign::Center, SdrVertAlign::Center);
3145             Cancel();
3146             rReq.Done ();
3147         }
3148         break;
3149
3150         case SID_OBJECT_ALIGN_DOWN:  // BASIC
3151         {
3152             mpDrawView->AlignMarkedObjects(SdrHorAlign::NONE, SdrVertAlign::Bottom);
3153             Cancel();
3154             rReq.Done ();
3155         }
3156         break;
3157
3158         case SID_SELECTALL:  // BASIC
3159         {
3160             if( (dynamic_cast<FuSelection*>( GetOldFunction().get() ) != nullptr) &&
3161                 !GetView()->IsFrameDragSingles() && GetView()->HasMarkablePoints())
3162             {
3163                 if ( !mpDrawView->IsAction() )
3164                     mpDrawView->MarkAllPoints();
3165             }
3166             else
3167                 mpDrawView->SelectAll();
3168
3169             FreshNavigatrTree();
3170
3171             Cancel();
3172             rReq.Done ();
3173         }
3174         break;
3175
3176         case SID_STYLE_NEW: // BASIC ???
3177         case SID_STYLE_APPLY:
3178         case SID_STYLE_EDIT:
3179         case SID_STYLE_DELETE:
3180         case SID_STYLE_HIDE:
3181         case SID_STYLE_SHOW:
3182         case SID_STYLE_FAMILY:
3183         case SID_STYLE_WATERCAN:
3184         case SID_STYLE_UPDATE_BY_EXAMPLE:
3185         case SID_STYLE_NEW_BY_EXAMPLE:
3186         {
3187             if (!rReq.GetArgs()
3188                 && (nSId == SID_STYLE_EDIT || nSId == SID_STYLE_UPDATE_BY_EXAMPLE
3189                      || nSId == SID_STYLE_NEW_BY_EXAMPLE))
3190             {
3191                 SfxStyleSheet* pStyleSheet = mpDrawView->GetStyleSheet();
3192                 if( pStyleSheet && pStyleSheet->GetFamily() == SfxStyleFamily::Page)
3193                     pStyleSheet = static_cast<SdStyleSheet*>(pStyleSheet)->GetPseudoStyleSheet();
3194
3195                 if( (pStyleSheet == nullptr) && GetView()->IsTextEdit() )
3196                 {
3197                     GetView()->SdrEndTextEdit();
3198
3199                     pStyleSheet = mpDrawView->GetStyleSheet();
3200                     if(pStyleSheet && pStyleSheet->GetFamily() == SfxStyleFamily::Page)
3201                         pStyleSheet = static_cast<SdStyleSheet*>(pStyleSheet)->GetPseudoStyleSheet();
3202                 }
3203
3204                 if( pStyleSheet == nullptr )
3205                 {
3206                     rReq.Ignore();
3207                     break;
3208                 }
3209
3210                 SfxAllItemSet aSet(GetDoc()->GetPool());
3211
3212                 aSet.Put(SfxUInt16Item(SID_STYLE_FAMILY,
3213                                        static_cast<sal_uInt16>(pStyleSheet->GetFamily())));
3214
3215                 if (nSId == SID_STYLE_NEW_BY_EXAMPLE)
3216                 {
3217                     weld::Window* pWindow = GetViewFrame()->GetFrameWeld();
3218                     SfxNewStyleDlg aDlg(pWindow, *pStyleSheet->GetPool(), pStyleSheet->GetFamily());
3219                     auto nResult = aDlg.run();
3220                     if (nResult == RET_OK)
3221                     {
3222                         aSet.Put(SfxStringItem(SID_STYLE_NEW_BY_EXAMPLE, aDlg.GetName()));
3223                         aSet.Put(SfxStringItem(SID_STYLE_REFERENCE, pStyleSheet->GetName()));
3224                     }
3225                     else
3226                     {
3227                         Cancel();
3228                         rReq.Ignore();
3229                         break;
3230                     }
3231                 }
3232                 else
3233                     aSet.Put(SfxStringItem(nSId, pStyleSheet->GetName()));
3234
3235                 rReq.SetArgs(aSet);
3236             }
3237
3238             if( rReq.GetArgs() )
3239             {
3240                 SetCurrentFunction( FuTemplate::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
3241                 if( rReq.GetSlot() == SID_STYLE_APPLY )
3242                     GetViewFrame()->GetBindings().Invalidate( SID_STYLE_APPLY );
3243                 Cancel();
3244             }
3245             else if( rReq.GetSlot() == SID_STYLE_APPLY )
3246                 GetViewFrame()->GetDispatcher()->Execute( SID_STYLE_DESIGNER, SfxCallMode::ASYNCHRON );
3247             rReq.Ignore ();
3248         }
3249         break;
3250
3251         case SID_IMAP:
3252         {
3253             sal_uInt16      nId = SvxIMapDlgChildWindow::GetChildWindowId();
3254
3255             GetViewFrame()->ToggleChildWindow( nId );
3256             GetViewFrame()->GetBindings().Invalidate( SID_IMAP );
3257
3258             if ( GetViewFrame()->HasChildWindow( nId )
3259                 && ( ( ViewShell::Implementation::GetImageMapDialog() ) != nullptr ) )
3260             {
3261                 if ( rMarkList.GetMarkCount() == 1 )
3262                     UpdateIMapDlg( rMarkList.GetMark( 0 )->GetMarkedSdrObj() );
3263             }
3264
3265             Cancel();
3266             rReq.Ignore ();
3267         }
3268         break;
3269
3270         case SID_GRID_FRONT:
3271         {
3272             mpDrawView->SetGridFront( !mpDrawView->IsGridFront() );
3273             Cancel();
3274             rReq.Done ();
3275         }
3276         break;
3277
3278         case SID_HELPLINES_FRONT:
3279         {
3280             mpDrawView->SetHlplFront( !mpDrawView->IsHlplFront() );
3281             Cancel();
3282             rReq.Done ();
3283         }
3284         break;
3285
3286         case SID_FONTWORK:
3287         {
3288             if ( rReq.GetArgs() )
3289             {
3290                 GetViewFrame()->SetChildWindow(SvxFontWorkChildWindow::GetChildWindowId(),
3291                                         static_cast<const SfxBoolItem&>(rReq.GetArgs()->
3292                                         Get(SID_FONTWORK)).GetValue());
3293             }
3294             else
3295             {
3296                 GetViewFrame()->ToggleChildWindow( SvxFontWorkChildWindow::GetChildWindowId() );
3297             }
3298
3299             GetViewFrame()->GetBindings().Invalidate(SID_FONTWORK);
3300             Cancel();
3301             rReq.Ignore ();
3302         }
3303         break;
3304
3305         case SID_COLOR_CONTROL:
3306         {
3307             if ( rReq.GetArgs() )
3308                 GetViewFrame()->SetChildWindow(SvxColorChildWindow::GetChildWindowId(),
3309                                         rReq.GetArgs()->Get(SID_COLOR_CONTROL).GetValue());
3310             else
3311                 GetViewFrame()->ToggleChildWindow(SvxColorChildWindow::GetChildWindowId() );
3312
3313             GetViewFrame()->GetBindings().Invalidate(SID_COLOR_CONTROL);
3314             Cancel();
3315             rReq.Ignore ();
3316         }
3317         break;
3318
3319         case SID_EXTRUSION_TOGGLE:
3320         case SID_EXTRUSION_TILT_DOWN:
3321         case SID_EXTRUSION_TILT_UP:
3322         case SID_EXTRUSION_TILT_LEFT:
3323         case SID_EXTRUSION_TILT_RIGHT:
3324         case SID_EXTRUSION_3D_COLOR:
3325         case SID_EXTRUSION_DEPTH:
3326         case SID_EXTRUSION_DIRECTION:
3327         case SID_EXTRUSION_PROJECTION:
3328         case SID_EXTRUSION_LIGHTING_DIRECTION:
3329         case SID_EXTRUSION_LIGHTING_INTENSITY:
3330         case SID_EXTRUSION_SURFACE:
3331         case SID_EXTRUSION_DEPTH_FLOATER:
3332         case SID_EXTRUSION_DIRECTION_FLOATER:
3333         case SID_EXTRUSION_LIGHTING_FLOATER:
3334         case SID_EXTRUSION_SURFACE_FLOATER:
3335         case SID_EXTRUSION_DEPTH_DIALOG:
3336             svx::ExtrusionBar::execute( mpDrawView.get(), rReq, GetViewFrame()->GetBindings() );
3337             Cancel();
3338             rReq.Ignore ();
3339             break;
3340
3341         case SID_FONTWORK_SHAPE:
3342         case SID_FONTWORK_SHAPE_TYPE:
3343         case SID_FONTWORK_ALIGNMENT:
3344         case SID_FONTWORK_SAME_LETTER_HEIGHTS:
3345         case SID_FONTWORK_CHARACTER_SPACING:
3346         case SID_FONTWORK_KERN_CHARACTER_PAIRS:
3347         case SID_FONTWORK_GALLERY_FLOATER:
3348         case SID_FONTWORK_CHARACTER_SPACING_FLOATER:
3349         case SID_FONTWORK_ALIGNMENT_FLOATER:
3350         case SID_FONTWORK_CHARACTER_SPACING_DIALOG:
3351             svx::FontworkBar::execute(*mpDrawView, rReq, GetViewFrame()->GetBindings());
3352             Cancel();
3353             rReq.Ignore ();
3354             break;
3355
3356         case SID_BMPMASK:
3357         {
3358             GetViewFrame()->ToggleChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() );
3359             GetViewFrame()->GetBindings().Invalidate( SID_BMPMASK );
3360
3361             Cancel();
3362             rReq.Ignore ();
3363         }
3364         break;
3365
3366         case SID_NAVIGATOR:
3367         {
3368             if (comphelper::LibreOfficeKit::isActive())
3369             {
3370                 GetViewFrame()->ShowChildWindow(SID_SIDEBAR);
3371                 OUString panelId = u"SdNavigatorPanel"_ustr;
3372                 ::sfx2::sidebar::Sidebar::TogglePanel(
3373                     panelId, GetViewFrame()->GetFrame().GetFrameInterface());
3374
3375                 Cancel();
3376                 rReq.Done();
3377             } else {
3378                 if ( rReq.GetArgs() )
3379                     GetViewFrame()->SetChildWindow(SID_NAVIGATOR,
3380                                             static_cast<const SfxBoolItem&>(rReq.GetArgs()->
3381                                             Get(SID_NAVIGATOR)).GetValue());
3382                 else
3383                     GetViewFrame()->ToggleChildWindow( SID_NAVIGATOR );
3384
3385                 GetViewFrame()->GetBindings().Invalidate(SID_NAVIGATOR);
3386                 Cancel();
3387                 rReq.Ignore ();
3388             }
3389         }
3390         break;
3391
3392         case SID_SLIDE_TRANSITIONS_PANEL:
3393         case SID_MASTER_SLIDES_PANEL:
3394         case SID_CUSTOM_ANIMATION_PANEL:
3395         case SID_GALLERY:
3396         {
3397             // First make sure that the sidebar is visible
3398             GetViewFrame()->ShowChildWindow(SID_SIDEBAR);
3399
3400             OUString panelId;
3401             if (nSId == SID_CUSTOM_ANIMATION_PANEL)
3402                 panelId = "SdCustomAnimationPanel";
3403             else if (nSId == SID_GALLERY)
3404                 panelId = "GalleryPanel";
3405             else if (nSId == SID_SLIDE_TRANSITIONS_PANEL)
3406                 panelId = "SdSlideTransitionPanel";
3407             else if (nSId == SID_MASTER_SLIDES_PANEL)
3408                 panelId = "SdAllMasterPagesPanel";
3409
3410             ::sfx2::sidebar::Sidebar::TogglePanel(
3411                 panelId,
3412                 GetViewFrame()->GetFrame().GetFrameInterface());
3413
3414             Cancel();
3415             rReq.Done();
3416         }
3417         break;
3418
3419         case SID_ANIMATION_OBJECTS:
3420         {
3421             if ( rReq.GetArgs() )
3422                 GetViewFrame()->SetChildWindow(
3423                     AnimationChildWindow::GetChildWindowId(),
3424                     static_cast<const SfxBoolItem&>(rReq.GetArgs()->
3425                         Get(SID_ANIMATION_OBJECTS)).GetValue());
3426             else
3427                 GetViewFrame()->ToggleChildWindow(
3428                     AnimationChildWindow::GetChildWindowId() );
3429
3430             GetViewFrame()->GetBindings().Invalidate(SID_ANIMATION_OBJECTS);
3431             Cancel();
3432             rReq.Ignore ();
3433         }
3434         break;
3435
3436         case SID_3D_WIN:
3437         {
3438             if ( rReq.GetArgs() )
3439                 GetViewFrame()->SetChildWindow( Svx3DChildWindow::GetChildWindowId(),
3440                                         static_cast<const SfxBoolItem&>(rReq.GetArgs()->
3441                                         Get( SID_3D_WIN )).GetValue());
3442             else
3443                 GetViewFrame()->ToggleChildWindow( Svx3DChildWindow::GetChildWindowId() );
3444
3445             GetViewFrame()->GetBindings().Invalidate( SID_3D_WIN );
3446             Cancel();
3447             rReq.Ignore ();
3448         }
3449         break;
3450
3451         case SID_CONVERT_TO_3D_LATHE_FAST:
3452         {
3453             /* The call is enough. The initialization via Start3DCreation and
3454                CreateMirrorPolygons is no longer needed if the parameter
3455                sal_True is provided. Then a tilted rotary body with an axis left
3456                besides the bounding rectangle of the selected objects is drawn
3457                immediately and without user interaction.  */
3458             mpDrawView->SdrEndTextEdit();
3459             if(GetActiveWindow())
3460                 GetActiveWindow()->EnterWait();
3461             mpDrawView->End3DCreation(true);
3462             Cancel();
3463             rReq.Ignore();
3464             if(GetActiveWindow())
3465                 GetActiveWindow()->LeaveWait();
3466         }
3467         break;
3468
3469         case SID_PRESENTATION_DLG:
3470         {
3471             SetCurrentFunction( FuSlideShowDlg::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
3472             Cancel();
3473         }
3474         break;
3475
3476         case SID_REMOTE_DLG:
3477         {
3478 #ifdef ENABLE_SDREMOTE
3479              SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
3480              ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateRemoteDialog(GetFrameWeld()));
3481              pDlg->Execute();
3482 #endif
3483         }
3484         break;
3485
3486         case SID_CUSTOMSHOW_DLG:
3487         {
3488             SetCurrentFunction( FuCustomShowDlg::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
3489             Cancel();
3490         }
3491         break;
3492
3493         case SID_EXPAND_PAGE:
3494         {
3495             SetCurrentFunction( FuExpandPage::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
3496             Cancel();
3497         }
3498         break;
3499
3500         case SID_SUMMARY_PAGE:
3501         {
3502             mpDrawView->SdrEndTextEdit();
3503             SetCurrentFunction( FuSummaryPage::Create( this, GetActiveWindow(), mpDrawView.get(), GetDoc(), rReq ) );
3504             Cancel();
3505         }
3506         break;
3507
3508 #if HAVE_FEATURE_AVMEDIA
3509         case SID_AVMEDIA_PLAYER:
3510         {
3511             GetViewFrame()->ToggleChildWindow( ::avmedia::MediaPlayer::GetChildWindowId() );
3512             GetViewFrame()->GetBindings().Invalidate( SID_AVMEDIA_PLAYER );
3513             Cancel();
3514             rReq.Ignore ();
3515         }
3516         break;
3517 #endif
3518
3519         case SID_PRESENTATION_MINIMIZER:
3520         {
3521             const Reference<XComponentContext>& xContext(::comphelper::getProcessComponentContext());
3522             Reference<util::XURLTransformer> xParser(util::URLTransformer::create(xContext));
3523             Reference<frame::XDispatchProvider> xProvider(GetViewShellBase().GetController()->getFrame(), UNO_QUERY);
3524             if (xProvider.is())
3525             {
3526                 util::URL aURL;
3527                 aURL.Complete = "vnd.com.sun.star.comp.PresentationMinimizer:execute";
3528                 xParser->parseStrict(aURL);
3529                 uno::Reference<frame::XDispatch> xDispatch(xProvider->queryDispatch(aURL, OUString(), 0));
3530                 if (xDispatch.is())
3531                 {
3532                     xDispatch->dispatch(aURL, uno::Sequence< beans::PropertyValue >());
3533                 }
3534             }
3535             Cancel();
3536             rReq.Ignore();
3537         }
3538         break;
3539
3540         case SID_DISPLAY_MASTER_BACKGROUND:
3541         case SID_DISPLAY_MASTER_OBJECTS:
3542         {
3543             // Determine current page and toggle visibility of layers
3544             // associated with master page background or master page shapes.
3545             // FIXME: This solution is wrong, because shapes of master pages need
3546             // not be on layer "background" or "backgroundobjects".
3547             // See tdf#118613
3548             SdPage* pPage = GetActualPage();
3549             if (pPage != nullptr
3550                 && GetDoc() != nullptr)
3551             {
3552                 SdrLayerIDSet aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();
3553                 SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
3554                 SdrLayerID aLayerId;
3555                 if (nSId == SID_DISPLAY_MASTER_BACKGROUND)
3556                     aLayerId = rLayerAdmin.GetLayerID(sUNO_LayerName_background);
3557                 else
3558                     aLayerId = rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects);
3559                 aVisibleLayers.Set(aLayerId, !aVisibleLayers.IsSet(aLayerId));
3560                 pPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
3561             }
3562             Cancel();
3563             rReq.Done(); // Mark task as done to auto-update the state of each buttons tdf#132816
3564         }
3565         break;
3566
3567         case SID_PHOTOALBUM:
3568         {
3569             SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
3570             vcl::Window* pWin = GetActiveWindow();
3571             ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateSdPhotoAlbumDialog(
3572                 pWin ? pWin->GetFrameWeld() : nullptr,
3573                 GetDoc()));
3574
3575             pDlg->Execute();
3576             Cancel();
3577             rReq.Ignore ();
3578         }
3579         break;
3580
3581         case SID_INSERT_QRCODE:
3582         case SID_EDIT_QRCODE:
3583         {
3584             VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
3585             const uno::Reference<frame::XModel> xModel = GetViewShellBase().GetController()->getModel();
3586             ScopedVclPtr<AbstractQrCodeGenDialog> pDlg(pFact->CreateQrCodeGenDialog(
3587                 GetFrameWeld(), xModel, rReq.GetSlot() == SID_EDIT_QRCODE));
3588             pDlg->Execute();
3589             Cancel();
3590             rReq.Ignore ();
3591         }
3592         break;
3593
3594         case SID_THEME_DIALOG:
3595         {
3596             SdrPage* pMasterPage = &GetActualPage()->TRG_GetMasterPage();
3597             auto pTheme = pMasterPage->getSdrPageProperties().getTheme();
3598             auto pDialog = std::make_shared<svx::ThemeDialog>(GetFrameWeld(), pTheme.get());
3599             auto* pDocShell = GetDocSh();
3600             weld::DialogController::runAsync(pDialog, [pDialog, pMasterPage, pDocShell](sal_uInt32 nResult)
3601             {
3602                 if (RET_OK != nResult)
3603                     return;
3604
3605                 auto pColorSet = pDialog->getCurrentColorSet();
3606                 if (pColorSet)
3607                 {
3608                     sd::ThemeColorChanger aChanger(pMasterPage, pDocShell);
3609                     aChanger.apply(pColorSet);
3610                 }
3611             });
3612
3613             Cancel();
3614             rReq.Ignore();
3615         }
3616         break;
3617
3618         case SID_ATTR_GLOW_COLOR:
3619         case SID_ATTR_GLOW_RADIUS:
3620         case SID_ATTR_GLOW_TRANSPARENCY:
3621         case SID_ATTR_GLOW_TEXT_COLOR:
3622         case SID_ATTR_GLOW_TEXT_RADIUS:
3623         case SID_ATTR_GLOW_TEXT_TRANSPARENCY:
3624         case SID_ATTR_SOFTEDGE_RADIUS:
3625         case SID_ATTR_TEXTCOLUMNS_NUMBER:
3626         case SID_ATTR_TEXTCOLUMNS_SPACING:
3627             if (const SfxItemSet* pNewArgs = rReq.GetArgs())
3628                 mpDrawView->SetAttributes(*pNewArgs);
3629             rReq.Done();
3630             Cancel();
3631             break;
3632
3633         default:
3634         {
3635             SAL_WARN( "sd.ui", "Slot without function" );
3636             Cancel();
3637             rReq.Ignore ();
3638         }
3639         break;
3640     }
3641
3642     if(HasCurrentFunction())
3643     {
3644         GetCurrentFunction()->Activate();
3645     }
3646 }
3647
3648 void DrawViewShell::ExecChar( SfxRequest &rReq )
3649 {
3650     SdDrawDocument* pDoc = GetDoc();
3651     if (!pDoc || !mpDrawView)
3652         return;
3653
3654     SfxItemSet aEditAttr( pDoc->GetPool() );
3655     mpDrawView->GetAttributes( aEditAttr );
3656
3657     //modified by wj for sym2_1580, if put old itemset into new set,
3658     //when mpDrawView->SetAttributes(aNewAttr) it will invalidate all the item
3659     // and use old attr to update all the attributes
3660 //  SfxItemSet aNewAttr( GetPool(),
3661 //  EE_ITEMS_START, EE_ITEMS_END );
3662 //  aNewAttr.Put( aEditAttr, sal_False );
3663     SfxItemSet aNewAttr( pDoc->GetPool() );
3664     //modified end
3665
3666     sal_uInt16 nSId = rReq.GetSlot();
3667
3668     switch ( nSId )
3669     {
3670     case SID_ATTR_CHAR_FONT:
3671         if( rReq.GetArgs() )
3672         {
3673             const SvxFontItem* pItem = rReq.GetArg<SvxFontItem>(SID_ATTR_CHAR_FONT);
3674             if (pItem)
3675             {
3676                 aNewAttr.Put(*pItem);
3677             }
3678         }
3679         break;
3680     case SID_ATTR_CHAR_FONTHEIGHT:
3681         if( rReq.GetArgs() )
3682         {
3683             const SvxFontHeightItem* pItem = rReq.GetArg<SvxFontHeightItem>(SID_ATTR_CHAR_FONTHEIGHT);
3684             if (pItem)
3685             {
3686                 aNewAttr.Put(*pItem);
3687             }
3688         }
3689         break;
3690     case SID_ATTR_CHAR_WEIGHT:
3691         if( rReq.GetArgs() )
3692         {
3693             const SvxWeightItem* pItem = rReq.GetArg<SvxWeightItem>(SID_ATTR_CHAR_WEIGHT);
3694             if (pItem)
3695             {
3696                 aNewAttr.Put(*pItem);
3697             }
3698         }
3699         break;
3700     case SID_ATTR_CHAR_POSTURE:
3701         if( rReq.GetArgs() )
3702         {
3703             const SvxPostureItem* pItem = rReq.GetArg<SvxPostureItem>(SID_ATTR_CHAR_POSTURE);
3704             if (pItem)
3705             {
3706                 aNewAttr.Put(*pItem);
3707             }
3708         }
3709         break;
3710     case SID_ATTR_CHAR_UNDERLINE:
3711         if( rReq.GetArgs() )
3712         {
3713             const SvxUnderlineItem* pItem = rReq.GetArg<SvxUnderlineItem>(SID_ATTR_CHAR_UNDERLINE);
3714             if (pItem)
3715             {
3716                 aNewAttr.Put(*pItem);
3717             }
3718             else
3719             {
3720                 FontLineStyle eFU = aEditAttr.Get( EE_CHAR_UNDERLINE ).GetLineStyle();
3721                 aNewAttr.Put( SvxUnderlineItem( eFU != LINESTYLE_NONE ?LINESTYLE_NONE : LINESTYLE_SINGLE,  EE_CHAR_UNDERLINE ) );
3722             }
3723         }
3724         break;
3725     case SID_ATTR_CHAR_OVERLINE:
3726         if( rReq.GetArgs() )
3727         {
3728             const SvxOverlineItem* pItem = rReq.GetArg<SvxOverlineItem>(SID_ATTR_CHAR_OVERLINE);
3729             if (pItem)
3730             {
3731                 aNewAttr.Put(*pItem);
3732             }
3733             else
3734             {
3735                 FontLineStyle eFU = aEditAttr.Get( EE_CHAR_OVERLINE ).GetLineStyle();
3736                 aNewAttr.Put( SvxOverlineItem( eFU != LINESTYLE_NONE ?LINESTYLE_NONE : LINESTYLE_SINGLE,  EE_CHAR_OVERLINE ) );
3737             }
3738         }
3739         break;
3740
3741         case SID_ULINE_VAL_NONE:
3742         {
3743             aNewAttr.Put(SvxUnderlineItem(LINESTYLE_NONE, EE_CHAR_UNDERLINE));
3744             break;
3745         }
3746
3747         case SID_ULINE_VAL_SINGLE:
3748         case SID_ULINE_VAL_DOUBLE:
3749         case SID_ULINE_VAL_DOTTED:
3750         {
3751             FontLineStyle eOld = aEditAttr.Get(EE_CHAR_UNDERLINE).GetLineStyle();
3752             FontLineStyle eNew = eOld;
3753
3754             switch (nSId)
3755             {
3756                 case SID_ULINE_VAL_SINGLE:
3757                     eNew = ( eOld == LINESTYLE_SINGLE ) ? LINESTYLE_NONE : LINESTYLE_SINGLE;
3758                     break;
3759                 case SID_ULINE_VAL_DOUBLE:
3760                     eNew = ( eOld == LINESTYLE_DOUBLE ) ? LINESTYLE_NONE : LINESTYLE_DOUBLE;
3761                     break;
3762                 case SID_ULINE_VAL_DOTTED:
3763                     eNew = ( eOld == LINESTYLE_DOTTED ) ? LINESTYLE_NONE : LINESTYLE_DOTTED;
3764                     break;
3765             }
3766
3767             SvxUnderlineItem aUnderline(eNew, EE_CHAR_UNDERLINE);
3768             aNewAttr.Put(aUnderline);
3769         }
3770         break;
3771
3772     case SID_ATTR_CHAR_SHADOWED:
3773         if( rReq.GetArgs() )
3774         {
3775             const SvxShadowedItem* pItem = rReq.GetArg<SvxShadowedItem>(SID_ATTR_CHAR_SHADOWED);
3776             if (pItem)
3777             {
3778                 aNewAttr.Put(*pItem);
3779             }
3780         }
3781         break;
3782     case SID_ATTR_CHAR_CONTOUR:
3783         if( rReq.GetArgs() )
3784         {
3785             const SvxContourItem* pItem = rReq.GetArg<SvxContourItem>(SID_ATTR_CHAR_CONTOUR);
3786             if (pItem)
3787             {
3788                 aNewAttr.Put(*pItem);
3789             }
3790         }
3791         break;
3792
3793     case SID_ATTR_CHAR_STRIKEOUT:
3794         if( rReq.GetArgs() )
3795         {
3796             const SvxCrossedOutItem* pItem = rReq.GetArg<SvxCrossedOutItem>(SID_ATTR_CHAR_STRIKEOUT);
3797             if (pItem)
3798             {
3799                 aNewAttr.Put(*pItem);
3800             }
3801         }
3802         break;
3803     case SID_ATTR_CHAR_COLOR:
3804         if( rReq.GetArgs() )
3805         {
3806             const SvxColorItem* pItem = rReq.GetArg<SvxColorItem>(SID_ATTR_CHAR_COLOR);
3807             if (pItem)
3808             {
3809                 aNewAttr.Put(*pItem);
3810             }
3811         }
3812         break;
3813     case SID_ATTR_CHAR_KERNING:
3814         if( rReq.GetArgs() )
3815         {
3816             const SvxKerningItem* pItem = rReq.GetArg<SvxKerningItem>(SID_ATTR_CHAR_KERNING);
3817             if (pItem)
3818             {
3819                 aNewAttr.Put(*pItem);
3820             }
3821         }
3822         break;
3823     case SID_ATTR_CHAR_CASEMAP:
3824         if( rReq.GetArgs() )
3825         {
3826             const SvxCaseMapItem* pItem = rReq.GetArg<SvxCaseMapItem>(SID_ATTR_CHAR_CASEMAP);
3827             if (pItem)
3828             {
3829                 aNewAttr.Put(*pItem);
3830             }
3831         }
3832         break;
3833     case SID_SET_SMALL_CAPS:
3834         {
3835             SvxCaseMap eCaseMap = aEditAttr.Get(EE_CHAR_CASEMAP).GetCaseMap();
3836             if (eCaseMap == SvxCaseMap::SmallCaps)
3837                 eCaseMap = SvxCaseMap::NotMapped;
3838             else
3839                 eCaseMap = SvxCaseMap::SmallCaps;
3840             SvxCaseMapItem aItem(eCaseMap, EE_CHAR_CASEMAP);
3841             aNewAttr.Put(aItem);
3842         }
3843         break;
3844     case SID_SET_SUB_SCRIPT:
3845         {
3846             SvxEscapementItem aItem( EE_CHAR_ESCAPEMENT );
3847             SvxEscapement eEsc = static_cast<SvxEscapement>(aEditAttr.Get( EE_CHAR_ESCAPEMENT ).GetEnumValue());
3848             if( eEsc == SvxEscapement::Subscript )
3849                 aItem.SetEscapement( SvxEscapement::Off );
3850             else
3851                 aItem.SetEscapement( SvxEscapement::Subscript );
3852             aNewAttr.Put( aItem );
3853         }
3854         break;
3855     case SID_SET_SUPER_SCRIPT:
3856         {
3857             SvxEscapementItem aItem( EE_CHAR_ESCAPEMENT );
3858             SvxEscapement eEsc = static_cast<SvxEscapement>(aEditAttr.Get( EE_CHAR_ESCAPEMENT ).GetEnumValue());
3859             if( eEsc == SvxEscapement::Superscript )
3860                 aItem.SetEscapement( SvxEscapement::Off );
3861             else
3862                 aItem.SetEscapement( SvxEscapement::Superscript );
3863             aNewAttr.Put( aItem );
3864         }
3865         break;
3866     case SID_SHRINK_FONT_SIZE:
3867     case SID_GROW_FONT_SIZE:
3868         {
3869             const SvxFontListItem* pFonts = dynamic_cast<const SvxFontListItem*>(GetDocSh()->GetItem( SID_ATTR_CHAR_FONTLIST ) );
3870             const FontList* pFontList = pFonts ? pFonts->GetFontList() : nullptr;
3871             if( pFontList )
3872             {
3873                 FuText::ChangeFontSize( nSId == SID_GROW_FONT_SIZE, nullptr, pFontList, mpView );
3874                 GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
3875             }
3876             break;
3877         }
3878     case SID_ATTR_CHAR_BACK_COLOR:
3879         if( rReq.GetArgs() )
3880         {
3881             const SvxColorItem* pItem = rReq.GetArg<SvxColorItem>(SID_ATTR_CHAR_BACK_COLOR);
3882             if (pItem)
3883             {
3884                 aNewAttr.Put(*pItem);
3885             }
3886         }
3887         break;
3888     default:
3889         break;
3890     }
3891
3892     mpDrawView->SetAttributes(aNewAttr);
3893     rReq.Done();
3894     Cancel();
3895 }
3896
3897 /** This method consists basically of three parts:
3898     1. Process the arguments of the SFX request.
3899     2. Use the model to create a new page or duplicate an existing one.
3900     3. Update the tab control and switch to the new page.
3901 */
3902 SdPage* DrawViewShell::CreateOrDuplicatePage (
3903     SfxRequest& rRequest,
3904     PageKind ePageKind,
3905     SdPage* pPage,
3906     const sal_Int32 nInsertPosition)
3907 {
3908     SdPage* pNewPage = nullptr;
3909     if (ePageKind == PageKind::Standard && meEditMode != EditMode::MasterPage)
3910     {
3911         if ( mpDrawView->IsTextEdit() )
3912         {
3913             mpDrawView->SdrEndTextEdit();
3914         }
3915         pNewPage = ViewShell::CreateOrDuplicatePage (rRequest, ePageKind, pPage, nInsertPosition);
3916     }
3917     return pNewPage;
3918 }
3919
3920 void DrawViewShell::DuplicateSelectedSlides (SfxRequest& rRequest)
3921 {
3922     // Create a list of the pages that are to be duplicated.  The process of
3923     // duplication alters the selection.
3924     sal_Int32 nInsertPosition (0);
3925     ::std::vector<SdPage*> aPagesToDuplicate;
3926     sd::slidesorter::SlideSorter &mrSlideSorter = sd::slidesorter::SlideSorterViewShell::GetSlideSorter(GetViewShellBase())->GetSlideSorter();
3927     sd::slidesorter::model::PageEnumeration aSelectedPages (
3928         sd::slidesorter::model::PageEnumerationProvider::CreateSelectedPagesEnumeration(mrSlideSorter.GetModel()));
3929     while (aSelectedPages.HasMoreElements())
3930     {
3931         sd::slidesorter::model::SharedPageDescriptor pDescriptor (aSelectedPages.GetNextElement());
3932         if (pDescriptor && pDescriptor->GetPage())
3933         {
3934             aPagesToDuplicate.push_back(pDescriptor->GetPage());
3935             nInsertPosition = pDescriptor->GetPage()->GetPageNum()+2;
3936         }
3937     }
3938
3939     // Duplicate the pages in aPagesToDuplicate and collect the newly
3940     // created pages in aPagesToSelect.
3941     const bool bUndo (aPagesToDuplicate.size()>1 && mrSlideSorter.GetView().IsUndoEnabled());
3942     if (bUndo)
3943         mrSlideSorter.GetView().BegUndo(SdResId(STR_INSERTPAGE));
3944
3945     ::std::vector<SdPage*> aPagesToSelect;
3946     for(::std::vector<SdPage*>::const_iterator
3947             iPage(aPagesToDuplicate.begin()),
3948             iEnd(aPagesToDuplicate.end());
3949         iPage!=iEnd;
3950         ++iPage, nInsertPosition+=2)
3951     {
3952         aPagesToSelect.push_back(
3953             mrSlideSorter.GetViewShell()->CreateOrDuplicatePage(
3954                 rRequest, PageKind::Standard, *iPage, nInsertPosition));
3955     }
3956     aPagesToDuplicate.clear();
3957
3958     if (bUndo)
3959         mrSlideSorter.GetView().EndUndo();
3960
3961     // Set the selection to the pages in aPagesToSelect.
3962     sd::slidesorter::controller::PageSelector& rSelector (mrSlideSorter.GetController().GetPageSelector());
3963     rSelector.DeselectAllPages();
3964     for (auto const& it: aPagesToSelect)
3965     {
3966         rSelector.SelectPage(it);
3967     }
3968 }
3969
3970 void DrawViewShell::ExecutePropPanelAttr (SfxRequest const & rReq)
3971 {
3972     if(SlideShow::IsRunning( GetViewShellBase() )
3973         && !SlideShow::IsInteractiveSlideshow( &GetViewShellBase() )) // IASS
3974         return;
3975
3976     SdDrawDocument* pDoc = GetDoc();
3977     if (!pDoc || !mpDrawView)
3978         return;
3979
3980     sal_uInt16 nSId = rReq.GetSlot();
3981     SfxItemSet aAttrs( pDoc->GetPool() );
3982
3983     switch ( nSId )
3984     {
3985     case SID_TABLE_VERT_NONE:
3986     case SID_TABLE_VERT_CENTER:
3987     case SID_TABLE_VERT_BOTTOM:
3988         SdrTextVertAdjust eTVA = SDRTEXTVERTADJUST_TOP;
3989         if (nSId == SID_TABLE_VERT_CENTER)
3990             eTVA = SDRTEXTVERTADJUST_CENTER;
3991         else if (nSId == SID_TABLE_VERT_BOTTOM)
3992             eTVA = SDRTEXTVERTADJUST_BOTTOM;
3993
3994         aAttrs.Put( SdrTextVertAdjustItem(eTVA) );
3995         mpDrawView->SetAttributes(aAttrs);
3996
3997         break;
3998     }
3999 }
4000
4001 void DrawViewShell::GetStatePropPanelAttr(SfxItemSet& rSet)
4002 {
4003     SfxWhichIter    aIter( rSet );
4004     sal_uInt16          nWhich = aIter.FirstWhich();
4005
4006     SdDrawDocument* pDoc = GetDoc();
4007     if (!pDoc || !mpDrawView)
4008         return;
4009
4010     SfxItemSet aAttrs( pDoc->GetPool() );
4011     mpDrawView->GetAttributes( aAttrs );
4012
4013     while ( nWhich )
4014     {
4015         sal_uInt16 nSlotId = SfxItemPool::IsWhich(nWhich)
4016             ? GetPool().GetSlotId(nWhich)
4017             : nWhich;
4018         switch ( nSlotId )
4019         {
4020             case SID_TABLE_VERT_NONE:
4021             case SID_TABLE_VERT_CENTER:
4022             case SID_TABLE_VERT_BOTTOM:
4023                 bool bContour = false;
4024                 SfxItemState eConState = aAttrs.GetItemState( SDRATTR_TEXT_CONTOURFRAME );
4025                 if( eConState != SfxItemState::INVALID )
4026                 {
4027                     bContour = aAttrs.Get( SDRATTR_TEXT_CONTOURFRAME ).GetValue();
4028                 }
4029                 if (bContour) break;
4030
4031                 SfxItemState eVState = aAttrs.GetItemState( SDRATTR_TEXT_VERTADJUST );
4032                 //SfxItemState eHState = aAttrs.GetItemState( SDRATTR_TEXT_HORZADJUST );
4033
4034                 //if(SfxItemState::INVALID != eVState && SfxItemState::INVALID != eHState)
4035                 if(SfxItemState::INVALID != eVState)
4036                 {
4037                     SdrTextVertAdjust eTVA = aAttrs.Get(SDRATTR_TEXT_VERTADJUST).GetValue();
4038                     bool bSet = (nSlotId == SID_TABLE_VERT_NONE && eTVA == SDRTEXTVERTADJUST_TOP) ||
4039                             (nSlotId == SID_TABLE_VERT_CENTER && eTVA == SDRTEXTVERTADJUST_CENTER) ||
4040                             (nSlotId == SID_TABLE_VERT_BOTTOM && eTVA == SDRTEXTVERTADJUST_BOTTOM);
4041                     rSet.Put(SfxBoolItem(nSlotId, bSet));
4042                 }
4043                 else
4044                 {
4045                     rSet.Put(SfxBoolItem(nSlotId, false));
4046                 }
4047                 break;
4048         }
4049         nWhich = aIter.NextWhich();
4050     }
4051 }
4052
4053 } // end of namespace sd
4054
4055 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */