sd/source/ui/view/viewshe2.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/EmbedVerbs.hpp>
  21 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  22
  23 #include <ViewShell.hxx>
  24 #include <ViewShellHint.hxx>
  25
  26 #include <ViewShellImplementation.hxx>
  27 #include <FactoryIds.hxx>
  28
  29 #include <svx/svxids.hrc>
  30 #include <vcl/scrbar.hxx>
  31 #include <svx/svdpagv.hxx>
  32 #include <sfx2/dispatch.hxx>
  33 #include <svx/ruler.hxx>
  34 #include <editeng/outlobj.hxx>
  35 #include <editeng/outliner.hxx>
  36 #include <svtools/ehdl.hxx>
  37 #include <svx/svdoole2.hxx>
  38 #include <svtools/sfxecode.hxx>
  39 #include <unotools/moduleoptions.hxx>
  40 #include <comphelper/classids.hxx>
  41
  42 #include <strings.hrc>
  43 #include <app.hrc>
  44 #include <unokywds.hxx>
  45
  46 #include <sdundogr.hxx>
  47 #include <FrameView.hxx>
  48 #include <sdresid.hxx>
  49 #include <drawdoc.hxx>
  50 #include <View.hxx>
  51 #include <fupoor.hxx>
  52 #include <Client.hxx>
  53 #include <DrawDocShell.hxx>
  54 #include <sdpage.hxx>
  55 #include <DrawViewShell.hxx>
  56 #include <ViewShellBase.hxx>
  57
  58 #include <Window.hxx>
  59
  60 #include <sfx2/viewfrm.hxx>
  61 #include <svtools/soerr.hxx>
  62 #include <svx/charthelper.hxx>
  63 #include <comphelper/lok.hxx>
  64
  65 using namespace com::sun::star;
  66
  67 namespace sd {
  68
  69 /**
  70  * adjust Thumbpos and VisibleSize
  71  */
  72 void ViewShell::UpdateScrollBars()
  73 {
  74     if (mpHorizontalScrollBar)
  75     {
  76         ::tools::Long nW = static_cast<::tools::Long>(mpContentWindow->GetVisibleWidth() * 32000);
  77         ::tools::Long nX = static_cast<::tools::Long>(mpContentWindow->GetVisibleX() * 32000);
  78         mpHorizontalScrollBar->SetVisibleSize(nW);
  79         mpHorizontalScrollBar->SetThumbPos(nX);
  80         nW = 32000 - nW;
  81         ::tools::Long nLine = static_cast<::tools::Long>(mpContentWindow->GetScrlLineWidth() * nW);
  82         ::tools::Long nPage = static_cast<::tools::Long>(mpContentWindow->GetScrlPageWidth() * nW);
  83         mpHorizontalScrollBar->SetLineSize(nLine);
  84         mpHorizontalScrollBar->SetPageSize(nPage);
  85     }
  86
  87     if (mpVerticalScrollBar)
  88     {
  89         ::tools::Long nH = static_cast<::tools::Long>(mpContentWindow->GetVisibleHeight() * 32000);
  90         ::tools::Long nY = static_cast<::tools::Long>(mpContentWindow->GetVisibleY() * 32000);
  91
  92         if(IsPageFlipMode()) // ie in zoom mode where no panning
  93         {
  94             SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage();
  95             sal_uInt16 nCurPage = (pPage->GetPageNum() - 1) / 2;
  96             sal_uInt16 nTotalPages = GetDoc()->GetSdPageCount(pPage->GetPageKind());
  97             mpVerticalScrollBar->SetRange(Range(0,256*nTotalPages));
  98             mpVerticalScrollBar->SetVisibleSize(256);
  99             mpVerticalScrollBar->SetThumbPos(256*nCurPage);
 100             mpVerticalScrollBar->SetLineSize(256);
 101             mpVerticalScrollBar->SetPageSize(256);
 102         }
 103         else
 104         {
 105             mpVerticalScrollBar->SetRange(Range(0,32000));
 106             mpVerticalScrollBar->SetVisibleSize(nH);
 107             mpVerticalScrollBar->SetThumbPos(nY);
 108             nH = 32000 - nH;
 109             ::tools::Long nLine = static_cast<::tools::Long>(mpContentWindow->GetScrlLineHeight() * nH);
 110             ::tools::Long nPage = static_cast<::tools::Long>(mpContentWindow->GetScrlPageHeight() * nH);
 111             mpVerticalScrollBar->SetLineSize(nLine);
 112             mpVerticalScrollBar->SetPageSize(nPage);
 113         }
 114     }
 115
 116     if (mbHasRulers)
 117     {
 118         UpdateHRuler();
 119         UpdateVRuler();
 120     }
 121
 122 }
 123 /**
 124  * Handling for horizontal Scrollbars
 125  */
 126 IMPL_LINK(ViewShell, HScrollHdl, ScrollBar *, pHScroll, void )
 127 {
 128     VirtHScrollHdl(pHScroll);
 129 }
 130
 131 /**
 132  * virtual scroll handler for horizontal Scrollbars
 133  */
 134 void ViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
 135 {
 136     ::tools::Long nDelta = pHScroll->GetDelta();
 137
 138     if (nDelta == 0)
 139         return;
 140
 141     double fX = static_cast<double>(pHScroll->GetThumbPos()) / pHScroll->GetRange().Len();
 142
 143     // scroll all windows of the column
 144     ::sd::View* pView = GetView();
 145     OutlinerView* pOLV = nullptr;
 146
 147     if (pView)
 148         pOLV = pView->GetTextEditOutlinerView();
 149
 150     if (pOLV)
 151         pOLV->HideCursor();
 152
 153     mpContentWindow->SetVisibleXY(fX, -1);
 154
 155     ::tools::Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
 156     Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
 157     aVisArea.SetPos(aVisAreaPos);
 158     GetDocSh()->SetVisArea(aVisArea);
 159
 160     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
 161     ::tools::Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
 162     VisAreaChanged(aVisAreaWin);
 163
 164     if (pView)
 165     {
 166         pView->VisAreaChanged(GetActiveWindow());
 167     }
 168
 169     if (pOLV)
 170         pOLV->ShowCursor();
 171
 172     if (mbHasRulers)
 173         UpdateHRuler();
 174 }
 175
 176 /**
 177  * handling for vertical Scrollbars
 178  */
 179 IMPL_LINK(ViewShell, VScrollHdl, ScrollBar *, pVScroll, void )
 180 {
 181     VirtVScrollHdl(pVScroll);
 182 }
 183
 184 /**
 185  * handling for vertical Scrollbars
 186  */
 187 void ViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
 188 {
 189     if(IsPageFlipMode())
 190     {
 191         SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage();
 192         sal_uInt16 nCurPage = (pPage->GetPageNum() - 1) >> 1;
 193         sal_uInt16 nNewPage = static_cast<sal_uInt16>(pVScroll->GetThumbPos())/256;
 194         if( nCurPage != nNewPage )
 195             static_cast<DrawViewShell*>(this)->SwitchPage(nNewPage);
 196     }
 197     else //panning mode
 198     {
 199         double fY = static_cast<double>(pVScroll->GetThumbPos()) / pVScroll->GetRange().Len();
 200
 201         ::sd::View* pView = GetView();
 202         OutlinerView* pOLV = nullptr;
 203
 204         if (pView)
 205             pOLV = pView->GetTextEditOutlinerView();
 206
 207         if (pOLV)
 208             pOLV->HideCursor();
 209
 210         mpContentWindow->SetVisibleXY(-1, fY);
 211
 212         ::tools::Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
 213         Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
 214         aVisArea.SetPos(aVisAreaPos);
 215         GetDocSh()->SetVisArea(aVisArea);
 216
 217         Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
 218         ::tools::Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
 219         VisAreaChanged(aVisAreaWin);
 220
 221         if (pView)
 222         {
 223             pView->VisAreaChanged(GetActiveWindow());
 224         }
 225
 226         if (pOLV)
 227             pOLV->ShowCursor();
 228
 229         if (mbHasRulers)
 230             UpdateVRuler();
 231
 232     }
 233 }
 234
 235 VclPtr<SvxRuler> ViewShell::CreateHRuler(::sd::Window* )
 236 {
 237     return nullptr;
 238 }
 239
 240 VclPtr<SvxRuler> ViewShell::CreateVRuler(::sd::Window* )
 241 {
 242     return nullptr;
 243 }
 244
 245 void ViewShell::UpdateHRuler()
 246 {
 247 }
 248
 249 void ViewShell::UpdateVRuler()
 250 {
 251 }
 252
 253 /**
 254  * Scroll a specific number of lines. Is used in the automatic scrolling
 255  * (character/drag).
 256  */
 257 void ViewShell::ScrollLines(::tools::Long nLinesX, ::tools::Long nLinesY)
 258 {
 259     if ( nLinesX )
 260     {
 261         nLinesX *= mpHorizontalScrollBar->GetLineSize();
 262     }
 263     if ( nLinesY )
 264     {
 265         nLinesY *= mpVerticalScrollBar->GetLineSize();
 266     }
 267
 268     Scroll(nLinesX, nLinesY);
 269 }
 270
 271 void ViewShell::Scroll(::tools::Long nScrollX, ::tools::Long nScrollY)
 272 {
 273     if (nScrollX)
 274     {
 275         ::tools::Long nNewThumb = mpHorizontalScrollBar->GetThumbPos() + nScrollX;
 276         mpHorizontalScrollBar->SetThumbPos(nNewThumb);
 277     }
 278     if (nScrollY)
 279     {
 280         ::tools::Long nNewThumb = mpVerticalScrollBar->GetThumbPos() + nScrollY;
 281         mpVerticalScrollBar->SetThumbPos(nNewThumb);
 282     }
 283     double  fX = static_cast<double>(mpHorizontalScrollBar->GetThumbPos()) /
 284                             mpHorizontalScrollBar->GetRange().Len();
 285     double  fY = static_cast<double>(mpVerticalScrollBar->GetThumbPos()) /
 286                             mpVerticalScrollBar->GetRange().Len();
 287
 288     GetActiveWindow()->SetVisibleXY(fX, fY);
 289
 290     ::tools::Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
 291     Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
 292     aVisArea.SetPos(aVisAreaPos);
 293     GetDocSh()->SetVisArea(aVisArea);
 294
 295     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
 296     ::tools::Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
 297     VisAreaChanged(aVisAreaWin);
 298
 299     ::sd::View* pView = GetView();
 300     if (pView)
 301     {
 302         pView->VisAreaChanged(GetActiveWindow());
 303     }
 304
 305     if (mbHasRulers)
 306     {
 307         UpdateHRuler();
 308         UpdateVRuler();
 309     }
 310 }
 311
 312 /**
 313  * Set zoom factor for all split windows.
 314  */
 315 void ViewShell::SetZoom(::tools::Long nZoom)
 316 {
 317     Fraction aUIScale(nZoom, 100);
 318     aUIScale *= GetDoc()->GetUIScale();
 319
 320     if (mpHorizontalRuler)
 321         mpHorizontalRuler->SetZoom(aUIScale);
 322
 323     if (mpVerticalRuler)
 324         mpVerticalRuler->SetZoom(aUIScale);
 325
 326     if (mpContentWindow)
 327     {
 328         mpContentWindow->SetZoomIntegral(nZoom);
 329
 330         // #i74769# Here is a 2nd way (besides Window::Scroll) to set the visible prt
 331         // of the window. It needs - like Scroll(ScrollFlags::Children) does - also to move
 332         // the child windows. I am trying InvalidateFlags::Children here which makes things better,
 333         // but does not solve the problem completely. Need to ask PL.
 334         mpContentWindow->Invalidate(InvalidateFlags::Children);
 335     }
 336
 337     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
 338     ::tools::Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
 339     VisAreaChanged(aVisAreaWin);
 340
 341     ::sd::View* pView = GetView();
 342     if (pView)
 343     {
 344         pView->VisAreaChanged(GetActiveWindow());
 345     }
 346
 347     UpdateScrollBars();
 348 }
 349
 350 ::tools::Long ViewShell::GetZoom() const
 351 {
 352     if (mpContentWindow)
 353     {
 354         return mpContentWindow->GetZoom();
 355     }
 356
 357     return 0;
 358 }
 359
 360 /**
 361  * Set zoom rectangle for active window. Sets all split windows to the same zoom
 362  * factor.
 363  */
 364 void ViewShell::SetZoomRect(const ::tools::Rectangle& rZoomRect)
 365 {
 366     ::tools::Long nZoom = GetActiveWindow()->SetZoomRect(rZoomRect);
 367     Fraction aUIScale(nZoom, 100);
 368     aUIScale *= GetDoc()->GetUIScale();
 369
 370     Point aPos = GetActiveWindow()->GetWinViewPos();
 371
 372     if (mpHorizontalRuler)
 373         mpHorizontalRuler->SetZoom(aUIScale);
 374
 375     if (mpVerticalRuler)
 376         mpVerticalRuler->SetZoom(aUIScale);
 377
 378     if (mpContentWindow)
 379     {
 380         Point aNewPos = mpContentWindow->GetWinViewPos();
 381         aNewPos.setX( aPos.X() );
 382         aNewPos.setY( aPos.Y() );
 383         mpContentWindow->SetZoomIntegral(nZoom);
 384         mpContentWindow->SetWinViewPos(aNewPos);
 385         mpContentWindow->UpdateMapOrigin();
 386
 387         // When tiled rendering, UpdateMapOrigin() doesn't touch the map mode.
 388         if (!comphelper::LibreOfficeKit::isActive())
 389             // #i74769# see above
 390             mpContentWindow->Invalidate(InvalidateFlags::Children);
 391     }
 392
 393     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
 394     ::tools::Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
 395     VisAreaChanged(aVisAreaWin);
 396
 397     ::sd::View* pView = GetView();
 398     if (pView)
 399     {
 400         pView->VisAreaChanged(GetActiveWindow());
 401     }
 402
 403     UpdateScrollBars();
 404 }
 405
 406 /**
 407  * Initialize imaging parameters for all split windows.
 408  */
 409 void ViewShell::InitWindows(const Point& rViewOrigin, const Size& rViewSize,
 410                               const Point& rWinPos, bool bUpdate)
 411 {
 412     if (mpContentWindow)
 413     {
 414         mpContentWindow->SetViewOrigin(rViewOrigin);
 415         mpContentWindow->SetViewSize(rViewSize);
 416         mpContentWindow->SetWinViewPos(rWinPos);
 417
 418         if ( bUpdate )
 419         {
 420             mpContentWindow->UpdateMapOrigin();
 421             mpContentWindow->Invalidate();
 422         }
 423     }
 424
 425     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
 426     ::tools::Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
 427     VisAreaChanged(aVisAreaWin);
 428
 429     ::sd::View* pView = GetView();
 430     if (pView)
 431     {
 432         pView->VisAreaChanged(GetActiveWindow());
 433     }
 434 }
 435
 436 /**
 437  * Invalidate all split windows below the ?provided rectangle.
 438  */
 439 void ViewShell::InvalidateWindows()
 440 {
 441     if (mpContentWindow)
 442         mpContentWindow->Invalidate();
 443 }
 444
 445 /**
 446  * Draw a selection rectangle with the ?provided pen on all split windows.
 447  */
 448 void ViewShell::DrawMarkRect(const ::tools::Rectangle& rRect) const
 449 {
 450     if (mpContentWindow)
 451     {
 452         mpContentWindow->InvertTracking(rRect, ShowTrackFlags::Object | ShowTrackFlags::TrackWindow);
 453     }
 454 }
 455
 456 void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
 457                                        ::tools::Long nLeft, ::tools::Long nRight,
 458                                        ::tools::Long nUpper, ::tools::Long nLower, bool bScaleAll,
 459                                        Orientation eOrientation, sal_uInt16 nPaperBin,
 460                                        bool bBackgroundFullSize)
 461 {
 462     const sal_uInt16 nMasterPageCnt(GetDoc()->GetMasterSdPageCount(ePageKind));
 463     const sal_uInt16 nPageCnt(GetDoc()->GetSdPageCount(ePageKind));
 464
 465     if(0 == nPageCnt && 0 == nMasterPageCnt)
 466     {
 467         return;
 468     }
 469
 470     std::unique_ptr<SdUndoGroup> pUndoGroup;
 471     SfxViewShell* pViewShell(GetViewShell());
 472     if (pViewShell)
 473     {
 474         pUndoGroup.reset(new SdUndoGroup(GetDoc()));
 475         pUndoGroup->SetComment(SdResId(STR_UNDO_CHANGE_PAGEFORMAT));
 476     }
 477     Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_START));
 478
 479     // use Model-based method at SdDrawDocument
 480     GetDoc()->AdaptPageSizeForAllPages(
 481         rNewSize,
 482         ePageKind,
 483         pUndoGroup.get(),
 484         nLeft,
 485         nRight,
 486         nUpper,
 487         nLower,
 488         bScaleAll,
 489         eOrientation,
 490         nPaperBin,
 491         bBackgroundFullSize);
 492
 493     // adjust handout page to new format of the standard page
 494     if(0 != nPageCnt && ((ePageKind == PageKind::Standard) || (ePageKind == PageKind::Handout)))
 495     {
 496         GetDoc()->GetSdPage(0, PageKind::Handout)->CreateTitleAndLayout(true);
 497     }
 498
 499     // handed over undo group to undo manager
 500     if (pViewShell)
 501     {
 502         pViewShell->GetViewFrame()->GetObjectShell()->GetUndoManager()->AddUndoAction(std::move(pUndoGroup));
 503     }
 504
 505     // calculate View-Sizes
 506     SdPage* pPage(0 != nPageCnt
 507         ? GetDoc()->GetSdPage(0, ePageKind)
 508         : GetDoc()->GetMasterSdPage(0, ePageKind));
 509     const ::tools::Long nWidth(pPage->GetSize().Width());
 510     const ::tools::Long nHeight(pPage->GetSize().Height());
 511     const Point aPageOrg(nWidth, nHeight / 2);
 512     const Size aViewSize(nWidth * 3, nHeight * 2);
 513     Point aVisAreaPos;
 514     ::sd::View* pView(GetView());
 515     const Point aNewOrigin(pPage->GetLeftBorder(), pPage->GetUpperBorder());
 516
 517     InitWindows(aPageOrg, aViewSize, Point(-1, -1), true);
 518
 519     if ( GetDocSh()->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
 520     {
 521         aVisAreaPos = GetDocSh()->GetVisArea(ASPECT_CONTENT).TopLeft();
 522     }
 523
 524     if (pView)
 525     {
 526         pView->SetWorkArea(::tools::Rectangle(Point() - aVisAreaPos - aPageOrg, aViewSize));
 527     }
 528
 529     UpdateScrollBars();
 530
 531     if (pView)
 532     {
 533         pView->GetSdrPageView()->SetPageOrigin(aNewOrigin);
 534     }
 535
 536     if(nullptr != pViewShell)
 537     {
 538         pViewShell->GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
 539         // zoom onto (new) page size
 540         pViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
 541     }
 542
 543     Broadcast(ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_END));
 544 }
 545
 546 /**
 547  * Set zoom factor for InPlace
 548  */
 549 void ViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction&)
 550 {
 551     ::tools::Long nZoom = static_cast<::tools::Long>(static_cast<double>(rZoomX) * 100);
 552     SetZoom(nZoom);
 553 }
 554
 555 void ViewShell::SetActiveWindow (::sd::Window* pWin)
 556 {
 557     SfxViewShell* pViewShell = GetViewShell();
 558     OSL_ASSERT (pViewShell!=nullptr);
 559
 560     if (pViewShell->GetWindow() != pWin)
 561     {
 562         // #i31551# was wrong, it may have been a problem with the repaint at that time.
 563         // For transparent form controls, it is necessary to have that flag set, all apps
 564         // do set it. Enabling again.
 565         if (pWin)
 566         {
 567             pWin->EnableChildTransparentMode();
 568         }
 569     }
 570
 571     if (mpActiveWindow.get() != pWin)
 572         mpActiveWindow = pWin;
 573
 574     // The rest of this function is not guarded anymore against calling this
 575     // method with an already active window because the functions may still
 576     // point to the old window when the new one has already been assigned to
 577     // pWindow elsewhere.
 578     ::sd::View* pView = GetView();
 579     if (pView)
 580     {
 581         pView->SetActualWin(pWin);
 582     }
 583     if(HasCurrentFunction())
 584     {
 585         GetCurrentFunction()->SetWindow(pWin);
 586     }
 587 }
 588
 589 bool ViewShell::RequestHelp(const HelpEvent& rHEvt)
 590 {
 591     bool bReturn = false;
 592
 593     if (bool(rHEvt.GetMode()))
 594     {
 595         if(HasCurrentFunction())
 596         {
 597             bReturn = GetCurrentFunction()->RequestHelp(rHEvt);
 598         }
 599     }
 600
 601     return bReturn;
 602 }
 603
 604 void ViewShell::SetFrameView (FrameView* pNewFrameView)
 605 {
 606     mpFrameView = pNewFrameView;
 607     ReadFrameViewData (mpFrameView);
 608 }
 609
 610 /*************************************************************************
 611 |*
 612 |* Read FrameViews data and set actual views data
 613 |*
 614 \************************************************************************/
 615
 616 void ViewShell::ReadFrameViewData(FrameView*)
 617 {
 618 }
 619
 620 /*************************************************************************
 621 |*
 622 |* Write actual views data to FrameView
 623 |*
 624 \************************************************************************/
 625
 626 void ViewShell::WriteFrameViewData()
 627 {
 628 }
 629
 630 bool ViewShell::ActivateObject(SdrOle2Obj* pObj, ::tools::Long nVerb)
 631 {
 632     ErrCode aErrCode = ERRCODE_NONE;
 633
 634     SfxErrorContext aEC(ERRCTX_SO_DOVERB, GetFrameWeld(), RID_SO_ERRCTX);
 635     bool bAbort = false;
 636     GetDocSh()->SetWaitCursor( true );
 637     SfxViewShell* pViewShell = GetViewShell();
 638     OSL_ASSERT (pViewShell!=nullptr);
 639     bool bChangeDefaultsForChart = false;
 640
 641     uno::Reference < embed::XEmbeddedObject > xObj = pObj->GetObjRef();
 642     if ( !xObj.is() )
 643     {
 644         // provide OLE object to empty OLE object
 645         OUString aName = pObj->GetProgName();
 646         OUString aObjName;
 647         SvGlobalName aClass;
 648
 649         if( aName == "StarChart"  || aName == "StarOrg" )
 650         {
 651             if( SvtModuleOptions().IsChart() )
 652             {
 653                 aClass = SvGlobalName( SO3_SCH_CLASSID );
 654                 bChangeDefaultsForChart = true;
 655             }
 656         }
 657         else if( aName == "StarCalc" )
 658         {
 659             if( SvtModuleOptions().IsCalc() )
 660                 aClass = SvGlobalName( SO3_SC_CLASSID );
 661         }
 662         else if( aName == "StarMath" )
 663         {
 664             if( SvtModuleOptions().IsMath() )
 665                 aClass = SvGlobalName( SO3_SM_CLASSID );
 666         }
 667
 668         if ( aClass != SvGlobalName() )
 669             xObj = GetDocSh()->GetEmbeddedObjectContainer().CreateEmbeddedObject( aClass.GetByteSequence(), aObjName );
 670
 671         if( !xObj.is() )
 672         {
 673             aName.clear();
 674
 675             // call dialog "insert OLE object"
 676             GetDocSh()->SetWaitCursor( false );
 677             pViewShell->GetViewFrame()->GetDispatcher()->Execute(
 678                 SID_INSERT_OBJECT,
 679                 SfxCallMode::SYNCHRON | SfxCallMode::RECORD);
 680             xObj = pObj->GetObjRef();
 681             GetDocSh()->SetWaitCursor( true );
 682
 683             if (!xObj.is())
 684             {
 685                 bAbort = true;
 686             }
 687         }
 688
 689         if ( xObj.is() )
 690         {
 691             // OLE object is no longer empty
 692             pObj->SetEmptyPresObj(false);
 693             pObj->SetOutlinerParaObject(nullptr);
 694             pObj->ClearGraphic();
 695
 696             // the empty OLE object gets a new IPObj
 697             if (!aName.isEmpty())
 698             {
 699                 pObj->SetObjRef(xObj);
 700                 pObj->SetName(aObjName);
 701                 pObj->SetPersistName(aObjName);
 702             }
 703             else
 704             {
 705                 // insertion was done by the dialog
 706                 pObj->SetObjRef(xObj);
 707             }
 708
 709             ::tools::Rectangle aRect = pObj->GetLogicRect();
 710
 711             if ( pObj->GetAspect() != embed::Aspects::MSOLE_ICON )
 712             {
 713                 awt::Size aSz;
 714                 aSz.Width = aRect.GetWidth();
 715                 aSz.Height = aRect.GetHeight();
 716                 xObj->setVisualAreaSize( pObj->GetAspect(), aSz );
 717             }
 718
 719             GetViewShellBase().SetVerbs( xObj->getSupportedVerbs() );
 720
 721             nVerb = embed::EmbedVerbs::MS_OLEVERB_SHOW;
 722         }
 723         else
 724         {
 725             aErrCode = ERRCODE_SFX_OLEGENERAL;
 726         }
 727     }
 728
 729     if( aErrCode == ERRCODE_NONE )
 730     {
 731         ::sd::View* pView = GetView();
 732
 733         if (pView->IsTextEdit())
 734         {
 735             pView->SdrEndTextEdit();
 736         }
 737
 738         SfxInPlaceClient* pSdClient =
 739             pViewShell->FindIPClient(pObj->GetObjRef(), GetActiveWindow());
 740
 741         if ( !pSdClient )
 742         {
 743             pSdClient = new Client(pObj, this, GetActiveWindow());
 744         }
 745
 746         ::tools::Rectangle aRect = pObj->GetLogicRect();
 747
 748         {
 749             // #i118485# center on BoundRect for activation,
 750             // OLE may be sheared/rotated now
 751             const ::tools::Rectangle& rBoundRect = pObj->GetCurrentBoundRect();
 752             const Point aDelta(rBoundRect.Center() - aRect.Center());
 753             aRect.Move(aDelta.X(), aDelta.Y());
 754         }
 755
 756         Size aDrawSize = aRect.GetSize();
 757
 758         MapMode aMapMode( GetDoc()->GetScaleUnit() );
 759         Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
 760         if( pObj->IsChart() ) //charts never should be stretched see #i84323# for example
 761             aObjAreaSize = aDrawSize;
 762
 763         Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
 764         Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
 765         aScaleWidth.ReduceInaccurate(10);       // compatible to the SdrOle2Obj
 766         aScaleHeight.ReduceInaccurate(10);
 767         pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
 768
 769         // visible section is only changed in-place!
 770         aRect.SetSize(aObjAreaSize);
 771         // the object area size must be set after scaling, since it triggers the resizing
 772         pSdClient->SetObjArea(aRect);
 773
 774         if( bChangeDefaultsForChart && xObj.is())
 775         {
 776             ChartHelper::AdaptDefaultsForChart( xObj );
 777         }
 778
 779         pSdClient->DoVerb(nVerb);   // if necessary, ErrCode is outputted by Sfx
 780         pViewShell->GetViewFrame()->GetBindings().Invalidate(
 781             SID_NAVIGATOR_STATE, true);
 782     }
 783
 784     GetDocSh()->SetWaitCursor( false );
 785
 786     if (aErrCode != ERRCODE_NONE && !bAbort)
 787     {
 788         ErrorHandler::HandleError(* new StringErrorInfo(aErrCode, OUString() ) );
 789     }
 790
 791     return aErrCode == ERRCODE_NONE;
 792 }
 793
 794 /**
 795  * @returns enclosing rectangle of all (split-) windows.
 796  */
 797 const ::tools::Rectangle& ViewShell::GetAllWindowRect()
 798 {
 799     maAllWindowRectangle.SetPos(
 800         mpContentWindow->OutputToScreenPixel(Point(0,0)));
 801     return maAllWindowRectangle;
 802 }
 803
 804 void ViewShell::ReadUserData()
 805 {
 806     // zoom onto VisArea from FrameView
 807     GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_VISAREA,
 808         SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
 809 }
 810
 811 void ViewShell::WriteUserData()
 812 {
 813     // writing of our data is always done in WriteFrameViewData()
 814     WriteFrameViewData();
 815 }
 816
 817 /**
 818  * Switch ruler on/off
 819  */
 820 void ViewShell::SetRuler(bool bRuler)
 821 {
 822     mbHasRulers = ( bRuler && !GetDocSh()->IsPreview() ); // no rulers on preview mode
 823
 824     if (mpHorizontalRuler)
 825     {
 826         if (mbHasRulers)
 827         {
 828             mpHorizontalRuler->Show();
 829         }
 830         else
 831         {
 832             mpHorizontalRuler->Hide();
 833         }
 834     }
 835
 836     if (mpVerticalRuler)
 837     {
 838         if (mbHasRulers)
 839         {
 840             mpVerticalRuler->Show();
 841         }
 842         else
 843         {
 844             mpVerticalRuler->Hide();
 845         }
 846     }
 847
 848     OSL_ASSERT(GetViewShell()!=nullptr);
 849     if (IsMainViewShell())
 850         GetViewShell()->InvalidateBorder();
 851 }
 852
 853 void ViewShell::SetScrollBarsVisible(bool bVisible)
 854 {
 855     if (mpVerticalScrollBar)
 856         mpVerticalScrollBar->Show( bVisible );
 857
 858     if (mpHorizontalScrollBar)
 859         mpHorizontalScrollBar->Show( bVisible );
 860
 861     if (mpScrollBarBox)
 862         mpScrollBarBox->Show(bVisible);
 863 }
 864
 865 sal_Int8 ViewShell::AcceptDrop (
 866     const AcceptDropEvent& rEvt,
 867     DropTargetHelper& rTargetHelper,
 868     ::sd::Window* /*pTargetWindow*/,
 869     sal_uInt16 /*nPage*/,
 870     SdrLayerID nLayer)
 871 {
 872     ::sd::View* pView = GetView();
 873     return( pView ? pView->AcceptDrop( rEvt, rTargetHelper, nLayer ) : DND_ACTION_NONE );
 874 }
 875
 876 sal_Int8 ViewShell::ExecuteDrop (
 877     const ExecuteDropEvent& rEvt,
 878     DropTargetHelper& /*rTargetHelper*/,
 879     ::sd::Window* pTargetWindow,
 880     sal_uInt16 nPage,
 881     SdrLayerID nLayer)
 882 {
 883     ::sd::View* pView = GetView();
 884     return pView ? pView->ExecuteDrop( rEvt, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE;
 885 }
 886
 887 void ViewShell::WriteUserDataSequence ( css::uno::Sequence < css::beans::PropertyValue >& rSequence )
 888 {
 889     const sal_Int32 nIndex = rSequence.getLength();
 890     rSequence.realloc( nIndex + 1 );
 891
 892     OSL_ASSERT (GetViewShell()!=nullptr);
 893     // Get the view id from the view shell in the center pane.  This will
 894     // usually be the called view shell, but to be on the safe side we call
 895     // the main view shell explicitly.
 896     SfxInterfaceId nViewID (IMPRESS_FACTORY_ID);
 897     if (GetViewShellBase().GetMainViewShell() != nullptr)
 898         nViewID = GetViewShellBase().GetMainViewShell()->mpImpl->GetViewId();
 899     rSequence[nIndex].Name = sUNO_View_ViewId;
 900     rSequence[nIndex].Value <<= "view" + OUString::number( static_cast<sal_uInt16>(nViewID));
 901
 902     mpFrameView->WriteUserDataSequence( rSequence );
 903 }
 904
 905 void ViewShell::ReadUserDataSequence ( const css::uno::Sequence < css::beans::PropertyValue >& rSequence )
 906 {
 907     mpFrameView->ReadUserDataSequence( rSequence );
 908 }
 909
 910 void ViewShell::VisAreaChanged(const ::tools::Rectangle& /*rRect*/)
 911 {
 912     OSL_ASSERT (GetViewShell()!=nullptr);
 913     GetViewShell()->VisAreaChanged();
 914 }
 915
 916 void ViewShell::SetWinViewPos(const Point& rWinPos)
 917 {
 918     if (mpContentWindow)
 919     {
 920         mpContentWindow->SetWinViewPos(rWinPos);
 921
 922         mpContentWindow->UpdateMapOrigin();
 923         mpContentWindow->Invalidate();
 924     }
 925
 926     if (mbHasRulers)
 927     {
 928         UpdateHRuler();
 929         UpdateVRuler();
 930     }
 931
 932     UpdateScrollBars();
 933
 934     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
 935     ::tools::Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( ::tools::Rectangle( Point(0,0), aVisSizePixel) );
 936     VisAreaChanged(aVisAreaWin);
 937
 938     ::sd::View* pView = GetView();
 939     if (pView)
 940     {
 941         pView->VisAreaChanged(GetActiveWindow());
 942     }
 943 }
 944
 945 Point const & ViewShell::GetWinViewPos() const
 946 {
 947     return mpContentWindow->GetWinViewPos();
 948 }
 949
 950 Point const & ViewShell::GetViewOrigin() const
 951 {
 952     return mpContentWindow->GetViewOrigin();
 953 }
 954
 955 } // end of namespace sd
 956
 957 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */