sd/source/ui/view/sdview.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
  21 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  22 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
  23
  24 #include <View.hxx>
  25 #include <editeng/outlobj.hxx>
  26 #include <editeng/unolingu.hxx>
  27 #include <svx/obj3d.hxx>
  28 #include <svx/fmview.hxx>
  29 #include <editeng/outliner.hxx>
  30 #include <svx/svdograf.hxx>
  31 #include <svx/svdoole2.hxx>
  32 #include <svx/svdundo.hxx>
  33
  34 #include <vcl/settings.hxx>
  35
  36 #include <sfx2/dispatch.hxx>
  37 #include <svx/svdpagv.hxx>
  38 #include <svx/svdoutl.hxx>
  39 #include <svx/sdr/contact/displayinfo.hxx>
  40
  41 #include <svx/svdetc.hxx>
  42 #include <editeng/editstat.hxx>
  43
  44 #include <sfx2/viewfrm.hxx>
  45 #include <toolkit/helper/vclunohelper.hxx>
  46 #include <svx/xfillit0.hxx>
  47
  48 #include <app.hrc>
  49 #include <strings.hrc>
  50 #include <Window.hxx>
  51 #include <Client.hxx>
  52 #include <drawdoc.hxx>
  53 #include <DrawDocShell.hxx>
  54 #include <sdmod.hxx>
  55 #include <sdpage.hxx>
  56 #include <sdresid.hxx>
  57 #include <unokywds.hxx>
  58 #include <ViewClipboard.hxx>
  59 #include <undo/undomanager.hxx>
  60 #include <svx/sdr/contact/viewobjectcontact.hxx>
  61 #include <svx/sdr/contact/viewcontact.hxx>
  62 #include <svx/svdotable.hxx>
  63 #include <EventMultiplexer.hxx>
  64 #include <ViewShellBase.hxx>
  65 #include <ViewShell.hxx>
  66
  67 #include <basegfx/polygon/b2dpolygontools.hxx>
  68 #include <basegfx/color/bcolor.hxx>
  69 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  70 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
  71 #include <svx/sdr/contact/objectcontact.hxx>
  72 #include <svx/sdr/table/tablecontroller.hxx>
  73 #include <basegfx/matrix/b2dhommatrix.hxx>
  74 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
  75 #include <svx/unoapi.hxx>
  76 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  77 #include <comphelper/lok.hxx>
  78 #include <sfx2/lokhelper.hxx>
  79 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  80 #include <DrawController.hxx>
  81
  82 #include <undo/undomanager.hxx>
  83
  84 #include <memory>
  85 #include <numeric>
  86
  87 using namespace com::sun::star;
  88 using namespace com::sun::star::uno;
  89 using namespace sdr::table;
  90 namespace sd {
  91
  92 View::View(
  93     SdDrawDocument& rDrawDoc,
  94     OutputDevice* pOutDev,
  95     ViewShell* pViewShell)
  96 :   FmFormView(rDrawDoc, pOutDev),
  97     mrDoc(rDrawDoc),
  98     mpDocSh(rDrawDoc.GetDocSh()),
  99     mpViewSh(pViewShell),
 100     mpDropMarkerObj(nullptr),
 101     mnDragSrcPgNum(SDRPAGE_NOTFOUND),
 102     mnAction(DND_ACTION_NONE),
 103     maDropErrorIdle("sd View DropError"),
 104     maDropInsertFileIdle("sd View DropInsertFile"),
 105     mnLockRedrawSmph(0),
 106     mbIsDropAllowed(true),
 107     maSmartTags(*this),
 108     mpClipboard (new ViewClipboard (*this))
 109 {
 110     // #i73602# Use default from the configuration
 111     SetBufferedOverlayAllowed(getOptionsDrawinglayer().IsOverlayBuffer_DrawImpress());
 112
 113     // #i74769#, #i75172# Use default from the configuration
 114     SetBufferedOutputAllowed(getOptionsDrawinglayer().IsPaintBuffer_DrawImpress());
 115
 116     EnableExtendedKeyInputDispatcher(false);
 117     EnableExtendedMouseEventDispatcher(false);
 118
 119     SetUseIncompatiblePathCreateInterface(false);
 120
 121     SetMinMoveDistancePixel(2);
 122     SetHitTolerancePixel(2);
 123     SetMeasureLayer(sUNO_LayerName_measurelines);
 124
 125     // Timer for delayed drop (has to be for MAC)
 126     maDropErrorIdle.SetInvokeHandler( LINK(this, View, DropErrorHdl) );
 127     maDropInsertFileIdle.SetInvokeHandler( LINK(this, View, DropInsertFileHdl) );
 128 }
 129
 130 void View::ImplClearDrawDropMarker()
 131 {
 132     mpDropMarker.reset();
 133 }
 134
 135 View::~View()
 136 {
 137     maSmartTags.Dispose();
 138
 139     // release content of selection clipboard, if we own the content
 140     UpdateSelectionClipboard( true );
 141
 142     maDropErrorIdle.Stop();
 143     maDropInsertFileIdle.Stop();
 144
 145     ImplClearDrawDropMarker();
 146
 147     while(PaintWindowCount())
 148     {
 149         // remove all registered OutDevs
 150         DeleteWindowFromPaintView(GetFirstOutputDevice() /*GetWin(0)*/);
 151     }
 152 }
 153
 154 namespace {
 155
 156 class ViewRedirector : public sdr::contact::ViewObjectContactRedirector
 157 {
 158 public:
 159     ViewRedirector();
 160
 161     // all default implementations just call the same methods at the original. To do something
 162     // different, override the method and at least do what the method does.
 163     virtual drawinglayer::primitive2d::Primitive2DContainer createRedirectedPrimitive2DSequence(
 164         const sdr::contact::ViewObjectContact& rOriginal,
 165         const sdr::contact::DisplayInfo& rDisplayInfo) override;
 166 };
 167
 168 }
 169
 170 ViewRedirector::ViewRedirector()
 171 {
 172 }
 173
 174 drawinglayer::primitive2d::Primitive2DContainer ViewRedirector::createRedirectedPrimitive2DSequence(
 175     const sdr::contact::ViewObjectContact& rOriginal,
 176     const sdr::contact::DisplayInfo& rDisplayInfo)
 177 {
 178     SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
 179     drawinglayer::primitive2d::Primitive2DContainer xRetval;
 180
 181     if(pObject && pObject->getSdrPageFromSdrObject())
 182     {
 183         const bool bDoCreateGeometry(pObject->getSdrPageFromSdrObject()->checkVisibility( rOriginal, rDisplayInfo, true ));
 184
 185         if(!bDoCreateGeometry &&
 186             (( pObject->GetObjInventor() != SdrInventor::Default ) || ( pObject->GetObjIdentifier() != OBJ_PAGE )) )
 187             return xRetval;
 188
 189         PresObjKind eKind(PresObjKind::NONE);
 190         const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive());
 191         const bool bIsMasterPageObject(pObject->getSdrPageFromSdrObject()->IsMasterPage());
 192         const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter());
 193         const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView();
 194         const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage());
 195         const SdPage* pObjectsSdPage = dynamic_cast< SdPage* >(pObject->getSdrPageFromSdrObject());
 196         const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage);
 197
 198         // check if we need to draw a placeholder border. Never do it for
 199         // objects inside a SdrPageObj and never when printing
 200         if(!bIsInsidePageObj && !bIsPrinting)
 201         {
 202             bool bCreateOutline(false);
 203
 204             if( pObject->IsEmptyPresObj() && dynamic_cast< SdrTextObj *>( pObject ) !=  nullptr )
 205             {
 206                 if( !bSubContentProcessing || !pObject->IsNotVisibleAsMaster() )
 207                 {
 208                     eKind = pObjectsSdPage ? pObjectsSdPage->GetPresObjKind(pObject) : PresObjKind::NONE;
 209                     bCreateOutline = true;
 210                 }
 211             }
 212             else if( ( pObject->GetObjInventor() == SdrInventor::Default ) && ( pObject->GetObjIdentifier() == OBJ_TEXT ) )
 213             {
 214                 if( pObjectsSdPage )
 215                 {
 216                     eKind = pObjectsSdPage->GetPresObjKind(pObject);
 217
 218                     if((eKind == PresObjKind::Footer) || (eKind == PresObjKind::Header) || (eKind == PresObjKind::DateTime) || (eKind == PresObjKind::SlideNumber) )
 219                     {
 220                         if( !bSubContentProcessing )
 221                         {
 222                             // only draw a boundary for header&footer objects on the masterpage itself
 223                             bCreateOutline = true;
 224                         }
 225                     }
 226                 }
 227             }
 228             else if( ( pObject->GetObjInventor() == SdrInventor::Default ) && ( pObject->GetObjIdentifier() == OBJ_PAGE ) )
 229             {
 230                 // only for handout page, else this frame will be created for each
 231                 // page preview object in SlideSorter and PagePane
 232                 if(pObjectsSdPage && PageKind::Handout == pObjectsSdPage->GetPageKind())
 233                 {
 234                     bCreateOutline = true;
 235                 }
 236             }
 237
 238             if(bCreateOutline)
 239             {
 240                 // empty presentation objects get a gray frame
 241                 const svtools::ColorConfig aColorConfig;
 242                 const svtools::ColorConfigValue aColor( aColorConfig.GetColorValue( svtools::OBJECTBOUNDARIES ) );
 243
 244                 if( aColor.bIsVisible )
 245                 {
 246                     // get basic object transformation
 247                     const basegfx::BColor aRGBColor(aColor.nColor.getBColor());
 248                     basegfx::B2DHomMatrix aObjectMatrix;
 249                     basegfx::B2DPolyPolygon aObjectPolyPolygon;
 250                     pObject->TRGetBaseGeometry(aObjectMatrix, aObjectPolyPolygon);
 251
 252                     // create dashed border
 253                     {
 254                         // create object polygon
 255                         basegfx::B2DPolygon aPolygon(basegfx::utils::createUnitPolygon());
 256                         aPolygon.transform(aObjectMatrix);
 257
 258                         // create line and stroke attribute
 259                         ::std::vector< double > aDotDashArray;
 260
 261                         aDotDashArray.push_back(160.0);
 262                         aDotDashArray.push_back(80.0);
 263
 264                         const double fFullDotDashLen(::std::accumulate(aDotDashArray.begin(), aDotDashArray.end(), 0.0));
 265                         const drawinglayer::attribute::LineAttribute aLine(aRGBColor);
 266                         const drawinglayer::attribute::StrokeAttribute aStroke(aDotDashArray, fFullDotDashLen);
 267
 268                         // create primitive and add
 269                         const drawinglayer::primitive2d::Primitive2DReference xRef(new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
 270                             aPolygon,
 271                             aLine,
 272                             aStroke));
 273                         xRetval.push_back(xRef);
 274                     }
 275
 276                     // now paint the placeholder description, but only when masterpage
 277                     // is displayed as page directly (MasterPage view)
 278                     if(!bSubContentProcessing && bIsMasterPageObject)
 279                     {
 280                         OUString aObjectString;
 281
 282                         switch( eKind )
 283                         {
 284                             case PresObjKind::Title:
 285                             {
 286                                 if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PageKind::Standard)
 287                                 {
 288                                     static OUString aTitleAreaStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_TITLE));
 289                                     aObjectString = aTitleAreaStr;
 290                                 }
 291
 292                                 break;
 293                             }
 294                             case PresObjKind::Outline:
 295                             {
 296                                 static OUString aOutlineAreaStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_OUTLINE));
 297                                 aObjectString = aOutlineAreaStr;
 298                                 break;
 299                             }
 300                             case PresObjKind::Footer:
 301                             {
 302                                 static OUString aFooterAreaStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_FOOTER));
 303                                 aObjectString = aFooterAreaStr;
 304                                 break;
 305                             }
 306                             case PresObjKind::Header:
 307                             {
 308                                 static OUString aHeaderAreaStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_HEADER));
 309                                 aObjectString = aHeaderAreaStr;
 310                                 break;
 311                             }
 312                             case PresObjKind::DateTime:
 313                             {
 314                                 static OUString aDateTimeStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_DATETIME));
 315                                 aObjectString = aDateTimeStr;
 316                                 break;
 317                             }
 318                             case PresObjKind::Notes:
 319                             {
 320                                 static OUString aDateTimeStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_NOTES));
 321                                 aObjectString = aDateTimeStr;
 322                                 break;
 323                             }
 324                             case PresObjKind::SlideNumber:
 325                             {
 326                                 if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PageKind::Standard)
 327                                 {
 328                                     static OUString aSlideAreaStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_SLIDE));
 329                                     aObjectString = aSlideAreaStr;
 330                                 }
 331                                 else
 332                                 {
 333                                     static OUString aNumberAreaStr(SdResId(STR_PLACEHOLDER_DESCRIPTION_NUMBER));
 334                                     aObjectString = aNumberAreaStr;
 335                                 }
 336                                 break;
 337                             }
 338                             default:
 339                             {
 340                                 break;
 341                             }
 342                         }
 343
 344                         if( !aObjectString.isEmpty() )
 345                         {
 346                             // decompose object matrix to be able to place text correctly
 347                             basegfx::B2DTuple aScale;
 348                             basegfx::B2DTuple aTranslate;
 349                             double fRotate, fShearX;
 350                             aObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
 351
 352                             // create font
 353                             SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObject );
 354                             const SdrTextVertAdjust eTVA(pTextObj ? pTextObj->GetTextVerticalAdjust() : SDRTEXTVERTADJUST_CENTER);
 355                             vcl::Font aScaledVclFont;
 356
 357                             // use a text size factor to get more reliable text sizes from the text layouter
 358                             // (and from vcl), tipp from HDU
 359                             static const sal_uInt32 nTextSizeFactor(100);
 360
 361                             // use a factor to get more linear text size calculations
 362                             aScaledVclFont.SetFontHeight( 500 * nTextSizeFactor );
 363
 364                             // get basic geometry and get text size
 365                             drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
 366                             aTextLayouter.setFont(aScaledVclFont);
 367                             const sal_Int32 nTextLength(aObjectString.getLength());
 368
 369                             // do not forget to use the factor again to get the width for the 500
 370                             const double fTextWidth(aTextLayouter.getTextWidth(aObjectString, 0, nTextLength) * (1.0 / nTextSizeFactor));
 371                             const double fTextHeight(aTextLayouter.getTextHeight() * (1.0 / nTextSizeFactor));
 372
 373                             // calculate text primitive position. If text is at bottom, use top for
 374                             // the extra text and vice versa
 375                             const double fHorDist(125);
 376                             const double fVerDist(125);
 377                             const double fPosX((aTranslate.getX() + aScale.getX()) - fTextWidth - fHorDist);
 378                             const double fPosY((SDRTEXTVERTADJUST_BOTTOM == eTVA)
 379                                 ? aTranslate.getY() - fVerDist + fTextHeight
 380                                 : (aTranslate.getY() + aScale.getY()) - fVerDist);
 381
 382                             // get font attributes; use normally scaled font
 383                             vcl::Font aVclFont;
 384                             basegfx::B2DVector aTextSizeAttribute;
 385
 386                             aVclFont.SetFontHeight( 500 );
 387
 388                             const drawinglayer::attribute::FontAttribute aFontAttribute(
 389                                 drawinglayer::primitive2d::getFontAttributeFromVclFont(
 390                                     aTextSizeAttribute,
 391                                     aVclFont,
 392                                     false,
 393                                     false));
 394
 395                             // fill text matrix
 396                             const basegfx::B2DHomMatrix aTextMatrix(basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
 397                                 aTextSizeAttribute.getX(), aTextSizeAttribute.getY(),
 398                                 fShearX,
 399                                 fRotate,
 400                                 fPosX, fPosY));
 401
 402                             // create DXTextArray (can be empty one)
 403                             const ::std::vector< double > aDXArray{};
 404
 405                             // create locale; this may need some more information in the future
 406                             const css::lang::Locale aLocale;
 407
 408                             // create primitive and add
 409                             const drawinglayer::primitive2d::Primitive2DReference xRef(
 410                                 new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
 411                                     aTextMatrix,
 412                                     aObjectString,
 413                                     0,
 414                                     nTextLength,
 415                                     aDXArray,
 416                                     aFontAttribute,
 417                                     aLocale,
 418                                     aRGBColor));
 419                             xRetval.push_back(xRef);
 420                         }
 421                     }
 422                 }
 423             }
 424         }
 425
 426         if(bDoCreateGeometry)
 427         {
 428             xRetval.append(
 429                 sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(
 430                     rOriginal,
 431                     rDisplayInfo));
 432         }
 433     }
 434     else
 435     {
 436         // not a SdrObject visualisation (maybe e.g. page) or no page
 437         xRetval = sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
 438     }
 439
 440     return xRetval;
 441 }
 442
 443 /**
 444  * The event will be forwarded to the View
 445  */
 446 void View::CompleteRedraw(OutputDevice* pOutDev, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector /*=0*/)
 447 {
 448     // execute ??
 449     if (mnLockRedrawSmph != 0)
 450         return;
 451
 452     SdrPageView* pPgView = GetSdrPageView();
 453
 454     if (pPgView)
 455     {
 456         SdPage* pPage = static_cast<SdPage*>( pPgView->GetPage() );
 457         if( pPage )
 458         {
 459             SdrOutliner& rOutl = mrDoc.GetDrawOutliner();
 460             bool bScreenDisplay(true);
 461
 462             // #i75566# printing; suppress AutoColor BackgroundColor generation
 463             // for visibility reasons by giving GetPageBackgroundColor()
 464             // the needed hint
 465             // #i75566# PDF export; suppress AutoColor BackgroundColor generation (see printing)
 466             if (pOutDev && ((OUTDEV_PRINTER == pOutDev->GetOutDevType())
 467                     || (OUTDEV_PDF == pOutDev->GetOutDevType())))
 468                 bScreenDisplay = false;
 469
 470             // #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and
 471             // hint value if screen display. Only then the AutoColor mechanisms shall be applied
 472             rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor(pPgView, bScreenDisplay) );
 473         }
 474     }
 475
 476     ViewRedirector aViewRedirector;
 477     FmFormView::CompleteRedraw(pOutDev, rReg, pRedirector ? pRedirector : &aViewRedirector);
 478 }
 479
 480 void View::MarkListHasChanged()
 481 {
 482     FmFormView::MarkListHasChanged();
 483
 484     if( GetMarkedObjectCount() > 0 )
 485         maSmartTags.deselect();
 486 }
 487
 488 bool View::SetAttributes(const SfxItemSet& rSet, bool bReplaceAll, bool /*bSlide*/, bool /*bMaster*/)
 489 {
 490     bool bOk = FmFormView::SetAttributes(rSet, bReplaceAll);
 491     return bOk;
 492 }
 493
 494 void View::GetAttributes( SfxItemSet& rTargetSet, bool bOnlyHardAttr ) const
 495 {
 496     FmFormView::GetAttributes( rTargetSet, bOnlyHardAttr );
 497 }
 498
 499 /**
 500  * Is a presentation object selected?
 501  */
 502 bool View::IsPresObjSelected(bool bOnPage, bool bOnMasterPage, bool bCheckPresObjListOnly, bool bCheckLayoutOnly) const
 503 {
 504     SdrMarkList* pMarkList;
 505
 506     if (mnDragSrcPgNum != SDRPAGE_NOTFOUND &&
 507         mnDragSrcPgNum != GetSdrPageView()->GetPage()->GetPageNum())
 508     {
 509         /* Drag&Drop is in progress
 510            Source and destination page are different:
 511            we use the saved mark list */
 512         pMarkList = mpDragSrcMarkList.get();
 513     }
 514     else
 515     {
 516         // We use the current mark list
 517         pMarkList = new SdrMarkList(GetMarkedObjectList());
 518     }
 519
 520     SdrMark* pMark;
 521     SdPage* pPage;
 522
 523     bool bSelected = false;
 524     bool bMasterPage = false;
 525
 526     for (size_t nMark = pMarkList->GetMarkCount(); nMark && !bSelected; )
 527     {
 528         --nMark;
 529         // Backwards through mark list
 530         pMark = pMarkList->GetMark(nMark);
 531         SdrObject* pObj = pMark->GetMarkedSdrObj();
 532
 533         if ( pObj && ( bCheckPresObjListOnly || pObj->IsEmptyPresObj() || pObj->GetUserCall() ) )
 534         {
 535             pPage = static_cast<SdPage*>( pObj->getSdrPageFromSdrObject() );
 536             bMasterPage = pPage && pPage->IsMasterPage();
 537
 538             if ( (bMasterPage && bOnMasterPage) || (!bMasterPage && bOnPage) )
 539             {
 540                 if ( pPage && pPage->IsPresObj(pObj) )
 541                 {
 542                     if( bCheckLayoutOnly )
 543                     {
 544                         PresObjKind eKind = pPage->GetPresObjKind(pObj);
 545
 546                         if((eKind != PresObjKind::Footer) && (eKind != PresObjKind::Header) && (eKind != PresObjKind::DateTime) && (eKind != PresObjKind::SlideNumber) )
 547                             bSelected = true;
 548                     }
 549                     else
 550                     {
 551                         bSelected = true;
 552                     }
 553                 }
 554             }
 555         }
 556     }
 557
 558     if (pMarkList != mpDragSrcMarkList.get())
 559     {
 560        delete pMarkList;
 561     }
 562
 563     return bSelected;
 564 }
 565
 566 void View::SelectAll()
 567 {
 568     if ( IsTextEdit() )
 569     {
 570         OutlinerView* pOLV = GetTextEditOutlinerView();
 571         const ::Outliner* pOutliner = GetTextEditOutliner();
 572         pOLV->SelectRange( 0, pOutliner->GetParagraphCount() );
 573     }
 574     else
 575     {
 576         MarkAll();
 577     }
 578 }
 579
 580 bool View::SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr)
 581 {
 582     // forward to SdrView
 583     FmFormView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr);
 584     return true;
 585 }
 586
 587 /**
 588  * Start text input
 589  */
 590 static void SetSpellOptions( const SdDrawDocument& rDoc, EEControlBits& rCntrl )
 591 {
 592     bool bOnlineSpell = rDoc.GetOnlineSpell();
 593
 594     if( bOnlineSpell )
 595         rCntrl |= EEControlBits::ONLINESPELLING;
 596     else
 597         rCntrl &= ~EEControlBits::ONLINESPELLING;
 598 }
 599
 600 void OutlinerMasterViewFilter::Start(SdrOutliner *pOutl)
 601 {
 602     m_pOutl = pOutl;
 603     OutlinerView* pOutlView = m_pOutl->GetView(0);
 604     m_bReadOnly = pOutlView->IsReadOnly();
 605     pOutlView->SetReadOnly(true);
 606 }
 607
 608 void OutlinerMasterViewFilter::End()
 609 {
 610     if (m_pOutl)
 611     {
 612         OutlinerView* pOutlView = m_pOutl->GetView(0);
 613         pOutlView->SetReadOnly(m_bReadOnly);
 614         m_pOutl = nullptr;
 615     }
 616 }
 617
 618 SfxViewShell* View::GetSfxViewShell() const
 619 {
 620     SfxViewShell* pRet = nullptr;
 621
 622     if (mpViewSh)
 623         pRet = &mpViewSh->GetViewShellBase();
 624
 625     return pRet;
 626 }
 627
 628 // Create a new view-local UndoManager manager for Impress/Draw
 629 std::unique_ptr<SdrUndoManager> View::createLocalTextUndoManager()
 630 {
 631     std::unique_ptr<SdrUndoManager> pUndoManager(new sd::UndoManager);
 632     pUndoManager->SetDocShell(mpDocSh);
 633     return pUndoManager;
 634 }
 635
 636 bool View::SdrBeginTextEdit(
 637     SdrObject* pObj, SdrPageView* pPV, vcl::Window* pWin,
 638     bool bIsNewObj,
 639     SdrOutliner* pOutl, OutlinerView* pGivenOutlinerView,
 640     bool bDontDeleteOutliner, bool bOnlyOneView, bool bGrabFocus )
 641 {
 642     SdrPage* pPage = pObj ? pObj->getSdrPageFromSdrObject() : nullptr;
 643     bool bMasterPage = pPage && pPage->IsMasterPage();
 644
 645     GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
 646         EventMultiplexerEventId::BeginTextEdit, static_cast<void*>(pObj) );
 647
 648     if( pOutl==nullptr && pObj )
 649         pOutl = SdrMakeOutliner(OutlinerMode::TextObject, pObj->getSdrModelFromSdrObject()).release();
 650
 651     // make draw&impress specific initialisations
 652     if( pOutl )
 653     {
 654         pOutl->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>( mrDoc.GetStyleSheetPool() ));
 655         pOutl->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
 656         EEControlBits nCntrl = pOutl->GetControlWord();
 657         nCntrl |= EEControlBits::ALLOWBIGOBJS;
 658         nCntrl |= EEControlBits::MARKFIELDS;
 659         nCntrl |= EEControlBits::AUTOCORRECT;
 660
 661         nCntrl &= ~EEControlBits::ULSPACESUMMATION;
 662         if ( mrDoc.IsSummationOfParagraphs() )
 663             nCntrl |= EEControlBits::ULSPACESUMMATION;
 664
 665         SetSpellOptions( mrDoc, nCntrl );
 666
 667         pOutl->SetControlWord(nCntrl);
 668
 669         Reference< linguistic2::XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
 670         if ( xSpellChecker.is() )
 671             pOutl->SetSpeller( xSpellChecker );
 672
 673         Reference< linguistic2::XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
 674         if( xHyphenator.is() )
 675             pOutl->SetHyphenator( xHyphenator );
 676
 677         pOutl->SetDefaultLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() );
 678     }
 679
 680     bool bReturn = FmFormView::SdrBeginTextEdit(
 681         pObj, pPV, pWin, bIsNewObj, pOutl,
 682         pGivenOutlinerView, bDontDeleteOutliner,
 683         bOnlyOneView, bGrabFocus);
 684
 685     if ( mpViewSh )
 686     {
 687         mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
 688
 689         if (pObj && pObj->GetObjIdentifier() == OBJ_TABLE)
 690             mpViewSh->UpdateScrollBars();
 691
 692         if (comphelper::LibreOfficeKit::isActive())
 693         {
 694             if (OutlinerView* pView = GetTextEditOutlinerView())
 695             {
 696                 ::tools::Rectangle aRectangle = pView->GetOutputArea();
 697                 if (pWin && pWin->GetMapMode().GetMapUnit() == MapUnit::Map100thMM)
 698                     aRectangle = OutputDevice::LogicToLogic(aRectangle, MapMode(MapUnit::Map100thMM), MapMode(MapUnit::MapTwip));
 699                 OString sRectangle = aRectangle.toString();
 700                 SfxLokHelper::notifyOtherViews(&mpViewSh->GetViewShellBase(), LOK_CALLBACK_VIEW_LOCK, "rectangle", sRectangle);
 701             }
 702         }
 703     }
 704
 705     if (::Outliner* pOL = bReturn ? GetTextEditOutliner() : nullptr)
 706     {
 707         if (pObj)
 708         {
 709             if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_TABLE )
 710             {
 711                 Color aBackground = GetTextEditBackgroundColor(*this);
 712                 pOL->SetBackgroundColor( aBackground  );
 713             }
 714             else
 715             {
 716                 pObj->setSuitableOutlinerBg(*pOL);
 717             }
 718         }
 719
 720         pOL->SetParaInsertedHdl(LINK(this, View, OnParagraphInsertedHdl));
 721         pOL->SetParaRemovingHdl(LINK(this, View, OnParagraphRemovingHdl));
 722     }
 723
 724     if (bMasterPage && bReturn && pOutl)
 725     {
 726         const SdrTextObj* pTextObj = pOutl->GetTextObj();
 727         const SdPage* pSdPage = pTextObj ? static_cast<const SdPage*>(pTextObj->getSdrPageFromSdrObject()) : nullptr;
 728         const PresObjKind eKind = pSdPage ? pSdPage->GetPresObjKind(const_cast<SdrTextObj*>(pTextObj)) : PresObjKind::NONE;
 729         switch (eKind)
 730         {
 731             case PresObjKind::Title:
 732             case PresObjKind::Outline:
 733             case PresObjKind::Text:
 734                 maMasterViewFilter.Start(pOutl);
 735                 break;
 736             default:
 737                 break;
 738         }
 739     }
 740
 741     return bReturn;
 742 }
 743
 744 /** ends current text editing */
 745 SdrEndTextEditKind View::SdrEndTextEdit(bool bDontDeleteReally)
 746 {
 747     maMasterViewFilter.End();
 748
 749     ::tools::WeakReference<SdrTextObj> xObj( GetTextEditObject() );
 750
 751     bool bDefaultTextRestored = RestoreDefaultText( xObj.get() );
 752
 753     SdrEndTextEditKind eKind = FmFormView::SdrEndTextEdit(bDontDeleteReally);
 754
 755     if( bDefaultTextRestored )
 756     {
 757         if( xObj.is() && !xObj->IsEmptyPresObj() )
 758         {
 759             xObj->SetEmptyPresObj( true );
 760         }
 761         else
 762         {
 763             eKind = SdrEndTextEditKind::Unchanged;
 764         }
 765     }
 766     else if( xObj.is() && xObj->IsEmptyPresObj() )
 767     {
 768         SdrTextObj* pObj = xObj.get();
 769         if( pObj && pObj->HasText() )
 770         {
 771             SdrPage* pPage = pObj->getSdrPageFromSdrObject();
 772             if( !pPage || !pPage->IsMasterPage() )
 773                 pObj->SetEmptyPresObj( false );
 774         }
 775     }
 776
 777     GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
 778         EventMultiplexerEventId::EndTextEdit,
 779         static_cast<void*>(xObj.get()) );
 780
 781     if( xObj.is() )
 782     {
 783         if ( mpViewSh )
 784         {
 785             mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
 786
 787             if (comphelper::LibreOfficeKit::isActive())
 788                 SfxLokHelper::notifyOtherViews(&mpViewSh->GetViewShellBase(), LOK_CALLBACK_VIEW_LOCK, "rectangle", "EMPTY");
 789
 790         }
 791
 792         SdPage* pPage = dynamic_cast< SdPage* >( xObj->getSdrPageFromSdrObject() );
 793         if( pPage )
 794             pPage->onEndTextEdit( xObj.get() );
 795     }
 796
 797     return eKind;
 798 }
 799
 800 /** restores the default text if the given text object is currently in edit mode and
 801     no text has been entered already. Is only useful just before text edit ends. */
 802 bool View::RestoreDefaultText( SdrTextObj* pTextObj )
 803 {
 804     bool bRestored = false;
 805
 806     if( pTextObj && (pTextObj == GetTextEditObject()) )
 807     {
 808         if( !pTextObj->HasText() )
 809         {
 810             SdPage* pPage = dynamic_cast< SdPage* >( pTextObj->getSdrPageFromSdrObject() );
 811
 812             if(pPage)
 813             {
 814                 bRestored = pPage->RestoreDefaultText( pTextObj );
 815                 if( bRestored )
 816                 {
 817                     SdrOutliner* pOutliner = GetTextEditOutliner();
 818                     pTextObj->SetTextEditOutliner( pOutliner );
 819                     OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
 820                     if (pOutliner)
 821                         pOutliner->SetText(*pParaObj);
 822                 }
 823             }
 824         }
 825     }
 826
 827     return bRestored;
 828 }
 829
 830 /**
 831  * Sets the original size of the marked objects.
 832  */
 833 void View::SetMarkedOriginalSize()
 834 {
 835     std::unique_ptr<SdrUndoGroup> pUndoGroup(new SdrUndoGroup(mrDoc));
 836     const size_t nCount = GetMarkedObjectCount();
 837     bool            bOK = false;
 838
 839     for( size_t i = 0; i < nCount; ++i )
 840     {
 841         SdrObject* pObj = GetMarkedObjectByIndex(i);
 842
 843         if( pObj->GetObjInventor() == SdrInventor::Default )
 844         {
 845             if( pObj->GetObjIdentifier() == OBJ_OLE2 )
 846             {
 847                 uno::Reference < embed::XEmbeddedObject > xObj = static_cast<SdrOle2Obj*>(pObj)->GetObjRef();
 848                 if( xObj.is() )
 849                 {
 850                     // TODO/LEAN: working with VisualArea can switch object to running state
 851
 852                     sal_Int64 nAspect = static_cast<SdrOle2Obj*>(pObj)->GetAspect();
 853                     Size aOleSize;
 854
 855                     if ( nAspect == embed::Aspects::MSOLE_ICON )
 856                     {
 857                         MapMode aMap100( MapUnit::Map100thMM );
 858                         aOleSize = static_cast<SdrOle2Obj*>(pObj)->GetOrigObjSize( &aMap100 );
 859                         bOK = true;
 860                     }
 861                     else
 862                     {
 863                         MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) );
 864                         try
 865                         {
 866                             awt::Size aSz = xObj->getVisualAreaSize( nAspect );
 867                             aOleSize = OutputDevice::LogicToLogic(Size(aSz.Width, aSz.Height), MapMode(aUnit), MapMode(MapUnit::Map100thMM));
 868                             bOK = true;
 869                         }
 870                         catch( embed::NoVisualAreaSizeException& )
 871                         {}
 872                     }
 873
 874                     if ( bOK )
 875                     {
 876                         ::tools::Rectangle   aDrawRect( pObj->GetLogicRect() );
 877
 878                         pUndoGroup->AddAction( mrDoc.GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) );
 879                         pObj->Resize( aDrawRect.TopLeft(), Fraction( aOleSize.Width(), aDrawRect.GetWidth() ),
 880                                                            Fraction( aOleSize.Height(), aDrawRect.GetHeight() ) );
 881                     }
 882                 }
 883             }
 884             else if( pObj->GetObjIdentifier() == OBJ_GRAF )
 885             {
 886                 const SdrGrafObj* pSdrGrafObj = static_cast< const SdrGrafObj* >(pObj);
 887                 const Size aSize = pSdrGrafObj->getOriginalSize( );
 888                 pUndoGroup->AddAction( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj ) );
 889                 ::tools::Rectangle aRect( pObj->GetLogicRect() );
 890                 aRect.SetSize( aSize );
 891                 pObj->SetLogicRect( aRect );
 892                 bOK = true;
 893             }
 894         }
 895     }
 896
 897     if( bOK )
 898     {
 899         pUndoGroup->SetComment(SdResId(STR_UNDO_ORIGINALSIZE));
 900         mpDocSh->GetUndoManager()->AddUndoAction(std::move(pUndoGroup));
 901     }
 902 }
 903
 904 /**
 905  * Connect OLE object to client.
 906  */
 907 void View::DoConnect(SdrOle2Obj* pObj)
 908 {
 909     if (!mpViewSh)
 910         return;
 911
 912     uno::Reference < embed::XEmbeddedObject > xObj( pObj->GetObjRef() );
 913     if( !xObj.is() )
 914         return;
 915
 916     ::sd::Window* pWindow = mpViewSh->GetActiveWindow();
 917     SfxInPlaceClient* pSdClient = mpViewSh-> GetViewShellBase().FindIPClient( xObj, pWindow );
 918     if ( pSdClient )
 919         return;
 920
 921     pSdClient = new Client(pObj, mpViewSh, pWindow);
 922     ::tools::Rectangle aRect = pObj->GetLogicRect();
 923     {
 924         // TODO/LEAN: working with visual area can switch object to running state
 925         Size aDrawSize = aRect.GetSize();
 926
 927         MapMode aMapMode( mrDoc.GetScaleUnit() );
 928         Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
 929
 930         Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
 931         Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
 932         aScaleWidth.ReduceInaccurate(10);       // compatible to SdrOle2Obj
 933         aScaleHeight.ReduceInaccurate(10);
 934         pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
 935
 936         // visible area is only changed in-place!
 937         // the object area must be set after the scaling, since it triggers resize
 938         aRect.SetSize(aObjAreaSize);
 939         pSdClient->SetObjArea(aRect);
 940     }
 941 }
 942
 943 bool View::IsMorphingAllowed() const
 944 {
 945     const SdrMarkList&  rMarkList = GetMarkedObjectList();
 946     bool                bRet = false;
 947
 948     if ( rMarkList.GetMarkCount() == 2 )
 949     {
 950         const SdrObject*    pObj1 = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
 951         const SdrObject*    pObj2 = rMarkList.GetMark( 1 )->GetMarkedSdrObj();
 952         const sal_uInt16        nKind1 = pObj1->GetObjIdentifier();
 953         const sal_uInt16        nKind2 = pObj2->GetObjIdentifier();
 954
 955         if ( ( nKind1 != OBJ_TEXT && nKind2 != OBJ_TEXT ) &&
 956              ( nKind1 != OBJ_TITLETEXT && nKind2 != OBJ_TITLETEXT ) &&
 957              ( nKind1 != OBJ_OUTLINETEXT && nKind2 != OBJ_OUTLINETEXT ) &&
 958              ( nKind1 != OBJ_GRUP && nKind2 != OBJ_GRUP ) &&
 959              ( nKind1 != OBJ_LINE && nKind2 != OBJ_LINE ) &&
 960              ( nKind1 != OBJ_PLIN && nKind2 != OBJ_PLIN ) &&
 961              ( nKind1 != OBJ_PATHLINE && nKind2 != OBJ_PATHLINE ) &&
 962              ( nKind1 != OBJ_FREELINE && nKind2 != OBJ_FREELINE ) &&
 963              ( nKind1 != OBJ_PATHPLIN && nKind2 != OBJ_PATHPLIN ) &&
 964              ( nKind1 != OBJ_MEASURE && nKind2 != OBJ_MEASURE ) &&
 965              ( nKind1 != OBJ_EDGE && nKind2 != OBJ_EDGE ) &&
 966              ( nKind1 != OBJ_GRAF && nKind2 != OBJ_GRAF ) &&
 967              ( nKind1 != OBJ_OLE2 && nKind2 != OBJ_OLE2 ) &&
 968              ( nKind1 != OBJ_CAPTION && nKind2 !=  OBJ_CAPTION ) &&
 969              dynamic_cast< const E3dObject *>( pObj1 ) == nullptr && dynamic_cast< const E3dObject *>( pObj2 ) ==  nullptr )
 970         {
 971             SfxItemSet      aSet1( mrDoc.GetPool(), svl::Items<XATTR_FILLSTYLE, XATTR_FILLSTYLE>{} );
 972             SfxItemSet      aSet2( mrDoc.GetPool(), svl::Items<XATTR_FILLSTYLE, XATTR_FILLSTYLE>{} );
 973
 974             aSet1.Put(pObj1->GetMergedItemSet());
 975             aSet2.Put(pObj2->GetMergedItemSet());
 976
 977             const drawing::FillStyle eFillStyle1 = aSet1.Get( XATTR_FILLSTYLE ).GetValue();
 978             const drawing::FillStyle eFillStyle2 = aSet2.Get( XATTR_FILLSTYLE ).GetValue();
 979
 980             if( ( eFillStyle1 == drawing::FillStyle_NONE || eFillStyle1 == drawing::FillStyle_SOLID ) &&
 981                 ( eFillStyle2 == drawing::FillStyle_NONE || eFillStyle2 == drawing::FillStyle_SOLID ) )
 982                 bRet = true;
 983         }
 984     }
 985
 986     return bRet;
 987 }
 988
 989 bool View::IsVectorizeAllowed() const
 990 {
 991     const SdrMarkList&  rMarkList = GetMarkedObjectList();
 992     bool                bRet = false;
 993
 994     if( rMarkList.GetMarkCount() == 1 )
 995     {
 996         const SdrGrafObj* pObj = dynamic_cast< const SdrGrafObj* >(rMarkList.GetMark( 0 )->GetMarkedSdrObj());
 997
 998         if(pObj)
 999         {
1000             if(GraphicType::Bitmap == pObj->GetGraphicType() && !pObj->isEmbeddedVectorGraphicData())
1001             {
1002                 bRet = true;
1003             }
1004         }
1005     }
1006
1007     return bRet;
1008 }
1009
1010 void View::onAccessibilityOptionsChanged()
1011 {
1012     if( !mpViewSh )
1013         return;
1014
1015     ::sd::Window* pWindow = mpViewSh->GetActiveWindow();
1016     if( !pWindow )
1017         return;
1018
1019     const StyleSettings& rStyleSettings = pWindow->GetSettings().GetStyleSettings();
1020
1021     SvtAccessibilityOptions& aAccOptions = getAccessibilityOptions();
1022
1023     if( mpViewSh->GetViewFrame() && mpViewSh->GetViewFrame()->GetDispatcher() )
1024     {
1025         sal_uInt16 nOutputSlot, nPreviewSlot;
1026
1027         if( rStyleSettings.GetHighContrastMode() )
1028         {
1029             nOutputSlot = SID_OUTPUT_QUALITY_CONTRAST;
1030         }
1031         else
1032         {
1033             nOutputSlot = SID_OUTPUT_QUALITY_COLOR;
1034         }
1035
1036         if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() )
1037         {
1038             nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST;
1039         }
1040         else
1041         {
1042             nPreviewSlot = SID_PREVIEW_QUALITY_COLOR;
1043         }
1044
1045         mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nOutputSlot, SfxCallMode::ASYNCHRON );
1046         mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nPreviewSlot, SfxCallMode::ASYNCHRON );
1047     }
1048
1049     mpViewSh->Invalidate();
1050 }
1051
1052 IMPL_LINK( View, OnParagraphInsertedHdl, ::Outliner::ParagraphHdlParam, aParam, void )
1053 {
1054     SdrObject* pObj = GetTextEditObject();
1055
1056     if( aParam.pPara && pObj )
1057     {
1058         SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
1059         if( pPage )
1060             pPage->onParagraphInserted( aParam.pOutliner, aParam.pPara, pObj );
1061     }
1062 }
1063
1064 /**
1065  * Handler for the deletion of the pages (paragraphs).
1066  */
1067 IMPL_LINK( View, OnParagraphRemovingHdl, ::Outliner::ParagraphHdlParam, aParam, void )
1068 {
1069     SdrObject* pObj = GetTextEditObject();
1070
1071     if( aParam.pPara && pObj )
1072     {
1073         SdPage* pPage = dynamic_cast< SdPage* >( pObj->getSdrPageFromSdrObject() );
1074         if( pPage )
1075             pPage->onParagraphRemoving( aParam.pOutliner, aParam.pPara, pObj );
1076     }
1077 }
1078
1079 bool View::isRecordingUndo() const
1080 {
1081     if( mrDoc.IsUndoEnabled() )
1082     {
1083         sd::UndoManager* pUndoManager = mrDoc.GetUndoManager();
1084         return pUndoManager && pUndoManager->IsInListAction();
1085     }
1086     else
1087     {
1088         return false;
1089     }
1090 }
1091
1092 void View::AddCustomHdl()
1093 {
1094     maSmartTags.addCustomHandles( maHdlList );
1095 }
1096
1097 void View::updateHandles()
1098 {
1099     AdjustMarkHdl();
1100 }
1101
1102 SdrViewContext View::GetContext() const
1103 {
1104     SdrViewContext eContext = SdrViewContext::Standard;
1105     if( maSmartTags.getContext( eContext ) )
1106         return eContext;
1107     else
1108         return FmFormView::GetContext();
1109 }
1110
1111 bool View::HasMarkablePoints() const
1112 {
1113     if( maSmartTags.HasMarkablePoints() )
1114         return true;
1115     else
1116         return FmFormView::HasMarkablePoints();
1117 }
1118
1119 sal_Int32 View::GetMarkablePointCount() const
1120 {
1121     sal_Int32 nCount = FmFormView::GetMarkablePointCount();
1122     nCount += maSmartTags.GetMarkablePointCount();
1123     return nCount;
1124 }
1125
1126 bool View::HasMarkedPoints() const
1127 {
1128     if( maSmartTags.HasMarkedPoints() )
1129         return true;
1130     else
1131         return FmFormView::HasMarkedPoints();
1132 }
1133
1134 bool View::MarkPoint(SdrHdl& rHdl, bool bUnmark )
1135 {
1136     if( maSmartTags.MarkPoint( rHdl, bUnmark ) )
1137         return true;
1138     else
1139         return FmFormView::MarkPoint( rHdl, bUnmark );
1140 }
1141
1142 bool View::MarkPoints(const ::tools::Rectangle* pRect, bool bUnmark)
1143 {
1144     if( maSmartTags.MarkPoints( pRect, bUnmark ) )
1145         return true;
1146     else
1147         return FmFormView::MarkPoints( pRect, bUnmark );
1148 }
1149
1150 void View::CheckPossibilities()
1151 {
1152     FmFormView::CheckPossibilities();
1153     maSmartTags.CheckPossibilities();
1154 }
1155
1156 void View::OnBeginPasteOrDrop( PasteOrDropInfos* pInfo )
1157 {
1158     SdrOutliner* pOutliner = GetTextEditOutliner();
1159     if (!pOutliner)
1160         return;
1161
1162     // Turn character attributes of the paragraph of the insert position into
1163     // character-level attributes, so they are not lost when OnEndPasteOrDrop()
1164     // sets the paragraph stylesheet.
1165     SfxItemSet aSet(pOutliner->GetParaAttribs(pInfo->nStartPara));
1166     pOutliner->SetCharAttribs(pInfo->nStartPara, aSet);
1167 }
1168
1169 /** this is called after a paste or drop operation, make sure that the newly inserted paragraphs
1170     get the correct style sheet. */
1171 void View::OnEndPasteOrDrop( PasteOrDropInfos* pInfo )
1172 {
1173     /* Style Sheet handling */
1174     SdrTextObj* pTextObj = GetTextEditObject();
1175     SdrOutliner* pOutliner = GetTextEditOutliner();
1176     if( !pOutliner || !pTextObj || !pTextObj->getSdrPageFromSdrObject() )
1177         return;
1178
1179     SdPage* pPage = static_cast< SdPage* >( pTextObj->getSdrPageFromSdrObject() );
1180     const PresObjKind eKind = pPage->GetPresObjKind(pTextObj);
1181
1182     // outline kinds are taken care of in Outliner::ImplSetLevelDependentStyleSheet
1183     if( eKind == PresObjKind::Outline )
1184         return;
1185
1186     SfxStyleSheet* pStyleSheet = nullptr;
1187     if( eKind != PresObjKind::NONE )
1188         pStyleSheet = pPage->GetStyleSheetForPresObj(eKind);
1189     else
1190          pStyleSheet = pTextObj->GetStyleSheet();
1191     // just put the object style on each new paragraph
1192     for ( sal_Int32 nPara = pInfo->nStartPara; nPara <= pInfo->nEndPara; nPara++ )
1193     {
1194         pOutliner->SetStyleSheet( nPara, pStyleSheet );
1195     }
1196 }
1197
1198 bool View::ShouldToggleOn(
1199     const bool bBulletOnOffMode,
1200     const bool bNormalBullet)
1201 {
1202     // If setting bullets/numbering by the dialog, always should toggle on.
1203     if (!bBulletOnOffMode)
1204         return true;
1205     SdrModel* pSdrModel = GetModel();
1206     if (!pSdrModel)
1207         return false;
1208
1209     bool bToggleOn = false;
1210     std::unique_ptr<SdrOutliner> pOutliner(SdrMakeOutliner(OutlinerMode::TextObject, *pSdrModel));
1211     const size_t nMarkCount = GetMarkedObjectCount();
1212     for (size_t nIndex = 0; nIndex < nMarkCount && !bToggleOn; ++nIndex)
1213     {
1214         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
1215         if (!pTextObj || pTextObj->IsTextEditActive())
1216             continue;
1217         if( dynamic_cast< const SdrTableObj *>( pTextObj ) !=  nullptr)
1218         {
1219             SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
1220             if (!pTableObj)
1221                 continue;
1222             CellPos aStart, aEnd;
1223             SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
1224             if (pTableController)
1225             {
1226                 pTableController->getSelectedCells(aStart, aEnd);
1227             }
1228             else
1229             {
1230                 aStart = SdrTableObj::getFirstCell();
1231                 aEnd = pTableObj->getLastCell();
1232             }
1233             sal_Int32 nColCount = pTableObj->getColumnCount();
1234             for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow && !bToggleOn; nRow++)
1235             {
1236                 for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol && !bToggleOn; nCol++)
1237                 {
1238                     sal_Int32 nCellIndex = nRow * nColCount + nCol;
1239                     SdrText* pText = pTableObj->getText(nCellIndex);
1240                     if (!pText || !pText->GetOutlinerParaObject())
1241                         continue;
1242                     pOutliner->SetText(*(pText->GetOutlinerParaObject()));
1243                     sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
1244                     bToggleOn = (bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1);
1245                     pOutliner->Clear();
1246                 }
1247             }
1248         }
1249         else
1250         {
1251             OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
1252             if (!pParaObj)
1253                 continue;
1254             pOutliner->SetText(*pParaObj);
1255             sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
1256             bToggleOn = (bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1);
1257             pOutliner->Clear();
1258         }
1259     }
1260     return bToggleOn;
1261 }
1262
1263 void View::ChangeMarkedObjectsBulletsNumbering(
1264     const bool bToggle,
1265     const bool bHandleBullets,
1266     const SvxNumRule* pNumRule )
1267 {
1268     SdrModel* pSdrModel = GetModel();
1269     vcl::Window* pWindow = dynamic_cast< vcl::Window* >(GetFirstOutputDevice());
1270     if (!pSdrModel || !pWindow)
1271         return;
1272
1273     const bool bUndoEnabled = pSdrModel->IsUndoEnabled();
1274     std::unique_ptr<SdrUndoGroup> pUndoGroup(bUndoEnabled ? new SdrUndoGroup(*pSdrModel) : nullptr);
1275
1276     const bool bToggleOn = ShouldToggleOn( bToggle, bHandleBullets );
1277
1278     std::unique_ptr<SdrOutliner> pOutliner(SdrMakeOutliner(OutlinerMode::TextObject, *pSdrModel));
1279     std::unique_ptr<OutlinerView> pOutlinerView(new OutlinerView(pOutliner.get(), pWindow));
1280
1281     const size_t nMarkCount = GetMarkedObjectCount();
1282     for (size_t nIndex = 0; nIndex < nMarkCount; ++nIndex)
1283     {
1284         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
1285         if (!pTextObj || pTextObj->IsTextEditActive())
1286             continue;
1287         if( dynamic_cast< SdrTableObj *>( pTextObj ) !=  nullptr)
1288         {
1289             SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
1290             if (!pTableObj)
1291                 continue;
1292             CellPos aStart, aEnd;
1293             SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
1294             if (pTableController)
1295             {
1296                 pTableController->getSelectedCells(aStart, aEnd);
1297             }
1298             else
1299             {
1300                 aStart = SdrTableObj::getFirstCell();
1301                 aEnd = pTableObj->getLastCell();
1302             }
1303             sal_Int32 nColCount = pTableObj->getColumnCount();
1304             for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++)
1305             {
1306                 for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++)
1307                 {
1308                     sal_Int32 nCellIndex = nRow * nColCount + nCol;
1309                     SdrText* pText = pTableObj->getText(nCellIndex);
1310                     if (!pText || !pText->GetOutlinerParaObject())
1311                         continue;
1312
1313                     pOutliner->SetText(*(pText->GetOutlinerParaObject()));
1314                     if (bUndoEnabled)
1315                     {
1316                         pUndoGroup->AddAction(pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, nCellIndex));
1317                     }
1318                     if ( !bToggleOn )
1319                     {
1320                         pOutlinerView->SwitchOffBulletsNumbering();
1321                     }
1322                     else
1323                     {
1324                         pOutlinerView->ApplyBulletsNumbering( bHandleBullets, pNumRule, bToggle );
1325                     }
1326                     sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
1327                     pText->SetOutlinerParaObject(pOutliner->CreateParaObject(0, static_cast<sal_uInt16>(nParaCount)));
1328                     pOutliner->Clear();
1329                 }
1330             }
1331             // Broadcast the object change event.
1332             if (!pTextObj->AdjustTextFrameWidthAndHeight())
1333             {
1334                 pTextObj->SetChanged();
1335                 pTextObj->BroadcastObjectChange();
1336             }
1337         }
1338         else
1339         {
1340             OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
1341             if (!pParaObj)
1342                 continue;
1343             pOutliner->SetText(*pParaObj);
1344             if (bUndoEnabled)
1345             {
1346                 pUndoGroup->AddAction(
1347                     pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, 0));
1348             }
1349             if ( !bToggleOn )
1350             {
1351                 pOutlinerView->SwitchOffBulletsNumbering();
1352             }
1353             else
1354             {
1355                 pOutlinerView->ApplyBulletsNumbering( bHandleBullets, pNumRule, bToggle );
1356             }
1357             sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
1358             pTextObj->SetOutlinerParaObject(pOutliner->CreateParaObject(0, static_cast<sal_uInt16>(nParaCount)));
1359             pOutliner->Clear();
1360         }
1361     }
1362
1363     if ( bUndoEnabled && pUndoGroup->GetActionCount() > 0 )
1364     {
1365         pSdrModel->BegUndo();
1366         pSdrModel->AddUndo(std::move(pUndoGroup));
1367         pSdrModel->EndUndo();
1368     }
1369 }
1370
1371 } // end of namespace sd
1372
1373 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */