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