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