?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
android: Update app-specific/MIME type icons
[LibreOffice.git] / sd / source / ui / view / viewshel.cxx
blob8a7d6f482c82b780d10bb023aeb2359c81a54493
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 <memory>
21 #include <ViewShell.hxx>
22 #include <ViewShellImplementation.hxx>
23 #include <createtableobjectbar.hxx>
24
25 #include <ViewShellBase.hxx>
26 #include <ShellFactory.hxx>
27 #include <DrawController.hxx>
28 #include <LayerTabBar.hxx>
29
30 #include <sal/log.hxx>
31 #include <sfx2/viewfrm.hxx>
32 #include <sfx2/bindings.hxx>
33 #include <sfx2/dispatch.hxx>
34 #include <vcl/commandevent.hxx>
35 #include <svl/eitem.hxx>
36 #include <svx/ruler.hxx>
37 #include <svx/svxids.hrc>
38 #include <svx/fmshell.hxx>
39 #include <WindowUpdater.hxx>
40 #include <sdxfer.hxx>
41
42 #include <app.hrc>
43
44 #include <OutlineView.hxx>
45 #include <DrawViewShell.hxx>
46 #include <DrawDocShell.hxx>
47 #include <slideshow.hxx>
48 #include <drawdoc.hxx>
49 #include <sdpage.hxx>
50 #include <zoomlist.hxx>
51 #include <FrameView.hxx>
52 #include <BezierObjectBar.hxx>
53 #include <TextObjectBar.hxx>
54 #include <GraphicObjectBar.hxx>
55 #include <MediaObjectBar.hxx>
56 #include <SlideSorter.hxx>
57 #include <SlideSorterViewShell.hxx>
58 #include <ViewShellManager.hxx>
59 #include <FormShellManager.hxx>
60 #include <svx/extrusionbar.hxx>
61 #include <svx/fontworkbar.hxx>
62 #include <svx/svdoutl.hxx>
63 #include <tools/svborder.hxx>
64 #include <comphelper/lok.hxx>
65
66 #include <svl/slstitm.hxx>
67 #include <sfx2/request.hxx>
68 #include <SpellDialogChildWindow.hxx>
69 #include <controller/SlideSorterController.hxx>
70 #include <controller/SlsPageSelector.hxx>
71 #include <controller/SlsSelectionObserver.hxx>
72 #include <view/SlideSorterView.hxx>
73
74 #include <basegfx/utils/zoomtools.hxx>
75
76 #include <Window.hxx>
77 #include <fupoor.hxx>
78 #include <futext.hxx>
79
80 #include <editeng/numitem.hxx>
81 #include <editeng/eeitem.hxx>
82 #include <editeng/editview.hxx>
83 #include <editeng/editeng.hxx>
84 #include <svl/itempool.hxx>
85 #include <svl/intitem.hxx>
86 #include <svl/poolitem.hxx>
87 #include <strings.hxx>
88 #include <sdmod.hxx>
89 #include <AccessibleDocumentViewBase.hxx>
90
91 using namespace ::com::sun::star;
92 using namespace ::com::sun::star::uno;
93 using namespace ::com::sun::star::presentation;
94
95 namespace {
96
97 class ViewShellObjectBarFactory
98 : public ::sd::ShellFactory<SfxShell>
99 {
100 public:
101 explicit ViewShellObjectBarFactory (::sd::ViewShell& rViewShell);
102 virtual SfxShell* CreateShell( ::sd::ShellId nId ) override;
103 virtual void ReleaseShell (SfxShell* pShell) override;
104 private:
105 ::sd::ViewShell& mrViewShell;
106 };
107
108 } // end of anonymous namespace
109
110 namespace sd {
111
112 bool ViewShell::IsPageFlipMode() const
113 {
114 return dynamic_cast< const DrawViewShell *>( this ) != nullptr && mpContentWindow &&
115 mpContentWindow->GetVisibleHeight() >= 1.0;
116 }
117
118 SfxViewFrame* ViewShell::GetViewFrame() const
119 {
120 const SfxViewShell* pViewShell = GetViewShell();
121 if (pViewShell != nullptr)
122 {
123 return &pViewShell->GetViewFrame();
124 }
125 else
126 {
127 OSL_ASSERT (GetViewShell()!=nullptr);
128 return nullptr;
129 }
130 }
131
132 /// declare SFX-Slotmap and standard interface
133
134 ViewShell::ViewShell( vcl::Window* pParentWindow, ViewShellBase& rViewShellBase)
135 : SfxShell(&rViewShellBase)
136 , mpParentWindow(pParentWindow)
137 {
138 construct();
139 }
140
141 ViewShell::~ViewShell()
142 {
143 // Keep the content window from accessing in its destructor the
144 // WindowUpdater.
145 if (mpContentWindow)
146 mpContentWindow->SetViewShell(nullptr);
147
148 mpZoomList.reset();
149
150 mpLayerTabBar.disposeAndClear();
151
152 if (mpImpl->mpSubShellFactory)
153 GetViewShellBase().GetViewShellManager()->RemoveSubShellFactory(
154 this,mpImpl->mpSubShellFactory);
155
156 if (mpContentWindow)
157 {
158 SAL_INFO(
159 "sd.view",
160 "destroying mpContentWindow at " << mpContentWindow.get()
161 << " with parent " << mpContentWindow->GetParent());
162 mpContentWindow.disposeAndClear();
163 }
164
165 mpVerticalRuler.disposeAndClear();
166 mpHorizontalRuler.disposeAndClear();
167 mpVerticalScrollBar.disposeAndClear();
168 mpHorizontalScrollBar.disposeAndClear();
169 }
170
171 /**
172 * common initialization part of both constructors
173 */
174 void ViewShell::construct()
175 {
176 mbHasRulers = false;
177 mpActiveWindow = nullptr;
178 mpView = nullptr;
179 mpFrameView = nullptr;
180 mpZoomList = nullptr;
181 mfLastZoomScale = 0;
182 mbStartShowWithDialog = false;
183 mnPrintedHandoutPageNum = 1;
184 mnPrintedHandoutPageCount = 0;
185 mpWindowUpdater.reset( new ::sd::WindowUpdater() );
186 mpImpl.reset(new Implementation(*this));
187 meShellType = ST_NONE;
188
189 OSL_ASSERT (GetViewShell()!=nullptr);
190
191 if (IsMainViewShell())
192 GetDocSh()->Connect (this);
193
194 mpZoomList.reset( new ZoomList( this ) );
195
196 mpContentWindow.reset(VclPtr< ::sd::Window >::Create(GetParentWindow()));
197 SetActiveWindow (mpContentWindow.get());
198
199 GetParentWindow()->SetBackground(Application::GetSettings().GetStyleSettings().GetFaceColor());
200 mpContentWindow->SetBackground (Wallpaper());
201 mpContentWindow->SetCenterAllowed(true);
202 mpContentWindow->SetViewShell(this);
203 mpContentWindow->SetPosSizePixel(
204 GetParentWindow()->GetPosPixel(),GetParentWindow()->GetSizePixel());
205
206 if ( ! GetDocSh()->IsPreview())
207 {
208 // Create scroll bars and the filler between the scroll bars.
209 mpHorizontalScrollBar.reset (VclPtr<ScrollAdaptor>::Create(GetParentWindow(), true));
210 mpHorizontalScrollBar->EnableRTL (false);
211 mpHorizontalScrollBar->SetRange(Range(0, 32000));
212 mpHorizontalScrollBar->SetScrollHdl(LINK(this, ViewShell, HScrollHdl));
213
214 mpVerticalScrollBar.reset (VclPtr<ScrollAdaptor>::Create(GetParentWindow(), false));
215 mpVerticalScrollBar->SetRange(Range(0, 32000));
216 mpVerticalScrollBar->SetScrollHdl(LINK(this, ViewShell, VScrollHdl));
217 }
218
219 SetName ("ViewShell");
220
221 GetDoc()->StartOnlineSpelling(false);
222
223 mpWindowUpdater->SetDocument (GetDoc());
224
225 // Re-initialize the spell dialog.
226 ::sd::SpellDialogChildWindow* pSpellDialog =
227 static_cast< ::sd::SpellDialogChildWindow*> (
228 GetViewFrame()->GetChildWindow (
229 ::sd::SpellDialogChildWindow::GetChildWindowId()));
230 if (pSpellDialog != nullptr)
231 pSpellDialog->InvalidateSpellDialog();
232
233 // Register the sub shell factory.
234 mpImpl->mpSubShellFactory = std::make_shared<ViewShellObjectBarFactory>(*this);
235 GetViewShellBase().GetViewShellManager()->AddSubShellFactory(this,mpImpl->mpSubShellFactory);
236 }
237
238 void ViewShell::doShow()
239 {
240 mpContentWindow->Show();
241 static_cast< vcl::Window*>(mpContentWindow.get())->Resize();
242 SAL_INFO(
243 "sd.view",
244 "content window has size " << mpContentWindow->GetSizePixel().Width()
245 << " " << mpContentWindow->GetSizePixel().Height());
246
247 if ( ! GetDocSh()->IsPreview())
248 {
249 // Show scroll bars
250 mpHorizontalScrollBar->Show();
251
252 mpVerticalScrollBar->Show();
253 maScrBarWH = Size(
254 mpVerticalScrollBar->GetSizePixel().Width(),
255 mpHorizontalScrollBar->GetSizePixel().Height());
256 }
257
258 GetParentWindow()->Show();
259 }
260
261 void ViewShell::Init (bool bIsMainViewShell)
262 {
263 mpImpl->mbIsInitialized = true;
264 SetIsMainViewShell(bIsMainViewShell);
265 if (bIsMainViewShell)
266 SetActiveWindow (mpContentWindow.get());
267 }
268
269 void ViewShell::Exit()
270 {
271 sd::View* pView = GetView();
272 if (pView!=nullptr && pView->IsTextEdit())
273 {
274 pView->SdrEndTextEdit();
275 pView->UnmarkAll();
276 }
277
278 Deactivate (true);
279
280 if (IsMainViewShell())
281 GetDocSh()->Disconnect(this);
282
283 SetIsMainViewShell(false);
284 }
285
286 /**
287 * set focus to working window
288 */
289 void ViewShell::Activate(bool bIsMDIActivate)
290 {
291 // Do not forward to SfxShell::Activate()
292
293 /* According to MI, nobody is allowed to call GrabFocus, who does not
294 exactly know from which window the focus is grabbed. Since Activate()
295 is sent sometimes asynchronous, it can happen, that the wrong window
296 gets the focus. */
297
298 if (mpHorizontalRuler)
299 mpHorizontalRuler->SetActive();
300 if (mpVerticalRuler)
301 mpVerticalRuler->SetActive();
302
303 if (bIsMDIActivate)
304 {
305 // thus, the Navigator will also get a current status
306 SfxBoolItem aItem( SID_NAVIGATOR_INIT, true );
307 if (GetDispatcher() != nullptr)
308 GetDispatcher()->ExecuteList(
309 SID_NAVIGATOR_INIT,
310 SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
311 { &aItem });
312
313 SfxViewShell* pViewShell = GetViewShell();
314 OSL_ASSERT (pViewShell!=nullptr);
315 SfxBindings& rBindings = pViewShell->GetViewFrame().GetBindings();
316 rBindings.Invalidate( SID_3D_STATE, true );
317
318 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
319 if (xSlideShow.is() && xSlideShow->isRunning())
320 {
321 bool bSuccess = xSlideShow->activate(GetViewShellBase());
322 assert(bSuccess && "can only return false with a PresentationViewShell"); (void)bSuccess;
323 }
324
325 if(HasCurrentFunction())
326 GetCurrentFunction()->Activate();
327
328 if(!GetDocSh()->IsUIActive())
329 UpdatePreview( GetActualPage() );
330 }
331
332 ReadFrameViewData( mpFrameView );
333
334 if (IsMainViewShell())
335 GetDocSh()->Connect(this);
336 }
337
338 void ViewShell::UIActivating( SfxInPlaceClient* )
339 {
340 OSL_ASSERT (GetViewShell()!=nullptr);
341 GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed();
342 }
343
344 void ViewShell::UIDeactivated( SfxInPlaceClient* )
345 {
346 OSL_ASSERT (GetViewShell()!=nullptr);
347 GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed();
348 if ( GetDrawView() )
349 GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this, *GetDrawView());
350 }
351
352 void ViewShell::Deactivate(bool bIsMDIActivate)
353 {
354 // remove view from a still active drag'n'drop session
355 SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
356
357 if (IsMainViewShell())
358 GetDocSh()->Disconnect(this);
359
360 if( pDragTransferable )
361 pDragTransferable->SetView( nullptr );
362
363 OSL_ASSERT (GetViewShell()!=nullptr);
364
365 // remember view attributes of FrameView
366 WriteFrameViewData();
367
368 if (bIsMDIActivate)
369 {
370 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
371 if(xSlideShow.is() && xSlideShow->isRunning() )
372 xSlideShow->deactivate();
373
374 if(HasCurrentFunction())
375 GetCurrentFunction()->Deactivate();
376 }
377
378 if (mpHorizontalRuler)
379 mpHorizontalRuler->SetActive(false);
380 if (mpVerticalRuler)
381 mpVerticalRuler->SetActive(false);
382
383 SfxShell::Deactivate(bIsMDIActivate);
384 }
385
386 void ViewShell::Shutdown()
387 {
388 Exit ();
389 }
390
391 bool ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
392 {
393 bool bReturn(false);
394
395 if(pWin)
396 SetActiveWindow(pWin);
397
398 // give key input first to SfxViewShell to give CTRL+Key
399 // (e.g. CTRL+SHIFT+'+', to front) priority.
400 OSL_ASSERT(GetViewShell() != nullptr);
401 bReturn = GetViewShell()->KeyInput(rKEvt);
402
403 const size_t OriCount = GetView()->GetMarkedObjectList().GetMarkCount();
404 if(!bReturn)
405 {
406 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
407 if(xSlideShow.is() && xSlideShow->isRunning())
408 {
409 bReturn = xSlideShow->keyInput(rKEvt);
410 }
411 else
412 {
413 bool bConsumed = false;
414 if( GetView() )
415 bConsumed = GetView()->getSmartTags().KeyInput(rKEvt);
416
417 if( !bConsumed )
418 {
419 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
420 if( !xSelectionController.is() || !xSelectionController->onKeyInput( rKEvt, pWin ) )
421 {
422 if(HasCurrentFunction())
423 bReturn = GetCurrentFunction()->KeyInput(rKEvt);
424 }
425 else
426 {
427 bReturn = true;
428 if (HasCurrentFunction())
429 {
430 FuText* pTextFunction = dynamic_cast<FuText*>(GetCurrentFunction().get());
431 if(pTextFunction != nullptr)
432 pTextFunction->InvalidateBindings();
433 }
434 }
435 }
436 }
437 }
438 const size_t EndCount = GetView()->GetMarkedObjectList().GetMarkCount();
439 // Here, oriCount or endCount must have one value=0, another value > 0, then to switch focus between Document and shape objects
440 if(bReturn && (OriCount + EndCount > 0) && (OriCount * EndCount == 0))
441 SwitchActiveViewFireFocus();
442
443 if(!bReturn && GetActiveWindow())
444 {
445 vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
446
447 if (aKeyCode.IsMod1() && aKeyCode.IsShift()
448 && aKeyCode.GetCode() == KEY_R)
449 {
450 InvalidateWindows();
451 bReturn = true;
452 }
453 }
454
455 return bReturn;
456 }
457
458 void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin)
459 {
460 // We have to lock tool bar updates while the mouse button is pressed in
461 // order to prevent the shape under the mouse to be moved (this happens
462 // when the number of docked tool bars changes as result of a changed
463 // selection; this changes the window size and thus the mouse position
464 // in model coordinates: with respect to model coordinates the mouse
465 // moves.)
466 OSL_ASSERT(mpImpl->mpUpdateLockForMouse.expired());
467 mpImpl->mpUpdateLockForMouse = ViewShell::Implementation::ToolBarManagerLock::Create(
468 GetViewShellBase().GetToolBarManager());
469
470 if ( pWin && !pWin->HasFocus() )
471 {
472 pWin->GrabFocus();
473 SetActiveWindow(pWin);
474 }
475
476 // insert MouseEvent into E3dView
477 if (GetView() != nullptr)
478 GetView()->SetMouseEvent(rMEvt);
479
480 bool bConsumed = false;
481 if( GetView() )
482 bConsumed = GetView()->getSmartTags().MouseButtonDown( rMEvt );
483
484 if( bConsumed )
485 return;
486
487 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
488 if( !xSelectionController.is() || !xSelectionController->onMouseButtonDown( rMEvt, pWin ) )
489 {
490 if(HasCurrentFunction())
491 GetCurrentFunction()->MouseButtonDown(rMEvt);
492 }
493 else
494 {
495 if (HasCurrentFunction())
496 {
497 FuText* pTextFunction = dynamic_cast<FuText*>(GetCurrentFunction().get());
498 if (pTextFunction != nullptr)
499 pTextFunction->InvalidateBindings();
500 }
501 }
502 }
503
504 void ViewShell::SetCursorMm100Position(const Point& rPosition, bool bPoint, bool bClearMark)
505 {
506 if (SdrView* pSdrView = GetView())
507 {
508 rtl::Reference<sdr::SelectionController> xSelectionController(GetView()->getSelectionController());
509 if (!xSelectionController.is() || !xSelectionController->setCursorLogicPosition(rPosition, bPoint))
510 {
511 if (pSdrView->GetTextEditObject())
512 {
513 EditView& rEditView = pSdrView->GetTextEditOutlinerView()->GetEditView();
514 rEditView.SetCursorLogicPosition(rPosition, bPoint, bClearMark);
515 }
516 }
517 }
518 }
519
520 uno::Reference<datatransfer::XTransferable> ViewShell::GetSelectionTransferable() const
521 {
522 SdrView* pSdrView = GetView();
523 if (!pSdrView)
524 return uno::Reference<datatransfer::XTransferable>();
525
526 if (!pSdrView->GetTextEditObject())
527 return uno::Reference<datatransfer::XTransferable>();
528
529 EditView& rEditView = pSdrView->GetTextEditOutlinerView()->GetEditView();
530 return rEditView.GetEditEngine()->CreateTransferable(rEditView.GetSelection());
531 }
532
533 void ViewShell::SetGraphicMm100Position(bool bStart, const Point& rPosition)
534 {
535 if (bStart)
536 {
537 MouseEvent aClickEvent(rPosition, 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT);
538 MouseButtonDown(aClickEvent, mpActiveWindow);
539 MouseEvent aMoveEvent(Point(rPosition.getX(), rPosition.getY()), 0, MouseEventModifiers::SIMPLEMOVE, MOUSE_LEFT);
540 MouseMove(aMoveEvent, mpActiveWindow);
541 }
542 else
543 {
544 MouseEvent aMoveEvent(Point(rPosition.getX(), rPosition.getY()), 0, MouseEventModifiers::SIMPLEMOVE, MOUSE_LEFT);
545 MouseMove(aMoveEvent, mpActiveWindow);
546 MouseEvent aClickEvent(rPosition, 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT);
547 MouseButtonUp(aClickEvent, mpActiveWindow);
548 }
549 }
550
551 void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
552 {
553 if (rMEvt.IsLeaveWindow())
554 {
555 if ( ! mpImpl->mpUpdateLockForMouse.expired())
556 {
557 std::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock(
558 mpImpl->mpUpdateLockForMouse);
559 if (pLock != nullptr)
560 pLock->Release();
561 }
562 }
563
564 if ( pWin )
565 {
566 SetActiveWindow(pWin);
567 }
568
569 // insert MouseEvent into E3dView
570 if (GetView() != nullptr)
571 GetView()->SetMouseEvent(rMEvt);
572
573 if(HasCurrentFunction())
574 {
575 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
576 if( !xSelectionController.is() || !xSelectionController->onMouseMove( rMEvt, pWin ) )
577 {
578 if(HasCurrentFunction())
579 GetCurrentFunction()->MouseMove(rMEvt);
580 }
581 }
582 }
583
584 void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
585 {
586 if ( pWin )
587 SetActiveWindow(pWin);
588
589 // insert MouseEvent into E3dView
590 if (GetView() != nullptr)
591 GetView()->SetMouseEvent(rMEvt);
592
593 if( HasCurrentFunction())
594 {
595 rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
596 if( !xSelectionController.is() || !xSelectionController->onMouseButtonUp( rMEvt, pWin ) )
597 {
598 if(HasCurrentFunction())
599 GetCurrentFunction()->MouseButtonUp(rMEvt);
600 }
601 else
602 {
603 if (HasCurrentFunction())
604 {
605 FuText* pTextFunction = dynamic_cast<FuText*>(GetCurrentFunction().get());
606 if (pTextFunction != nullptr)
607 pTextFunction->InvalidateBindings();
608 }
609 }
610 }
611
612 if ( ! mpImpl->mpUpdateLockForMouse.expired())
613 {
614 std::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock(
615 mpImpl->mpUpdateLockForMouse);
616 if (pLock != nullptr)
617 pLock->Release();
618 }
619 }
620
621 void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
622 {
623 bool bDone = HandleScrollCommand (rCEvt, pWin);
624
625 if( bDone )
626 return;
627
628 if( rCEvt.GetCommand() == CommandEventId::InputLanguageChange )
629 {
630 //#i42732# update state of fontname if input language changes
631 GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONT );
632 GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
633 }
634 else
635 {
636 bool bConsumed = false;
637 if( GetView() )
638 bConsumed = GetView()->getSmartTags().Command(rCEvt);
639
640 if( !bConsumed && HasCurrentFunction())
641 GetCurrentFunction()->Command(rCEvt);
642 }
643 }
644
645 bool ViewShell::Notify(NotifyEvent const & rNEvt, ::sd::Window* pWin)
646 {
647 // handle scroll commands when they arrived at child windows
648 bool bRet = false;
649 if( rNEvt.GetType() == NotifyEventType::COMMAND )
650 {
651 // note: dynamic_cast is not possible as GetData() returns a void*
652 CommandEvent* pCmdEvent = static_cast< CommandEvent* >(rNEvt.GetData());
653 bRet = HandleScrollCommand(*pCmdEvent, pWin);
654 }
655 return bRet;
656 }
657
658 bool ViewShell::HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin)
659 {
660 bool bDone = false;
661
662 switch( rCEvt.GetCommand() )
663 {
664 case CommandEventId::GestureSwipe:
665 {
666 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
667 if (xSlideShow.is())
668 {
669 const CommandGestureSwipeData* pSwipeData = rCEvt.GetGestureSwipeData();
670 bDone = xSlideShow->swipe(*pSwipeData);
671 }
672 }
673 break;
674 case CommandEventId::GestureLongPress:
675 {
676 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
677 if (xSlideShow.is())
678 {
679 const CommandGestureLongPressData* pLongPressData = rCEvt.GetLongPressData();
680 bDone = xSlideShow->longpress(*pLongPressData);
681 }
682 }
683 break;
684
685 case CommandEventId::Wheel:
686 {
687 Reference< XSlideShowController > xSlideShowController( SlideShow::GetSlideShowController(GetViewShellBase() ) );
688 if( xSlideShowController.is() )
689 {
690 // We ignore zooming with control+mouse wheel.
691 const CommandWheelData* pData = rCEvt.GetWheelData();
692 if( pData && !pData->GetModifier() && ( pData->GetMode() == CommandWheelMode::SCROLL ) && !pData->IsHorz() )
693 {
694 ::tools::Long nDelta = pData->GetDelta();
695 if( nDelta > 0 )
696 xSlideShowController->gotoPreviousSlide();
697 else if( nDelta < 0 )
698 xSlideShowController->gotoNextEffect();
699 }
700 break;
701 }
702 }
703 [[fallthrough]];
704 case CommandEventId::StartAutoScroll:
705 case CommandEventId::AutoScroll:
706 {
707 const CommandWheelData* pData = rCEvt.GetWheelData();
708
709 if (pData != nullptr)
710 {
711 if (pData->IsMod1())
712 {
713 if( !GetDocSh()->IsUIActive() )
714 {
715 const sal_uInt16 nOldZoom = GetActiveWindow()->GetZoom();
716 sal_uInt16 nNewZoom;
717 Point aOldMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel());
718
719 if( pData->GetDelta() < 0 )
720 nNewZoom = std::max<sal_uInt16>( pWin->GetMinZoom(), basegfx::zoomtools::zoomOut( nOldZoom ));
721 else
722 nNewZoom = std::min<sal_uInt16>( pWin->GetMaxZoom(), basegfx::zoomtools::zoomIn( nOldZoom ));
723
724 SetZoom( nNewZoom );
725 // Keep mouse at same doc point before zoom
726 Point aNewMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel());
727 SetWinViewPos(GetWinViewPos() - (aNewMousePos - aOldMousePos));
728
729 Invalidate( SID_ATTR_ZOOM );
730 Invalidate( SID_ATTR_ZOOMSLIDER );
731
732 bDone = true;
733 }
734 }
735 else
736 {
737 if( mpContentWindow.get() == pWin )
738 {
739 sal_uLong nScrollLines = pData->GetScrollLines();
740 if(IsPageFlipMode())
741 nScrollLines = COMMAND_WHEEL_PAGESCROLL;
742 CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(),
743 nScrollLines,pData->GetMode(),pData->GetModifier(),pData->IsHorz() );
744 CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),
745 rCEvt.IsMouseEvent(),static_cast<const void *>(&aWheelData) );
746 bDone = pWin->HandleScrollCommand( aReWrite,
747 mpHorizontalScrollBar.get(),
748 mpVerticalScrollBar.get());
749 }
750 }
751 }
752 }
753 break;
754
755 case CommandEventId::GestureZoom:
756 {
757 const CommandGestureZoomData* pData = rCEvt.GetGestureZoomData();
758
759 Reference<XSlideShowController> xSlideShowController(SlideShow::GetSlideShowController(GetViewShellBase()));
760
761 if (pData->meEventType == GestureEventZoomType::Begin)
762 {
763 mfLastZoomScale = pData->mfScaleDelta;
764 bDone = true;
765 break;
766 }
767
768 if (pData->meEventType == GestureEventZoomType::Update)
769 {
770 double deltaBetweenEvents = (pData->mfScaleDelta - mfLastZoomScale) / mfLastZoomScale;
771 mfLastZoomScale = pData->mfScaleDelta;
772
773 if (!GetDocSh()->IsUIActive() && !xSlideShowController.is())
774 {
775 const ::tools::Long nOldZoom = GetActiveWindow()->GetZoom();
776 ::tools::Long nNewZoom;
777 Point aOldMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel());
778
779 // Accumulate fractional zoom to avoid small zoom changes from being ignored
780 mfAccumulatedZoom += deltaBetweenEvents;
781 int nZoomChangePercent = mfAccumulatedZoom * 100;
782 mfAccumulatedZoom -= nZoomChangePercent / 100.0;
783
784 nNewZoom = nOldZoom + nZoomChangePercent;
785 nNewZoom = std::max<::tools::Long>(pWin->GetMinZoom(), nNewZoom);
786 nNewZoom = std::min<::tools::Long>(pWin->GetMaxZoom(), nNewZoom);
787
788 SetZoom(nNewZoom);
789
790 // Keep mouse at same doc point before zoom
791 Point aNewMousePos = GetActiveWindow()->PixelToLogic(rCEvt.GetMousePosPixel());
792 SetWinViewPos(GetWinViewPos() - (aNewMousePos - aOldMousePos));
793
794 Invalidate(SID_ATTR_ZOOM);
795 Invalidate(SID_ATTR_ZOOMSLIDER);
796 }
797 }
798
799 bDone = true;
800 }
801 break;
802
803 default:
804 break;
805 }
806
807 return bDone;
808 }
809
810 void ViewShell::SetupRulers()
811 {
812 if(!mbHasRulers || !mpContentWindow || SlideShow::IsRunning(GetViewShellBase()))
813 return;
814
815 ::tools::Long nHRulerOfs = 0;
816
817 if ( !mpVerticalRuler )
818 {
819 mpVerticalRuler.reset(CreateVRuler(GetActiveWindow()));
820 if ( mpVerticalRuler )
821 {
822 nHRulerOfs = mpVerticalRuler->GetSizePixel().Width();
823 mpVerticalRuler->SetActive();
824 mpVerticalRuler->Show();
825 }
826 }
827 if ( !mpHorizontalRuler )
828 {
829 mpHorizontalRuler.reset(CreateHRuler(GetActiveWindow()));
830 if ( mpHorizontalRuler )
831 {
832 mpHorizontalRuler->SetWinPos(nHRulerOfs);
833 mpHorizontalRuler->SetActive();
834 mpHorizontalRuler->Show();
835 }
836 }
837 }
838
839 const SvxNumBulletItem* ViewShell::GetNumBulletItem(SfxItemSet& aNewAttr, TypedWhichId<SvxNumBulletItem>& nNumItemId)
840 {
841 const SvxNumBulletItem* pTmpItem = aNewAttr.GetItemIfSet(nNumItemId, false);
842 if(pTmpItem)
843 return pTmpItem;
844
845 nNumItemId = aNewAttr.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE);
846 pTmpItem = aNewAttr.GetItemIfSet(nNumItemId, false);
847 if(pTmpItem)
848 return pTmpItem;
849
850 bool bOutliner = false;
851 bool bTitle = false;
852
853 if( mpView )
854 {
855 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
856 const size_t nCount = rMarkList.GetMarkCount();
857
858 for(size_t nNum = 0; nNum < nCount; ++nNum)
859 {
860 SdrObject* pObj = rMarkList.GetMark(nNum)->GetMarkedSdrObj();
861 if( pObj->GetObjInventor() == SdrInventor::Default )
862 {
863 switch(pObj->GetObjIdentifier())
864 {
865 case SdrObjKind::TitleText:
866 bTitle = true;
867 break;
868 case SdrObjKind::OutlineText:
869 bOutliner = true;
870 break;
871 default:
872 break;
873 }
874 }
875 }
876 }
877
878 const SvxNumBulletItem *pItem = nullptr;
879 if(bOutliner)
880 {
881 SfxStyleSheetBasePool* pSSPool = mpView->GetDocSh()->GetStyleSheetPool();
882 SfxStyleSheetBase* pFirstStyleSheet = pSSPool->Find( STR_LAYOUT_OUTLINE + " 1", SfxStyleFamily::Pseudo);
883 if( pFirstStyleSheet )
884 pItem = pFirstStyleSheet->GetItemSet().GetItemIfSet(EE_PARA_NUMBULLET, false);
885 }
886
887 if( pItem == nullptr )
888 pItem = aNewAttr.GetPool()->GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET);
889
890 aNewAttr.Put(pItem->CloneSetWhich(EE_PARA_NUMBULLET));
891
892 if(bTitle && aNewAttr.GetItemState(EE_PARA_NUMBULLET) == SfxItemState::SET )
893 {
894 const SvxNumBulletItem* pBulletItem = aNewAttr.GetItem(EE_PARA_NUMBULLET);
895 const SvxNumRule& rRule = pBulletItem->GetNumRule();
896 SvxNumRule aNewRule( rRule );
897 aNewRule.SetFeatureFlag( SvxNumRuleFlags::NO_NUMBERS );
898
899 SvxNumBulletItem aNewItem( std::move(aNewRule), EE_PARA_NUMBULLET );
900 aNewAttr.Put(aNewItem);
901 }
902
903 pTmpItem = aNewAttr.GetItemIfSet(nNumItemId, false);
904
905 return pTmpItem;
906 }
907
908 void ViewShell::Resize()
909 {
910 SetupRulers ();
911
912 if (mpParentWindow == nullptr)
913 return;
914
915 // Make sure that the new size is not degenerate.
916 const Size aSize (mpParentWindow->GetSizePixel());
917 if (aSize.IsEmpty())
918 return;
919
920 // Remember the new position and size.
921 maViewPos = Point(0,0);
922 maViewSize = aSize;
923
924 // Rearrange the UI elements to take care of the new position and size.
925 ArrangeGUIElements ();
926 // end of included AdjustPosSizePixel.
927
928 ::sd::View* pView = GetView();
929
930 if (pView)
931 pView->VisAreaChanged(GetActiveWindow()->GetOutDev());
932 }
933
934 SvBorder ViewShell::GetBorder()
935 {
936 SvBorder aBorder;
937
938 // Horizontal scrollbar.
939 if (mpHorizontalScrollBar
940 && mpHorizontalScrollBar->IsVisible())
941 {
942 aBorder.Bottom() = maScrBarWH.Height();
943 }
944
945 // Vertical scrollbar.
946 if (mpVerticalScrollBar
947 && mpVerticalScrollBar->IsVisible())
948 {
949 aBorder.Right() = maScrBarWH.Width();
950 }
951
952 // Place horizontal ruler below tab bar.
953 if (mbHasRulers && mpContentWindow)
954 {
955 SetupRulers();
956 if (mpHorizontalRuler)
957 aBorder.Top() = mpHorizontalRuler->GetSizePixel().Height();
958 if (mpVerticalRuler)
959 aBorder.Left() = mpVerticalRuler->GetSizePixel().Width();
960 }
961
962 return aBorder;
963 }
964
965 void ViewShell::ArrangeGUIElements()
966 {
967 if (mpImpl->mbArrangeActive)
968 return;
969 if (maViewSize.IsEmpty())
970 return;
971 mpImpl->mbArrangeActive = true;
972
973 // Calculate border for in-place editing.
974 ::tools::Long nLeft = maViewPos.X();
975 ::tools::Long nTop = maViewPos.Y();
976 ::tools::Long nRight = maViewPos.X() + maViewSize.Width();
977 ::tools::Long nBottom = maViewPos.Y() + maViewSize.Height();
978
979 // Horizontal scrollbar.
980 if (mpHorizontalScrollBar
981 && mpHorizontalScrollBar->IsVisible())
982 {
983 nBottom -= maScrBarWH.Height();
984 if (mpLayerTabBar && mpLayerTabBar->IsVisible())
985 nBottom -= mpLayerTabBar->GetSizePixel().Height();
986 mpHorizontalScrollBar->SetPosSizePixel (
987 Point(nLeft, nBottom),
988 Size(nRight - nLeft - maScrBarWH.Width(), maScrBarWH.Height()));
989 }
990
991 // Vertical scrollbar.
992 if (mpVerticalScrollBar
993 && mpVerticalScrollBar->IsVisible())
994 {
995 nRight -= maScrBarWH.Width();
996 mpVerticalScrollBar->SetPosSizePixel (
997 Point(nRight,nTop),
998 Size (maScrBarWH.Width(), nBottom-nTop));
999 }
1000
1001 // Place horizontal ruler below tab bar.
1002 if (mbHasRulers && mpContentWindow)
1003 {
1004 if (mpHorizontalRuler)
1005 {
1006 Size aRulerSize = mpHorizontalRuler->GetSizePixel();
1007 aRulerSize.setWidth( nRight - nLeft );
1008 mpHorizontalRuler->SetPosSizePixel (
1009 Point(nLeft,nTop), aRulerSize);
1010 if (mpVerticalRuler)
1011 mpHorizontalRuler->SetBorderPos(
1012 mpVerticalRuler->GetSizePixel().Width()-1);
1013 nTop += aRulerSize.Height();
1014 }
1015 if (mpVerticalRuler)
1016 {
1017 Size aRulerSize = mpVerticalRuler->GetSizePixel();
1018 aRulerSize.setHeight( nBottom - nTop );
1019 mpVerticalRuler->SetPosSizePixel (
1020 Point (nLeft,nTop), aRulerSize);
1021 nLeft += aRulerSize.Width();
1022 }
1023 }
1024
1025 rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
1026
1027 // The size of the window of the center pane is set differently from
1028 // that of the windows in the docking windows.
1029 bool bSlideShowActive = (xSlideShow.is() && xSlideShow->isRunning()) && !xSlideShow->isFullScreen() && xSlideShow->getAnimationMode() == ANIMATIONMODE_SHOW;
1030 if ( !bSlideShowActive)
1031 {
1032 OSL_ASSERT (GetViewShell()!=nullptr);
1033
1034 if (mpContentWindow)
1035 mpContentWindow->SetPosSizePixel(
1036 Point(nLeft,nTop),
1037 Size(nRight-nLeft,nBottom-nTop));
1038 }
1039
1040 // Windows in the center and rulers at the left and top side.
1041 maAllWindowRectangle = ::tools::Rectangle(
1042 maViewPos,
1043 Size(maViewSize.Width()-maScrBarWH.Width(),
1044 maViewSize.Height()-maScrBarWH.Height()));
1045
1046 if (mpContentWindow)
1047 mpContentWindow->UpdateMapOrigin();
1048
1049 UpdateScrollBars();
1050
1051 mpImpl->mbArrangeActive = false;
1052 }
1053
1054 void ViewShell::SetUIUnit(FieldUnit eUnit)
1055 {
1056 // Set unit at horizontal and vertical rulers.
1057 if (mpHorizontalRuler)
1058 mpHorizontalRuler->SetUnit(eUnit);
1059
1060 if (mpVerticalRuler)
1061 mpVerticalRuler->SetUnit(eUnit);
1062 }
1063
1064 /**
1065 * set DefTab at horizontal rulers
1066 */
1067 void ViewShell::SetDefTabHRuler( sal_uInt16 nDefTab )
1068 {
1069 if (mpHorizontalRuler)
1070 mpHorizontalRuler->SetDefTabDist( nDefTab );
1071 }
1072
1073 /** Tell the FmFormShell that the view shell is closing. Give it the
1074 opportunity to prevent that.
1075 */
1076 bool ViewShell::PrepareClose (bool bUI)
1077 {
1078 bool bResult = true;
1079
1080 FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
1081 if (pFormShell != nullptr)
1082 bResult = pFormShell->PrepareClose (bUI);
1083
1084 return bResult;
1085 }
1086
1087 void ViewShell::UpdatePreview (SdPage*)
1088 {
1089 // Do nothing. After the actual preview has been removed,
1090 // OutlineViewShell::UpdatePreview() is the place where something
1091 // useful is still done.
1092 }
1093
1094 SfxUndoManager* ViewShell::ImpGetUndoManager() const
1095 {
1096 const ViewShell* pMainViewShell = GetViewShellBase().GetMainViewShell().get();
1097
1098 if( pMainViewShell == nullptr )
1099 pMainViewShell = this;
1100
1101 ::sd::View* pView = pMainViewShell->GetView();
1102
1103 // check for text edit our outline view
1104 if( pView )
1105 {
1106 if( pMainViewShell->GetShellType() == ViewShell::ST_OUTLINE )
1107 {
1108 OutlineView* pOlView = dynamic_cast< OutlineView* >( pView );
1109 if( pOlView )
1110 {
1111 ::Outliner& rOutl = pOlView->GetOutliner();
1112 return &rOutl.GetUndoManager();
1113 }
1114 }
1115 else if( pView->IsTextEdit() )
1116 {
1117 SdrOutliner* pOL = pView->GetTextEditOutliner();
1118 if( pOL )
1119 return &pOL->GetUndoManager();
1120 }
1121 }
1122
1123 if( GetDocSh() )
1124 return GetDocSh()->GetUndoManager();
1125
1126 return nullptr;
1127 }
1128
1129 void ViewShell::ImpGetUndoStrings(SfxItemSet &rSet) const
1130 {
1131 SfxUndoManager* pUndoManager = ImpGetUndoManager();
1132 if(!pUndoManager)
1133 return;
1134
1135 sal_uInt16 nCount(pUndoManager->GetUndoActionCount());
1136 if(nCount)
1137 {
1138 // prepare list
1139 std::vector<OUString> aStringList;
1140 aStringList.reserve(nCount);
1141 for (sal_uInt16 a = 0; a < nCount; ++a)
1142 {
1143 // generate one String in list per undo step
1144 aStringList.push_back( pUndoManager->GetUndoActionComment(a) );
1145 }
1146
1147 // set item
1148 rSet.Put(SfxStringListItem(SID_GETUNDOSTRINGS, &aStringList));
1149 }
1150 else
1151 {
1152 rSet.DisableItem(SID_GETUNDOSTRINGS);
1153 }
1154 }
1155
1156 void ViewShell::ImpGetRedoStrings(SfxItemSet &rSet) const
1157 {
1158 SfxUndoManager* pUndoManager = ImpGetUndoManager();
1159 if(!pUndoManager)
1160 return;
1161
1162 sal_uInt16 nCount(pUndoManager->GetRedoActionCount());
1163 if(nCount)
1164 {
1165 // prepare list
1166 ::std::vector< OUString > aStringList;
1167 aStringList.reserve(nCount);
1168 for(sal_uInt16 a = 0; a < nCount; a++)
1169 // generate one String in list per undo step
1170 aStringList.push_back( pUndoManager->GetRedoActionComment(a) );
1171
1172 // set item
1173 rSet.Put(SfxStringListItem(SID_GETREDOSTRINGS, &aStringList));
1174 }
1175 else
1176 {
1177 rSet.DisableItem(SID_GETREDOSTRINGS);
1178 }
1179 }
1180
1181 namespace {
1182
1183 class KeepSlideSorterInSyncWithPageChanges
1184 {
1185 sd::slidesorter::view::SlideSorterView::DrawLock m_aDrawLock;
1186 sd::slidesorter::controller::SlideSorterController::ModelChangeLock m_aModelLock;
1187 sd::slidesorter::controller::PageSelector::UpdateLock m_aUpdateLock;
1188 sd::slidesorter::controller::SelectionObserver::Context m_aContext;
1189
1190 public:
1191 explicit KeepSlideSorterInSyncWithPageChanges(sd::slidesorter::SlideSorter const & rSlideSorter)
1192 : m_aDrawLock(rSlideSorter)
1193 , m_aModelLock(rSlideSorter.GetController())
1194 , m_aUpdateLock(rSlideSorter)
1195 , m_aContext(rSlideSorter)
1196 {
1197 }
1198 };
1199
1200 }
1201
1202 void ViewShell::ImpSidUndo(SfxRequest& rReq)
1203 {
1204 //The xWatcher keeps the SlideSorter selection in sync
1205 //with the page insertions/deletions that Undo may introduce
1206 std::unique_ptr<KeepSlideSorterInSyncWithPageChanges, o3tl::default_delete<KeepSlideSorterInSyncWithPageChanges>> xWatcher;
1207 slidesorter::SlideSorterViewShell* pSlideSorterViewShell
1208 = slidesorter::SlideSorterViewShell::GetSlideSorter(GetViewShellBase());
1209 if (pSlideSorterViewShell)
1210 xWatcher.reset(new KeepSlideSorterInSyncWithPageChanges(pSlideSorterViewShell->GetSlideSorter()));
1211
1212 SfxUndoManager* pUndoManager = ImpGetUndoManager();
1213 sal_uInt16 nNumber(1);
1214 const SfxItemSet* pReqArgs = rReq.GetArgs();
1215 bool bRepair = false;
1216
1217 if(pReqArgs)
1218 {
1219 const SfxUInt16Item* pUIntItem = static_cast<const SfxUInt16Item*>(&pReqArgs->Get(SID_UNDO));
1220 nNumber = pUIntItem->GetValue();
1221
1222 // Repair mode: allow undo/redo of all undo actions, even if access would
1223 // be limited based on the view shell ID.
1224 if (const SfxBoolItem* pRepairItem = pReqArgs->GetItemIfSet(SID_REPAIRPACKAGE, false))
1225 bRepair = pRepairItem->GetValue();
1226 }
1227
1228 if(nNumber && pUndoManager)
1229 {
1230 sal_uInt16 nCount(pUndoManager->GetUndoActionCount());
1231 if(nCount >= nNumber)
1232 {
1233 if (comphelper::LibreOfficeKit::isActive() && !bRepair)
1234 {
1235 // If another view created the first undo action, prevent redoing it from this view.
1236 const SfxUndoAction* pAction = pUndoManager->GetUndoAction();
1237 if (pAction->GetViewShellId() != GetViewShellBase().GetViewShellId())
1238 {
1239 rReq.SetReturnValue(SfxUInt32Item(SID_UNDO, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)));
1240 return;
1241 }
1242 }
1243
1244 try
1245 {
1246 // when UndoStack is cleared by ModifyPageUndoAction
1247 // the nCount may have changed, so test GetUndoActionCount()
1248 while(nNumber-- && pUndoManager->GetUndoActionCount())
1249 pUndoManager->Undo();
1250 }
1251 catch( const Exception& )
1252 {
1253 // no need to handle. By definition, the UndoManager handled this by clearing the
1254 // Undo/Redo stacks
1255 }
1256 }
1257
1258 // refresh rulers, maybe UNDO was move of TAB marker in ruler
1259 if (mbHasRulers)
1260 Invalidate(SID_ATTR_TABSTOP);
1261 }
1262
1263 // This one is corresponding to the default handling
1264 // of SID_UNDO in sfx2
1265 GetViewFrame()->GetBindings().InvalidateAll(false);
1266
1267 rReq.Done();
1268 }
1269
1270 void ViewShell::ImpSidRedo(SfxRequest& rReq)
1271 {
1272 //The xWatcher keeps the SlideSorter selection in sync
1273 //with the page insertions/deletions that Undo may introduce
1274 std::unique_ptr<KeepSlideSorterInSyncWithPageChanges, o3tl::default_delete<KeepSlideSorterInSyncWithPageChanges>> xWatcher;
1275 slidesorter::SlideSorterViewShell* pSlideSorterViewShell
1276 = slidesorter::SlideSorterViewShell::GetSlideSorter(GetViewShellBase());
1277 if (pSlideSorterViewShell)
1278 xWatcher.reset(new KeepSlideSorterInSyncWithPageChanges(pSlideSorterViewShell->GetSlideSorter()));
1279
1280 SfxUndoManager* pUndoManager = ImpGetUndoManager();
1281 sal_uInt16 nNumber(1);
1282 const SfxItemSet* pReqArgs = rReq.GetArgs();
1283 bool bRepair = false;
1284
1285 if(pReqArgs)
1286 {
1287 const SfxUInt16Item* pUIntItem = static_cast<const SfxUInt16Item*>(&pReqArgs->Get(SID_REDO));
1288 nNumber = pUIntItem->GetValue();
1289 // Repair mode: allow undo/redo of all undo actions, even if access would
1290 // be limited based on the view shell ID.
1291 if (const SfxBoolItem* pRepairItem = pReqArgs->GetItemIfSet(SID_REPAIRPACKAGE, false))
1292 bRepair = pRepairItem->GetValue();
1293 }
1294
1295 if(nNumber && pUndoManager)
1296 {
1297 sal_uInt16 nCount(pUndoManager->GetRedoActionCount());
1298 if(nCount >= nNumber)
1299 {
1300 if (comphelper::LibreOfficeKit::isActive() && !bRepair)
1301 {
1302 // If another view created the first undo action, prevent redoing it from this view.
1303 const SfxUndoAction* pAction = pUndoManager->GetRedoAction();
1304 if (pAction->GetViewShellId() != GetViewShellBase().GetViewShellId())
1305 {
1306 rReq.SetReturnValue(SfxUInt32Item(SID_REDO, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)));
1307 return;
1308 }
1309 }
1310
1311 try
1312 {
1313 // when UndoStack is cleared by ModifyPageRedoAction
1314 // the nCount may have changed, so test GetRedoActionCount()
1315 while(nNumber-- && pUndoManager->GetRedoActionCount())
1316 pUndoManager->Redo();
1317 }
1318 catch( const Exception& )
1319 {
1320 // no need to handle. By definition, the UndoManager handled this by clearing the
1321 // Undo/Redo stacks
1322 }
1323 }
1324
1325 // refresh rulers, maybe REDO was move of TAB marker in ruler
1326 if (mbHasRulers)
1327 {
1328 Invalidate(SID_ATTR_TABSTOP);
1329 }
1330 }
1331
1332 // This one is corresponding to the default handling
1333 // of SID_UNDO in sfx2
1334 GetViewFrame()->GetBindings().InvalidateAll(false);
1335
1336 rReq.Done();
1337 }
1338
1339 void ViewShell::ExecReq( SfxRequest& rReq )
1340 {
1341 sal_uInt16 nSlot = rReq.GetSlot();
1342 switch( nSlot )
1343 {
1344 case SID_MAIL_SCROLLBODY_PAGEDOWN:
1345 {
1346 rtl::Reference<FuPoor> xFunc( GetCurrentFunction() );
1347 if( xFunc.is() )
1348 ScrollLines( 0, -1 );
1349
1350 rReq.Done();
1351 }
1352 break;
1353
1354 case SID_OUTPUT_QUALITY_COLOR:
1355 case SID_OUTPUT_QUALITY_GRAYSCALE:
1356 case SID_OUTPUT_QUALITY_BLACKWHITE:
1357 case SID_OUTPUT_QUALITY_CONTRAST:
1358 {
1359 DrawModeFlags nMode = OUTPUT_DRAWMODE_COLOR;
1360
1361 switch( nSlot )
1362 {
1363 case SID_OUTPUT_QUALITY_COLOR: nMode = OUTPUT_DRAWMODE_COLOR; break;
1364 case SID_OUTPUT_QUALITY_GRAYSCALE: nMode = OUTPUT_DRAWMODE_GRAYSCALE; break;
1365 case SID_OUTPUT_QUALITY_BLACKWHITE: nMode = OUTPUT_DRAWMODE_BLACKWHITE; break;
1366 case SID_OUTPUT_QUALITY_CONTRAST: nMode = OUTPUT_DRAWMODE_CONTRAST; break;
1367 }
1368
1369 GetActiveWindow()->GetOutDev()->SetDrawMode( nMode );
1370 mpFrameView->SetDrawMode( nMode );
1371
1372 GetActiveWindow()->Invalidate();
1373
1374 Invalidate();
1375 rReq.Done();
1376 break;
1377 }
1378 }
1379 }
1380
1381 /** This default implementation returns only an empty reference. See derived
1382 classes for more interesting examples.
1383 */
1384 css::uno::Reference<css::accessibility::XAccessible>
1385 ViewShell::CreateAccessibleDocumentView (::sd::Window* )
1386 {
1387 OSL_FAIL("ViewShell::CreateAccessibleDocumentView should not be called!, perhaps Meyers, 3rd edition, Item 9:");
1388
1389 return css::uno::Reference<css::accessibility::XAccessible> ();
1390 }
1391
1392 ::sd::WindowUpdater* ViewShell::GetWindowUpdater() const
1393 {
1394 return mpWindowUpdater.get();
1395 }
1396
1397 ViewShellBase& ViewShell::GetViewShellBase() const
1398 {
1399 return *static_cast<ViewShellBase*>(GetViewShell());
1400 }
1401
1402 ViewShell::ShellType ViewShell::GetShellType() const
1403 {
1404 return meShellType;
1405 }
1406
1407 DrawDocShell* ViewShell::GetDocSh() const
1408 {
1409 return GetViewShellBase().GetDocShell();
1410 }
1411
1412 SdDrawDocument* ViewShell::GetDoc() const
1413 {
1414 return GetViewShellBase().GetDocument();
1415 }
1416
1417 ErrCode ViewShell::DoVerb(sal_Int32 /*nVerb*/)
1418 {
1419 return ERRCODE_NONE;
1420 }
1421
1422 void ViewShell::SetCurrentFunction( const rtl::Reference<FuPoor>& xFunction)
1423 {
1424 if( mxCurrentFunction.is() && (mxOldFunction != mxCurrentFunction) )
1425 mxCurrentFunction->Dispose();
1426 rtl::Reference<FuPoor> xDisposeAfterNewOne( mxCurrentFunction );
1427 mxCurrentFunction = xFunction;
1428 }
1429
1430 void ViewShell::SetOldFunction(const rtl::Reference<FuPoor>& xFunction)
1431 {
1432 if( mxOldFunction.is() && (xFunction != mxOldFunction) && (mxCurrentFunction != mxOldFunction) )
1433 mxOldFunction->Dispose();
1434
1435 rtl::Reference<FuPoor> xDisposeAfterNewOne( mxOldFunction );
1436 mxOldFunction = xFunction;
1437 }
1438
1439 /** this method deactivates the current function. If an old function is
1440 saved, this will become activated and current function.
1441 */
1442 void ViewShell::Cancel()
1443 {
1444 if(mxCurrentFunction.is() && (mxCurrentFunction != mxOldFunction ))
1445 {
1446 rtl::Reference<FuPoor> xTemp( mxCurrentFunction );
1447 mxCurrentFunction.clear();
1448 xTemp->Deactivate();
1449 xTemp->Dispose();
1450 }
1451
1452 if(mxOldFunction.is())
1453 {
1454 mxCurrentFunction = mxOldFunction;
1455 mxCurrentFunction->Activate();
1456 }
1457 }
1458
1459 void ViewShell::DeactivateCurrentFunction( bool bPermanent /* == false */ )
1460 {
1461 if( mxCurrentFunction.is() )
1462 {
1463 if(bPermanent && (mxOldFunction == mxCurrentFunction))
1464 mxOldFunction.clear();
1465
1466 mxCurrentFunction->Deactivate();
1467 if( mxCurrentFunction != mxOldFunction )
1468 mxCurrentFunction->Dispose();
1469
1470 rtl::Reference<FuPoor> xDisposeAfterNewOne( mxCurrentFunction );
1471 mxCurrentFunction.clear();
1472 }
1473 }
1474
1475 void ViewShell::DisposeFunctions()
1476 {
1477 if(mxCurrentFunction.is())
1478 {
1479 rtl::Reference<FuPoor> xTemp( mxCurrentFunction );
1480 mxCurrentFunction.clear();
1481 xTemp->Deactivate();
1482 xTemp->Dispose();
1483 }
1484
1485 if(mxOldFunction.is())
1486 {
1487 rtl::Reference<FuPoor> xDisposeAfterNewOne( mxOldFunction );
1488 mxOldFunction->Dispose();
1489 mxOldFunction.clear();
1490 }
1491 }
1492
1493 bool ViewShell::IsMainViewShell() const
1494 {
1495 return mpImpl->mbIsMainViewShell;
1496 }
1497
1498 void ViewShell::SetIsMainViewShell (bool bIsMainViewShell)
1499 {
1500 if (bIsMainViewShell != mpImpl->mbIsMainViewShell)
1501 {
1502 mpImpl->mbIsMainViewShell = bIsMainViewShell;
1503 if (bIsMainViewShell)
1504 GetDocSh()->Connect (this);
1505 else
1506 GetDocSh()->Disconnect (this);
1507 }
1508 }
1509
1510 void ViewShell::PrePaint()
1511 {
1512 }
1513
1514 void ViewShell::Paint (const ::tools::Rectangle&, ::sd::Window* )
1515 {
1516 }
1517
1518 void ViewShell::ShowUIControls (bool bVisible)
1519 {
1520 if (mbHasRulers)
1521 {
1522 if (mpHorizontalRuler)
1523 mpHorizontalRuler->Show( bVisible );
1524
1525 if (mpVerticalRuler)
1526 mpVerticalRuler->Show( bVisible );
1527 }
1528
1529 if (mpVerticalScrollBar)
1530 mpVerticalScrollBar->Show( bVisible );
1531
1532 if (mpHorizontalScrollBar)
1533 mpHorizontalScrollBar->Show( bVisible );
1534
1535 if (mpContentWindow)
1536 mpContentWindow->Show( bVisible );
1537 }
1538
1539 bool ViewShell::RelocateToParentWindow (vcl::Window* pParentWindow)
1540 {
1541 mpParentWindow = pParentWindow;
1542
1543 mpParentWindow->SetBackground (Wallpaper());
1544
1545 if (mpContentWindow)
1546 mpContentWindow->SetParent(pParentWindow);
1547
1548 if (mpHorizontalScrollBar)
1549 mpHorizontalScrollBar->SetParent(mpParentWindow);
1550 if (mpVerticalScrollBar)
1551 mpVerticalScrollBar->SetParent(mpParentWindow);
1552
1553 return true;
1554 }
1555
1556 void ViewShell::SwitchViewFireFocus(const css::uno::Reference< css::accessibility::XAccessible >& xAcc )
1557 {
1558 if (xAcc)
1559 {
1560 ::accessibility::AccessibleDocumentViewBase* pBase = static_cast< ::accessibility::AccessibleDocumentViewBase* >(xAcc.get());
1561 if (pBase)
1562 pBase->SwitchViewActivated();
1563 }
1564 }
1565 void ViewShell::SwitchActiveViewFireFocus()
1566 {
1567 if (mpContentWindow)
1568 {
1569 SwitchViewFireFocus(mpContentWindow->GetAccessible(false));
1570 }
1571 }
1572 // move these two methods from DrawViewShell.
1573 void ViewShell::fireSwitchCurrentPage(sal_Int32 pageIndex)
1574 {
1575 GetViewShellBase().GetDrawController()->fireSwitchCurrentPage(pageIndex);
1576 }
1577 void ViewShell::NotifyAccUpdate( )
1578 {
1579 GetViewShellBase().GetDrawController()->NotifyAccUpdate();
1580 }
1581
1582 weld::Window* ViewShell::GetFrameWeld() const
1583 {
1584 return mpActiveWindow ? mpActiveWindow->GetFrameWeld() : nullptr;
1585 }
1586
1587 sd::Window* ViewShell::GetContentWindow() const
1588 {
1589 return mpContentWindow.get();
1590 }
1591
1592 } // end of namespace sd
1593
1594 //===== ViewShellObjectBarFactory =============================================
1595
1596 namespace {
1597
1598 ViewShellObjectBarFactory::ViewShellObjectBarFactory (
1599 ::sd::ViewShell& rViewShell)
1600 : mrViewShell (rViewShell)
1601 {
1602 }
1603
1604 SfxShell* ViewShellObjectBarFactory::CreateShell( ::sd::ShellId nId )
1605 {
1606 SfxShell* pShell = nullptr;
1607
1608 ::sd::View* pView = mrViewShell.GetView();
1609 switch (nId)
1610 {
1611 case ToolbarId::Bezier_Toolbox_Sd:
1612 pShell = new ::sd::BezierObjectBar(&mrViewShell, pView);
1613 break;
1614
1615 case ToolbarId::Draw_Text_Toolbox_Sd:
1616 pShell = new ::sd::TextObjectBar(
1617 &mrViewShell, mrViewShell.GetDoc()->GetPool(), pView);
1618 break;
1619
1620 case ToolbarId::Draw_Graf_Toolbox:
1621 pShell = new ::sd::GraphicObjectBar(&mrViewShell, pView);
1622 break;
1623
1624 case ToolbarId::Draw_Media_Toolbox:
1625 pShell = new ::sd::MediaObjectBar(&mrViewShell, pView);
1626 break;
1627
1628 case ToolbarId::Draw_Table_Toolbox:
1629 pShell = ::sd::ui::table::CreateTableObjectBar( mrViewShell, pView );
1630 break;
1631
1632 case ToolbarId::Svx_Extrusion_Bar:
1633 pShell = new svx::ExtrusionBar(
1634 &mrViewShell.GetViewShellBase());
1635 break;
1636
1637 case ToolbarId::Svx_Fontwork_Bar:
1638 pShell = new svx::FontworkBar(
1639 &mrViewShell.GetViewShellBase());
1640 break;
1641
1642 default:
1643 pShell = nullptr;
1644 break;
1645 }
1646
1647 return pShell;
1648 }
1649
1650 void ViewShellObjectBarFactory::ReleaseShell (SfxShell* pShell)
1651 {
1652 delete pShell;
1653 }
1654
1655 } // end of anonymous namespace
1656
1657 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE