xref: /aoo4110/main/sd/source/ui/view/viewshel.cxx (revision b1cdbd2c)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 
27 #include "ViewShell.hxx"
28 #include "ViewShellImplementation.hxx"
29 
30 #ifndef _COM_SUN_STAR_EMBED_EMBEDSTATE_HPP_
31 #include <com/sun/star/embed/EmbedStates.hpp>
32 #endif
33 #include "ViewShellBase.hxx"
34 #include "ShellFactory.hxx"
35 #include "DrawController.hxx"
36 #include "LayerTabBar.hxx"
37 
38 #include <sfx2/viewfrm.hxx>
39 #include <sfx2/bindings.hxx>
40 #include <sfx2/dispatch.hxx>
41 #ifndef _SCRBAR_HXX //autogen
42 #include <vcl/scrbar.hxx>
43 #endif
44 #include <svl/eitem.hxx>
45 #include <svx/ruler.hxx>
46 #ifndef _SVXIDS_HXX
47 #include <svx/svxids.hrc>
48 #endif
49 #include <svx/fmshell.hxx>
50 #ifndef SD_WINDOW_UPDATER_HXX
51 #include "WindowUpdater.hxx"
52 #endif
53 #include "GraphicViewShell.hxx"
54 #include <sfx2/childwin.hxx>
55 #include <sdxfer.hxx>
56 #include "GraphicViewShell.hxx"
57 #include <sfx2/childwin.hxx>
58 
59 #include "app.hrc"
60 #include "helpids.h"
61 #include "strings.hrc"
62 #include "res_bmp.hrc"
63 #include "OutlineView.hxx"
64 #include "Client.hxx"
65 #include "sdresid.hxx"
66 #include "DrawDocShell.hxx"
67 #include "slideshow.hxx"
68 #include "drawdoc.hxx"
69 #include "sdpage.hxx"
70 #include "zoomlist.hxx"
71 #include "FrameView.hxx"
72 #include "optsitem.hxx"
73 #include "BezierObjectBar.hxx"
74 #include "TextObjectBar.hxx"
75 #include "GraphicObjectBar.hxx"
76 #include "MediaObjectBar.hxx"
77 #include "ViewShellManager.hxx"
78 #include "FormShellManager.hxx"
79 #include <svx/fmshell.hxx>
80 #include <svx/dialogs.hrc>
81 #include <svx/extrusionbar.hxx>
82 #include <svx/fontworkbar.hxx>
83 #include <svx/svdoutl.hxx>
84 #include <tools/diagnose_ex.h>
85 
86 // #96090#
87 #include <svl/slstitm.hxx>
88 #include <sfx2/request.hxx>
89 #include "SpellDialogChildWindow.hxx"
90 
91 #include "Window.hxx"
92 #include "fupoor.hxx"
93 
94 #include <editeng/numitem.hxx>
95 #include <editeng/eeitem.hxx>
96 #include <svl/poolitem.hxx>
97 #include <glob.hrc>
98 #include "AccessibleDocumentViewBase.hxx"
99 #ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED
100 #define SO2_DECL_SVINPLACEOBJECT_DEFINED
101 SO2_DECL_REF(SvInPlaceObject)
102 #endif
103 
104 namespace sd { namespace ui { namespace table {
105 	extern SfxShell* CreateTableObjectBar( ViewShell& rShell, ::sd::View* pView );
106 } } }
107 
108 using namespace ::com::sun::star;
109 using namespace ::com::sun::star::uno;
110 using namespace ::com::sun::star::presentation;
111 
112 namespace {
113 
114 class ViewShellObjectBarFactory
115     : public ::sd::ShellFactory<SfxShell>
116 {
117 public:
118     ViewShellObjectBarFactory (::sd::ViewShell& rViewShell);
119     virtual ~ViewShellObjectBarFactory (void);
120     virtual SfxShell* CreateShell (
121         ::sd::ShellId nId,
122         ::Window* pParentWindow,
123         ::sd::FrameView* pFrameView);
124     virtual void ReleaseShell (SfxShell* pShell);
125 private:
126     ::sd::ViewShell& mrViewShell;
127     /** This cache holds the already created object bars.
128     */
129     typedef ::std::map< ::sd::ShellId,SfxShell*> ShellCache;
130     ShellCache maShellCache;
131 };
132 
133 
134 } // end of anonymous namespace
135 
136 
137 namespace sd {
138 
139 static const int DELTA_ZOOM = 10;
140 
IsPageFlipMode(void) const141 sal_Bool ViewShell::IsPageFlipMode(void) const
142 {
143 	return this->ISA(DrawViewShell) && mpContentWindow.get() != NULL &&
144 		mpContentWindow->GetVisibleHeight() >= 1.0;
145 }
146 
GetViewFrame(void) const147 SfxViewFrame* ViewShell::GetViewFrame (void) const
148 {
149     const SfxViewShell* pViewShell = GetViewShell();
150     if (pViewShell != NULL)
151     {
152         return pViewShell->GetViewFrame();
153     }
154     else
155     {
156         OSL_ASSERT (GetViewShell()!=NULL);
157         return NULL;
158     }
159 }
160 
161 
162 /*************************************************************************
163 |*
164 |* SFX-Slotmap und Standardinterface deklarieren
165 |*
166 \************************************************************************/
167 TYPEINIT1(ViewShell, SfxShell);
168 
169 
ViewShell(SfxViewFrame *,::Window * pParentWindow,ViewShellBase & rViewShellBase,bool bAllowCenter)170 ViewShell::ViewShell( SfxViewFrame*, ::Window* pParentWindow, ViewShellBase& rViewShellBase, bool bAllowCenter)
171 :	SfxShell(&rViewShellBase)
172 ,	mbCenterAllowed(bAllowCenter)
173 ,	mpParentWindow(pParentWindow)
174 {
175 	construct();
176 }
177 
~ViewShell()178 ViewShell::~ViewShell()
179 {
180     // Keep the content window from accessing in its destructor the
181     // WindowUpdater.
182     if (mpContentWindow)
183         mpContentWindow->SetViewShell(NULL);
184 
185 	delete mpZoomList;
186 
187     mpLayerTabBar.reset();
188 
189     if (mpImpl->mpSubShellFactory.get() != NULL)
190         GetViewShellBase().GetViewShellManager()->RemoveSubShellFactory(
191             this,mpImpl->mpSubShellFactory);
192 
193     if (mpContentWindow)
194     {
195         OSL_TRACE("destroying mpContentWindow at %x with parent %x", mpContentWindow.get(),
196             mpContentWindow->GetParent());
197         mpContentWindow.reset();
198     }
199 }
200 
201 
202 /*************************************************************************
203 |*
204 |* gemeinsamer Initialiserungsanteil der beiden Konstruktoren
205 |*
206 \************************************************************************/
207 
construct(void)208 void ViewShell::construct(void)
209 {
210 	mbHasRulers = false;
211 	mpActiveWindow = 0;
212 	mpView = 0;
213 	mpFrameView = 0;
214 	mpZoomList = 0;
215 	mbStartShowWithDialog = sal_False;
216 	mnPrintedHandoutPageNum = 1;
217     mnPrintedHandoutPageCount = 0;
218 	mpWindowUpdater.reset( new ::sd::WindowUpdater() );
219 	mpImpl.reset(new Implementation(*this));
220 	meShellType = ST_NONE;
221 
222     OSL_ASSERT (GetViewShell()!=NULL);
223 
224     if (IsMainViewShell())
225         GetDocSh()->Connect (this);
226 
227 	mpZoomList = new ZoomList( this );
228 
229 	mpContentWindow.reset(new ::sd::Window(GetParentWindow()));
230     SetActiveWindow (mpContentWindow.get());
231 
232     GetParentWindow()->SetBackground (Wallpaper());
233     mpContentWindow->SetBackground (Wallpaper());
234 	mpContentWindow->SetCenterAllowed(mbCenterAllowed);
235 	mpContentWindow->SetViewShell(this);
236     mpContentWindow->SetPosSizePixel(
237         GetParentWindow()->GetPosPixel(),GetParentWindow()->GetSizePixel());
238     mpContentWindow->Show();
239     static_cast< ::Window*>(mpContentWindow.get())->Resize();
240     OSL_TRACE("content window has size %d %d",
241         mpContentWindow->GetSizePixel().Width(),
242         mpContentWindow->GetSizePixel().Height());
243 
244     if ( ! GetDocSh()->IsPreview())
245     {
246         // Create scroll bars and the filler between the scroll bars.
247         mpHorizontalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_HSCROLL | WB_DRAG)));
248         mpHorizontalScrollBar->EnableRTL (sal_False);
249         mpHorizontalScrollBar->SetRange(Range(0, 32000));
250         mpHorizontalScrollBar->SetScrollHdl(LINK(this, ViewShell, HScrollHdl));
251         mpHorizontalScrollBar->Show();
252 
253         mpVerticalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_VSCROLL | WB_DRAG)));
254         mpVerticalScrollBar->SetRange(Range(0, 32000));
255         mpVerticalScrollBar->SetScrollHdl(LINK(this, ViewShell, VScrollHdl));
256         mpVerticalScrollBar->Show();
257         maScrBarWH = Size(
258             mpVerticalScrollBar->GetSizePixel().Width(),
259             mpHorizontalScrollBar->GetSizePixel().Height());
260 
261         mpScrollBarBox.reset(new ScrollBarBox(GetParentWindow(), WB_SIZEABLE));
262         mpScrollBarBox->Show();
263     }
264 
265 	String aName( RTL_CONSTASCII_USTRINGPARAM( "ViewShell" ));
266 	SetName (aName);
267 
268 	GetDoc()->StartOnlineSpelling(sal_False);
269 
270     mpWindowUpdater->SetViewShell (*this);
271     mpWindowUpdater->SetDocument (GetDoc());
272 
273     // Re-initialize the spell dialog.
274     ::sd::SpellDialogChildWindow* pSpellDialog =
275           static_cast< ::sd::SpellDialogChildWindow*> (
276               GetViewFrame()->GetChildWindow (
277                   ::sd::SpellDialogChildWindow::GetChildWindowId()));
278     if (pSpellDialog != NULL)
279         pSpellDialog->InvalidateSpellDialog();
280 
281     // Register the sub shell factory.
282     mpImpl->mpSubShellFactory.reset(new ViewShellObjectBarFactory(*this));
283     GetViewShellBase().GetViewShellManager()->AddSubShellFactory(this,mpImpl->mpSubShellFactory);
284 
285     GetParentWindow()->Show();
286 }
287 
288 
289 
290 
Init(bool bIsMainViewShell)291 void ViewShell::Init (bool bIsMainViewShell)
292 {
293     mpImpl->mbIsInitialized = true;
294     SetIsMainViewShell(bIsMainViewShell);
295     if (bIsMainViewShell)
296         SetActiveWindow (mpContentWindow.get());
297 }
298 
299 
300 
301 
Exit(void)302 void ViewShell::Exit (void)
303 {
304     sd::View* pView = GetView();
305     if (pView!=NULL && pView->IsTextEdit())
306     {
307         pView->SdrEndTextEdit();
308         pView->UnmarkAll();
309     }
310 
311     Deactivate (sal_True);
312 
313     if (IsMainViewShell())
314     {
315         GetDocSh()->Disconnect(this);
316     }
317 
318     SetIsMainViewShell(false);
319 }
320 
321 
322 
323 
324 /*************************************************************************
325 |*
326 |* Aktivierung: Arbeitsfenster den Fokus zuweisen
327 |*
328 \************************************************************************/
329 
Activate(sal_Bool bIsMDIActivate)330 void ViewShell::Activate(sal_Bool bIsMDIActivate)
331 {
332     // Do not forward to SfxShell::Activate()
333 
334 	// Laut MI darf keiner GrabFocus rufen, der nicht genau weiss von
335 	// welchem Window der Focus gegrabt wird. Da Activate() vom SFX teilweise
336 	// asynchron verschickt wird, kann es sein, dass ein falsches Window
337 	// den Focus hat (#29682#):
338 	//GetViewFrame()->GetWindow().GrabFocus();
339 
340     if (mpHorizontalRuler.get() != NULL)
341         mpHorizontalRuler->SetActive(sal_True);
342     if (mpVerticalRuler.get() != NULL)
343         mpVerticalRuler->SetActive(sal_True);
344 
345     if (bIsMDIActivate)
346     {
347         // Damit der Navigator auch einen aktuellen Status bekommt
348         SfxBoolItem aItem( SID_NAVIGATOR_INIT, sal_True );
349         if (GetDispatcher() != NULL)
350             GetDispatcher()->Execute(
351                 SID_NAVIGATOR_INIT,
352                 SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
353                 &aItem,
354                 0L);
355 
356         SfxViewShell* pViewShell = GetViewShell();
357         OSL_ASSERT (pViewShell!=NULL);
358 		SfxBindings& rBindings = pViewShell->GetViewFrame()->GetBindings();
359 		rBindings.Invalidate( SID_3D_STATE, sal_True, sal_False );
360 
361 		rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
362 		if(xSlideShow.is() && xSlideShow->isRunning() )
363 		{
364 			xSlideShow->activate(GetViewShellBase());
365 		}
366 		if(HasCurrentFunction())
367 		{
368 			GetCurrentFunction()->Activate();
369 		}
370 
371 		if(!GetDocSh()->IsUIActive())
372 			UpdatePreview( GetActualPage(), sal_True );
373 
374 		//HMH::sd::View* pView = GetView();
375 
376 		//HMHif (pView)
377 		//HMH{
378 		//HMH	pView->ShowMarkHdl();
379 		//HMH}
380 	}
381 
382 	ReadFrameViewData( mpFrameView );
383 
384     if (IsMainViewShell())
385         GetDocSh()->Connect(this);
386 }
387 
UIActivating(SfxInPlaceClient *)388 void ViewShell::UIActivating( SfxInPlaceClient*  )
389 {
390     OSL_ASSERT (GetViewShell()!=NULL);
391     GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed();
392 }
393 
394 
395 
UIDeactivated(SfxInPlaceClient *)396 void ViewShell::UIDeactivated( SfxInPlaceClient*  )
397 {
398     OSL_ASSERT (GetViewShell()!=NULL);
399     GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed();
400     if ( GetDrawView() )
401         GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this, *GetDrawView());
402 }
403 
404 /*************************************************************************
405 |*
406 |* Deaktivierung
407 |*
408 \************************************************************************/
409 
Deactivate(sal_Bool bIsMDIActivate)410 void ViewShell::Deactivate(sal_Bool bIsMDIActivate)
411 {
412 	// remove view from a still active drag'n'drop session
413 	SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
414 
415     if (IsMainViewShell())
416         GetDocSh()->Disconnect(this);
417 
418 	if( pDragTransferable )
419 		pDragTransferable->SetView( NULL );
420 
421     OSL_ASSERT (GetViewShell()!=NULL);
422 
423 	// View-Attribute an der FrameView merken
424 	WriteFrameViewData();
425 
426 	if (bIsMDIActivate)
427 	{
428 		rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
429 		if(xSlideShow.is() && xSlideShow->isRunning() )
430 		{
431 			xSlideShow->deactivate(GetViewShellBase());
432 		}
433 		if(HasCurrentFunction())
434 		{
435 			GetCurrentFunction()->Deactivate();
436 		}
437 	}
438 
439     if (mpHorizontalRuler.get() != NULL)
440         mpHorizontalRuler->SetActive(sal_False);
441     if (mpVerticalRuler.get() != NULL)
442         mpVerticalRuler->SetActive(sal_False);
443 
444 	SfxShell::Deactivate(bIsMDIActivate);
445 }
446 
447 
448 
449 
Shutdown(void)450 void ViewShell::Shutdown (void)
451 {
452     Exit ();
453 }
454 
455 
456 
457 
458 /*************************************************************************
459 |*
460 |* Keyboard event
461 |*
462 \************************************************************************/
463 
KeyInput(const KeyEvent & rKEvt,::sd::Window * pWin)464 sal_Bool ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
465 {
466 	sal_Bool bReturn(sal_False);
467 
468 	if(pWin)
469 	{
470 		SetActiveWindow(pWin);
471 	}
472 
473 	if(!bReturn)
474 	{
475 		// #76008#
476 		// give key input first to SfxViewShell to give CTRL+Key
477 		// (e.g. CTRL+SHIFT+'+', to front) priority.
478         OSL_ASSERT (GetViewShell()!=NULL);
479 		bReturn = (sal_Bool)GetViewShell()->KeyInput(rKEvt);
480 	}
481 
482 	sal_Int32 OriCount = GetView()->GetMarkedObjectList().GetMarkCount();
483 	if(!bReturn)
484 	{
485 		rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
486 		if(xSlideShow.is() && xSlideShow->isRunning())
487 		{
488 			bReturn = xSlideShow->keyInput(rKEvt);
489 		}
490 		else
491 		{
492 			bool bConsumed = false;
493 			if( GetView() )
494 				bConsumed = GetView()->getSmartTags().KeyInput(rKEvt);
495 
496 
497 			if( !bConsumed )
498 			{
499 				rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
500 				if( !xSelectionController.is() || !xSelectionController->onKeyInput( rKEvt, pWin ) )
501 				{
502 					if(HasCurrentFunction())
503 						bReturn = GetCurrentFunction()->KeyInput(rKEvt);
504 				}
505 				else
506 				{
507 					bReturn = sal_True;
508 				}
509 			}
510 		}
511 	}
512 	sal_Int32 EndCount = GetView()->GetMarkedObjectList().GetMarkCount();
513 	// Here, oriCount or endCount must have one value=0, another value > 0, then to switch focus between Document and shape objects
514 	if(bReturn &&  (OriCount + EndCount > 0) && (OriCount * EndCount == 0))
515 	{
516 		SwitchActiveViewFireFocus();
517 	}
518 
519 	if(!bReturn && GetActiveWindow())
520 	{
521 		KeyCode aKeyCode = rKEvt.GetKeyCode();
522 
523 		if (aKeyCode.IsMod1() && aKeyCode.IsShift()
524 			&& aKeyCode.GetCode() == KEY_R)
525 		{
526 			InvalidateWindows();
527 			bReturn = sal_True;
528 		}
529 	}
530 
531 	return(bReturn);
532 }
533 
534 /*************************************************************************
535 |*
536 |* MouseButtonDown event
537 |*
538 \************************************************************************/
539 
MouseButtonDown(const MouseEvent & rMEvt,::sd::Window * pWin)540 void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin)
541 {
542     // We have to lock tool bar updates while the mouse button is pressed in
543     // order to prevent the shape under the mouse to be moved (this happens
544     // when the number of docked tool bars changes as result of a changed
545     // selection;  this changes the window size and thus the mouse position
546     // in model coordinates: with respect to model coordinates the mouse
547     // moves.)
548     OSL_ASSERT(mpImpl->mpUpdateLockForMouse.expired());
549     mpImpl->mpUpdateLockForMouse = ViewShell::Implementation::ToolBarManagerLock::Create(
550         GetViewShellBase().GetToolBarManager());
551 
552 	if ( pWin && !pWin->HasFocus() )
553 	{
554         pWin->GrabFocus();
555         SetActiveWindow(pWin);
556 //		  GetViewFrame()->GetWindow().GrabFocus();
557 	}
558 
559 	// MouseEvent in E3dView eintragen
560     if (GetView() != NULL)
561         GetView()->SetMouseEvent(rMEvt);
562 
563 	bool bConsumed = false;
564 	if( GetView() )
565 		bConsumed = GetView()->getSmartTags().MouseButtonDown( rMEvt );
566 
567 	if( !bConsumed )
568 	{
569 		rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
570 		if( !xSelectionController.is() || !xSelectionController->onMouseButtonDown( rMEvt, pWin ) )
571 		{
572 			if(HasCurrentFunction())
573 			{
574 				GetCurrentFunction()->MouseButtonDown(rMEvt);
575 			}
576 		}
577 	}
578 }
579 
580 /*************************************************************************
581 |*
582 |* MouseMove event
583 |*
584 \************************************************************************/
585 
MouseMove(const MouseEvent & rMEvt,::sd::Window * pWin)586 void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
587 {
588     if (rMEvt.IsLeaveWindow())
589     {
590         if ( ! mpImpl->mpUpdateLockForMouse.expired())
591         {
592             ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock(
593                 mpImpl->mpUpdateLockForMouse);
594             if (pLock.get() != NULL)
595                 pLock->Release();
596         }
597     }
598 
599 	if ( pWin )
600 	{
601 		SetActiveWindow(pWin);
602 	}
603 
604 	// MouseEvent in E3dView eintragen
605     if (GetView() != NULL)
606         GetView()->SetMouseEvent(rMEvt);
607 
608 	if(HasCurrentFunction())
609 	{
610 		rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
611 		if( !xSelectionController.is() || !xSelectionController->onMouseMove( rMEvt, pWin ) )
612 		{
613 			if(HasCurrentFunction())
614 				GetCurrentFunction()->MouseMove(rMEvt);
615 		}
616 	}
617 }
618 
619 /*************************************************************************
620 |*
621 |* MouseButtonUp event
622 |*
623 \************************************************************************/
624 
MouseButtonUp(const MouseEvent & rMEvt,::sd::Window * pWin)625 void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
626 {
627 	if ( pWin )
628 	{
629 		SetActiveWindow(pWin);
630 	}
631 
632 	// MouseEvent in E3dView eintragen
633     if (GetView() != NULL)
634         GetView()->SetMouseEvent(rMEvt);
635 
636 	if( HasCurrentFunction())
637 	{
638 		rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() );
639 		if( !xSelectionController.is() || !xSelectionController->onMouseButtonUp( rMEvt, pWin ) )
640 		{
641 			if(HasCurrentFunction())
642 				GetCurrentFunction()->MouseButtonUp(rMEvt);
643 		}
644 	}
645 
646     if ( ! mpImpl->mpUpdateLockForMouse.expired())
647     {
648         ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock(
649             mpImpl->mpUpdateLockForMouse);
650         if (pLock.get() != NULL)
651             pLock->Release();
652     }
653 }
654 
655 
656 /*************************************************************************
657 |*
658 |* Command event
659 |*
660 \************************************************************************/
661 
Command(const CommandEvent & rCEvt,::sd::Window * pWin)662 void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
663 {
664 	sal_Bool bDone = HandleScrollCommand (rCEvt, pWin);
665 
666 	if( !bDone )
667 	{
668 		if( rCEvt.GetCommand() == COMMAND_INPUTLANGUAGECHANGE )
669 		{
670             //#i42732# update state of fontname if input language changes
671             GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONT );
672             GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
673 		}
674 		else
675 		{
676 		    bool bConsumed = false;
677    			if( GetView() )
678    			{
679 				bConsumed = GetView()->getSmartTags().Command(rCEvt);
680 		    }
681 
682 			if( !bConsumed && HasCurrentFunction())
683 		    {
684 		        GetCurrentFunction()->Command(rCEvt);
685             }
686 		}
687 	}
688 }
689 
Notify(NotifyEvent & rNEvt,::sd::Window * pWin)690 long ViewShell::Notify(NotifyEvent& rNEvt, ::sd::Window* pWin)
691 {
692     // handle scroll commands when they arrived at child windows
693     long nRet = sal_False;
694     if( rNEvt.GetType() == EVENT_COMMAND )
695     {
696         // note: dynamic_cast is not possible as GetData() returns a void*
697         CommandEvent* pCmdEvent = reinterpret_cast< CommandEvent* >(rNEvt.GetData());
698         nRet = HandleScrollCommand(*pCmdEvent, pWin);
699     }
700     return nRet;
701 }
702 
703 
HandleScrollCommand(const CommandEvent & rCEvt,::sd::Window * pWin)704 bool ViewShell::HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin)
705 {
706     bool bDone = false;
707 
708     switch( rCEvt.GetCommand() )
709     {
710         case COMMAND_WHEEL:
711 			{
712 				Reference< XSlideShowController > xSlideShowController( SlideShow::GetSlideShowController(GetViewShellBase() ) );
713 				if( xSlideShowController.is() )
714 				{
715 					// We ignore zooming with control+mouse wheel.
716 					const CommandWheelData* pData = rCEvt.GetWheelData();
717 					if( pData && !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) && !pData->IsHorz() )
718 					{
719 						long nDelta = pData->GetDelta();
720 						if( nDelta > 0 )
721 						{
722 							xSlideShowController->gotoPreviousSlide();
723 						}
724 						else if( nDelta < 0 )
725 						{
726 							xSlideShowController->gotoNextEffect();
727 						}
728 					}
729 					break;
730 				}
731 			}
732 			// fall through when not running slideshow
733         case COMMAND_STARTAUTOSCROLL:
734         case COMMAND_AUTOSCROLL:
735         {
736             const CommandWheelData* pData = rCEvt.GetWheelData();
737 
738             if (pData != NULL)
739             {
740                 if (pData->IsMod1())
741                 {
742                     if( !GetDocSh()->IsUIActive() )
743                     {
744                         const long  nOldZoom = GetActiveWindow()->GetZoom();
745                         long        nNewZoom;
746 
747                         if( pData->GetDelta() < 0L )
748                             nNewZoom = Max( (long) pWin->GetMinZoom(), (long)(nOldZoom - DELTA_ZOOM) );
749                         else
750                             nNewZoom = Min( (long) pWin->GetMaxZoom(), (long)(nOldZoom + DELTA_ZOOM) );
751 
752                         SetZoom( nNewZoom );
753                         Invalidate( SID_ATTR_ZOOM );
754 						Invalidate( SID_ATTR_ZOOMSLIDER );
755 
756                         bDone = true;
757                     }
758                 }
759                 else
760                 {
761                     if( mpContentWindow.get() == pWin )
762                     {
763                         sal_uLong nScrollLines = pData->GetScrollLines();
764                         if(IsPageFlipMode())
765                             nScrollLines = COMMAND_WHEEL_PAGESCROLL;
766                         CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(),
767                             nScrollLines,pData->GetMode(),pData->GetModifier(),pData->IsHorz() );
768                         CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),
769                             rCEvt.IsMouseEvent(),(const void *) &aWheelData );
770                         bDone = pWin->HandleScrollCommand( aReWrite,
771                             mpHorizontalScrollBar.get(),
772                             mpVerticalScrollBar.get()) == sal_True;
773                     }
774                 }
775             }
776         }
777         break;
778 
779         default:
780         break;
781     }
782 
783     return bDone;
784 }
785 
786 
787 
SetupRulers(void)788 void ViewShell::SetupRulers (void)
789 {
790 	if(mbHasRulers && (mpContentWindow.get() != NULL) && !SlideShow::IsRunning(GetViewShellBase()))
791 	{
792 		long nHRulerOfs = 0;
793 
794 		if ( mpVerticalRuler.get() == NULL )
795 		{
796 			mpVerticalRuler.reset(CreateVRuler(GetActiveWindow()));
797 			if ( mpVerticalRuler.get() != NULL )
798 			{
799 				nHRulerOfs = mpVerticalRuler->GetSizePixel().Width();
800 				mpVerticalRuler->SetActive(sal_True);
801 				mpVerticalRuler->Show();
802 			}
803 		}
804 		if ( mpHorizontalRuler.get() == NULL )
805 		{
806 			mpHorizontalRuler.reset(CreateHRuler(GetActiveWindow(), sal_True));
807 			if ( mpHorizontalRuler.get() != NULL )
808 			{
809 				mpHorizontalRuler->SetWinPos(nHRulerOfs);
810 				mpHorizontalRuler->SetActive(sal_True);
811 				mpHorizontalRuler->Show();
812 			}
813 		}
814 	}
815 }
816 
GetNumBulletItem(SfxItemSet & aNewAttr,sal_uInt16 & nNumItemId)817 const SfxPoolItem* ViewShell::GetNumBulletItem(SfxItemSet& aNewAttr, sal_uInt16& nNumItemId)
818 {
819 	const SfxPoolItem* pTmpItem = NULL;
820 
821 	if(aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem) == SFX_ITEM_SET)
822 	{
823 		return pTmpItem;
824 	}
825 	else
826 	{
827 		nNumItemId = aNewAttr.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE);
828 		SfxItemState eState = aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem);
829 		if (eState == SFX_ITEM_SET)
830 			return pTmpItem;
831 		else
832 		{
833 			sal_Bool bOutliner = sal_False;
834 			sal_Bool bTitle = sal_False;
835 
836 			if( mpView )
837      			{
838 				const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
839 				const sal_uInt32 nCount = rMarkList.GetMarkCount();
840 
841 				for(sal_uInt32 nNum = 0; nNum < nCount; nNum++)
842 				{
843 					SdrObject* pObj = rMarkList.GetMark(nNum)->GetMarkedSdrObj();
844 					if( pObj->GetObjInventor() == SdrInventor )
845 					{
846 						switch(pObj->GetObjIdentifier())
847 						{
848 						case OBJ_TITLETEXT:
849 							bTitle = sal_True;
850 							break;
851 						case OBJ_OUTLINETEXT:
852 							bOutliner = sal_True;
853 							break;
854 						}
855 					}
856 				}
857 			}
858 
859 			const SvxNumBulletItem *pItem = NULL;
860 			if(bOutliner)
861 			{
862 				SfxStyleSheetBasePool* pSSPool = mpView->GetDocSh()->GetStyleSheetPool();
863 				String aStyleName((SdResId(STR_LAYOUT_OUTLINE)));
864 				aStyleName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " 1" ) );
865 				SfxStyleSheetBase* pFirstStyleSheet = pSSPool->Find( aStyleName, SD_STYLE_FAMILY_PSEUDO);
866 				if( pFirstStyleSheet )
867 					pFirstStyleSheet->GetItemSet().GetItemState(EE_PARA_NUMBULLET, sal_False, (const SfxPoolItem**)&pItem);
868 			}
869 
870 			if( pItem == NULL )
871 				pItem = (SvxNumBulletItem*) aNewAttr.GetPool()->GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET);
872 
873 			aNewAttr.Put(*pItem, EE_PARA_NUMBULLET);
874 
875 			if(bTitle && aNewAttr.GetItemState(EE_PARA_NUMBULLET,sal_True) == SFX_ITEM_ON )
876 			{
877 				SvxNumBulletItem* pItem = (SvxNumBulletItem*)aNewAttr.GetItem(EE_PARA_NUMBULLET,sal_True);
878 				SvxNumRule* pRule = pItem->GetNumRule();
879 				if(pRule)
880 				{
881 					SvxNumRule aNewRule( *pRule );
882 					aNewRule.SetFeatureFlag( NUM_NO_NUMBERS, sal_True );
883 
884 					SvxNumBulletItem aNewItem( aNewRule, EE_PARA_NUMBULLET );
885 					aNewAttr.Put(aNewItem);
886 				}
887 			}
888 
889 			SfxItemState eState = aNewAttr.GetItemState(nNumItemId, sal_False, &pTmpItem);
890 			if (eState == SFX_ITEM_SET)
891 				return pTmpItem;
892 
893 		}
894 	}
895 	return pTmpItem;
896 }
897 
898 
HasRuler(void)899 sal_Bool ViewShell::HasRuler (void)
900 {
901     return mbHasRulers;
902 }
903 
904 
905 
906 
Resize(void)907 void ViewShell::Resize (void)
908 {
909 	SetupRulers ();
910 
911     if (mpParentWindow == NULL)
912         return;
913 
914     // Make sure that the new size is not degenerate.
915     const Size aSize (mpParentWindow->GetSizePixel());
916 	if (aSize.Width()==0 || aSize.Height()==0)
917 		return;
918 
919     // Remember the new position and size.
920 	maViewPos = Point(0,0); //mpParentWindow->GetPosPixel();
921 	maViewSize = aSize;
922 
923     // Rearrange the UI elements to take care of the new position and size.
924     ArrangeGUIElements ();
925     // end of included AdjustPosSizePixel.
926 
927     Size aS (GetParentWindow()->GetOutputSizePixel());
928 	Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
929 	Rectangle aVisArea = GetParentWindow()->PixelToLogic(
930         Rectangle( Point(0,0), aVisSizePixel));
931     Rectangle aCurrentVisArea (GetDocSh()->GetVisArea(ASPECT_CONTENT));
932     Rectangle aWindowRect = GetActiveWindow()->LogicToPixel(aCurrentVisArea);
933 	if (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED
934         && IsMainViewShell())
935 	{
936         //        GetDocSh()->SetVisArea(aVisArea);
937 	}
938 
939     //	VisAreaChanged(aVisArea);
940 
941 	::sd::View* pView = GetView();
942 
943 	if (pView)
944 	{
945 		pView->VisAreaChanged(GetActiveWindow());
946 	}
947 }
948 
GetBorder(bool)949 SvBorder ViewShell::GetBorder (bool )
950 {
951     SvBorder aBorder;
952 
953 	// Horizontal scrollbar.
954     if (mpHorizontalScrollBar.get()!=NULL
955         && mpHorizontalScrollBar->IsVisible())
956     {
957         aBorder.Bottom() = maScrBarWH.Height();
958     }
959 
960 	// Vertical scrollbar.
961     if (mpVerticalScrollBar.get()!=NULL
962         && mpVerticalScrollBar->IsVisible())
963     {
964         aBorder.Right() = maScrBarWH.Width();
965     }
966 
967     // Place horizontal ruler below tab bar.
968     if (mbHasRulers && mpContentWindow.get() != NULL)
969     {
970         SetupRulers();
971         if (mpHorizontalRuler.get() != NULL)
972             aBorder.Top() = mpHorizontalRuler->GetSizePixel().Height();
973         if (mpVerticalRuler.get() != NULL)
974             aBorder.Left() = mpVerticalRuler->GetSizePixel().Width();
975     }
976 
977     return aBorder;
978 }
979 
980 
981 
982 
ArrangeGUIElements(void)983 void ViewShell::ArrangeGUIElements (void)
984 {
985     if (mpImpl->mbArrangeActive)
986         return;
987     mpImpl->mbArrangeActive = true;
988 
989     // Calculate border for in-place editing.
990 	long nLeft = maViewPos.X();
991 	long nTop  = maViewPos.Y();
992 	long nRight = maViewPos.X() + maViewSize.Width();
993 	long nBottom = maViewPos.Y() + maViewSize.Height();
994 
995 	// Horizontal scrollbar.
996     if (mpHorizontalScrollBar.get()!=NULL
997         && mpHorizontalScrollBar->IsVisible())
998     {
999         int nLocalLeft = nLeft;
1000         if (mpLayerTabBar.get()!=NULL && mpLayerTabBar->IsVisible())
1001             nLocalLeft += mpLayerTabBar->GetSizePixel().Width();
1002         nBottom -= maScrBarWH.Height();
1003         mpHorizontalScrollBar->SetPosSizePixel (
1004             Point(nLocalLeft,nBottom),
1005             Size(nRight-nLocalLeft-maScrBarWH.Width(),maScrBarWH.Height()));
1006     }
1007 
1008 	// Vertical scrollbar.
1009     if (mpVerticalScrollBar.get()!=NULL
1010         && mpVerticalScrollBar->IsVisible())
1011     {
1012         nRight -= maScrBarWH.Width();
1013         mpVerticalScrollBar->SetPosSizePixel (
1014             Point(nRight,nTop),
1015             Size (maScrBarWH.Width(),nBottom-nTop));
1016     }
1017 
1018     // Filler in the lower right corner.
1019     if (mpScrollBarBox.get() != NULL)
1020     {
1021         if (mpHorizontalScrollBar.get()!=NULL
1022             && mpHorizontalScrollBar->IsVisible()
1023             && mpVerticalScrollBar.get()!=NULL
1024             && mpVerticalScrollBar->IsVisible())
1025         {
1026             mpScrollBarBox->Show();
1027             mpScrollBarBox->SetPosSizePixel(Point(nRight, nBottom), maScrBarWH);
1028         }
1029         else
1030             mpScrollBarBox->Hide();
1031     }
1032 
1033     // Place horizontal ruler below tab bar.
1034     if (mbHasRulers && mpContentWindow.get() != NULL)
1035     {
1036         if (mpHorizontalRuler.get() != NULL)
1037         {
1038             Size aRulerSize = mpHorizontalRuler->GetSizePixel();
1039             aRulerSize.Width() = nRight - nLeft;
1040             mpHorizontalRuler->SetPosSizePixel (
1041                 Point(nLeft,nTop), aRulerSize);
1042             if (mpVerticalRuler.get() != NULL)
1043                 mpHorizontalRuler->SetBorderPos(
1044                     mpVerticalRuler->GetSizePixel().Width()-1);
1045             nTop += aRulerSize.Height();
1046         }
1047         if (mpVerticalRuler.get() != NULL)
1048         {
1049             Size aRulerSize = mpVerticalRuler->GetSizePixel();
1050             aRulerSize.Height() = nBottom  - nTop;
1051             mpVerticalRuler->SetPosSizePixel (
1052                 Point (nLeft,nTop), aRulerSize);
1053             nLeft += aRulerSize.Width();
1054         }
1055     }
1056 
1057 	rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) );
1058 
1059     // The size of the window of the center pane is set differently from
1060     // that of the windows in the docking windows.
1061     bool bSlideShowActive = (xSlideShow.is() && xSlideShow->isRunning()) && !xSlideShow->isFullScreen() && xSlideShow->getAnimationMode() == ANIMATIONMODE_SHOW;
1062     if ( !bSlideShowActive)
1063     {
1064         OSL_ASSERT (GetViewShell()!=NULL);
1065 
1066         if (mpContentWindow)
1067             mpContentWindow->SetPosSizePixel(
1068                 Point(nLeft,nTop),
1069                 Size(nRight-nLeft,nBottom-nTop));
1070     }
1071 
1072     // Windows in the center and rulers at the left and top side.
1073 	maAllWindowRectangle = Rectangle(
1074         maViewPos,
1075         Size(maViewSize.Width()-maScrBarWH.Width(),
1076             maViewSize.Height()-maScrBarWH.Height()));
1077 
1078     if (mpContentWindow.get() != NULL)
1079     {
1080         mpContentWindow->UpdateMapOrigin();
1081     }
1082 
1083     UpdateScrollBars();
1084 
1085     mpImpl->mbArrangeActive = false;
1086 }
1087 
1088 
1089 
1090 
SetUIUnit(FieldUnit eUnit)1091 void ViewShell::SetUIUnit(FieldUnit eUnit)
1092 {
1093     // Set unit at horizontal and vertical rulers.
1094     if (mpHorizontalRuler.get() != NULL)
1095         mpHorizontalRuler->SetUnit(eUnit);
1096 
1097 
1098 	if (mpVerticalRuler.get() != NULL)
1099         mpVerticalRuler->SetUnit(eUnit);
1100 }
1101 
1102 /*************************************************************************
1103 |*
1104 |* DefTab an den horizontalen Linealen setzen
1105 |*
1106 \************************************************************************/
SetDefTabHRuler(sal_uInt16 nDefTab)1107 void ViewShell::SetDefTabHRuler( sal_uInt16 nDefTab )
1108 {
1109     if (mpHorizontalRuler.get() != NULL)
1110         mpHorizontalRuler->SetDefTabDist( nDefTab );
1111 }
1112 
1113 
1114 
1115 
1116 /** Tell the FmFormShell that the view shell is closing.  Give it the
1117     oportunity to prevent that.
1118 */
PrepareClose(sal_Bool bUI,sal_Bool bForBrowsing)1119 sal_uInt16 ViewShell::PrepareClose (sal_Bool bUI, sal_Bool bForBrowsing)
1120 {
1121     sal_uInt16 nResult = sal_True;
1122 
1123     FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
1124     if (pFormShell != NULL)
1125         nResult = pFormShell->PrepareClose (bUI, bForBrowsing);
1126 
1127 	return nResult;
1128 }
1129 
1130 
1131 
1132 
UpdatePreview(SdPage *,sal_Bool)1133 void ViewShell::UpdatePreview (SdPage*, sal_Bool )
1134 {
1135     // Do nothing.  After the actual preview has been removed,
1136     // OutlineViewShell::UpdatePreview() is the place where something
1137     // usefull is still done.
1138 }
1139 
ImpGetUndoManager(void) const1140 ::svl::IUndoManager* ViewShell::ImpGetUndoManager (void) const
1141 {
1142 	const ViewShell* pMainViewShell = GetViewShellBase().GetMainViewShell().get();
1143 
1144 	if( pMainViewShell == 0 )
1145 		pMainViewShell = this;
1146 
1147 	::sd::View* pView = pMainViewShell->GetView();
1148 
1149 	// check for text edit our outline view
1150 	if( pView )
1151 	{
1152 		if( pMainViewShell->GetShellType() == ViewShell::ST_OUTLINE )
1153 		{
1154 			OutlineView* pOlView = dynamic_cast< OutlineView* >( pView );
1155 			if( pOlView )
1156 			{
1157 				::Outliner* pOutl = pOlView->GetOutliner();
1158 				if( pOutl )
1159 					return &pOutl->GetUndoManager();
1160 			}
1161 		}
1162 		else if( pView->IsTextEdit() )
1163 		{
1164 			SdrOutliner* pOL = pView->GetTextEditOutliner();
1165 			if( pOL )
1166 				return &pOL->GetUndoManager();
1167 		}
1168 	}
1169 
1170 	if( GetDocSh() )
1171 		return GetDocSh()->GetUndoManager();
1172 
1173 	return NULL;
1174 }
1175 
1176 
1177 
1178 
ImpGetUndoStrings(SfxItemSet & rSet) const1179 void ViewShell::ImpGetUndoStrings(SfxItemSet &rSet) const
1180 {
1181 	::svl::IUndoManager* pUndoManager = ImpGetUndoManager();
1182 	if(pUndoManager)
1183 	{
1184 		sal_uInt16 nCount(pUndoManager->GetUndoActionCount());
1185 		if(nCount)
1186 		{
1187 			// prepare list
1188 			List aStringList;
1189 			sal_uInt16 a;
1190 
1191 			for( a = 0; a < nCount; a++)
1192 			{
1193 				// generate one String in list per undo step
1194 				String* pInsertString = new String(pUndoManager->GetUndoActionComment(a));
1195 				aStringList.Insert(pInsertString, LIST_APPEND);
1196 			}
1197 
1198 			// set item
1199 			rSet.Put(SfxStringListItem(SID_GETUNDOSTRINGS, &aStringList));
1200 
1201 			// delete Strings again
1202 			for(a = 0; a < nCount; a++)
1203 				delete (String*)aStringList.GetObject(a);
1204 		}
1205 		else
1206 		{
1207 			rSet.DisableItem(SID_GETUNDOSTRINGS);
1208 		}
1209 	}
1210 }
1211 
1212 // -----------------------------------------------------------------------------
1213 
ImpGetRedoStrings(SfxItemSet & rSet) const1214 void ViewShell::ImpGetRedoStrings(SfxItemSet &rSet) const
1215 {
1216 	::svl::IUndoManager* pUndoManager = ImpGetUndoManager();
1217 	if(pUndoManager)
1218 	{
1219 		sal_uInt16 nCount(pUndoManager->GetRedoActionCount());
1220 		if(nCount)
1221 		{
1222 			// prepare list
1223 			List aStringList;
1224 			sal_uInt16 a;
1225 
1226 			for( a = 0; a < nCount; a++)
1227 			{
1228 				// generate one String in list per undo step
1229 				String* pInsertString = new String(pUndoManager->GetRedoActionComment(a));
1230 				aStringList.Insert(pInsertString, LIST_APPEND);
1231 			}
1232 
1233 			// set item
1234 			rSet.Put(SfxStringListItem(SID_GETREDOSTRINGS, &aStringList));
1235 
1236 			// delete Strings again
1237 			for(a = 0; a < nCount; a++)
1238 				delete (String*)aStringList.GetObject(a);
1239 		}
1240 		else
1241 		{
1242 			rSet.DisableItem(SID_GETREDOSTRINGS);
1243 		}
1244 	}
1245 }
1246 
1247 // -----------------------------------------------------------------------------
1248 
ImpSidUndo(sal_Bool,SfxRequest & rReq)1249 void ViewShell::ImpSidUndo(sal_Bool, SfxRequest& rReq)
1250 {
1251 	::svl::IUndoManager* pUndoManager = ImpGetUndoManager();
1252 	sal_uInt16 nNumber(1);
1253 	const SfxItemSet* pReqArgs = rReq.GetArgs();
1254 
1255 	if(pReqArgs)
1256 	{
1257 		SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_UNDO);
1258 		nNumber = pUIntItem->GetValue();
1259 	}
1260 
1261 	if(nNumber && pUndoManager)
1262 	{
1263 		sal_uInt16 nCount(pUndoManager->GetUndoActionCount());
1264 		if(nCount >= nNumber)
1265 		{
1266             try
1267             {
1268 			    // #94637# when UndoStack is cleared by ModifyPageUndoAction
1269 			    // the nCount may have changed, so test GetUndoActionCount()
1270 			    while(nNumber-- && pUndoManager->GetUndoActionCount())
1271 			    {
1272 				    pUndoManager->Undo();
1273 			    }
1274             }
1275             catch( const Exception& e )
1276             {
1277                 // no need to handle. By definition, the UndoManager handled this by clearing the
1278                 // Undo/Redo stacks
1279             }
1280 		}
1281 
1282 		// #91081# refresh rulers, maybe UNDO was move of TAB marker in ruler
1283 		if (mbHasRulers)
1284 		{
1285 			Invalidate(SID_ATTR_TABSTOP);
1286 		}
1287 	}
1288 
1289 	// This one is corresponding to the default handling
1290 	// of SID_UNDO in sfx2
1291 	GetViewFrame()->GetBindings().InvalidateAll(sal_False);
1292 
1293 	rReq.Done();
1294 }
1295 
1296 // -----------------------------------------------------------------------------
1297 
ImpSidRedo(sal_Bool,SfxRequest & rReq)1298 void ViewShell::ImpSidRedo(sal_Bool, SfxRequest& rReq)
1299 {
1300 	::svl::IUndoManager* pUndoManager = ImpGetUndoManager();
1301 	sal_uInt16 nNumber(1);
1302 	const SfxItemSet* pReqArgs = rReq.GetArgs();
1303 
1304 	if(pReqArgs)
1305 	{
1306 		SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_REDO);
1307 		nNumber = pUIntItem->GetValue();
1308 	}
1309 
1310 	if(nNumber && pUndoManager)
1311 	{
1312 		sal_uInt16 nCount(pUndoManager->GetRedoActionCount());
1313 		if(nCount >= nNumber)
1314 		{
1315             try
1316             {
1317 			    // #94637# when UndoStack is cleared by ModifyPageRedoAction
1318 			    // the nCount may have changed, so test GetRedoActionCount()
1319 			    while(nNumber-- && pUndoManager->GetRedoActionCount())
1320 			    {
1321 				    pUndoManager->Redo();
1322 			    }
1323             }
1324             catch( const Exception& e )
1325             {
1326                 // no need to handle. By definition, the UndoManager handled this by clearing the
1327                 // Undo/Redo stacks
1328             }
1329 		}
1330 
1331 		// #91081# refresh rulers, maybe REDO was move of TAB marker in ruler
1332 		if (mbHasRulers)
1333 		{
1334 			Invalidate(SID_ATTR_TABSTOP);
1335 		}
1336 	}
1337 
1338 	// This one is corresponding to the default handling
1339 	// of SID_UNDO in sfx2
1340 	GetViewFrame()->GetBindings().InvalidateAll(sal_False);
1341 
1342 	rReq.Done();
1343 }
1344 
1345 // -----------------------------------------------------------------------------
1346 
ExecReq(SfxRequest & rReq)1347 void ViewShell::ExecReq( SfxRequest& rReq )
1348 {
1349     sal_uInt16 nSlot = rReq.GetSlot();
1350     switch( nSlot )
1351     {
1352 		case SID_MAIL_SCROLLBODY_PAGEDOWN:
1353 		{
1354 			FunctionReference xFunc( GetCurrentFunction() );
1355 			if( xFunc.is() )
1356 			{
1357 				xFunc->ScrollStart();
1358 				ScrollLines( 0, -1 );
1359 				xFunc->ScrollEnd();
1360 			}
1361 
1362             rReq.Done();
1363 		}
1364 		break;
1365 
1366 		case SID_OUTPUT_QUALITY_COLOR:
1367 		case SID_OUTPUT_QUALITY_GRAYSCALE:
1368 		case SID_OUTPUT_QUALITY_BLACKWHITE:
1369 		case SID_OUTPUT_QUALITY_CONTRAST:
1370 		{
1371 			sal_uLong nMode = OUTPUT_DRAWMODE_COLOR;
1372 
1373             switch( nSlot )
1374 			{
1375 			    case SID_OUTPUT_QUALITY_COLOR: nMode = OUTPUT_DRAWMODE_COLOR; break;
1376 			    case SID_OUTPUT_QUALITY_GRAYSCALE: nMode = OUTPUT_DRAWMODE_GRAYSCALE; break;
1377 			    case SID_OUTPUT_QUALITY_BLACKWHITE: nMode = OUTPUT_DRAWMODE_BLACKWHITE; break;
1378 			    case SID_OUTPUT_QUALITY_CONTRAST: nMode = OUTPUT_DRAWMODE_CONTRAST; break;
1379 			}
1380 
1381 			GetActiveWindow()->SetDrawMode( nMode );
1382             mpFrameView->SetDrawMode( nMode );
1383 // #110094#-7
1384 //            GetView()->ReleaseMasterPagePaintCache();
1385 			GetActiveWindow()->Invalidate();
1386 
1387 			Invalidate();
1388 			rReq.Done();
1389 			break;
1390 		}
1391     }
1392 }
1393 
1394 
1395 
1396 
1397 /** This default implemenation returns only an empty reference.  See derived
1398     classes for more interesting examples.
1399 */
1400 ::com::sun::star::uno::Reference<
1401     ::com::sun::star::accessibility::XAccessible>
CreateAccessibleDocumentView(::sd::Window *)1402 ViewShell::CreateAccessibleDocumentView (::sd::Window* )
1403 {
1404     return ::com::sun::star::uno::Reference<
1405         ::com::sun::star::accessibility::XAccessible> ();
1406 }
1407 
1408 
1409 
GetWindowUpdater(void) const1410 ::sd::WindowUpdater* ViewShell::GetWindowUpdater (void) const
1411 {
1412     return mpWindowUpdater.get();
1413 }
1414 
1415 
1416 
1417 
GetViewShellBase(void) const1418 ViewShellBase& ViewShell::GetViewShellBase (void) const
1419 {
1420     return *static_cast<ViewShellBase*>(GetViewShell());
1421 }
1422 
1423 
1424 
1425 
GetShellType(void) const1426 ViewShell::ShellType ViewShell::GetShellType (void) const
1427 {
1428     return meShellType;
1429 }
1430 
1431 
1432 
1433 
GetDocSh(void) const1434 DrawDocShell* ViewShell::GetDocSh (void) const
1435 {
1436     return GetViewShellBase().GetDocShell();
1437 }
1438 
1439 
1440 
1441 
GetDoc(void) const1442 SdDrawDocument* ViewShell::GetDoc (void) const
1443 {
1444     return GetViewShellBase().GetDocument();
1445 }
1446 
DoVerb(long)1447 ErrCode ViewShell::DoVerb (long )
1448 {
1449     return ERRCODE_NONE;
1450 }
1451 
SetCurrentFunction(const FunctionReference & xFunction)1452 void ViewShell::SetCurrentFunction( const FunctionReference& xFunction)
1453 {
1454 	if( mxCurrentFunction.is() && (mxOldFunction != mxCurrentFunction) )
1455 		mxCurrentFunction->Dispose();
1456 	FunctionReference xTemp( mxCurrentFunction );
1457     mxCurrentFunction = xFunction;
1458 }
1459 
SetOldFunction(const FunctionReference & xFunction)1460 void ViewShell::SetOldFunction(const FunctionReference& xFunction)
1461 {
1462 	if( mxOldFunction.is() && (xFunction != mxOldFunction) && (mxCurrentFunction != mxOldFunction) )
1463 		mxOldFunction->Dispose();
1464 
1465 	FunctionReference xTemp( mxOldFunction );
1466     mxOldFunction = xFunction;
1467 }
1468 
1469 /** this method deactivates the current function. If an old function is
1470 	saved, this will become activated and current function.
1471 */
Cancel()1472 void ViewShell::Cancel()
1473 {
1474 	if(mxCurrentFunction.is() && (mxCurrentFunction != mxOldFunction ))
1475 	{
1476 		FunctionReference xTemp( mxCurrentFunction );
1477 		mxCurrentFunction.clear();
1478 		xTemp->Deactivate();
1479 		xTemp->Dispose();
1480 	}
1481 
1482 	if(mxOldFunction.is())
1483 	{
1484 		mxCurrentFunction = mxOldFunction;
1485 		mxCurrentFunction->Activate();
1486 	}
1487 }
1488 
DeactivateCurrentFunction(bool bPermanent)1489 void ViewShell::DeactivateCurrentFunction( bool bPermanent /* == false */ )
1490 {
1491 	if( mxCurrentFunction.is() )
1492 	{
1493 		if(bPermanent && (mxOldFunction == mxCurrentFunction))
1494 			mxOldFunction.clear();
1495 
1496 		mxCurrentFunction->Deactivate();
1497 		if( mxCurrentFunction != mxOldFunction )
1498 			mxCurrentFunction->Dispose();
1499 
1500 		FunctionReference xTemp( mxCurrentFunction );
1501 		mxCurrentFunction.clear();
1502 	}
1503 }
1504 
DisposeFunctions()1505 void ViewShell::DisposeFunctions()
1506 {
1507 	if(mxCurrentFunction.is())
1508 	{
1509 		FunctionReference xTemp( mxCurrentFunction );
1510 		mxCurrentFunction.clear();
1511 		xTemp->Deactivate();
1512 		xTemp->Dispose();
1513 	}
1514 
1515 	if(mxOldFunction.is())
1516 	{
1517 		FunctionReference xTemp( mxOldFunction );
1518 		mxOldFunction->Dispose();
1519 		mxOldFunction.clear();
1520 	}
1521 }
1522 
IsMainViewShell(void) const1523 bool ViewShell::IsMainViewShell (void) const
1524 {
1525     return mpImpl->mbIsMainViewShell;
1526     //    return GetViewShellBase().GetMainViewShell() == this;
1527 }
1528 
SetIsMainViewShell(bool bIsMainViewShell)1529 void ViewShell::SetIsMainViewShell (bool bIsMainViewShell)
1530 {
1531     if (bIsMainViewShell != mpImpl->mbIsMainViewShell)
1532     {
1533         mpImpl->mbIsMainViewShell = bIsMainViewShell;
1534         if (bIsMainViewShell)
1535         {
1536             GetDocSh()->Connect (this);
1537         }
1538         else
1539         {
1540             GetDocSh()->Disconnect (this);
1541         }
1542     }
1543 }
1544 
1545 
1546 
1547 
GetActiveWindow(void) const1548 ::sd::Window* ViewShell::GetActiveWindow (void) const
1549 {
1550     return mpActiveWindow;
1551 }
1552 
1553 
1554 
1555 
PrePaint()1556 void ViewShell::PrePaint()
1557 {
1558 }
1559 
1560 
1561 
1562 
Paint(const Rectangle &,::sd::Window *)1563 void ViewShell::Paint (const Rectangle&, ::sd::Window* )
1564 {
1565 }
1566 
1567 
1568 
1569 
Draw(OutputDevice &,const Region &)1570 void ViewShell::Draw(OutputDevice &, const Region &)
1571 {
1572 }
1573 
1574 
1575 
1576 
GetZoomList(void)1577 ZoomList* ViewShell::GetZoomList (void)
1578 {
1579     return mpZoomList;
1580 }
1581 
1582 
1583 
1584 
ShowUIControls(bool bVisible)1585 void ViewShell::ShowUIControls (bool bVisible)
1586 {
1587     mpImpl->mbIsShowingUIControls = bVisible;
1588 
1589 	if (mbHasRulers)
1590 	{
1591 		if (mpHorizontalRuler.get() != NULL)
1592 			mpHorizontalRuler->Show( bVisible );
1593 
1594 		if (mpVerticalRuler.get() != NULL)
1595             mpVerticalRuler->Show( bVisible );
1596 	}
1597 
1598 	if (mpVerticalScrollBar.get() != NULL)
1599 		mpVerticalScrollBar->Show( bVisible );
1600 
1601 	if (mpHorizontalScrollBar.get() != NULL)
1602 		mpHorizontalScrollBar->Show( bVisible );
1603 
1604 	if (mpScrollBarBox.get() != NULL)
1605         mpScrollBarBox->Show(bVisible);
1606 
1607     if (mpContentWindow.get() != NULL)
1608         mpContentWindow->Show( bVisible );
1609 }
1610 
1611 
1612 
1613 
1614 
RelocateToParentWindow(::Window * pParentWindow)1615 bool ViewShell::RelocateToParentWindow (::Window* pParentWindow)
1616 {
1617     mpParentWindow = pParentWindow;
1618 
1619     mpParentWindow->SetBackground (Wallpaper());
1620 
1621     if (mpContentWindow.get() != NULL)
1622         mpContentWindow->SetParent(pParentWindow);
1623 
1624     if (mpHorizontalScrollBar.get() != NULL)
1625         mpHorizontalScrollBar->SetParent(mpParentWindow);
1626     if (mpVerticalScrollBar.get() != NULL)
1627         mpVerticalScrollBar->SetParent(mpParentWindow);
1628     if (mpScrollBarBox.get() != NULL)
1629         mpScrollBarBox->SetParent(mpParentWindow);
1630 
1631     return true;
1632 }
1633 
SwitchViewFireFocus(::com::sun::star::uno::Reference<::com::sun::star::accessibility::XAccessible> xAcc)1634 void ViewShell::SwitchViewFireFocus(::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc )
1635 {
1636 	if (xAcc.get())
1637 	{
1638 		::accessibility::AccessibleDocumentViewBase* pBase = static_cast< ::accessibility::AccessibleDocumentViewBase* >(xAcc.get());
1639 		if (pBase)
1640 		{
1641 			pBase->SwitchViewActivated();
1642 		}
1643 	}
1644 }
SwitchActiveViewFireFocus()1645 void ViewShell::SwitchActiveViewFireFocus()
1646 {
1647 	if (mpContentWindow)
1648 	{
1649 		SwitchViewFireFocus(mpContentWindow->GetAccessible(sal_False));
1650 	}
1651 }
1652 // move these two methods from DrawViewShell.
fireSwitchCurrentPage(sal_Int32 pageIndex)1653 void ViewShell::fireSwitchCurrentPage(sal_Int32 pageIndex)
1654 {
1655 	GetViewShellBase().GetDrawController().fireSwitchCurrentPage(pageIndex);
1656 }
NotifyAccUpdate()1657 void ViewShell::NotifyAccUpdate( )
1658 {
1659 	GetViewShellBase().GetDrawController().NotifyAccUpdate();
1660 }
1661 
1662 
1663 } // end of namespace sd
1664 
1665 
1666 
1667 
1668 
1669 //===== ViewShellObjectBarFactory =============================================
1670 
1671 namespace {
1672 
ViewShellObjectBarFactory(::sd::ViewShell & rViewShell)1673 ViewShellObjectBarFactory::ViewShellObjectBarFactory (
1674     ::sd::ViewShell& rViewShell)
1675     : mrViewShell (rViewShell)
1676 {
1677 }
1678 
1679 
1680 
1681 
~ViewShellObjectBarFactory(void)1682 ViewShellObjectBarFactory::~ViewShellObjectBarFactory (void)
1683 {
1684     for (ShellCache::iterator aI(maShellCache.begin());
1685          aI!=maShellCache.end();
1686          aI++)
1687     {
1688         delete aI->second;
1689     }
1690 }
1691 
1692 
1693 
1694 
CreateShell(::sd::ShellId nId,::Window *,::sd::FrameView *)1695 SfxShell* ViewShellObjectBarFactory::CreateShell (
1696     ::sd::ShellId nId,
1697     ::Window*,
1698     ::sd::FrameView* )
1699 {
1700     SfxShell* pShell = NULL;
1701 
1702     ShellCache::iterator aI (maShellCache.find(nId));
1703     if (aI == maShellCache.end() || aI->second==NULL)
1704     {
1705         ::sd::View* pView = mrViewShell.GetView();
1706         switch (nId)
1707         {
1708             case RID_BEZIER_TOOLBOX:
1709                 pShell = new ::sd::BezierObjectBar(&mrViewShell, pView);
1710                 break;
1711 
1712             case RID_DRAW_TEXT_TOOLBOX:
1713                 pShell = new ::sd::TextObjectBar(
1714                     &mrViewShell, mrViewShell.GetDoc()->GetPool(), pView);
1715                 break;
1716 
1717             case RID_DRAW_GRAF_TOOLBOX:
1718                 pShell = new ::sd::GraphicObjectBar(&mrViewShell, pView);
1719                 break;
1720 
1721             case RID_DRAW_MEDIA_TOOLBOX:
1722                 pShell = new ::sd::MediaObjectBar(&mrViewShell, pView);
1723                 break;
1724 
1725 			case RID_DRAW_TABLE_TOOLBOX:
1726 				pShell = ::sd::ui::table::CreateTableObjectBar( mrViewShell, pView );
1727 				break;
1728 
1729             case RID_SVX_EXTRUSION_BAR:
1730                 pShell = new ::svx::ExtrusionBar(
1731                     &mrViewShell.GetViewShellBase());
1732                 break;
1733 
1734             case RID_SVX_FONTWORK_BAR:
1735                 pShell = new ::svx::FontworkBar(
1736                     &mrViewShell.GetViewShellBase());
1737                 break;
1738 
1739             default:
1740                 pShell = NULL;
1741                 break;
1742         }
1743     }
1744     else
1745         pShell = aI->second;
1746 
1747     return pShell;
1748 }
1749 
1750 
1751 
1752 
ReleaseShell(SfxShell * pShell)1753 void ViewShellObjectBarFactory::ReleaseShell (SfxShell* pShell)
1754 {
1755     if (pShell != NULL)
1756         delete pShell;
1757 }
1758 
1759 } // end of anonymous namespace
1760