xref: /aoo42x/main/sd/source/ui/view/drviews1.cxx (revision 2d19362e)
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 "DrawViewShell.hxx"
28 #include "ViewShellImplementation.hxx"
29 
30 #include "DrawController.hxx"
31 #include <com/sun/star/embed/EmbedStates.hpp>
32 
33 #include "comphelper/anytostring.hxx"
34 #include "comphelper/scopeguard.hxx"
35 #include "cppuhelper/exc_hlp.hxx"
36 #include "rtl/ref.hxx"
37 
38 #ifndef _SVXIDS_HRC
39 #include <svx/svxids.hrc>
40 #endif
41 #include <svx/svdpagv.hxx>
42 #include <sfx2/viewfrm.hxx>
43 #include <sfx2/bindings.hxx>
44 #include <svx/svdoole2.hxx>
45 #include <sfx2/dispatch.hxx>
46 #include <vcl/scrbar.hxx>
47 #include <svx/svdograf.hxx>
48 #include <svx/svdopage.hxx>
49 #include <vcl/msgbox.hxx>
50 #include <sot/storage.hxx>
51 #include <svx/fmshell.hxx>
52 #include <svx/globl3d.hxx>
53 #include <svx/fmglob.hxx>
54 #include <editeng/outliner.hxx>
55 
56 #include "misc.hxx"
57 
58 #ifdef STARIMAGE_AVAILABLE
59 #ifndef _SIMDLL_HXX
60 #include <sim2/simdll.hxx>
61 #endif
62 #endif
63 
64 #include <svx/dialogs.hrc>
65 
66 #include "view/viewoverlaymanager.hxx"
67 
68 #include "glob.hrc"
69 #include "app.hrc"
70 #include "res_bmp.hrc"
71 #include "strings.hrc"
72 #include "helpids.h"
73 
74 #include "app.hxx"
75 #include "fupoor.hxx"
76 #include "sdresid.hxx"
77 #include "fusel.hxx"
78 #include "sdpage.hxx"
79 #include "FrameView.hxx"
80 #include "stlpool.hxx"
81 #include "Window.hxx"
82 #ifndef SD_DRAWVIEW_HXX
83 #include "drawview.hxx"
84 #endif
85 #include "drawdoc.hxx"
86 #include "DrawDocShell.hxx"
87 #include "Ruler.hxx"
88 #include "Client.hxx"
89 #include "slideshow.hxx"
90 #include "optsitem.hxx"
91 #include "fusearch.hxx"
92 #include "Outliner.hxx"
93 #include "AnimationChildWindow.hxx"
94 #include "SdUnoDrawView.hxx"
95 #include "ToolBarManager.hxx"
96 #include "FormShellManager.hxx"
97 #include "ViewShellBase.hxx"
98 #include "LayerDialogChildWindow.hxx"
99 #include "LayerTabBar.hxx"
100 #include "ViewShellManager.hxx"
101 #include "ViewShellHint.hxx"
102 
103 #include <sfx2/request.hxx>
104 #include <boost/bind.hpp>
105 
106 #ifdef _MSC_VER
107 #if (_MSC_VER < 1400)
108 #pragma optimize ( "", off )
109 #endif
110 #endif
111 
112 using namespace com::sun::star;
113 
114 namespace sd {
115 
Activate(sal_Bool bIsMDIActivate)116 void DrawViewShell::Activate(sal_Bool bIsMDIActivate)
117 {
118     ViewShell::Activate(bIsMDIActivate);
119 }
120 
UIActivating(SfxInPlaceClient * pCli)121 void DrawViewShell::UIActivating( SfxInPlaceClient* pCli )
122 {
123     ViewShell::UIActivating(pCli);
124 
125     // #94252# Disable own controls
126     maTabControl.Disable();
127     if (GetLayerTabControl() != NULL)
128         GetLayerTabControl()->Disable();
129 }
130 
UIDeactivated(SfxInPlaceClient * pCli)131 void DrawViewShell::UIDeactivated( SfxInPlaceClient* pCli )
132 {
133     // #94252# Enable own controls
134     maTabControl.Enable();
135     if (GetLayerTabControl() != NULL)
136         GetLayerTabControl()->Enable();
137 
138     ViewShell::UIDeactivated(pCli);
139 }
140 
141 
142 /*************************************************************************
143 |*
144 |* Deactivate()
145 |*
146 \************************************************************************/
147 
Deactivate(sal_Bool bIsMDIActivate)148 void DrawViewShell::Deactivate(sal_Bool bIsMDIActivate)
149 {
150     // Temporarily disable context broadcasting while the Deactivate()
151     // call is forwarded to our base class.
152     const bool bIsContextBroadcasterEnabled (SfxShell::SetContextBroadcasterEnabled(false));
153 
154     ViewShell::Deactivate(bIsMDIActivate);
155 
156     SfxShell::SetContextBroadcasterEnabled(bIsContextBroadcasterEnabled);
157 }
158 
159 namespace
160 {
161     class LockUI
162     {
163     private:
164         void Lock(bool bLock);
165         SfxViewFrame *mpFrame;
166     public:
LockUI(SfxViewFrame * pFrame)167         LockUI(SfxViewFrame *pFrame) : mpFrame(pFrame) { Lock(true); }
~LockUI()168         ~LockUI() { Lock(false); }
169 
170     };
171 
Lock(bool bLock)172     void LockUI::Lock(bool bLock)
173     {
174         if (!mpFrame)
175             return;
176         mpFrame->Enable( !bLock );
177     }
178 }
179 
180 /*************************************************************************
181 |*
182 |* Wird gerufen, wenn sich der Selektionszustand der View aendert
183 |*
184 \************************************************************************/
SelectionHasChanged(void)185 void DrawViewShell::SelectionHasChanged (void)
186 {
187 	Invalidate();
188 
189 	//Update3DWindow(); // 3D-Controller
190 	SfxBoolItem aItem( SID_3D_STATE, sal_True );
191 	GetViewFrame()->GetDispatcher()->Execute(
192 		SID_3D_STATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
193 
194 	SdrOle2Obj* pOleObj = NULL;
195 	SdrGrafObj* pGrafObj = NULL;
196 
197 	if ( mpDrawView->AreObjectsMarked() )
198 	{
199 		const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
200 
201 		if (rMarkList.GetMarkCount() == 1)
202 		{
203 			SdrMark* pMark = rMarkList.GetMark(0);
204 			SdrObject* pObj = pMark->GetMarkedSdrObj();
205 
206 			sal_uInt32 nInv = pObj->GetObjInventor();
207 			sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
208 
209 			if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
210 			{
211 				pOleObj = (SdrOle2Obj*) pObj;
212 				UpdateIMapDlg( pObj );
213 			}
214 			else if (nSdrObjKind == OBJ_GRAF)
215 			{
216 				pGrafObj = (SdrGrafObj*) pObj;
217 				UpdateIMapDlg( pObj );
218 			}
219 		}
220 	}
221 
222     ViewShellBase& rBase = GetViewShellBase();
223 	rBase.SetVerbs( uno::Sequence< embed::VerbDescriptor >() );
224 
225 	try
226 	{
227 		Client* pIPClient = static_cast<Client*>(rBase.GetIPClient());
228 		if ( pIPClient && pIPClient->IsObjectInPlaceActive() )
229 		{
230 			/**********************************************************************
231 			* Ggf. OLE-Objekt beruecksichtigen und deaktivieren
232 			**********************************************************************/
233 
234 			// this means we recently deselected an inplace active ole object so
235 			// we need to deselect it now
236 			if (!pOleObj)
237 			{
238                 //#i47279# disable frame until after object has completed unload
239                 LockUI aUILock(GetViewFrame());
240                 pIPClient->DeactivateObject();
241 				//HMHmpDrView->ShowMarkHdl();
242 			}
243 			else
244 			{
245 				uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
246 				if ( xObj.is() )
247 				{
248 					rBase.SetVerbs( xObj->getSupportedVerbs() );
249 				}
250 				else
251 				{
252 					rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
253 				}
254 			}
255 		}
256 		else
257 		{
258 			if ( pOleObj )
259 			{
260 				uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
261 				if ( xObj.is() )
262 				{
263 					rBase.SetVerbs( xObj->getSupportedVerbs() );
264 				}
265 				else
266 				{
267 					rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
268 				}
269 			}
270 			else
271 			{
272 				rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
273 			}
274 		}
275 	}
276 	catch( ::com::sun::star::uno::Exception& e )
277 	{
278 		(void)e;
279 		DBG_ERROR(
280 			(rtl::OString("sd::DrawViewShell::SelectionHasChanged(), "
281 					"exception caught: ") +
282 			rtl::OUStringToOString(
283 				comphelper::anyToString( cppu::getCaughtException() ),
284 				RTL_TEXTENCODING_UTF8 )).getStr() );
285 	}
286 
287 	if( HasCurrentFunction() )
288 	{
289 		GetCurrentFunction()->SelectionHasChanged();
290 	}
291 	else
292 	{
293         GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this,*mpDrawView);
294 	}
295 
296     // #96124# Invalidate for every subshell
297     GetViewShellBase().GetViewShellManager()->InvalidateAllSubShells(this);
298 
299     mpDrawView->UpdateSelectionClipboard( sal_False );
300 
301     GetViewShellBase().GetDrawController().FireSelectionChangeListener();
302 }
303 
304 
305 /*************************************************************************
306 |*
307 |* Zoomfaktor setzen
308 |*
309 \************************************************************************/
310 
SetZoom(long nZoom)311 void DrawViewShell::SetZoom( long nZoom )
312 {
313     // Make sure that the zoom factor will not be recalculated on
314     // following window resizings.
315     mbZoomOnPage = sal_False;
316 	ViewShell::SetZoom( nZoom );
317 	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
318 	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
319 	mpViewOverlayManager->onZoomChanged();
320 }
321 
322 /*************************************************************************
323 |*
324 |* Zoomrechteck fuer aktives Fenster einstellen
325 |*
326 \************************************************************************/
327 
SetZoomRect(const Rectangle & rZoomRect)328 void DrawViewShell::SetZoomRect( const Rectangle& rZoomRect )
329 {
330 	ViewShell::SetZoomRect( rZoomRect );
331 	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
332 	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
333 	mpViewOverlayManager->onZoomChanged();
334 }
335 
336 /*************************************************************************
337 |*
338 |* PrepareClose, ggfs. Texteingabe beenden, damit andere Viewshells ein
339 |* aktualisiertes Textobjekt vorfinden
340 |*
341 \************************************************************************/
342 
PrepareClose(sal_Bool bUI,sal_Bool bForBrowsing)343 sal_uInt16 DrawViewShell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing )
344 {
345 	if ( ViewShell::PrepareClose(bUI, bForBrowsing) != sal_True )
346 		return sal_False;
347 
348 	sal_Bool			bRet = sal_True;
349 
350 	if( bRet && HasCurrentFunction() )
351 	{
352 		sal_uInt16 nID = GetCurrentFunction()->GetSlotID();
353 		if (nID == SID_TEXTEDIT || nID == SID_ATTR_CHAR)
354 		{
355 			mpDrawView->SdrEndTextEdit();
356 		}
357 	}
358 	else if( !bRet )
359 	{
360 		maCloseTimer.SetTimeoutHdl( LINK( this, DrawViewShell, CloseHdl ) );
361 		maCloseTimer.SetTimeout( 20 );
362 		maCloseTimer.Start();
363 	}
364 
365 	return bRet;
366 }
367 
368 /*************************************************************************
369 |*
370 |* Status (Enabled/Disabled) von Menue-SfxSlots setzen
371 |*
372 \************************************************************************/
373 
ChangeEditMode(EditMode eEMode,bool bIsLayerModeActive)374 void DrawViewShell::ChangeEditMode(EditMode eEMode, bool bIsLayerModeActive)
375 {
376 	if (meEditMode != eEMode || mbIsLayerModeActive != bIsLayerModeActive)
377 	{
378         ViewShellManager::UpdateLock aLock (GetViewShellBase().GetViewShellManager());
379 
380         sal_uInt16 nActualPageNum = 0;
381 
382         GetViewShellBase().GetDrawController().FireChangeEditMode (eEMode == EM_MASTERPAGE);
383         GetViewShellBase().GetDrawController().FireChangeLayerMode (bIsLayerModeActive);
384 
385 		if ( mpDrawView->IsTextEdit() )
386 		{
387 			mpDrawView->SdrEndTextEdit();
388 		}
389 
390 		LayerTabBar* pLayerBar = GetLayerTabControl();
391         if (pLayerBar != NULL)
392             pLayerBar->EndEditMode();
393 		maTabControl.EndEditMode();
394 
395 		if (mePageKind == PK_HANDOUT)
396 		{
397 			// Bei Handzetteln nur MasterPage zulassen
398 			eEMode = EM_MASTERPAGE;
399 		}
400 
401         GetViewShellBase().GetDrawController().BroadcastContextChange();
402 
403 		meEditMode = eEMode;
404 
405         if(pLayerBar)
406         {
407             // #87182# only switch activation mode of LayerTabBar when there is one,
408             // else it will not get initialized with the current set of Layers as needed
409             mbIsLayerModeActive = bIsLayerModeActive;
410         }
411 
412         // Determine whether to show the master view toolbar.  The master
413         // page mode has to be active and the shell must not be a handout
414         // view.
415         bool bShowMasterViewToolbar (meEditMode == EM_MASTERPAGE
416              && GetShellType() != ViewShell::ST_HANDOUT);
417 
418         // If the master view toolbar is not shown we hide it before
419         // switching the edit mode.
420         if (::sd::ViewShell::mpImpl->mbIsInitialized
421             && IsMainViewShell()
422             && ! bShowMasterViewToolbar)
423         {
424             GetViewShellBase().GetToolBarManager()->ResetToolBars(ToolBarManager::TBG_MASTER_MODE);
425         }
426 
427 		if (meEditMode == EM_PAGE)
428 		{
429 			/******************************************************************
430 			* PAGEMODE
431 			******************************************************************/
432 
433 			maTabControl.Clear();
434 
435 			SdPage* pPage;
436 			String aPageName;
437 			sal_uInt16 nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
438 
439 			for (sal_uInt16 i = 0; i < nPageCnt; i++)
440 			{
441 				pPage = GetDoc()->GetSdPage(i, mePageKind);
442 				aPageName = pPage->GetName();
443 				maTabControl.InsertPage(i + 1, aPageName);
444 
445 				if ( pPage->IsSelected() && nActualPageNum == 0 )
446 				{
447 					nActualPageNum = i;
448 				}
449 			}
450 
451             maTabControl.SetCurPageId(nActualPageNum + 1);
452 
453 			SwitchPage(nActualPageNum);
454 		}
455 		else
456 		{
457 			/******************************************************************
458 			* MASTERPAGE
459 			******************************************************************/
460 			GetViewFrame()->SetChildWindow(
461                 AnimationChildWindow::GetChildWindowId(), sal_False );
462 
463 			if (!mpActualPage)
464 			{
465 				// Sofern es keine mpActualPage gibt, wird die erste genommen
466 				mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
467 			}
468 
469 			maTabControl.Clear();
470 			sal_uInt16 nActualMasterPageNum = 0;
471 			sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
472 
473 			for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
474 			{
475 				SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
476 				String aLayoutName(pMaster->GetLayoutName());
477 				aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR));
478 
479 				maTabControl.InsertPage(i + 1, aLayoutName);
480 
481 				if (&(mpActualPage->TRG_GetMasterPage()) == pMaster)
482 				{
483 					nActualMasterPageNum = i;
484 				}
485 			}
486 
487 			maTabControl.SetCurPageId(nActualMasterPageNum + 1);
488 			SwitchPage(nActualMasterPageNum);
489 		}
490 
491         // If the master view toolbar is to be shown we turn it on after the
492         // edit mode has been changed.
493         if (::sd::ViewShell::mpImpl->mbIsInitialized
494             && IsMainViewShell()
495             && bShowMasterViewToolbar)
496         {
497             GetViewShellBase().GetToolBarManager()->SetToolBar(
498                 ToolBarManager::TBG_MASTER_MODE,
499                 ToolBarManager::msMasterViewToolBar);
500         }
501 
502 		if ( ! mbIsLayerModeActive)
503 		{
504             maTabControl.Show();
505             // Set the tab control only for draw pages.  For master page
506             // this has been done already above.
507             if (meEditMode == EM_PAGE)
508                 maTabControl.SetCurPageId (nActualPageNum + 1);
509 		}
510         /*AF: The LayerDialogChildWindow is not used anymore (I hope).
511         if (GetViewFrame()->KnowsChildWindow(
512             LayerDialogChildWindow::GetChildWindowId()))
513         {
514             GetViewFrame()->SetChildWindow(
515                 LayerDialogChildWindow::GetChildWindowId(),
516                 IsLayerModeActive());
517         }
518         */
519 		ResetActualLayer();
520 
521 		Invalidate( SID_PAGEMODE );
522 		Invalidate( SID_LAYERMODE );
523 		Invalidate( SID_MASTERPAGE );
524         Invalidate( SID_DELETE_MASTER_PAGE );
525         Invalidate( SID_DELETE_PAGE );
526 		Invalidate( SID_SLIDE_MASTERPAGE );
527 		Invalidate( SID_TITLE_MASTERPAGE );
528 		Invalidate( SID_NOTES_MASTERPAGE );
529 		Invalidate( SID_HANDOUT_MASTERPAGE );
530 
531         SetContextName(GetSidebarContextName());
532 	}
533 }
534 
535 
536 
537 
IsLayerModeActive(void) const538 bool DrawViewShell::IsLayerModeActive (void) const
539 {
540     return mbIsLayerModeActive;
541 }
542 
543 
544 
545 
546 /*************************************************************************
547 |*
548 |* Groesse des TabControls und der ModeButtons zurueckgeben
549 |*
550 \************************************************************************/
551 
GetHCtrlWidth()552 long DrawViewShell::GetHCtrlWidth()
553 {
554     //	return maTabControl.GetSizePixel().Width();
555     return 0;
556 }
557 
558 
559 /*************************************************************************
560 |*
561 |* Horizontales Lineal erzeugen
562 |*
563 \************************************************************************/
564 
CreateHRuler(::sd::Window * pWin,sal_Bool bIsFirst)565 SvxRuler* DrawViewShell::CreateHRuler (::sd::Window* pWin, sal_Bool bIsFirst)
566 {
567 	Ruler* pRuler;
568 	WinBits  aWBits;
569 	sal_uInt16	 nFlags = SVXRULER_SUPPORT_OBJECT;
570 
571 	if ( bIsFirst )
572 	{
573 		aWBits	= WB_HSCROLL | WB_3DLOOK | WB_BORDER | WB_EXTRAFIELD;
574 		nFlags |= ( SVXRULER_SUPPORT_SET_NULLOFFSET |
575 					SVXRULER_SUPPORT_TABS |
576 					SVXRULER_SUPPORT_PARAGRAPH_MARGINS ); // Neu
577 	}
578 	else
579 		aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER;
580 
581 	pRuler = new Ruler (*this, GetParentWindow(), pWin, nFlags,
582         GetViewFrame()->GetBindings(), aWBits);
583 	pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
584 
585 	// Metric ...
586 	sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
587 
588 	if( nMetric == 0xffff )
589 		nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
590 
591 	pRuler->SetUnit( FieldUnit( nMetric ) );
592 
593 	// ... und auch DefTab am Lineal einstellen
594 	pRuler->SetDefTabDist( GetDoc()->GetDefaultTabulator() ); // Neu
595 
596 	Fraction aUIScale(pWin->GetMapMode().GetScaleX());
597 	aUIScale *= GetDoc()->GetUIScale();
598 	pRuler->SetZoom(aUIScale);
599 
600 	return pRuler;
601 }
602 
603 /*************************************************************************
604 |*
605 |* Vertikales Lineal erzeugen
606 |*
607 \************************************************************************/
608 
CreateVRuler(::sd::Window * pWin)609 SvxRuler* DrawViewShell::CreateVRuler(::sd::Window* pWin)
610 {
611 	Ruler* pRuler;
612 	WinBits  aWBits = WB_VSCROLL | WB_3DLOOK | WB_BORDER;
613 	sal_uInt16	 nFlags = SVXRULER_SUPPORT_OBJECT;
614 
615 	pRuler = new Ruler(*this, GetParentWindow(), pWin, nFlags,
616         GetViewFrame()->GetBindings(), aWBits);
617 	pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
618 
619 	// #96629# Metric same as HRuler, use document setting
620 	sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
621 
622 	if( nMetric == 0xffff )
623 		nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
624 
625 	pRuler->SetUnit( FieldUnit( nMetric ) );
626 
627 	Fraction aUIScale(pWin->GetMapMode().GetScaleY());
628 	aUIScale *= GetDoc()->GetUIScale();
629 	pRuler->SetZoom(aUIScale);
630 
631 	return pRuler;
632 }
633 
634 /*************************************************************************
635 |*
636 |* Horizontales Lineal aktualisieren
637 |*
638 \************************************************************************/
639 
UpdateHRuler()640 void DrawViewShell::UpdateHRuler()
641 {
642 	Invalidate( SID_ATTR_LONG_LRSPACE );
643 	Invalidate( SID_RULER_PAGE_POS );
644 	Invalidate( SID_RULER_OBJECT );
645 	Invalidate( SID_RULER_TEXT_RIGHT_TO_LEFT );
646 
647     if (mpHorizontalRuler.get() != NULL)
648         mpHorizontalRuler->ForceUpdate();
649 }
650 
651 /*************************************************************************
652 |*
653 |* Vertikales Lineal aktualisieren
654 |*
655 \************************************************************************/
656 
UpdateVRuler()657 void DrawViewShell::UpdateVRuler()
658 {
659 	Invalidate( SID_ATTR_LONG_LRSPACE );
660 	Invalidate( SID_RULER_PAGE_POS );
661 	Invalidate( SID_RULER_OBJECT );
662 
663     if (mpVerticalRuler.get() != NULL)
664         mpVerticalRuler->ForceUpdate();
665 }
666 
667 /*************************************************************************
668 |*
669 |* Metrik setzen
670 |*
671 \************************************************************************/
672 
SetUIUnit(FieldUnit eUnit)673 void DrawViewShell::SetUIUnit(FieldUnit eUnit)
674 {
675 	ViewShell::SetUIUnit(eUnit);
676 }
677 
678 /*************************************************************************
679 |*
680 |* TabControl nach Splitteraenderung aktualisieren
681 |*
682 \************************************************************************/
683 
IMPL_LINK(DrawViewShell,TabSplitHdl,TabBar *,pTab)684 IMPL_LINK( DrawViewShell, TabSplitHdl, TabBar *, pTab )
685 {
686     const long int nMax = maViewSize.Width() - maScrBarWH.Width()
687         - maTabControl.GetPosPixel().X() ;
688 
689 	Size aTabSize = maTabControl.GetSizePixel();
690 	aTabSize.Width() = Min(pTab->GetSplitSize(), (long)(nMax-1));
691 
692 	maTabControl.SetSizePixel(aTabSize);
693 
694     if(GetLayerTabControl()) // #87182#
695     {
696         GetLayerTabControl()->SetSizePixel(aTabSize);
697     }
698 
699 	Point aPos = maTabControl.GetPosPixel();
700 	aPos.X() += aTabSize.Width();
701 
702 	Size aScrSize(nMax - aTabSize.Width(), maScrBarWH.Height());
703 	mpHorizontalScrollBar->SetPosSizePixel(aPos, aScrSize);
704 
705 	return 0;
706 }
707 
708 /// inherited from sd::ViewShell
getCurrentPage() const709 SdPage* DrawViewShell::getCurrentPage() const
710 {
711 	const sal_Int32 nPageCount = (meEditMode == EM_PAGE)?
712 									GetDoc()->GetSdPageCount(mePageKind):
713 									GetDoc()->GetMasterSdPageCount(mePageKind);
714 
715 	sal_Int32 nCurrentPage = maTabControl.GetCurPageId() - 1;
716 	DBG_ASSERT( (nPageCount>0) && (nCurrentPage<nPageCount), "sd::DrawViewShell::getCurrentPage(), illegal page index!" );
717 	if( (nPageCount < 0) || (nCurrentPage>=nPageCount) )
718 		nCurrentPage = 0; // play safe here
719 
720 	if (meEditMode == EM_PAGE)
721 	{
722 		return GetDoc()->GetSdPage((sal_uInt16)nCurrentPage, mePageKind);
723 	}
724 	else // EM_MASTERPAGE
725 	{
726 		return GetDoc()->GetMasterSdPage((sal_uInt16)nCurrentPage, mePageKind);
727 	}
728 }
729 
730 /*************************************************************************
731 |*
732 |* neue aktuelle Seite auswaehlen, falls sich die Seitenfolge geaendert
733 |* hat (z. B. durch Undo)
734 |*
735 \************************************************************************/
736 
ResetActualPage()737 void DrawViewShell::ResetActualPage()
738 {
739 	sal_uInt16 nCurrentPage = maTabControl.GetCurPageId() - 1;
740 	sal_uInt16 nPageCount	= (meEditMode == EM_PAGE)?GetDoc()->GetSdPageCount(mePageKind):GetDoc()->GetMasterSdPageCount(mePageKind);
741 	if (nPageCount > 0)
742 		nCurrentPage = Min((sal_uInt16)(nPageCount - 1), nCurrentPage);
743 	else
744 		nCurrentPage = 0;
745 
746 	if (meEditMode == EM_PAGE)
747 	{
748 
749 		// Update fuer TabControl
750 		maTabControl.Clear();
751 
752 		SdPage* pPage = NULL;
753 		String aPageName;
754 
755 		for (sal_uInt16 i = 0; i < nPageCount; i++)
756 		{
757 			pPage = GetDoc()->GetSdPage(i, mePageKind);
758 			aPageName = pPage->GetName();
759 			maTabControl.InsertPage(i + 1, aPageName);
760 
761 			// Selektionskennungen der Seiten korrigieren
762 			GetDoc()->SetSelected(pPage, i == nCurrentPage);
763 		}
764 
765 		maTabControl.SetCurPageId(nCurrentPage + 1);
766 	}
767 	else // EM_MASTERPAGE
768 	{
769 		SdPage* pActualPage = GetDoc()->GetMasterSdPage(nCurrentPage, mePageKind);
770 		maTabControl.Clear();
771 		sal_uInt16 nActualMasterPageNum = 0;
772 
773 		sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
774 		for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
775 		{
776 			SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
777 			String aLayoutName(pMaster->GetLayoutName());
778 			aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR));
779 			maTabControl.InsertPage(i + 1, aLayoutName);
780 
781 			if (pActualPage == pMaster)
782 				nActualMasterPageNum = i;
783 		}
784 
785 		maTabControl.SetCurPageId(nActualMasterPageNum + 1);
786 		SwitchPage(nActualMasterPageNum);
787 	}
788 
789 	GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE,
790 				SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
791 }
792 
793 /*************************************************************************
794 |*
795 |* Verb auf OLE-Objekt anwenden
796 |*
797 \************************************************************************/
798 
799 
DoVerb(long nVerb)800 ErrCode DrawViewShell::DoVerb(long nVerb)
801 {
802 	if ( mpDrawView->AreObjectsMarked() )
803 	{
804 		const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
805 
806 		if (rMarkList.GetMarkCount() == 1)
807 		{
808 			SdrMark* pMark = rMarkList.GetMark(0);
809 			SdrObject* pObj = pMark->GetMarkedSdrObj();
810 
811 			sal_uInt32 nInv = pObj->GetObjInventor();
812 			sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
813 
814 			if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
815 			{
816 				ActivateObject( (SdrOle2Obj*) pObj, nVerb);
817 			}
818 #ifdef STARIMAGE_AVAILABLE
819 			else if (nInv = SdrInventor && nSdrObjKind == OBJ_GRAF &&
820 					 ((SdrGrafObj*) pObj)->GetGraphicType() == GRAPHIC_BITMAP &&
821 					 SFX_APP()->HasFeature(SFX_FEATURE_SIMAGE))
822 			{
823 				SdrGrafObj* pSdrGrafObj = (SdrGrafObj*) pObj;
824 				short nOK = RET_YES;
825 
826 				if ( pSdrGrafObj->GetFileName().Len() )
827 				{
828 					// Graphik ist gelinkt, soll der Link aufgehoben werden?
829 					QueryBox aBox(pWindow, WB_YES_NO | WB_DEF_YES,
830 								  String( SdResId(STR_REMOVE_LINK) ) );
831 					nOK = aBox.Execute();
832 
833 					if (nOK == RET_YES)
834 					{
835 						// Link aufheben (File- und Filtername zuruecksetzen)
836 						pSdrGrafObj->SetGraphicLink(String(), String());
837 					}
838 				}
839 
840 				if (nOK == RET_YES)
841 				{
842 					/**************************************************************
843 					* OLE-Objekt erzeugen, StarImage starten
844 					* Grafik-Objekt loeschen (durch OLE-Objekt ersetzt)
845 					**************************************************************/
846 					//HMHmpDrView->HideMarkHdl();
847 
848 					SvStorageRef aStor = new SvStorage(String());
849 					SvInPlaceObjectRef aNewIPObj = &((SvFactory*)SvInPlaceObject::ClassFactory())
850 					->CreateAndInit(SimModuleDummy::GetID(SOFFICE_FILEFORMAT_CURRENT), aStor);
851 					if ( aNewIPObj.Is() )
852 					{
853 						SdrGrafObj* pTempSdrGrafObj = (SdrGrafObj*) pSdrGrafObj->Clone ();
854 
855 						SvEmbeddedInfoObject * pInfo;
856 						pInfo = GetViewFrame()->GetObjectShell()->
857 									   InsertObject( aNewIPObj, String() );
858 
859 						String aName;
860 						if (pInfo)
861 						{
862 							aName = pInfo->GetObjName();
863 						}
864 
865 						Rectangle aRect = pObj->GetLogicRect();
866 						SdrOle2Obj* pSdrOle2Obj = new SdrOle2Obj( aNewIPObj,
867 																  aName, aRect );
868 
869 						SdrPageView* pPV = mpDrawView->GetSdrPageView();
870 
871 						pPV->GetObjList()->InsertObject( pSdrOle2Obj );
872 						mpDrawView->ReplaceObjectAtView( pObj, *pPV, pTempSdrGrafObj );
873 
874 						pSdrOle2Obj->SetLogicRect(aRect);
875 						aNewIPObj->SetVisAreaSize(aRect.GetSize());
876 
877 						SimDLL::Update(aNewIPObj, pTempSdrGrafObj->GetGraphic(), pWindow);
878 						ActivateObject(pSdrOle2Obj, SVVERB_SHOW);
879 
880 						Client* pClient = (Client*) GetIPClient();
881 
882 						if (pClient)
883 							pClient->SetSdrGrafObj( pTempSdrGrafObj );
884 					}
885 				}
886 			}
887 #endif
888 		}
889 	}
890 
891 	return 0;
892 }
893 
894 
895 /*************************************************************************
896 |*
897 |* OLE-Object aktivieren
898 |*
899 \************************************************************************/
900 
ActivateObject(SdrOle2Obj * pObj,long nVerb)901 sal_Bool DrawViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
902 {
903 	sal_Bool bActivated = sal_False;
904 
905 	if ( !GetDocSh()->IsUIActive() )
906 	{
907         ToolBarManager::UpdateLock aLock (GetViewShellBase().GetToolBarManager());
908 
909 		bActivated = ViewShell::ActivateObject(pObj, nVerb);
910 
911         OSL_ASSERT(GetViewShell()!=NULL);
912         Client* pClient = static_cast<Client*>(GetViewShell()->GetIPClient());
913 		if (pClient)
914 			pClient->SetSdrGrafObj(NULL);
915 	}
916 
917 	return(bActivated);
918 }
919 
920 /*************************************************************************
921 |*
922 |* Auf gewuenschte Seite schalten
923 |* Der Parameter nSelectedPage bezieht sich auf den aktuellen EditMode
924 |*
925 \************************************************************************/
926 
LclResetFlag(bool & rbFlag)927 void LclResetFlag (bool& rbFlag) {rbFlag = false;}
928 
SwitchPage(sal_uInt16 nSelectedPage)929 sal_Bool DrawViewShell::SwitchPage(sal_uInt16 nSelectedPage)
930 {
931     /** Under some circumstances there are nested calls to SwitchPage() and
932         may crash the application (activation of form controls when the
933         shell of the edit view is not on top of the shell stack, see issue
934         83888 for details.)  Therefore the nested calls are ignored (they
935         would jump to the wrong page anyway.)
936     */
937     if (mbIsInSwitchPage)
938         return sal_False;
939     mbIsInSwitchPage = true;
940     comphelper::ScopeGuard aGuard (::boost::bind(LclResetFlag, ::boost::ref(mbIsInSwitchPage)));
941 
942     if (GetActiveWindow()->IsInPaint())
943     {
944         // Switching the current page while a Paint is being executed is
945         // dangerous.  So, post it for later execution and return.
946         maAsynchronousSwitchPageCall.Post(::boost::bind(
947             ::std::mem_fun(&DrawViewShell::SwitchPage),
948             this,
949             nSelectedPage));
950         return sal_False;
951     }
952 
953 	sal_Bool bOK = sal_False;
954 
955     // With the current implementation of FuSlideShow there is a problem
956     // when it dsplays the show in a window: When the show is stopped it
957     // returns at one point in time SDRPAGE_NOTFOUND as current page index.
958     // Because FuSlideShow is currently being rewritten this bug is fixed
959     // here.
960     // This is not as bad a hack as it may look because making SwitchPage()
961     // more robust with respect to invalid page numbers is a good thing
962     // anyway.
963     if (nSelectedPage == SDRPAGE_NOTFOUND)
964 	{
965         nSelectedPage = 0;
966 	}
967 	else
968 	{
969 	    // Make sure that the given page index points to an existing page.  Move
970 		// the index into the valid range if necessary.
971 		sal_uInt16 nPageCount = (meEditMode == EM_PAGE)
972 			? GetDoc()->GetSdPageCount(mePageKind)
973 			: GetDoc()->GetMasterSdPageCount(mePageKind);
974 		if (nSelectedPage >= nPageCount)
975 			nSelectedPage = nPageCount-1;
976 	}
977 
978 	if (IsSwitchPageAllowed())
979 	{
980 		ModifyGuard aGuard2( GetDoc() );
981 
982 		bOK = sal_True;
983 
984 		if (mpActualPage)
985 		{
986             SdPage* pNewPage = NULL;
987 
988 			if (meEditMode == EM_MASTERPAGE)
989 			{
990 				if( GetDoc()->GetMasterSdPageCount(mePageKind) > nSelectedPage )
991 					pNewPage = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
992 
993 				if( pNewPage )
994 				{
995 					SdrPageView* pPV = mpDrawView->GetSdrPageView();
996 
997                     String sPageText (pNewPage->GetLayoutName());
998                     sPageText.Erase(sPageText.SearchAscii(SD_LT_SEPARATOR));
999 					if (pPV
1000                         && pNewPage == dynamic_cast< SdPage* >( pPV->GetPage() )
1001                         && sPageText == maTabControl.GetPageText(nSelectedPage+1))
1002 					{
1003 						// this slide is already visible
1004 						return sal_True;
1005 					}
1006 				}
1007 			}
1008 			else
1009 			{
1010                 OSL_ASSERT(mpFrameView!=NULL);
1011                 mpFrameView->SetSelectedPage(nSelectedPage);
1012 
1013 				if (GetDoc()->GetSdPageCount(mePageKind) > nSelectedPage)
1014 					pNewPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
1015 
1016 				if (mpActualPage == pNewPage)
1017 				{
1018 					SdrPageView* pPV = mpDrawView->GetSdrPageView();
1019 
1020                     SdPage* pCurrentPage = dynamic_cast< SdPage* >( pPV->GetPage());
1021                     if (pPV
1022                         && pNewPage == pCurrentPage
1023                         && pNewPage->GetName() == maTabControl.GetPageText(nSelectedPage+1))
1024 					{
1025 						// this slide is already visible
1026 						return sal_True;
1027 					}
1028 				}
1029 			}
1030 		}
1031 
1032 		if( mpDrawView )
1033 			mpDrawView->SdrEndTextEdit();
1034 
1035 		mpActualPage = NULL;
1036 
1037 		if (meEditMode == EM_PAGE)
1038 		{
1039 			mpActualPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
1040 		}
1041 		else
1042 		{
1043 			SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
1044 
1045 			// Passt die selektierte Seite zur MasterPage?
1046 			sal_uInt16 nPageCount = GetDoc()->GetSdPageCount(mePageKind);
1047 			for (sal_uInt16 i = 0; i < nPageCount; i++)
1048 			{
1049 				SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
1050 				if(pPage && pPage->IsSelected() && pMaster == &(pPage->TRG_GetMasterPage()))
1051 				{
1052 					mpActualPage = pPage;
1053 					break;
1054 				}
1055 			}
1056 
1057 			if (!mpActualPage)
1058 			{
1059 				// Die erste Seite nehmen, welche zur MasterPage passt
1060 				for (sal_uInt16 i = 0; i < nPageCount; i++)
1061 				{
1062 					SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
1063 					if(pPage && pMaster == &(pPage->TRG_GetMasterPage()))
1064 					{
1065 						mpActualPage = pPage;
1066 						break;
1067 					}
1068 				}
1069 			}
1070 		}
1071 
1072 		for (sal_uInt16 i = 0; i < GetDoc()->GetSdPageCount(mePageKind); i++)
1073 		{
1074 			// Alle Seiten deselektieren
1075 			GetDoc()->SetSelected( GetDoc()->GetSdPage(i, mePageKind), sal_False);
1076 		}
1077 
1078 		if (!mpActualPage)
1079 		{
1080 			// Sofern es keine mpActualPage gibt, wird die erste genommen
1081 			mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
1082 		}
1083 
1084 		// diese Seite auch selektieren (mpActualPage zeigt immer auf Zeichenseite,
1085 		// nie auf eine Masterpage)
1086 		GetDoc()->SetSelected(mpActualPage, sal_True);
1087 
1088 		rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) );
1089         if( !xSlideshow.is() || !xSlideshow->isRunning() || ( xSlideshow->getAnimationMode() != ANIMATIONMODE_SHOW ) )
1090         {
1091     		// VisArea zuziehen, um ggf. Objekte zu deaktivieren
1092             // !!! only if we are not in presentation mode (#96279) !!!
1093             OSL_ASSERT (GetViewShell()!=NULL);
1094             GetViewShell()->DisconnectAllClients();
1095     		VisAreaChanged(Rectangle(Point(), Size(1, 1)));
1096         }
1097 
1098 		if (meEditMode == EM_PAGE)
1099 		{
1100 			/**********************************************************************
1101 			* PAGEMODE
1102 			**********************************************************************/
1103 			GetDoc()->SetSelected(mpActualPage, sal_True);
1104 
1105 			SdrPageView* pPageView = mpDrawView->GetSdrPageView();
1106 
1107 			if (pPageView)
1108 			{
1109 				mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
1110 				mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
1111 				mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
1112 
1113 				if (mePageKind == PK_NOTES)
1114 				{
1115 					mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
1116 				}
1117 				else if (mePageKind == PK_HANDOUT)
1118 				{
1119 					mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
1120 				}
1121 				else
1122 				{
1123 					mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
1124 				}
1125 			}
1126 
1127 			mpDrawView->HideSdrPage();
1128 			mpDrawView->ShowSdrPage(mpActualPage);
1129             GetViewShellBase().GetDrawController().FireSwitchCurrentPage(mpActualPage);
1130 
1131 			SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
1132 
1133 			if (pNewPageView)
1134 			{
1135 				pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
1136 				pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
1137 				pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
1138 
1139 				if (mePageKind == PK_NOTES)
1140 				{
1141 					pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
1142 				}
1143 				else if (mePageKind == PK_HANDOUT)
1144 				{
1145 					pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
1146 				}
1147 				else
1148 				{
1149 					pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
1150 				}
1151 			}
1152 
1153 			maTabControl.SetCurPageId(nSelectedPage+1);
1154 			String aPageName = mpActualPage->GetName();
1155 
1156 			if (maTabControl.GetPageText(nSelectedPage+1) != aPageName)
1157 			{
1158 				maTabControl.SetPageText(nSelectedPage+1, aPageName);
1159 			}
1160 		}
1161 		else
1162 		{
1163 			/**********************************************************************
1164 			* MASTERPAGE
1165 			**********************************************************************/
1166 			SdrPageView* pPageView = mpDrawView->GetSdrPageView();
1167 
1168 			if (pPageView)
1169 			{
1170 				mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
1171 				mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
1172 				mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
1173 
1174 				if (mePageKind == PK_NOTES)
1175 				{
1176 					mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
1177 				}
1178 				else if (mePageKind == PK_HANDOUT)
1179 				{
1180 					mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
1181 				}
1182 				else
1183 				{
1184 					mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
1185 				}
1186 			}
1187 
1188 			mpDrawView->HideSdrPage();
1189 
1190 			SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
1191 
1192 			if( !pMaster )              // Falls es diese Page nicht geben sollte
1193 				pMaster = GetDoc()->GetMasterSdPage(0, mePageKind);
1194 
1195 			sal_uInt16 nNum = pMaster->GetPageNum();
1196 			mpDrawView->ShowSdrPage(mpDrawView->GetModel()->GetMasterPage(nNum));
1197 
1198             GetViewShellBase().GetDrawController().FireSwitchCurrentPage(pMaster);
1199 
1200 			SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
1201 
1202 			if (pNewPageView)
1203 			{
1204 				pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
1205 				pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
1206 				pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
1207 
1208 				if (mePageKind == PK_NOTES)
1209 				{
1210 					pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
1211 				}
1212 				else if (mePageKind == PK_HANDOUT)
1213 				{
1214 					pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
1215 				}
1216 				else
1217 				{
1218 					pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
1219 				}
1220 			}
1221 
1222 			String aLayoutName(pMaster->GetLayoutName());
1223 			aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR));
1224 
1225 			maTabControl.SetCurPageId(nSelectedPage+1);
1226 
1227 			if (maTabControl.GetPageText(nSelectedPage+1) != aLayoutName)
1228 			{
1229 				maTabControl.SetPageText(nSelectedPage+1, aLayoutName);
1230 			}
1231 
1232 			if( mePageKind == PK_HANDOUT )
1233 			{
1234 				// set pages for all available handout presentation objects
1235 				sd::ShapeList& rShapeList = pMaster->GetPresentationShapeList();
1236 				SdrObject* pObj = 0;
1237 
1238                 while( (pObj = rShapeList.getNextShape(pObj)) != 0 )
1239 				{
1240 					if( pMaster->GetPresObjKind(pObj) == PRESOBJ_HANDOUT )
1241 					{
1242                         // #i105146# We want no content to be displayed for PK_HANDOUT,
1243                         // so just never set a page as content
1244 						static_cast<SdrPageObj*>(pObj)->SetReferencedPage(0);
1245 					}
1246 				}
1247 			}
1248 		}
1249 
1250 		Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1251 		Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1252 		VisAreaChanged(aVisAreaWin);
1253 		mpDrawView->VisAreaChanged(GetActiveWindow());
1254 
1255 		// Damit der Navigator (und das Effekte-Window) das mitbekommt (/-men)
1256 		SfxBindings& rBindings = GetViewFrame()->GetBindings();
1257 		rBindings.Invalidate(SID_NAVIGATOR_PAGENAME, sal_True, sal_False);
1258 		rBindings.Invalidate(SID_STATUS_PAGE, sal_True, sal_False);
1259 		rBindings.Invalidate(SID_DELETE_MASTER_PAGE, sal_True, sal_False);
1260 		rBindings.Invalidate(SID_DELETE_PAGE, sal_True, sal_False);
1261 		rBindings.Invalidate(SID_ASSIGN_LAYOUT,sal_True,sal_False);
1262 		rBindings.Invalidate(SID_INSERTPAGE,sal_True,sal_False);
1263 		UpdatePreview( mpActualPage );
1264 
1265 		mpDrawView->AdjustMarkHdl();
1266 	}
1267 
1268 	return (bOK);
1269 }
1270 
1271 
1272 /*************************************************************************
1273 |*
1274 |* Pruefen, ob ein Seitenwechsel erlaubt ist
1275 |*
1276 \************************************************************************/
1277 
IsSwitchPageAllowed() const1278 sal_Bool DrawViewShell::IsSwitchPageAllowed() const
1279 {
1280 	bool bOK = true;
1281 
1282     FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
1283     if (pFormShell!=NULL && !pFormShell->PrepareClose (sal_False))
1284         bOK = false;
1285 
1286 	return bOK;
1287 }
1288 
1289 /*************************************************************************
1290 |*
1291 |* neue aktuelle Seite auswaehlen, falls sich die Seitenfolge geaendert
1292 |* hat (z. B. durch Undo)
1293 |*
1294 \************************************************************************/
1295 
ResetActualLayer()1296 void DrawViewShell::ResetActualLayer()
1297 {
1298     LayerTabBar* pLayerBar = GetLayerTabControl();
1299     if (pLayerBar != NULL)
1300     {
1301         // remember old layer cound and current layer id
1302         // this is needed when one layer is renamed to
1303         // restore current layer
1304         sal_uInt16 nOldLayerCnt = pLayerBar->GetPageCount();
1305         sal_uInt16 nOldLayerId = pLayerBar->GetCurPageId();
1306 
1307         /*************************************************************
1308             * Update fuer LayerTab
1309             *************************************************************/
1310         pLayerBar->Clear();
1311 
1312         String aName;
1313         String aActiveLayer = mpDrawView->GetActiveLayer();
1314         String aBackgroundLayer( SdResId(STR_LAYER_BCKGRND) );
1315         String aBackgroundObjLayer( SdResId(STR_LAYER_BCKGRNDOBJ) );
1316         String aLayoutLayer( SdResId(STR_LAYER_LAYOUT) );
1317         String aControlsLayer( SdResId(STR_LAYER_CONTROLS) );
1318         String aMeasureLinesLayer( SdResId(STR_LAYER_MEASURELINES) );
1319         sal_uInt16 nActiveLayer = SDRLAYER_NOTFOUND;
1320         SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
1321         sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
1322 
1323         for ( sal_uInt16 nLayer = 0; nLayer < nLayerCnt; nLayer++ )
1324         {
1325             aName = rLayerAdmin.GetLayer(nLayer)->GetName();
1326 
1327             if ( aName == aActiveLayer )
1328             {
1329                 nActiveLayer = nLayer;
1330             }
1331 
1332             if ( aName != aBackgroundLayer )
1333             {
1334                 if (meEditMode == EM_MASTERPAGE)
1335                 {
1336                     // Layer der Page nicht auf MasterPage anzeigen
1337                     if (aName != aLayoutLayer   &&
1338                         aName != aControlsLayer &&
1339                         aName != aMeasureLinesLayer)
1340                     {
1341                         pLayerBar->InsertPage(nLayer+1, aName);
1342 
1343                         TabBarPageBits nBits = 0;
1344                         SdrPageView* pPV = mpDrawView->GetSdrPageView();
1345 
1346                         if (pPV && !pPV->IsLayerVisible(aName))
1347                         {
1348                             // Unsichtbare Layer werden anders dargestellt
1349                             nBits = TPB_SPECIAL;
1350                         }
1351 
1352                         pLayerBar->SetPageBits(nLayer+1, nBits);
1353                     }
1354                 }
1355                 else
1356                 {
1357                     // Layer der MasterPage nicht auf Page anzeigen
1358                     if ( aName != aBackgroundObjLayer )
1359                     {
1360                         pLayerBar->InsertPage(nLayer+1, aName);
1361 
1362                         TabBarPageBits nBits = 0;
1363 
1364                         if (!mpDrawView->GetSdrPageView()->IsLayerVisible(aName))
1365                         {
1366                             // Unsichtbare Layer werden anders dargestellt
1367                             nBits = TPB_SPECIAL;
1368                         }
1369 
1370                         pLayerBar->SetPageBits(nLayer+1, nBits);
1371                     }
1372                 }
1373             }
1374         }
1375 
1376         if ( nActiveLayer == SDRLAYER_NOTFOUND )
1377         {
1378             if( nOldLayerCnt == pLayerBar->GetPageCount() )
1379             {
1380                 nActiveLayer = nOldLayerId - 1;
1381             }
1382             else
1383             {
1384                 nActiveLayer = ( meEditMode == EM_MASTERPAGE ) ? 2 : 0;
1385             }
1386 
1387             mpDrawView->SetActiveLayer( pLayerBar->GetPageText(nActiveLayer + 1) );
1388         }
1389 
1390         pLayerBar->SetCurPageId(nActiveLayer + 1);
1391         GetViewFrame()->GetBindings().Invalidate( SID_MODIFYLAYER );
1392         GetViewFrame()->GetBindings().Invalidate( SID_DELETE_LAYER );
1393     }
1394 }
1395 
1396 /*************************************************************************
1397 |*
1398 |* Verzoegertes Close ausfuehren
1399 |*
1400 \************************************************************************/
1401 
IMPL_LINK(DrawViewShell,CloseHdl,Timer *,pTimer)1402 IMPL_LINK( DrawViewShell, CloseHdl, Timer*, pTimer )
1403 {
1404 	pTimer->Stop();
1405 	GetViewFrame()->GetBindings().Execute( SID_CLOSEWIN );
1406 	return 0L;
1407 }
1408 
1409 /*************************************************************************
1410 |*
1411 |* AcceptDrop
1412 |*
1413 \************************************************************************/
1414 
AcceptDrop(const AcceptDropEvent & rEvt,DropTargetHelper & rTargetHelper,::sd::Window * pTargetWindow,sal_uInt16 nPage,sal_uInt16 nLayer)1415 sal_Int8 DrawViewShell::AcceptDrop (
1416     const AcceptDropEvent& rEvt,
1417     DropTargetHelper& rTargetHelper,
1418     ::sd::Window* pTargetWindow,
1419     sal_uInt16 nPage,
1420     sal_uInt16 nLayer )
1421 {
1422 	if( nPage != SDRPAGE_NOTFOUND )
1423 		nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1424 
1425 	if( SlideShow::IsRunning( GetViewShellBase() ) )
1426 		return DND_ACTION_NONE;
1427 
1428 	return mpDrawView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer );
1429 }
1430 
1431 /*************************************************************************
1432 |*
1433 |* ExecuteDrop
1434 |*
1435 \************************************************************************/
1436 
ExecuteDrop(const ExecuteDropEvent & rEvt,DropTargetHelper & rTargetHelper,::sd::Window * pTargetWindow,sal_uInt16 nPage,sal_uInt16 nLayer)1437 sal_Int8 DrawViewShell::ExecuteDrop (
1438     const ExecuteDropEvent& rEvt,
1439     DropTargetHelper& rTargetHelper,
1440     ::sd::Window* pTargetWindow,
1441     sal_uInt16 nPage,
1442     sal_uInt16 nLayer)
1443 {
1444 	if( nPage != SDRPAGE_NOTFOUND )
1445 		nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1446 
1447 	if( SlideShow::IsRunning( GetViewShellBase() ) )
1448 		return DND_ACTION_NONE;
1449 
1450     Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START));
1451     sal_Int8 nResult (mpDrawView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ));
1452     Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END));
1453 
1454     return nResult;
1455 }
1456 
1457 } // end of namespace sd
1458 
1459 #ifdef _MSC_VER
1460 #if (_MSC_VER < 1400)
1461 #pragma optimize ( "", on )
1462 #endif
1463 #endif
1464 
1465