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 : #include "DrawViewShell.hxx"
21 : #include "ViewShellImplementation.hxx"
22 :
23 : #include "DrawController.hxx"
24 : #include <com/sun/star/embed/EmbedStates.hpp>
25 :
26 : #include "comphelper/anytostring.hxx"
27 : #include "comphelper/scopeguard.hxx"
28 : #include "cppuhelper/exc_hlp.hxx"
29 : #include "rtl/ref.hxx"
30 :
31 : #include <svx/svxids.hrc>
32 : #include <svx/svdpagv.hxx>
33 : #include <sfx2/viewfrm.hxx>
34 : #include <sfx2/bindings.hxx>
35 : #include <svx/svdoole2.hxx>
36 : #include <sfx2/dispatch.hxx>
37 : #include <vcl/scrbar.hxx>
38 : #include <svx/svdograf.hxx>
39 : #include <svx/svdopage.hxx>
40 : #include <vcl/msgbox.hxx>
41 : #include <sot/storage.hxx>
42 : #include <svx/fmshell.hxx>
43 : #include <svx/globl3d.hxx>
44 : #include <svx/fmglob.hxx>
45 : #include <editeng/outliner.hxx>
46 : #include <svx/dialogs.hrc>
47 :
48 : #include "view/viewoverlaymanager.hxx"
49 :
50 : #include "glob.hrc"
51 : #include "app.hrc"
52 : #include "res_bmp.hrc"
53 : #include "strings.hrc"
54 : #include "helpids.h"
55 :
56 : #include "sdmod.hxx"
57 : #include "fupoor.hxx"
58 : #include "sdresid.hxx"
59 : #include "fusel.hxx"
60 : #include "sdpage.hxx"
61 : #include "FrameView.hxx"
62 : #include "stlpool.hxx"
63 : #include "Window.hxx"
64 : #include "drawview.hxx"
65 : #include "drawdoc.hxx"
66 : #include "DrawDocShell.hxx"
67 : #include "Ruler.hxx"
68 : #include "Client.hxx"
69 : #include "slideshow.hxx"
70 : #include "optsitem.hxx"
71 : #include "fusearch.hxx"
72 : #include "Outliner.hxx"
73 : #include "AnimationChildWindow.hxx"
74 : #include "SdUnoDrawView.hxx"
75 : #include "ToolBarManager.hxx"
76 : #include "FormShellManager.hxx"
77 : #include "ViewShellBase.hxx"
78 : #include "LayerTabBar.hxx"
79 : #include "ViewShellManager.hxx"
80 : #include "ViewShellHint.hxx"
81 :
82 : #include <sfx2/request.hxx>
83 : #include <boost/bind.hpp>
84 :
85 : using namespace com::sun::star;
86 :
87 : namespace sd {
88 :
89 338 : void DrawViewShell::Activate(bool bIsMDIActivate)
90 : {
91 338 : ViewShell::Activate(bIsMDIActivate);
92 338 : }
93 :
94 0 : void DrawViewShell::UIActivating( SfxInPlaceClient* pCli )
95 : {
96 0 : ViewShell::UIActivating(pCli);
97 :
98 : // Disable own controls
99 0 : maTabControl.Disable();
100 0 : if (GetLayerTabControl() != NULL)
101 0 : GetLayerTabControl()->Disable();
102 0 : }
103 :
104 0 : void DrawViewShell::UIDeactivated( SfxInPlaceClient* pCli )
105 : {
106 : // Enable own controls
107 0 : maTabControl.Enable();
108 0 : if (GetLayerTabControl() != NULL)
109 0 : GetLayerTabControl()->Enable();
110 :
111 0 : ViewShell::UIDeactivated(pCli);
112 0 : }
113 :
114 888 : void DrawViewShell::Deactivate(bool bIsMDIActivate)
115 : {
116 : // Temporarily disable context broadcasting while the Deactivate()
117 : // call is forwarded to our base class.
118 888 : const bool bIsContextBroadcasterEnabled (SfxShell::SetContextBroadcasterEnabled(false));
119 :
120 888 : ViewShell::Deactivate(bIsMDIActivate);
121 :
122 888 : SfxShell::SetContextBroadcasterEnabled(bIsContextBroadcasterEnabled);
123 888 : }
124 :
125 : namespace
126 : {
127 : class LockUI
128 : {
129 : private:
130 : void Lock(bool bLock);
131 : SfxViewFrame *mpFrame;
132 : public:
133 0 : LockUI(SfxViewFrame *pFrame) : mpFrame(pFrame) { Lock(true); }
134 0 : ~LockUI() { Lock(false); }
135 :
136 : };
137 :
138 0 : void LockUI::Lock(bool bLock)
139 : {
140 0 : if (!mpFrame)
141 0 : return;
142 0 : mpFrame->Enable( !bLock );
143 : }
144 : }
145 :
146 : /**
147 : * Called, if state of selection of view is changed
148 : */
149 :
150 214 : void DrawViewShell::SelectionHasChanged (void)
151 : {
152 214 : Invalidate();
153 :
154 : //Update3DWindow(); // 3D-Controller
155 214 : SfxBoolItem aItem( SID_3D_STATE, true );
156 : GetViewFrame()->GetDispatcher()->Execute(
157 214 : SID_3D_STATE, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, &aItem, 0L );
158 :
159 214 : SdrOle2Obj* pOleObj = NULL;
160 :
161 214 : if ( mpDrawView->AreObjectsMarked() )
162 : {
163 2 : const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
164 :
165 2 : if (rMarkList.GetMarkCount() == 1)
166 : {
167 2 : SdrMark* pMark = rMarkList.GetMark(0);
168 2 : SdrObject* pObj = pMark->GetMarkedSdrObj();
169 :
170 2 : sal_uInt32 nInv = pObj->GetObjInventor();
171 2 : sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
172 :
173 2 : if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
174 : {
175 0 : pOleObj = (SdrOle2Obj*) pObj;
176 0 : UpdateIMapDlg( pObj );
177 : }
178 2 : else if (nSdrObjKind == OBJ_GRAF)
179 0 : UpdateIMapDlg( pObj );
180 : }
181 : }
182 :
183 214 : ViewShellBase& rBase = GetViewShellBase();
184 214 : rBase.SetVerbs( uno::Sequence< embed::VerbDescriptor >() );
185 :
186 : try
187 : {
188 214 : Client* pIPClient = static_cast<Client*>(rBase.GetIPClient());
189 214 : if ( pIPClient && pIPClient->IsObjectInPlaceActive() )
190 : {
191 : // as appropriate take ole-objects into account and deactivate
192 :
193 : // this means we recently deselected an inplace active ole object so
194 : // we need to deselect it now
195 0 : if (!pOleObj)
196 : {
197 : //#i47279# disable frame until after object has completed unload
198 0 : LockUI aUILock(GetViewFrame());
199 0 : pIPClient->DeactivateObject();
200 : //HMHmpDrView->ShowMarkHdl();
201 : }
202 : else
203 : {
204 0 : uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
205 0 : if ( xObj.is() )
206 : {
207 0 : rBase.SetVerbs( xObj->getSupportedVerbs() );
208 : }
209 : else
210 : {
211 0 : rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
212 0 : }
213 : }
214 : }
215 : else
216 : {
217 214 : if ( pOleObj )
218 : {
219 0 : uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
220 0 : if ( xObj.is() )
221 : {
222 0 : rBase.SetVerbs( xObj->getSupportedVerbs() );
223 : }
224 : else
225 : {
226 0 : rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
227 0 : }
228 : }
229 : else
230 : {
231 214 : rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
232 : }
233 : }
234 : }
235 0 : catch( ::com::sun::star::uno::Exception& )
236 : {
237 : OSL_FAIL(
238 : OString(OString("sd::DrawViewShell::SelectionHasChanged(), "
239 : "exception caught: ") +
240 : OUStringToOString(
241 : comphelper::anyToString( cppu::getCaughtException() ),
242 : RTL_TEXTENCODING_UTF8 )).getStr() );
243 : }
244 :
245 214 : if( HasCurrentFunction() )
246 : {
247 2 : GetCurrentFunction()->SelectionHasChanged();
248 : }
249 : else
250 : {
251 212 : GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this,*mpDrawView);
252 : }
253 :
254 : // Invalidate for every subshell
255 214 : GetViewShellBase().GetViewShellManager()->InvalidateAllSubShells(this);
256 :
257 214 : mpDrawView->UpdateSelectionClipboard( false );
258 :
259 214 : GetViewShellBase().GetDrawController().FireSelectionChangeListener();
260 214 : }
261 :
262 : /**
263 : * set zoom factor
264 : */
265 0 : void DrawViewShell::SetZoom( long nZoom )
266 : {
267 : // Make sure that the zoom factor will not be recalculated on
268 : // following window resizings.
269 0 : mbZoomOnPage = false;
270 0 : ViewShell::SetZoom( nZoom );
271 0 : GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
272 0 : GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
273 0 : mpViewOverlayManager->onZoomChanged();
274 0 : }
275 :
276 : /**
277 : * Set zoom rectangle for active window
278 : */
279 :
280 726 : void DrawViewShell::SetZoomRect( const Rectangle& rZoomRect )
281 : {
282 726 : ViewShell::SetZoomRect( rZoomRect );
283 726 : GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
284 726 : GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
285 726 : mpViewOverlayManager->onZoomChanged();
286 726 : }
287 :
288 : /**
289 : * PrepareClose, as appropriate end text input, so other viewshells
290 : * discover an refreshed text objext.
291 : */
292 :
293 354 : bool DrawViewShell::PrepareClose( bool bUI )
294 : {
295 354 : if ( !ViewShell::PrepareClose(bUI) )
296 0 : return false;
297 :
298 354 : if( HasCurrentFunction() )
299 : {
300 354 : sal_uInt16 nID = GetCurrentFunction()->GetSlotID();
301 354 : if (nID == SID_TEXTEDIT || nID == SID_ATTR_CHAR)
302 : {
303 0 : mpDrawView->SdrEndTextEdit();
304 : }
305 : }
306 :
307 354 : return true;
308 : }
309 :
310 : /**
311 : * Set status (enabled/disabled) of menu SfxSlots
312 : */
313 :
314 1190 : void DrawViewShell::ChangeEditMode(EditMode eEMode, bool bIsLayerModeActive)
315 : {
316 1190 : if (meEditMode != eEMode || mbIsLayerModeActive != bIsLayerModeActive)
317 : {
318 700 : ViewShellManager::UpdateLock aLock (GetViewShellBase().GetViewShellManager());
319 :
320 700 : sal_uInt16 nActualPageNum = 0;
321 :
322 700 : GetViewShellBase().GetDrawController().FireChangeEditMode (eEMode == EM_MASTERPAGE);
323 700 : GetViewShellBase().GetDrawController().FireChangeLayerMode (bIsLayerModeActive);
324 :
325 700 : if ( mpDrawView->IsTextEdit() )
326 : {
327 0 : mpDrawView->SdrEndTextEdit();
328 : }
329 :
330 700 : LayerTabBar* pLayerBar = GetLayerTabControl();
331 700 : if (pLayerBar != NULL)
332 422 : pLayerBar->EndEditMode();
333 700 : maTabControl.EndEditMode();
334 :
335 700 : if (mePageKind == PK_HANDOUT)
336 : {
337 : // at handouts only allow MasterPage
338 0 : eEMode = EM_MASTERPAGE;
339 : }
340 :
341 700 : GetViewShellBase().GetDrawController().BroadcastContextChange();
342 :
343 700 : meEditMode = eEMode;
344 :
345 700 : if(pLayerBar)
346 : {
347 : // #i87182# only switch activation mode of LayerTabBar when there is one,
348 : // else it will not get initialized with the current set of Layers as needed
349 422 : mbIsLayerModeActive = bIsLayerModeActive;
350 : }
351 :
352 : // Determine whether to show the master view toolbar. The master
353 : // page mode has to be active and the shell must not be a handout
354 : // view.
355 700 : bool bShowMasterViewToolbar (meEditMode == EM_MASTERPAGE
356 700 : && GetShellType() != ViewShell::ST_HANDOUT);
357 :
358 : // If the master view toolbar is not shown we hide it before
359 : // switching the edit mode.
360 1400 : if (::sd::ViewShell::mpImpl->mbIsInitialized
361 488 : && IsMainViewShell()
362 1188 : && ! bShowMasterViewToolbar)
363 : {
364 488 : GetViewShellBase().GetToolBarManager()->ResetToolBars(ToolBarManager::TBG_MASTER_MODE);
365 : }
366 :
367 700 : if (meEditMode == EM_PAGE)
368 : {
369 : /******************************************************************
370 : * PAGEMODE
371 : ******************************************************************/
372 :
373 700 : maTabControl.Clear();
374 :
375 : SdPage* pPage;
376 700 : sal_uInt16 nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
377 :
378 1414 : for (sal_uInt16 i = 0; i < nPageCnt; i++)
379 : {
380 714 : pPage = GetDoc()->GetSdPage(i, mePageKind);
381 714 : OUString aPageName = pPage->GetName();
382 714 : maTabControl.InsertPage(i + 1, aPageName);
383 :
384 714 : if ( pPage->IsSelected() && nActualPageNum == 0 )
385 : {
386 488 : nActualPageNum = i;
387 : }
388 714 : }
389 :
390 700 : maTabControl.SetCurPageId(nActualPageNum + 1);
391 :
392 700 : SwitchPage(nActualPageNum);
393 : }
394 : else
395 : {
396 : /******************************************************************
397 : * MASTERPAGE
398 : ******************************************************************/
399 : GetViewFrame()->SetChildWindow(
400 0 : AnimationChildWindow::GetChildWindowId(), false );
401 :
402 0 : if (!mpActualPage)
403 : {
404 : // as long as there is no mpActualPage, take first
405 0 : mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
406 : }
407 :
408 0 : maTabControl.Clear();
409 0 : sal_uInt16 nActualMasterPageNum = 0;
410 0 : sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
411 :
412 0 : for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
413 : {
414 0 : SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
415 0 : OUString aLayoutName = pMaster->GetLayoutName();
416 0 : sal_Int32 nPos = aLayoutName.indexOf(SD_LT_SEPARATOR);
417 0 : if (nPos != -1)
418 0 : aLayoutName = aLayoutName.copy(0, nPos);
419 :
420 0 : maTabControl.InsertPage(i + 1, aLayoutName);
421 :
422 0 : if (&(mpActualPage->TRG_GetMasterPage()) == pMaster)
423 : {
424 0 : nActualMasterPageNum = i;
425 : }
426 0 : }
427 :
428 0 : maTabControl.SetCurPageId(nActualMasterPageNum + 1);
429 0 : SwitchPage(nActualMasterPageNum);
430 : }
431 :
432 : // If the master view toolbar is to be shown we turn it on after the
433 : // edit mode has been changed.
434 1400 : if (::sd::ViewShell::mpImpl->mbIsInitialized
435 488 : && IsMainViewShell()
436 1188 : && bShowMasterViewToolbar)
437 : {
438 0 : GetViewShellBase().GetToolBarManager()->SetToolBar(
439 : ToolBarManager::TBG_MASTER_MODE,
440 0 : ToolBarManager::msMasterViewToolBar);
441 : }
442 :
443 700 : if ( ! mbIsLayerModeActive)
444 : {
445 278 : maTabControl.Show();
446 : // Set the tab control only for draw pages. For master page
447 : // this has been done already above.
448 278 : if (meEditMode == EM_PAGE)
449 278 : maTabControl.SetCurPageId (nActualPageNum + 1);
450 : }
451 :
452 700 : ResetActualLayer();
453 :
454 700 : Invalidate( SID_PAGEMODE );
455 700 : Invalidate( SID_LAYERMODE );
456 700 : Invalidate( SID_MASTERPAGE );
457 700 : Invalidate( SID_DELETE_MASTER_PAGE );
458 700 : Invalidate( SID_DELETE_PAGE );
459 700 : Invalidate( SID_SLIDE_MASTERPAGE );
460 700 : Invalidate( SID_TITLE_MASTERPAGE );
461 700 : Invalidate( SID_NOTES_MASTERPAGE );
462 700 : Invalidate( SID_HANDOUT_MASTERPAGE );
463 :
464 700 : SetContextName(GetSidebarContextName());
465 : }
466 1190 : }
467 :
468 : /**
469 : * Generate horizontal ruler
470 : */
471 :
472 160 : SvxRuler* DrawViewShell::CreateHRuler (::sd::Window* pWin, bool bIsFirst)
473 : {
474 : Ruler* pRuler;
475 : WinBits aWBits;
476 160 : sal_uInt16 nFlags = SVXRULER_SUPPORT_OBJECT;
477 :
478 160 : if ( bIsFirst )
479 : {
480 160 : aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER | WB_EXTRAFIELD;
481 : nFlags |= ( SVXRULER_SUPPORT_SET_NULLOFFSET |
482 : SVXRULER_SUPPORT_TABS |
483 160 : SVXRULER_SUPPORT_PARAGRAPH_MARGINS ); // Neu
484 : }
485 : else
486 0 : aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER;
487 :
488 160 : pRuler = new Ruler (*this, GetParentWindow(), pWin, nFlags,
489 160 : GetViewFrame()->GetBindings(), aWBits);
490 160 : pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
491 :
492 : // Metric ...
493 160 : sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
494 :
495 160 : if( nMetric == 0xffff )
496 0 : nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
497 :
498 160 : pRuler->SetUnit( FieldUnit( nMetric ) );
499 :
500 : // ... and also set DefTab at the ruler
501 160 : pRuler->SetDefTabDist( GetDoc()->GetDefaultTabulator() ); // new
502 :
503 160 : Fraction aUIScale(pWin->GetMapMode().GetScaleX());
504 160 : aUIScale *= GetDoc()->GetUIScale();
505 160 : pRuler->SetZoom(aUIScale);
506 :
507 160 : return pRuler;
508 : }
509 :
510 : /**
511 : * Generate vertical ruler
512 : */
513 :
514 160 : SvxRuler* DrawViewShell::CreateVRuler(::sd::Window* pWin)
515 : {
516 : Ruler* pRuler;
517 160 : WinBits aWBits = WB_VSCROLL | WB_3DLOOK | WB_BORDER;
518 160 : sal_uInt16 nFlags = SVXRULER_SUPPORT_OBJECT;
519 :
520 160 : pRuler = new Ruler(*this, GetParentWindow(), pWin, nFlags,
521 160 : GetViewFrame()->GetBindings(), aWBits);
522 160 : pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
523 :
524 : // Metric same as HRuler, use document setting
525 160 : sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
526 :
527 160 : if( nMetric == 0xffff )
528 0 : nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
529 :
530 160 : pRuler->SetUnit( FieldUnit( nMetric ) );
531 :
532 160 : Fraction aUIScale(pWin->GetMapMode().GetScaleY());
533 160 : aUIScale *= GetDoc()->GetUIScale();
534 160 : pRuler->SetZoom(aUIScale);
535 :
536 160 : return pRuler;
537 : }
538 :
539 : /**
540 : * Refresh horizontal ruler
541 : */
542 :
543 1106 : void DrawViewShell::UpdateHRuler()
544 : {
545 1106 : Invalidate( SID_ATTR_LONG_LRSPACE );
546 1106 : Invalidate( SID_RULER_PAGE_POS );
547 1106 : Invalidate( SID_RULER_OBJECT );
548 1106 : Invalidate( SID_RULER_TEXT_RIGHT_TO_LEFT );
549 :
550 1106 : if (mpHorizontalRuler.get() != NULL)
551 1106 : mpHorizontalRuler->ForceUpdate();
552 1106 : }
553 :
554 : /**
555 : * Refresh vertical ruler
556 : */
557 :
558 1102 : void DrawViewShell::UpdateVRuler()
559 : {
560 1102 : Invalidate( SID_ATTR_LONG_LRSPACE );
561 1102 : Invalidate( SID_RULER_PAGE_POS );
562 1102 : Invalidate( SID_RULER_OBJECT );
563 :
564 1102 : if (mpVerticalRuler.get() != NULL)
565 1102 : mpVerticalRuler->ForceUpdate();
566 1102 : }
567 :
568 : /**
569 : * Set metric
570 : */
571 :
572 0 : void DrawViewShell::SetUIUnit(FieldUnit eUnit)
573 : {
574 0 : ViewShell::SetUIUnit(eUnit);
575 0 : }
576 :
577 : /**
578 : * Refresh TabControl on splitter change
579 : */
580 :
581 0 : IMPL_LINK( DrawViewShell, TabSplitHdl, TabBar *, pTab )
582 : {
583 0 : const long int nMax = maViewSize.Width() - maScrBarWH.Width()
584 0 : - maTabControl.GetPosPixel().X() ;
585 :
586 0 : Size aTabSize = maTabControl.GetSizePixel();
587 0 : aTabSize.Width() = std::min(pTab->GetSplitSize(), (long)(nMax-1));
588 :
589 0 : maTabControl.SetSizePixel(aTabSize);
590 :
591 0 : if(GetLayerTabControl()) // #i87182#
592 : {
593 0 : GetLayerTabControl()->SetSizePixel(aTabSize);
594 : }
595 :
596 0 : Point aPos = maTabControl.GetPosPixel();
597 0 : aPos.X() += aTabSize.Width();
598 :
599 0 : Size aScrSize(nMax - aTabSize.Width(), maScrBarWH.Height());
600 0 : mpHorizontalScrollBar->SetPosSizePixel(aPos, aScrSize);
601 :
602 0 : return 0;
603 : }
604 :
605 : /// inherited from sd::ViewShell
606 852 : SdPage* DrawViewShell::getCurrentPage() const
607 : {
608 852 : const sal_Int32 nPageCount = (meEditMode == EM_PAGE)?
609 852 : GetDoc()->GetSdPageCount(mePageKind):
610 1704 : GetDoc()->GetMasterSdPageCount(mePageKind);
611 :
612 852 : sal_Int32 nCurrentPage = maTabControl.GetCurPageId() - 1;
613 : DBG_ASSERT( (nPageCount>0) && (nCurrentPage<nPageCount), "sd::DrawViewShell::getCurrentPage(), illegal page index!" );
614 852 : if( (nPageCount < 0) || (nCurrentPage>=nPageCount) )
615 0 : nCurrentPage = 0; // play safe here
616 :
617 852 : if (meEditMode == EM_PAGE)
618 : {
619 852 : return GetDoc()->GetSdPage((sal_uInt16)nCurrentPage, mePageKind);
620 : }
621 : else // EM_MASTERPAGE
622 : {
623 0 : return GetDoc()->GetMasterSdPage((sal_uInt16)nCurrentPage, mePageKind);
624 : }
625 : }
626 :
627 : /**
628 : * Select new refreshed page, in case of a page order change (eg. by undo)
629 : */
630 :
631 896 : void DrawViewShell::ResetActualPage()
632 : {
633 896 : if (!GetDoc())
634 896 : return;
635 :
636 896 : sal_uInt16 nCurrentPage = maTabControl.GetCurPageId() - 1;
637 896 : sal_uInt16 nPageCount = (meEditMode == EM_PAGE)?GetDoc()->GetSdPageCount(mePageKind):GetDoc()->GetMasterSdPageCount(mePageKind);
638 896 : if (nPageCount > 0)
639 896 : nCurrentPage = std::min((sal_uInt16)(nPageCount - 1), nCurrentPage);
640 : else
641 0 : nCurrentPage = 0;
642 :
643 896 : if (meEditMode == EM_PAGE)
644 : {
645 :
646 : // Update for TabControl
647 896 : maTabControl.Clear();
648 :
649 896 : SdPage* pPage = NULL;
650 :
651 2044 : for (sal_uInt16 i = 0; i < nPageCount; i++)
652 : {
653 1148 : pPage = GetDoc()->GetSdPage(i, mePageKind);
654 1148 : OUString aPageName = pPage->GetName();
655 1148 : maTabControl.InsertPage(i + 1, aPageName);
656 :
657 : // correct selection recognition of the pages
658 1148 : GetDoc()->SetSelected(pPage, i == nCurrentPage);
659 1148 : }
660 :
661 896 : maTabControl.SetCurPageId(nCurrentPage + 1);
662 : }
663 : else // EM_MASTERPAGE
664 : {
665 0 : SdPage* pActualPage = GetDoc()->GetMasterSdPage(nCurrentPage, mePageKind);
666 0 : maTabControl.Clear();
667 0 : sal_uInt16 nActualMasterPageNum = 0;
668 :
669 0 : sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
670 0 : for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
671 : {
672 0 : SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
673 0 : OUString aLayoutName = pMaster->GetLayoutName();
674 0 : sal_Int32 nPos = aLayoutName.indexOf(SD_LT_SEPARATOR);
675 0 : if (nPos != -1)
676 0 : aLayoutName = aLayoutName.copy(0, nPos);
677 0 : maTabControl.InsertPage(i + 1, aLayoutName);
678 :
679 0 : if (pActualPage == pMaster)
680 0 : nActualMasterPageNum = i;
681 0 : }
682 :
683 0 : maTabControl.SetCurPageId(nActualMasterPageNum + 1);
684 0 : SwitchPage(nActualMasterPageNum);
685 : }
686 :
687 : GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE,
688 896 : SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
689 : }
690 :
691 : /**
692 : * Apply "Verb" on OLE-object.
693 : */
694 :
695 0 : ErrCode DrawViewShell::DoVerb(long nVerb)
696 : {
697 0 : if ( mpDrawView->AreObjectsMarked() )
698 : {
699 0 : const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
700 :
701 0 : if (rMarkList.GetMarkCount() == 1)
702 : {
703 0 : SdrMark* pMark = rMarkList.GetMark(0);
704 0 : SdrObject* pObj = pMark->GetMarkedSdrObj();
705 :
706 0 : sal_uInt32 nInv = pObj->GetObjInventor();
707 0 : sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
708 :
709 0 : if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
710 : {
711 0 : ActivateObject( (SdrOle2Obj*) pObj, nVerb);
712 : }
713 : }
714 : }
715 :
716 0 : return 0;
717 : }
718 :
719 : /**
720 : * Activate OLE-object
721 : */
722 :
723 0 : bool DrawViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
724 : {
725 0 : bool bActivated = false;
726 :
727 0 : if ( !GetDocSh()->IsUIActive() )
728 : {
729 0 : ToolBarManager::UpdateLock aLock (GetViewShellBase().GetToolBarManager());
730 :
731 0 : bActivated = ViewShell::ActivateObject(pObj, nVerb);
732 :
733 : OSL_ASSERT(GetViewShell()!=NULL);
734 0 : Client* pClient = static_cast<Client*>(GetViewShell()->GetIPClient());
735 0 : if (pClient)
736 0 : pClient->SetSdrGrafObj(NULL);
737 : }
738 :
739 0 : return(bActivated);
740 : }
741 :
742 : /**
743 : * Switch to desired page.
744 : * nSelectPage refers to the current EditMode
745 : */
746 :
747 1627 : void LclResetFlag (bool& rbFlag) {rbFlag = false;}
748 :
749 1627 : bool DrawViewShell::SwitchPage(sal_uInt16 nSelectedPage)
750 : {
751 : /** Under some circumstances there are nested calls to SwitchPage() and
752 : may crash the application (activation of form controls when the
753 : shell of the edit view is not on top of the shell stack, see issue
754 : 83888 for details.) Therefore the nested calls are ignored (they
755 : would jump to the wrong page anyway.)
756 : */
757 1627 : if (mbIsInSwitchPage)
758 0 : return false;
759 1627 : mbIsInSwitchPage = true;
760 1627 : comphelper::ScopeGuard aGuard (::boost::bind(LclResetFlag, ::boost::ref(mbIsInSwitchPage)));
761 :
762 1627 : if (GetActiveWindow()->IsInPaint())
763 : {
764 : // Switching the current page while a Paint is being executed is
765 : // dangerous. So, post it for later execution and return.
766 : maAsynchronousSwitchPageCall.Post(::boost::bind(
767 : ::std::mem_fun(&DrawViewShell::SwitchPage),
768 : this,
769 0 : nSelectedPage));
770 0 : return false;
771 : }
772 :
773 1627 : bool bOK = false;
774 :
775 : // With the current implementation of FuSlideShow there is a problem
776 : // when it dsplays the show in a window: When the show is stopped it
777 : // returns at one point in time SDRPAGE_NOTFOUND as current page index.
778 : // Because FuSlideShow is currently being rewritten this bug is fixed
779 : // here.
780 : // This is not as bad a hack as it may look because making SwitchPage()
781 : // more robust with respect to invalid page numbers is a good thing
782 : // anyway.
783 1627 : if (nSelectedPage == SDRPAGE_NOTFOUND)
784 : {
785 0 : nSelectedPage = 0;
786 : }
787 : else
788 : {
789 : // Make sure that the given page index points to an existing page. Move
790 : // the index into the valid range if necessary.
791 1627 : sal_uInt16 nPageCount = (meEditMode == EM_PAGE)
792 1627 : ? GetDoc()->GetSdPageCount(mePageKind)
793 3254 : : GetDoc()->GetMasterSdPageCount(mePageKind);
794 1627 : if (nSelectedPage >= nPageCount)
795 0 : nSelectedPage = nPageCount-1;
796 : }
797 :
798 1627 : if (IsSwitchPageAllowed())
799 : {
800 1627 : ModifyGuard aGuard2( GetDoc() );
801 :
802 1627 : bOK = true;
803 :
804 1627 : if (mpActualPage)
805 : {
806 1415 : SdPage* pNewPage = NULL;
807 :
808 1415 : if (meEditMode == EM_MASTERPAGE)
809 : {
810 0 : if( GetDoc()->GetMasterSdPageCount(mePageKind) > nSelectedPage )
811 0 : pNewPage = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
812 :
813 0 : if( pNewPage )
814 : {
815 0 : SdrPageView* pPV = mpDrawView->GetSdrPageView();
816 0 : OUString sPageText(pNewPage->GetLayoutName());
817 0 : sal_Int32 nPos = sPageText.indexOf(SD_LT_SEPARATOR);
818 0 : if (nPos != -1)
819 0 : sPageText = sPageText.copy(0, nPos);
820 0 : if (pPV
821 0 : && pNewPage == dynamic_cast< SdPage* >( pPV->GetPage() )
822 0 : && sPageText == maTabControl.GetPageText(nSelectedPage+1))
823 : {
824 : // this slide is already visible
825 0 : return true;
826 0 : }
827 : }
828 : }
829 : else
830 : {
831 : OSL_ASSERT(mpFrameView!=NULL);
832 1415 : mpFrameView->SetSelectedPage(nSelectedPage);
833 :
834 1415 : if (GetDoc()->GetSdPageCount(mePageKind) > nSelectedPage)
835 1415 : pNewPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
836 :
837 1415 : if (mpActualPage == pNewPage)
838 : {
839 1407 : SdrPageView* pPV = mpDrawView->GetSdrPageView();
840 :
841 1407 : SdPage* pCurrentPage = pPV ? dynamic_cast<SdPage*>(pPV->GetPage()) : NULL;
842 2814 : if (pCurrentPage
843 1407 : && pNewPage == pCurrentPage
844 5628 : && maTabControl.GetPageText(nSelectedPage+1).equals(pNewPage->GetName()))
845 : {
846 : // this slide is already visible
847 1407 : return true;
848 : }
849 : }
850 : }
851 : }
852 :
853 220 : mpDrawView->SdrEndTextEdit();
854 :
855 220 : mpActualPage = NULL;
856 :
857 220 : if (meEditMode == EM_PAGE)
858 : {
859 220 : mpActualPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
860 : }
861 : else
862 : {
863 0 : SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
864 :
865 : // does the selected page fit to the masterpage?
866 0 : sal_uInt16 nPageCount = GetDoc()->GetSdPageCount(mePageKind);
867 0 : for (sal_uInt16 i = 0; i < nPageCount; i++)
868 : {
869 0 : SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
870 0 : if(pPage && pPage->IsSelected() && pMaster == &(pPage->TRG_GetMasterPage()))
871 : {
872 0 : mpActualPage = pPage;
873 0 : break;
874 : }
875 : }
876 :
877 0 : if (!mpActualPage)
878 : {
879 : // take the first page, that fits to the masterpage
880 0 : for (sal_uInt16 i = 0; i < nPageCount; i++)
881 : {
882 0 : SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
883 0 : if(pPage && pMaster == &(pPage->TRG_GetMasterPage()))
884 : {
885 0 : mpActualPage = pPage;
886 0 : break;
887 : }
888 : }
889 : }
890 : }
891 :
892 454 : for (sal_uInt16 i = 0; i < GetDoc()->GetSdPageCount(mePageKind); i++)
893 : {
894 : // deselect all pages
895 234 : GetDoc()->SetSelected( GetDoc()->GetSdPage(i, mePageKind), false);
896 : }
897 :
898 220 : if (!mpActualPage)
899 : {
900 : // as far as there is no mpActualPage, take the first
901 0 : mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
902 : }
903 :
904 : // also select this page (mpActualPage always points at a drawing page,
905 : // never at a masterpage)
906 220 : GetDoc()->SetSelected(mpActualPage, true);
907 :
908 440 : rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) );
909 220 : if( !xSlideshow.is() || !xSlideshow->isRunning() || ( xSlideshow->getAnimationMode() != ANIMATIONMODE_SHOW ) )
910 : {
911 : // tighten VisArea, to possibly deactivate objects
912 : // !!! only if we are not in presentation mode (#96279) !!!
913 : OSL_ASSERT (GetViewShell()!=NULL);
914 220 : GetViewShell()->DisconnectAllClients();
915 220 : VisAreaChanged(Rectangle(Point(), Size(1, 1)));
916 : }
917 :
918 220 : if (meEditMode == EM_PAGE)
919 : {
920 : /**********************************************************************
921 : * PAGEMODE
922 : **********************************************************************/
923 220 : GetDoc()->SetSelected(mpActualPage, true);
924 :
925 220 : SdrPageView* pPageView = mpDrawView->GetSdrPageView();
926 :
927 220 : if (pPageView)
928 : {
929 8 : mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
930 8 : mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
931 8 : mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
932 :
933 8 : if (mePageKind == PK_NOTES)
934 : {
935 0 : mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
936 : }
937 8 : else if (mePageKind == PK_HANDOUT)
938 : {
939 0 : mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
940 : }
941 : else
942 : {
943 8 : mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
944 : }
945 : }
946 :
947 220 : mpDrawView->HideSdrPage();
948 220 : mpDrawView->ShowSdrPage(mpActualPage);
949 220 : GetViewShellBase().GetDrawController().FireSwitchCurrentPage(mpActualPage);
950 :
951 220 : SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
952 :
953 220 : if (pNewPageView)
954 : {
955 220 : pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
956 220 : pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
957 220 : pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
958 :
959 220 : if (mePageKind == PK_NOTES)
960 : {
961 0 : pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
962 : }
963 220 : else if (mePageKind == PK_HANDOUT)
964 : {
965 0 : pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
966 : }
967 : else
968 : {
969 220 : pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
970 : }
971 : }
972 :
973 220 : maTabControl.SetCurPageId(nSelectedPage+1);
974 220 : OUString aPageName = mpActualPage->GetName();
975 :
976 220 : if (maTabControl.GetPageText(nSelectedPage+1) != aPageName)
977 : {
978 0 : maTabControl.SetPageText(nSelectedPage+1, aPageName);
979 220 : }
980 : }
981 : else
982 : {
983 : /**********************************************************************
984 : * MASTERPAGE
985 : **********************************************************************/
986 0 : SdrPageView* pPageView = mpDrawView->GetSdrPageView();
987 :
988 0 : if (pPageView)
989 : {
990 0 : mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
991 0 : mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
992 0 : mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
993 :
994 0 : if (mePageKind == PK_NOTES)
995 : {
996 0 : mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
997 : }
998 0 : else if (mePageKind == PK_HANDOUT)
999 : {
1000 0 : mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
1001 : }
1002 : else
1003 : {
1004 0 : mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
1005 : }
1006 : }
1007 :
1008 0 : mpDrawView->HideSdrPage();
1009 :
1010 0 : SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
1011 :
1012 0 : if( !pMaster ) // if this page should not exist
1013 0 : pMaster = GetDoc()->GetMasterSdPage(0, mePageKind);
1014 :
1015 0 : sal_uInt16 nNum = pMaster->GetPageNum();
1016 0 : mpDrawView->ShowSdrPage(mpDrawView->GetModel()->GetMasterPage(nNum));
1017 :
1018 0 : GetViewShellBase().GetDrawController().FireSwitchCurrentPage(pMaster);
1019 :
1020 0 : SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
1021 :
1022 0 : if (pNewPageView)
1023 : {
1024 0 : pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
1025 0 : pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
1026 0 : pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
1027 :
1028 0 : if (mePageKind == PK_NOTES)
1029 : {
1030 0 : pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
1031 : }
1032 0 : else if (mePageKind == PK_HANDOUT)
1033 : {
1034 0 : pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
1035 : }
1036 : else
1037 : {
1038 0 : pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
1039 : }
1040 : }
1041 :
1042 0 : OUString aLayoutName(pMaster->GetLayoutName());
1043 0 : sal_Int32 nPos = aLayoutName.indexOf(SD_LT_SEPARATOR);
1044 0 : if (nPos != -1)
1045 0 : aLayoutName = aLayoutName.copy(0, nPos);
1046 :
1047 0 : maTabControl.SetCurPageId(nSelectedPage+1);
1048 :
1049 0 : if (maTabControl.GetPageText(nSelectedPage+1) != aLayoutName)
1050 : {
1051 0 : maTabControl.SetPageText(nSelectedPage+1, aLayoutName);
1052 : }
1053 :
1054 0 : if( mePageKind == PK_HANDOUT )
1055 : {
1056 : // set pages for all available handout presentation objects
1057 0 : sd::ShapeList& rShapeList = pMaster->GetPresentationShapeList();
1058 0 : SdrObject* pObj = 0;
1059 0 : rShapeList.seekShape(0);
1060 :
1061 0 : while( (pObj = rShapeList.getNextShape()) )
1062 : {
1063 0 : if( pMaster->GetPresObjKind(pObj) == PRESOBJ_HANDOUT )
1064 : {
1065 : // #i105146# We want no content to be displayed for PK_HANDOUT,
1066 : // so just never set a page as content
1067 0 : static_cast<SdrPageObj*>(pObj)->SetReferencedPage(0);
1068 : }
1069 : }
1070 0 : }
1071 : }
1072 :
1073 220 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1074 220 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1075 220 : VisAreaChanged(aVisAreaWin);
1076 220 : mpDrawView->VisAreaChanged(GetActiveWindow());
1077 :
1078 : // so navigator (and effect window) notice that
1079 220 : SfxBindings& rBindings = GetViewFrame()->GetBindings();
1080 220 : rBindings.Invalidate(SID_NAVIGATOR_PAGENAME, true, false);
1081 220 : rBindings.Invalidate(SID_STATUS_PAGE, true, false);
1082 220 : rBindings.Invalidate(SID_DELETE_MASTER_PAGE, true, false);
1083 220 : rBindings.Invalidate(SID_DELETE_PAGE, true, false);
1084 220 : rBindings.Invalidate(SID_ASSIGN_LAYOUT, true, false);
1085 220 : rBindings.Invalidate(SID_INSERTPAGE, true, false);
1086 220 : UpdatePreview( mpActualPage );
1087 :
1088 440 : mpDrawView->AdjustMarkHdl();
1089 : }
1090 :
1091 220 : return (bOK);
1092 : }
1093 :
1094 : /**
1095 : * Check if page change is allowed
1096 : */
1097 :
1098 1627 : bool DrawViewShell::IsSwitchPageAllowed() const
1099 : {
1100 1627 : bool bOK = true;
1101 :
1102 1627 : FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
1103 1627 : if (pFormShell != NULL && !pFormShell->PrepareClose(false))
1104 0 : bOK = false;
1105 :
1106 1627 : return bOK;
1107 : }
1108 :
1109 : /**
1110 : * Select new refreshed page, in case of a page order change (eg. by undo)
1111 : */
1112 :
1113 916 : void DrawViewShell::ResetActualLayer()
1114 : {
1115 916 : LayerTabBar* pLayerBar = GetLayerTabControl();
1116 916 : if (pLayerBar != NULL)
1117 : {
1118 : // remember old layer cound and current layer id
1119 : // this is needed when one layer is renamed to
1120 : // restore current layer
1121 586 : sal_uInt16 nOldLayerCnt = pLayerBar->GetPageCount();
1122 586 : sal_uInt16 nOldLayerId = pLayerBar->GetCurPageId();
1123 :
1124 : /**
1125 : * Update for LayerTab
1126 : */
1127 586 : pLayerBar->Clear();
1128 :
1129 586 : OUString aName;
1130 1172 : OUString aActiveLayer = mpDrawView->GetActiveLayer();
1131 1172 : OUString aBackgroundLayer = SD_RESSTR(STR_LAYER_BCKGRND);
1132 1172 : OUString aBackgroundObjLayer = SD_RESSTR(STR_LAYER_BCKGRNDOBJ);
1133 1172 : OUString aLayoutLayer = SD_RESSTR(STR_LAYER_LAYOUT);
1134 1172 : OUString aControlsLayer = SD_RESSTR(STR_LAYER_CONTROLS);
1135 1172 : OUString aMeasureLinesLayer = SD_RESSTR(STR_LAYER_MEASURELINES);
1136 586 : sal_uInt16 nActiveLayer = SDRLAYER_NOTFOUND;
1137 586 : SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
1138 586 : sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
1139 :
1140 3518 : for ( sal_uInt16 nLayer = 0; nLayer < nLayerCnt; nLayer++ )
1141 : {
1142 2932 : aName = rLayerAdmin.GetLayer(nLayer)->GetName();
1143 :
1144 2932 : if ( aName == aActiveLayer )
1145 : {
1146 586 : nActiveLayer = nLayer;
1147 : }
1148 :
1149 2932 : if ( aName != aBackgroundLayer )
1150 : {
1151 2346 : if (meEditMode == EM_MASTERPAGE)
1152 : {
1153 : // don't show page layer onto the masterpage
1154 0 : if (aName != aLayoutLayer &&
1155 0 : aName != aControlsLayer &&
1156 0 : aName != aMeasureLinesLayer)
1157 : {
1158 0 : pLayerBar->InsertPage(nLayer+1, aName);
1159 :
1160 0 : TabBarPageBits nBits = 0;
1161 0 : SdrPageView* pPV = mpDrawView->GetSdrPageView();
1162 :
1163 0 : if (pPV && !pPV->IsLayerVisible(aName))
1164 : {
1165 : // invisible layers are displayed differently
1166 0 : nBits = TPB_SPECIAL;
1167 : }
1168 :
1169 0 : pLayerBar->SetPageBits(nLayer+1, nBits);
1170 : }
1171 : }
1172 : else
1173 : {
1174 : // don't show masterpage layer onto the page
1175 2346 : if ( aName != aBackgroundObjLayer )
1176 : {
1177 1760 : pLayerBar->InsertPage(nLayer+1, aName);
1178 :
1179 1760 : TabBarPageBits nBits = 0;
1180 :
1181 1760 : if (!mpDrawView->GetSdrPageView()->IsLayerVisible(aName))
1182 : {
1183 : // invisible layers are displayed differently
1184 0 : nBits = TPB_SPECIAL;
1185 : }
1186 :
1187 1760 : pLayerBar->SetPageBits(nLayer+1, nBits);
1188 : }
1189 : }
1190 : }
1191 : }
1192 :
1193 586 : if ( nActiveLayer == SDRLAYER_NOTFOUND )
1194 : {
1195 0 : if( nOldLayerCnt == pLayerBar->GetPageCount() )
1196 : {
1197 0 : nActiveLayer = nOldLayerId - 1;
1198 : }
1199 : else
1200 : {
1201 0 : nActiveLayer = ( meEditMode == EM_MASTERPAGE ) ? 2 : 0;
1202 : }
1203 :
1204 0 : mpDrawView->SetActiveLayer( pLayerBar->GetPageText(nActiveLayer + 1) );
1205 : }
1206 :
1207 586 : pLayerBar->SetCurPageId(nActiveLayer + 1);
1208 586 : GetViewFrame()->GetBindings().Invalidate( SID_MODIFYLAYER );
1209 1172 : GetViewFrame()->GetBindings().Invalidate( SID_DELETE_LAYER );
1210 : }
1211 916 : }
1212 :
1213 : /**
1214 : * AcceptDrop
1215 : */
1216 :
1217 0 : sal_Int8 DrawViewShell::AcceptDrop (
1218 : const AcceptDropEvent& rEvt,
1219 : DropTargetHelper& rTargetHelper,
1220 : ::sd::Window* pTargetWindow,
1221 : sal_uInt16 nPage,
1222 : sal_uInt16 nLayer )
1223 : {
1224 0 : if( nPage != SDRPAGE_NOTFOUND )
1225 0 : nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1226 :
1227 0 : if( SlideShow::IsRunning( GetViewShellBase() ) )
1228 0 : return DND_ACTION_NONE;
1229 :
1230 0 : return mpDrawView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer );
1231 : }
1232 :
1233 : /**
1234 : * ExecuteDrop
1235 : */
1236 :
1237 0 : sal_Int8 DrawViewShell::ExecuteDrop (
1238 : const ExecuteDropEvent& rEvt,
1239 : DropTargetHelper& rTargetHelper,
1240 : ::sd::Window* pTargetWindow,
1241 : sal_uInt16 nPage,
1242 : sal_uInt16 nLayer)
1243 : {
1244 0 : if( nPage != SDRPAGE_NOTFOUND )
1245 0 : nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1246 :
1247 0 : if( SlideShow::IsRunning( GetViewShellBase() ) )
1248 0 : return DND_ACTION_NONE;
1249 :
1250 0 : Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START));
1251 0 : sal_Int8 nResult (mpDrawView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ));
1252 0 : Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END));
1253 :
1254 0 : return nResult;
1255 : }
1256 :
1257 114 : } // end of namespace sd
1258 :
1259 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
