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