sc/source/ui/drawfunc/drawsh.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 <svx/svxdlg.hxx>
  21 #include <svx/dialogs.hrc>
  22 #include <sc.hrc>
  23
  24 #include <svx/fontwork.hxx>
  25 #include <svx/svdpage.hxx>
  26 #include <sfx2/app.hxx>
  27 #include <sfx2/objface.hxx>
  28 #include <sfx2/objsh.hxx>
  29 #include <sfx2/request.hxx>
  30 #include <sfx2/dispatch.hxx>
  31 #include <sfx2/viewfrm.hxx>
  32 #include <svl/whiter.hxx>
  33
  34 #include <drawsh.hxx>
  35 #include <drwlayer.hxx>
  36 #include <strings.hrc>
  37 #include <viewdata.hxx>
  38 #include <document.hxx>
  39 #include <drawview.hxx>
  40 #include <scresid.hxx>
  41 #include <svx/svdobj.hxx>
  42 #include <tabvwsh.hxx>
  43 #include <gridwin.hxx>
  44 #include <sfx2/bindings.hxx>
  45
  46 #define ShellClass_ScDrawShell
  47 #include <scslots.hxx>
  48
  49 #include <userdat.hxx>
  50 #include <svl/macitem.hxx>
  51 #include <sfx2/evntconf.hxx>
  52 #include <sfx2/viewsh.hxx>
  53 #include <com/sun/star/util/XModifiable.hpp>
  54 #include <memory>
  55 #include <svx/xlnwtit.hxx>
  56 #include <svx/chrtitem.hxx>
  57 #include <svx/xflgrit.hxx>
  58 #include <tools/UnitConversion.hxx>
  59 #include <comphelper/lok.hxx>
  60 #include <vcl/unohelp2.hxx>
  61
  62 using namespace css;
  63
  64 SFX_IMPL_INTERFACE(ScDrawShell, SfxShell)
  65
  66 namespace
  67 {
  68     void lcl_convertStringArguments(SfxItemSet& rArgs)
  69     {
  70         if (const SvxDoubleItem* pWidthItem = rArgs.GetItemIfSet(SID_ATTR_LINE_WIDTH_ARG, false))
  71         {
  72             double fValue = pWidthItem->GetValue();
  73             // FIXME: different units...
  74             int nPow = 100;
  75             int nValue = fValue * nPow;
  76
  77             XLineWidthItem aItem(nValue);
  78             rArgs.Put(aItem);
  79         }
  80         if (const SfxStringItem* pJSON = rArgs.GetItemIfSet(SID_FILL_GRADIENT_JSON, false))
  81         {
  82             basegfx::BGradient aGradient = basegfx::BGradient::fromJSON(pJSON->GetValue());
  83             XFillGradientItem aItem(aGradient);
  84             rArgs.Put(aItem);
  85         }
  86     }
  87 }
  88
  89 void ScDrawShell::InitInterface_Impl()
  90 {
  91     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT,
  92                                             SfxVisibilityFlags::Standard | SfxVisibilityFlags::Server,
  93                                             ToolbarId::Draw_Objectbar);
  94
  95     GetStaticInterface()->RegisterPopupMenu(u"draw"_ustr);
  96
  97     GetStaticInterface()->RegisterChildWindow(SvxFontWorkChildWindow::GetChildWindowId());
  98 }
  99
 100 // disable the unwanted Accelerators
 101
 102 void ScDrawShell::StateDisableItems( SfxItemSet &rSet )
 103 {
 104     SfxWhichIter aIter(rSet);
 105     sal_uInt16 nWhich = aIter.FirstWhich();
 106
 107     while (nWhich)
 108     {
 109         rSet.DisableItem( nWhich );
 110         nWhich = aIter.NextWhich();
 111     }
 112 }
 113
 114 void ScDrawShell::setModified()
 115 {
 116     const SfxObjectShell* pShell = GetObjectShell();
 117     if ( pShell )
 118     {
 119         css::uno::Reference< css::util::XModifiable > xModif( pShell->GetModel(), css::uno::UNO_QUERY );
 120         if ( xModif.is() )
 121             xModif->setModified( true );
 122     }
 123 }
 124
 125 static void lcl_invalidateTransformAttr(const ScTabViewShell* pViewShell)
 126 {
 127     SfxBindings& rBindings=pViewShell->GetViewFrame().GetBindings();
 128     rBindings.Invalidate(SID_ATTR_TRANSFORM_WIDTH);
 129     rBindings.Invalidate(SID_ATTR_TRANSFORM_HEIGHT);
 130     rBindings.Invalidate(SID_ATTR_TRANSFORM_POS_X);
 131     rBindings.Invalidate(SID_ATTR_TRANSFORM_POS_Y);
 132     rBindings.Invalidate(SID_ATTR_TRANSFORM_ANGLE);
 133     rBindings.Invalidate(SID_ATTR_TRANSFORM_ROT_X);
 134     rBindings.Invalidate(SID_ATTR_TRANSFORM_ROT_Y);
 135     rBindings.Invalidate(SID_ATTR_TRANSFORM_AUTOWIDTH);
 136     rBindings.Invalidate(SID_ATTR_TRANSFORM_AUTOHEIGHT);
 137 }
 138
 139 void ScDrawShell::ExecDrawAttr( SfxRequest& rReq )
 140 {
 141     sal_uInt16              nSlot       = rReq.GetSlot();
 142     vcl::Window*             pWin        = rViewData.GetActiveWin();
 143     ScDrawView*         pView       = rViewData.GetScDrawView();
 144     SdrModel*           pDoc        = rViewData.GetDocument().GetDrawLayer();
 145
 146     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 147     const size_t nMarkCount = rMarkList.GetMarkCount();
 148     SdrObject* pSingleSelectedObj = nullptr;
 149     if ( nMarkCount > 0 )
 150         pSingleSelectedObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 151
 152     switch ( nSlot )
 153     {
 154         case SID_ASSIGNMACRO:
 155             {
 156                 if ( pSingleSelectedObj )
 157                     ExecuteMacroAssign(pSingleSelectedObj, pWin ? pWin->GetFrameWeld() : nullptr);
 158             }
 159             break;
 160
 161         case SID_CELL_FORMAT_RESET:
 162         case SID_TEXT_STANDARD:
 163             {
 164                 SfxItemSetFixed<SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_MINFRAMEHEIGHT,
 165                                 SDRATTR_TEXT_MAXFRAMEHEIGHT, SDRATTR_TEXT_MAXFRAMEWIDTH> aEmptyAttr(GetPool());
 166
 167                 if (ScDrawLayer::IsNoteCaption(pSingleSelectedObj))
 168                     aEmptyAttr.Put(pView->GetAttrFromMarked(true));
 169
 170                 pView->SetAttributes(aEmptyAttr, true);
 171             }
 172             break;
 173         case SID_MOVE_SHAPE_HANDLE:
 174         {
 175             const SfxItemSet *pArgs = rReq.GetArgs ();
 176             if (pArgs && pArgs->Count () >= 3)
 177             {
 178                 const SfxUInt32Item* handleNumItem = rReq.GetArg<SfxUInt32Item>(FN_PARAM_1);
 179                 const SfxUInt32Item* newPosXTwips = rReq.GetArg<SfxUInt32Item>(FN_PARAM_2);
 180                 const SfxUInt32Item* newPosYTwips = rReq.GetArg<SfxUInt32Item>(FN_PARAM_3);
 181                 const SfxInt32Item* OrdNum = rReq.GetArg<SfxInt32Item>(FN_PARAM_4);
 182
 183                 const sal_uLong handleNum = handleNumItem->GetValue();
 184                 const sal_uLong newPosX = convertTwipToMm100(newPosXTwips->GetValue());
 185                 const sal_uLong newPosY = convertTwipToMm100(newPosYTwips->GetValue());
 186
 187                 bool bNegateX = comphelper::LibreOfficeKit::isActive() && rViewData.GetDocument().IsLayoutRTL(rViewData.GetTabNo());
 188                 pView->MoveShapeHandle(handleNum, Point(bNegateX ? -static_cast<tools::Long>(newPosX) : newPosX, newPosY), OrdNum ? OrdNum->GetValue() : -1);
 189             }
 190         }
 191         break;
 192
 193         case SID_ATTR_LINE_STYLE:
 194         case SID_ATTR_LINEEND_STYLE:
 195         case SID_ATTR_LINE_START:
 196         case SID_ATTR_LINE_END:
 197         case SID_ATTR_LINE_DASH:
 198         case SID_ATTR_LINE_WIDTH:
 199         case SID_ATTR_LINE_COLOR:
 200         case SID_ATTR_LINE_TRANSPARENCE:
 201         case SID_ATTR_LINE_JOINT:
 202         case SID_ATTR_LINE_CAP:
 203         case SID_ATTR_FILL_STYLE:
 204         case SID_ATTR_FILL_COLOR:
 205         case SID_ATTR_FILL_GRADIENT:
 206         case SID_ATTR_FILL_HATCH:
 207         case SID_ATTR_FILL_BITMAP:
 208         case SID_ATTR_FILL_TRANSPARENCE:
 209         case SID_ATTR_FILL_FLOATTRANSPARENCE:
 210
 211         // #i25616#
 212         case SID_ATTR_FILL_SHADOW:
 213         case SID_ATTR_SHADOW_TRANSPARENCE:
 214         case SID_ATTR_SHADOW_COLOR:
 215         case SID_ATTR_SHADOW_XDISTANCE:
 216         case SID_ATTR_SHADOW_YDISTANCE:
 217             {
 218                 // if toolbar is vertical :
 219                 if ( !rReq.GetArgs() )
 220                 {
 221                     switch ( nSlot )
 222                     {
 223                         case SID_ATTR_LINE_STYLE:
 224                         case SID_ATTR_LINE_DASH:
 225                         case SID_ATTR_LINE_WIDTH:
 226                         case SID_ATTR_LINE_COLOR:
 227                         case SID_ATTR_LINE_TRANSPARENCE:
 228                         case SID_ATTR_LINE_JOINT:
 229                         case SID_ATTR_LINE_CAP:
 230                             ExecuteLineDlg( rReq );
 231                             break;
 232
 233                         case SID_ATTR_FILL_STYLE:
 234                         case SID_ATTR_FILL_COLOR:
 235                         case SID_ATTR_FILL_GRADIENT:
 236                         case SID_ATTR_FILL_HATCH:
 237                         case SID_ATTR_FILL_BITMAP:
 238                         case SID_ATTR_FILL_TRANSPARENCE:
 239                         case SID_ATTR_FILL_FLOATTRANSPARENCE:
 240
 241                         // #i25616#
 242                         case SID_ATTR_FILL_SHADOW:
 243                         case SID_ATTR_SHADOW_TRANSPARENCE:
 244                         case SID_ATTR_SHADOW_COLOR:
 245                         case SID_ATTR_SHADOW_XDISTANCE:
 246                         case SID_ATTR_SHADOW_YDISTANCE:
 247                             ExecuteAreaDlg( rReq );
 248                             break;
 249
 250                         default:
 251                             break;
 252                     }
 253
 254                     return;
 255
 256                 }
 257
 258                 if( rMarkList.GetMarkCount() != 0 )
 259                 {
 260                     std::unique_ptr<SfxItemSet> pNewArgs = rReq.GetArgs()->Clone();
 261                     lcl_convertStringArguments(*pNewArgs);
 262                     pView->SetAttrToMarked(*pNewArgs, false);
 263                 }
 264                 else
 265                     pView->SetDefaultAttr( *rReq.GetArgs(), false);
 266                 pView->InvalidateAttribs();
 267             }
 268             break;
 269
 270         case SID_ATTRIBUTES_LINE:
 271             ExecuteLineDlg( rReq );
 272             break;
 273
 274         case SID_ATTRIBUTES_AREA:
 275             ExecuteAreaDlg( rReq );
 276             break;
 277
 278         case SID_MEASURE_DLG:
 279             ExecuteMeasureDlg( rReq );
 280             break;
 281
 282         case SID_DRAWTEXT_ATTR_DLG:
 283             ExecuteTextAttrDlg( rReq );
 284             break;
 285
 286         case SID_EDIT_HYPERLINK:
 287             if ( pSingleSelectedObj )
 288                 rViewData.GetDispatcher().Execute( SID_HYPERLINK_DIALOG );
 289             break;
 290
 291         case SID_REMOVE_HYPERLINK:
 292             if ( pSingleSelectedObj )
 293             {
 294                 pSingleSelectedObj->setHyperlink(OUString());
 295                 setModified();
 296             }
 297             break;
 298
 299         case SID_OPEN_HYPERLINK:
 300         case SID_COPY_HYPERLINK_LOCATION:
 301             if ( nMarkCount == 1 )
 302             {
 303                 SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 304                 if ( pObj->IsGroupObject() )
 305                 {
 306                     SdrPageView* pPV = nullptr;
 307                     SdrObject* pHit = pView->PickObj(pWin->PixelToLogic(rViewData.GetMousePosPixel()), pView->getHitTolLog(), pPV, SdrSearchOptions::DEEP);
 308                     if (pHit)
 309                         pObj = pHit;
 310                 }
 311
 312                 if (!pObj->getHyperlink().isEmpty())
 313                 {
 314                     if (nSlot == SID_OPEN_HYPERLINK)
 315                     {
 316                         ScGlobal::OpenURL(pObj->getHyperlink(), OUString(), true);
 317                     }
 318                     else if (nSlot == SID_COPY_HYPERLINK_LOCATION)
 319                     {
 320                         uno::Reference<datatransfer::clipboard::XClipboard> xClipboard
 321                             = GetViewShell()->GetWindow()->GetClipboard();
 322                         vcl::unohelper::TextDataObject::CopyStringTo(pObj->getHyperlink(), xClipboard);
 323                     }
 324                 }
 325             }
 326             break;
 327
 328         case SID_ATTR_TRANSFORM:
 329             {
 330                 if ( rMarkList.GetMarkCount() != 0 )
 331                 {
 332                     const SfxItemSet* pArgs = rReq.GetArgs();
 333
 334                     if( !pArgs )
 335                     {
 336                         if( rMarkList.GetMark(0) != nullptr )
 337                         {
 338                             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 339                             std::shared_ptr<SfxRequest> pRequest = std::make_shared<SfxRequest>(rReq);
 340
 341                             if( pObj->GetObjIdentifier() == SdrObjKind::Caption )
 342                             {
 343                                 // Caption Itemset
 344                                 SfxItemSet aNewAttr(pDoc->GetItemPool());
 345                                 pView->GetAttributes(aNewAttr);
 346                                 // Size and Position Itemset
 347                                 SfxItemSet aNewGeoAttr(pView->GetGeoAttrFromMarked());
 348
 349                                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 350                                 VclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateCaptionDialog(pWin ? pWin->GetFrameWeld() : nullptr, pView));
 351
 352                                 const WhichRangesContainer aRange = pDlg->GetInputRanges( *aNewAttr.GetPool() );
 353                                 SfxItemSet aCombSet( *aNewAttr.GetPool(), aRange );
 354                                 aCombSet.Put( aNewAttr );
 355                                 aCombSet.Put( aNewGeoAttr );
 356                                 pDlg->SetInputSet( &aCombSet );
 357
 358                                 pDlg->StartExecuteAsync([pDlg, pRequest=std::move(pRequest), pView, this](
 359                                                             sal_Int32 nResult){
 360                                     if (nResult == RET_OK)
 361                                     {
 362                                         pRequest->Done(*(pDlg->GetOutputItemSet()));
 363                                         pView->SetAttributes(*pDlg->GetOutputItemSet());
 364                                         pView->SetGeoAttrToMarked(*pDlg->GetOutputItemSet());
 365                                     }
 366
 367                                     lcl_invalidateTransformAttr(rViewData.GetViewShell());
 368                                     pDlg->disposeOnce();
 369                                 });
 370                             }
 371                             else
 372                             {
 373                                 SfxItemSet aNewAttr(pView->GetGeoAttrFromMarked());
 374                                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 375                                 VclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateSvxTransformTabDialog(pWin ? pWin->GetFrameWeld() : nullptr, &aNewAttr, pView));
 376
 377                                 pDlg->StartExecuteAsync([pDlg, pRequest=std::move(pRequest), pView, this](
 378                                                             sal_Int32 nResult){
 379                                     if (nResult == RET_OK)
 380                                     {
 381                                         pRequest->Done(*(pDlg->GetOutputItemSet()));
 382                                         pView->SetGeoAttrToMarked(*pDlg->GetOutputItemSet());
 383                                     }
 384
 385                                     lcl_invalidateTransformAttr(rViewData.GetViewShell());
 386                                     pDlg->disposeOnce();
 387                                 });
 388                             }
 389                         }
 390
 391                     }
 392                     else
 393                         pView->SetGeoAttrToMarked( *pArgs );
 394                 }
 395
 396                 lcl_invalidateTransformAttr(rViewData.GetViewShell());
 397             }
 398             break;
 399
 400         case SID_ATTR_GLOW_COLOR:
 401         case SID_ATTR_GLOW_RADIUS:
 402         case SID_ATTR_GLOW_TRANSPARENCY:
 403         case SID_ATTR_GLOW_TEXT_COLOR:
 404         case SID_ATTR_GLOW_TEXT_RADIUS:
 405         case SID_ATTR_GLOW_TEXT_TRANSPARENCY:
 406         case SID_ATTR_SOFTEDGE_RADIUS:
 407         case SID_ATTR_TEXTCOLUMNS_NUMBER:
 408         case SID_ATTR_TEXTCOLUMNS_SPACING:
 409             if (const SfxItemSet* pNewArgs = rReq.GetArgs())
 410                 pView->SetAttrToMarked(*pNewArgs, false);
 411             rReq.Done();
 412             break;
 413
 414         default:
 415             break;
 416     }
 417 }
 418
 419 void ScDrawShell::ExecuteMacroAssign(SdrObject* pObj, weld::Window* pWin)
 420 {
 421     SvxMacroItem aItem ( SfxGetpApp()->GetPool().GetWhichIDFromSlotID( SID_ATTR_MACROITEM ) );
 422     ScMacroInfo* pInfo = ScDrawLayer::GetMacroInfo( pObj, true );
 423     if ( !pInfo->GetMacro().isEmpty() )
 424     {
 425         SvxMacroTableDtor aTab;
 426         const OUString& sMacro = pInfo->GetMacro();
 427         aTab.Insert(SvMacroItemId::OnClick, SvxMacro(sMacro, OUString()));
 428         aItem.SetMacroTable( aTab );
 429     }
 430
 431     // create empty itemset for macro-dlg
 432     auto xItemSet = std::make_unique<SfxItemSetFixed<SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, SID_EVENTCONFIG, SID_EVENTCONFIG>>( SfxGetpApp()->GetPool() );
 433     xItemSet->Put ( aItem );
 434
 435     SfxEventNamesItem aNamesItem(SID_EVENTCONFIG);
 436     aNamesItem.AddEvent( ScResId(RID_SCSTR_ONCLICK), OUString(), SvMacroItemId::OnClick );
 437     xItemSet->Put( aNamesItem );
 438
 439     css::uno::Reference < css::frame::XFrame > xFrame;
 440     if (GetViewShell())
 441         xFrame = GetViewShell()->GetViewFrame().GetFrame().GetFrameInterface();
 442
 443     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 444     VclPtr<SfxAbstractDialog> pMacroDlg(pFact->CreateEventConfigDialog( pWin, std::move(xItemSet), xFrame ));
 445     pMacroDlg->StartExecuteAsync(
 446         [this, pMacroDlg, pObj, pInfo] (sal_Int32 nResult) mutable -> void
 447         {
 448             ScopedVclPtr<SfxAbstractDialog> pDlgDisposer(std::move(pMacroDlg));
 449             if (nResult != RET_OK)
 450                 return;
 451
 452             const SfxItemSet* pOutSet = pDlgDisposer->GetOutputItemSet();
 453             const SvxMacroItem* pItem = pOutSet->GetItemIfSet( SID_ATTR_MACROITEM, false );
 454             if( !pItem )
 455                 return;
 456
 457             OUString sMacro;
 458             const SvxMacro* pMacro = pItem->GetMacroTable().Get( SvMacroItemId::OnClick );
 459             if ( pMacro )
 460                 sMacro = pMacro->GetMacName();
 461
 462             if ( pObj->IsGroupObject() )
 463             {
 464                 SdrObjList* pOL = pObj->GetSubList();
 465                 for (const rtl::Reference<SdrObject>& pChildObj : *pOL)
 466                 {
 467                     pInfo = ScDrawLayer::GetMacroInfo( pChildObj.get(), true );
 468                     pInfo->SetMacro( sMacro );
 469                 }
 470             }
 471             else
 472                 pInfo->SetMacro( sMacro );
 473             setModified();
 474         }
 475     );
 476
 477 }
 478
 479 void ScDrawShell::ExecuteLineDlg( const SfxRequest& rReq )
 480 {
 481     ScDrawView*         pView       = rViewData.GetScDrawView();
 482     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 483     bool                bHasMarked  = rMarkList.GetMarkCount() != 0;
 484     const SdrObject*    pObj        = nullptr;
 485
 486     std::shared_ptr<SfxRequest> xRequest = std::make_shared<SfxRequest>(rReq);
 487
 488     if( rMarkList.GetMarkCount() == 1 )
 489         pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 490
 491     SfxItemSet  aNewAttr( pView->GetDefaultAttr() );
 492     if( bHasMarked )
 493         pView->MergeAttrFromMarked( aNewAttr, false );
 494
 495     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 496     VclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateSvxLineTabDialog( rViewData.GetDialogParent(),
 497                 &aNewAttr,
 498             rViewData.GetDocument().GetDrawLayer(),
 499             pObj,
 500             bHasMarked));
 501
 502     pDlg->StartExecuteAsync([pDlg, xRequest=std::move(xRequest), pView, bHasMarked](sal_Int32 nResult){
 503         if ( nResult == RET_OK )
 504         {
 505             if( bHasMarked )
 506                 pView->SetAttrToMarked( *pDlg->GetOutputItemSet(), false );
 507             else
 508                 pView->SetDefaultAttr( *pDlg->GetOutputItemSet(), false );
 509
 510             pView->InvalidateAttribs();
 511             xRequest->Done();
 512         }
 513         pDlg->disposeOnce();
 514     });
 515 }
 516
 517 void ScDrawShell::ExecuteAreaDlg( const SfxRequest& rReq )
 518 {
 519     ScDrawView* pView       = rViewData.GetScDrawView();
 520     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 521     bool        bHasMarked  = rMarkList.GetMarkCount() != 0;
 522
 523     std::shared_ptr<SfxRequest> xRequest = std::make_shared<SfxRequest>(rReq);
 524
 525     SfxItemSet  aNewAttr( pView->GetDefaultAttr() );
 526     if( bHasMarked )
 527         pView->MergeAttrFromMarked( aNewAttr, false );
 528
 529     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 530     weld::Window* pWin = rViewData.GetDialogParent();
 531     VclPtr<AbstractSvxAreaTabDialog> pDlg(pFact->CreateSvxAreaTabDialog(
 532         pWin, &aNewAttr,
 533         rViewData.GetDocument().GetDrawLayer(), true, false));
 534
 535     pDlg->StartExecuteAsync([pDlg, xRequest=std::move(xRequest), pView, bHasMarked](sal_Int32 nResult){
 536         if ( nResult == RET_OK )
 537         {
 538             if( bHasMarked )
 539                 pView->SetAttrToMarked( *pDlg->GetOutputItemSet(), false );
 540             else
 541                 pView->SetDefaultAttr( *pDlg->GetOutputItemSet(), false );
 542
 543             pView->InvalidateAttribs();
 544             xRequest->Done();
 545         }
 546         pDlg->disposeOnce();
 547     });
 548 }
 549
 550 void ScDrawShell::ExecuteTextAttrDlg( SfxRequest& rReq )
 551 {
 552     ScDrawView* pView       = rViewData.GetScDrawView();
 553     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 554     bool        bHasMarked  = rMarkList.GetMarkCount() != 0;
 555     SfxItemSet  aNewAttr    ( pView->GetDefaultAttr() );
 556
 557     if( bHasMarked )
 558         pView->MergeAttrFromMarked( aNewAttr, false );
 559
 560     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 561     weld::Window* pWin = rViewData.GetDialogParent();
 562     ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateTextTabDialog(pWin, &aNewAttr, pView));
 563
 564     sal_uInt16 nResult = pDlg->Execute();
 565
 566     if ( RET_OK == nResult )
 567     {
 568         if ( bHasMarked )
 569             pView->SetAttributes( *pDlg->GetOutputItemSet() );
 570         else
 571             pView->SetDefaultAttr( *pDlg->GetOutputItemSet(), false );
 572
 573         pView->InvalidateAttribs();
 574         rReq.Done();
 575     }
 576 }
 577
 578 void ScDrawShell::ExecuteMeasureDlg( SfxRequest& rReq )
 579 {
 580     ScDrawView* pView       = rViewData.GetScDrawView();
 581     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
 582     bool        bHasMarked  = rMarkList.GetMarkCount() != 0;
 583     SfxItemSet  aNewAttr    ( pView->GetDefaultAttr() );
 584
 585     if( bHasMarked )
 586         pView->MergeAttrFromMarked( aNewAttr, false );
 587
 588     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 589     weld::Window* pWin = rViewData.GetDialogParent();
 590     ScopedVclPtr<SfxAbstractDialog> pDlg(pFact->CreateSfxDialog(pWin, aNewAttr, pView, RID_SVXPAGE_MEASURE));
 591
 592     sal_uInt16 nResult = pDlg->Execute();
 593
 594     if ( RET_OK == nResult )
 595     {
 596         if ( bHasMarked )
 597             pView->SetAttrToMarked( *pDlg->GetOutputItemSet(), false );
 598         else
 599             pView->SetDefaultAttr( *pDlg->GetOutputItemSet(), false );
 600
 601         pView->InvalidateAttribs();
 602         rReq.Done();
 603     }
 604 }
 605
 606 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */