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 mbIsLayerModeActive = bIsLayerModeActive;
405
406 // Determine whether to show the master view toolbar. The master
407 // page mode has to be active and the shell must not be a handout
408 // view.
409 bool bShowMasterViewToolbar (meEditMode == EM_MASTERPAGE
410 && GetShellType() != ViewShell::ST_HANDOUT);
411
412 // If the master view toolbar is not shown we hide it before
413 // switching the edit mode.
414 if (::sd::ViewShell::mpImpl->mbIsInitialized
415 && IsMainViewShell()
416 && ! bShowMasterViewToolbar)
417 {
418 GetViewShellBase().GetToolBarManager()->ResetToolBars(ToolBarManager::TBG_MASTER_MODE);
419 }
420
421 if (meEditMode == EM_PAGE)
422 {
423 /******************************************************************
424 * PAGEMODE
425 ******************************************************************/
426
427 maTabControl.Clear();
428
429 SdPage* pPage;
430 String aPageName;
431 sal_uInt16 nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
432
433 for (sal_uInt16 i = 0; i < nPageCnt; i++)
434 {
435 pPage = GetDoc()->GetSdPage(i, mePageKind);
436 aPageName = pPage->GetName();
437 maTabControl.InsertPage(i + 1, aPageName);
438
439 if ( pPage->IsSelected() && nActualPageNum == 0 )
440 {
441 nActualPageNum = i;
442 }
443 }
444
445 maTabControl.SetCurPageId(nActualPageNum + 1);
446
447 SwitchPage(nActualPageNum);
448 }
449 else
450 {
451 /******************************************************************
452 * MASTERPAGE
453 ******************************************************************/
454 GetViewFrame()->SetChildWindow(
455 AnimationChildWindow::GetChildWindowId(), sal_False );
456
457 if (!mpActualPage)
458 {
459 // Sofern es keine mpActualPage gibt, wird die erste genommen
460 mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
461 }
462
463 maTabControl.Clear();
464 sal_uInt16 nActualMasterPageNum = 0;
465 sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
466
467 for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
468 {
469 SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
470 String aLayoutName(pMaster->GetLayoutName());
471 aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR));
472
473 maTabControl.InsertPage(i + 1, aLayoutName);
474
475 if (&(mpActualPage->TRG_GetMasterPage()) == pMaster)
476 {
477 nActualMasterPageNum = i;
478 }
479 }
480
481 maTabControl.SetCurPageId(nActualMasterPageNum + 1);
482 SwitchPage(nActualMasterPageNum);
483 }
484
485 // If the master view toolbar is to be shown we turn it on after the
486 // edit mode has been changed.
487 if (::sd::ViewShell::mpImpl->mbIsInitialized
488 && IsMainViewShell()
489 && bShowMasterViewToolbar)
490 {
491 GetViewShellBase().GetToolBarManager()->SetToolBar(
492 ToolBarManager::TBG_MASTER_MODE,
493 ToolBarManager::msMasterViewToolBar);
494 }
495
496 if ( ! mbIsLayerModeActive)
497 {
498 maTabControl.Show();
499 // Set the tab control only for draw pages. For master page
500 // this has been done already above.
501 if (meEditMode == EM_PAGE)
502 maTabControl.SetCurPageId (nActualPageNum + 1);
503 }
504 /*AF: The LayerDialogChildWindow is not used anymore (I hope).
505 if (GetViewFrame()->KnowsChildWindow(
506 LayerDialogChildWindow::GetChildWindowId()))
507 {
508 GetViewFrame()->SetChildWindow(
509 LayerDialogChildWindow::GetChildWindowId(),
510 IsLayerModeActive());
511 }
512 */
513 ResetActualLayer();
514
515 Invalidate( SID_PAGEMODE );
516 Invalidate( SID_LAYERMODE );
517 Invalidate( SID_MASTERPAGE );
518 Invalidate( SID_DELETE_MASTER_PAGE );
519 Invalidate( SID_DELETE_PAGE );
520 Invalidate( SID_SLIDE_MASTERPAGE );
521 Invalidate( SID_TITLE_MASTERPAGE );
522 Invalidate( SID_NOTES_MASTERPAGE );
523 Invalidate( SID_HANDOUT_MASTERPAGE );
524
525 SetContextName(GetSidebarContextName());
526 }
527 }
528
529
530
531
IsLayerModeActive(void) const532 bool DrawViewShell::IsLayerModeActive (void) const
533 {
534 return mbIsLayerModeActive;
535 }
536
537
538
539
540 /*************************************************************************
541 |*
542 |* Groesse des TabControls und der ModeButtons zurueckgeben
543 |*
544 \************************************************************************/
545
GetHCtrlWidth()546 long DrawViewShell::GetHCtrlWidth()
547 {
548 // return maTabControl.GetSizePixel().Width();
549 return 0;
550 }
551
552
553 /*************************************************************************
554 |*
555 |* Horizontales Lineal erzeugen
556 |*
557 \************************************************************************/
558
CreateHRuler(::sd::Window * pWin,sal_Bool bIsFirst)559 SvxRuler* DrawViewShell::CreateHRuler (::sd::Window* pWin, sal_Bool bIsFirst)
560 {
561 Ruler* pRuler;
562 WinBits aWBits;
563 sal_uInt16 nFlags = SVXRULER_SUPPORT_OBJECT;
564
565 if ( bIsFirst )
566 {
567 aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER | WB_EXTRAFIELD;
568 nFlags |= ( SVXRULER_SUPPORT_SET_NULLOFFSET |
569 SVXRULER_SUPPORT_TABS |
570 SVXRULER_SUPPORT_PARAGRAPH_MARGINS ); // Neu
571 }
572 else
573 aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER;
574
575 pRuler = new Ruler (*this, GetParentWindow(), pWin, nFlags,
576 GetViewFrame()->GetBindings(), aWBits);
577 pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
578
579 // Metric ...
580 sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
581
582 if( nMetric == 0xffff )
583 nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
584
585 pRuler->SetUnit( FieldUnit( nMetric ) );
586
587 // ... und auch DefTab am Lineal einstellen
588 pRuler->SetDefTabDist( GetDoc()->GetDefaultTabulator() ); // Neu
589
590 Fraction aUIScale(pWin->GetMapMode().GetScaleX());
591 aUIScale *= GetDoc()->GetUIScale();
592 pRuler->SetZoom(aUIScale);
593
594 return pRuler;
595 }
596
597 /*************************************************************************
598 |*
599 |* Vertikales Lineal erzeugen
600 |*
601 \************************************************************************/
602
CreateVRuler(::sd::Window * pWin)603 SvxRuler* DrawViewShell::CreateVRuler(::sd::Window* pWin)
604 {
605 Ruler* pRuler;
606 WinBits aWBits = WB_VSCROLL | WB_3DLOOK | WB_BORDER;
607 sal_uInt16 nFlags = SVXRULER_SUPPORT_OBJECT;
608
609 pRuler = new Ruler(*this, GetParentWindow(), pWin, nFlags,
610 GetViewFrame()->GetBindings(), aWBits);
611 pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit());
612
613 // #96629# Metric same as HRuler, use document setting
614 sal_uInt16 nMetric = (sal_uInt16)GetDoc()->GetUIUnit();
615
616 if( nMetric == 0xffff )
617 nMetric = (sal_uInt16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit();
618
619 pRuler->SetUnit( FieldUnit( nMetric ) );
620
621 Fraction aUIScale(pWin->GetMapMode().GetScaleY());
622 aUIScale *= GetDoc()->GetUIScale();
623 pRuler->SetZoom(aUIScale);
624
625 return pRuler;
626 }
627
628 /*************************************************************************
629 |*
630 |* Horizontales Lineal aktualisieren
631 |*
632 \************************************************************************/
633
UpdateHRuler()634 void DrawViewShell::UpdateHRuler()
635 {
636 Invalidate( SID_ATTR_LONG_LRSPACE );
637 Invalidate( SID_RULER_PAGE_POS );
638 Invalidate( SID_RULER_OBJECT );
639 Invalidate( SID_RULER_TEXT_RIGHT_TO_LEFT );
640
641 if (mpHorizontalRuler.get() != NULL)
642 mpHorizontalRuler->ForceUpdate();
643 }
644
645 /*************************************************************************
646 |*
647 |* Vertikales Lineal aktualisieren
648 |*
649 \************************************************************************/
650
UpdateVRuler()651 void DrawViewShell::UpdateVRuler()
652 {
653 Invalidate( SID_ATTR_LONG_LRSPACE );
654 Invalidate( SID_RULER_PAGE_POS );
655 Invalidate( SID_RULER_OBJECT );
656
657 if (mpVerticalRuler.get() != NULL)
658 mpVerticalRuler->ForceUpdate();
659 }
660
661 /*************************************************************************
662 |*
663 |* Metrik setzen
664 |*
665 \************************************************************************/
666
SetUIUnit(FieldUnit eUnit)667 void DrawViewShell::SetUIUnit(FieldUnit eUnit)
668 {
669 ViewShell::SetUIUnit(eUnit);
670 }
671
672 /*************************************************************************
673 |*
674 |* TabControl nach Splitteraenderung aktualisieren
675 |*
676 \************************************************************************/
677
IMPL_LINK(DrawViewShell,TabSplitHdl,TabBar *,pTab)678 IMPL_LINK( DrawViewShell, TabSplitHdl, TabBar *, pTab )
679 {
680 const long int nMax = maViewSize.Width() - maScrBarWH.Width()
681 - maTabControl.GetPosPixel().X() ;
682
683 Size aTabSize = maTabControl.GetSizePixel();
684 aTabSize.Width() = Min(pTab->GetSplitSize(), (long)(nMax-1));
685
686 maTabControl.SetSizePixel(aTabSize);
687 GetLayerTabControl()->SetSizePixel(aTabSize);
688
689 Point aPos = maTabControl.GetPosPixel();
690 aPos.X() += aTabSize.Width();
691
692 Size aScrSize(nMax - aTabSize.Width(), maScrBarWH.Height());
693 mpHorizontalScrollBar->SetPosSizePixel(aPos, aScrSize);
694
695 return 0;
696 }
697
698 /// inherited from sd::ViewShell
getCurrentPage() const699 SdPage* DrawViewShell::getCurrentPage() const
700 {
701 const sal_Int32 nPageCount = (meEditMode == EM_PAGE)?
702 GetDoc()->GetSdPageCount(mePageKind):
703 GetDoc()->GetMasterSdPageCount(mePageKind);
704
705 sal_Int32 nCurrentPage = maTabControl.GetCurPageId() - 1;
706 DBG_ASSERT( (nPageCount>0) && (nCurrentPage<nPageCount), "sd::DrawViewShell::getCurrentPage(), illegal page index!" );
707 if( (nPageCount < 0) || (nCurrentPage>=nPageCount) )
708 nCurrentPage = 0; // play safe here
709
710 if (meEditMode == EM_PAGE)
711 {
712 return GetDoc()->GetSdPage((sal_uInt16)nCurrentPage, mePageKind);
713 }
714 else // EM_MASTERPAGE
715 {
716 return GetDoc()->GetMasterSdPage((sal_uInt16)nCurrentPage, mePageKind);
717 }
718 }
719
720 /*************************************************************************
721 |*
722 |* neue aktuelle Seite auswaehlen, falls sich die Seitenfolge geaendert
723 |* hat (z. B. durch Undo)
724 |*
725 \************************************************************************/
726
ResetActualPage()727 void DrawViewShell::ResetActualPage()
728 {
729 sal_uInt16 nCurrentPage = maTabControl.GetCurPageId() - 1;
730 sal_uInt16 nPageCount = (meEditMode == EM_PAGE)?GetDoc()->GetSdPageCount(mePageKind):GetDoc()->GetMasterSdPageCount(mePageKind);
731 if (nPageCount > 0)
732 nCurrentPage = Min((sal_uInt16)(nPageCount - 1), nCurrentPage);
733 else
734 nCurrentPage = 0;
735
736 if (meEditMode == EM_PAGE)
737 {
738
739 // Update fuer TabControl
740 maTabControl.Clear();
741
742 SdPage* pPage = NULL;
743 String aPageName;
744
745 for (sal_uInt16 i = 0; i < nPageCount; i++)
746 {
747 pPage = GetDoc()->GetSdPage(i, mePageKind);
748 aPageName = pPage->GetName();
749 maTabControl.InsertPage(i + 1, aPageName);
750
751 // Selektionskennungen der Seiten korrigieren
752 GetDoc()->SetSelected(pPage, i == nCurrentPage);
753 }
754
755 maTabControl.SetCurPageId(nCurrentPage + 1);
756 }
757 else // EM_MASTERPAGE
758 {
759 SdPage* pActualPage = GetDoc()->GetMasterSdPage(nCurrentPage, mePageKind);
760 maTabControl.Clear();
761 sal_uInt16 nActualMasterPageNum = 0;
762
763 sal_uInt16 nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
764 for (sal_uInt16 i = 0; i < nMasterPageCnt; i++)
765 {
766 SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
767 String aLayoutName(pMaster->GetLayoutName());
768 aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR));
769 maTabControl.InsertPage(i + 1, aLayoutName);
770
771 if (pActualPage == pMaster)
772 nActualMasterPageNum = i;
773 }
774
775 maTabControl.SetCurPageId(nActualMasterPageNum + 1);
776 SwitchPage(nActualMasterPageNum);
777 }
778
779 GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE,
780 SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
781 }
782
783 /*************************************************************************
784 |*
785 |* Verb auf OLE-Objekt anwenden
786 |*
787 \************************************************************************/
788
789
DoVerb(long nVerb)790 ErrCode DrawViewShell::DoVerb(long nVerb)
791 {
792 if ( mpDrawView->AreObjectsMarked() )
793 {
794 const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
795
796 if (rMarkList.GetMarkCount() == 1)
797 {
798 SdrMark* pMark = rMarkList.GetMark(0);
799 SdrObject* pObj = pMark->GetMarkedSdrObj();
800
801 sal_uInt32 nInv = pObj->GetObjInventor();
802 sal_uInt16 nSdrObjKind = pObj->GetObjIdentifier();
803
804 if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
805 {
806 ActivateObject( (SdrOle2Obj*) pObj, nVerb);
807 }
808 #ifdef STARIMAGE_AVAILABLE
809 else if (nInv = SdrInventor && nSdrObjKind == OBJ_GRAF &&
810 ((SdrGrafObj*) pObj)->GetGraphicType() == GRAPHIC_BITMAP &&
811 SFX_APP()->HasFeature(SFX_FEATURE_SIMAGE))
812 {
813 SdrGrafObj* pSdrGrafObj = (SdrGrafObj*) pObj;
814 short nOK = RET_YES;
815
816 if ( pSdrGrafObj->GetFileName().Len() )
817 {
818 // Graphik ist gelinkt, soll der Link aufgehoben werden?
819 QueryBox aBox(pWindow, WB_YES_NO | WB_DEF_YES,
820 String( SdResId(STR_REMOVE_LINK) ) );
821 nOK = aBox.Execute();
822
823 if (nOK == RET_YES)
824 {
825 // Link aufheben (File- und Filtername zuruecksetzen)
826 pSdrGrafObj->SetGraphicLink(String(), String());
827 }
828 }
829
830 if (nOK == RET_YES)
831 {
832 /**************************************************************
833 * OLE-Objekt erzeugen, StarImage starten
834 * Grafik-Objekt loeschen (durch OLE-Objekt ersetzt)
835 **************************************************************/
836 //HMHmpDrView->HideMarkHdl();
837
838 SvStorageRef aStor = new SvStorage(String());
839 SvInPlaceObjectRef aNewIPObj = &((SvFactory*)SvInPlaceObject::ClassFactory())
840 ->CreateAndInit(SimModuleDummy::GetID(SOFFICE_FILEFORMAT_CURRENT), aStor);
841 if ( aNewIPObj.Is() )
842 {
843 SdrGrafObj* pTempSdrGrafObj = (SdrGrafObj*) pSdrGrafObj->Clone ();
844
845 SvEmbeddedInfoObject * pInfo;
846 pInfo = GetViewFrame()->GetObjectShell()->
847 InsertObject( aNewIPObj, String() );
848
849 String aName;
850 if (pInfo)
851 {
852 aName = pInfo->GetObjName();
853 }
854
855 Rectangle aRect = pObj->GetLogicRect();
856 SdrOle2Obj* pSdrOle2Obj = new SdrOle2Obj( aNewIPObj,
857 aName, aRect );
858
859 SdrPageView* pPV = mpDrawView->GetSdrPageView();
860
861 pPV->GetObjList()->InsertObject( pSdrOle2Obj );
862 mpDrawView->ReplaceObjectAtView( pObj, *pPV, pTempSdrGrafObj );
863
864 pSdrOle2Obj->SetLogicRect(aRect);
865 aNewIPObj->SetVisAreaSize(aRect.GetSize());
866
867 SimDLL::Update(aNewIPObj, pTempSdrGrafObj->GetGraphic(), pWindow);
868 ActivateObject(pSdrOle2Obj, SVVERB_SHOW);
869
870 Client* pClient = (Client*) GetIPClient();
871
872 if (pClient)
873 pClient->SetSdrGrafObj( pTempSdrGrafObj );
874 }
875 }
876 }
877 #endif
878 }
879 }
880
881 return 0;
882 }
883
884
885 /*************************************************************************
886 |*
887 |* OLE-Object aktivieren
888 |*
889 \************************************************************************/
890
ActivateObject(SdrOle2Obj * pObj,long nVerb)891 sal_Bool DrawViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
892 {
893 sal_Bool bActivated = sal_False;
894
895 if ( !GetDocSh()->IsUIActive() )
896 {
897 ToolBarManager::UpdateLock aLock (GetViewShellBase().GetToolBarManager());
898
899 bActivated = ViewShell::ActivateObject(pObj, nVerb);
900
901 OSL_ASSERT(GetViewShell()!=NULL);
902 Client* pClient = static_cast<Client*>(GetViewShell()->GetIPClient());
903 if (pClient)
904 pClient->SetSdrGrafObj(NULL);
905 }
906
907 return(bActivated);
908 }
909
910 /*************************************************************************
911 |*
912 |* Auf gewuenschte Seite schalten
913 |* Der Parameter nSelectedPage bezieht sich auf den aktuellen EditMode
914 |*
915 \************************************************************************/
916
LclResetFlag(bool & rbFlag)917 void LclResetFlag (bool& rbFlag) {rbFlag = false;}
918
SwitchPage(sal_uInt16 nSelectedPage)919 sal_Bool DrawViewShell::SwitchPage(sal_uInt16 nSelectedPage)
920 {
921 /** Under some circumstances there are nested calls to SwitchPage() and
922 may crash the application (activation of form controls when the
923 shell of the edit view is not on top of the shell stack, see issue
924 83888 for details.) Therefore the nested calls are ignored (they
925 would jump to the wrong page anyway.)
926 */
927 if (mbIsInSwitchPage)
928 return sal_False;
929 mbIsInSwitchPage = true;
930 comphelper::ScopeGuard aGuard (::boost::bind(LclResetFlag, ::boost::ref(mbIsInSwitchPage)));
931
932 if (GetActiveWindow()->IsInPaint())
933 {
934 // Switching the current page while a Paint is being executed is
935 // dangerous. So, post it for later execution and return.
936 maAsynchronousSwitchPageCall.Post(::boost::bind(
937 ::std::mem_fun(&DrawViewShell::SwitchPage),
938 this,
939 nSelectedPage));
940 return sal_False;
941 }
942
943 sal_Bool bOK = sal_False;
944
945 // With the current implementation of FuSlideShow there is a problem
946 // when it dsplays the show in a window: When the show is stopped it
947 // returns at one point in time SDRPAGE_NOTFOUND as current page index.
948 // Because FuSlideShow is currently being rewritten this bug is fixed
949 // here.
950 // This is not as bad a hack as it may look because making SwitchPage()
951 // more robust with respect to invalid page numbers is a good thing
952 // anyway.
953 if (nSelectedPage == SDRPAGE_NOTFOUND)
954 {
955 nSelectedPage = 0;
956 }
957 else
958 {
959 // Make sure that the given page index points to an existing page. Move
960 // the index into the valid range if necessary.
961 sal_uInt16 nPageCount = (meEditMode == EM_PAGE)
962 ? GetDoc()->GetSdPageCount(mePageKind)
963 : GetDoc()->GetMasterSdPageCount(mePageKind);
964 if (nSelectedPage >= nPageCount)
965 nSelectedPage = nPageCount-1;
966 }
967
968 if (IsSwitchPageAllowed())
969 {
970 ModifyGuard aGuard2( GetDoc() );
971
972 bOK = sal_True;
973
974 if (mpActualPage)
975 {
976 SdPage* pNewPage = NULL;
977
978 if (meEditMode == EM_MASTERPAGE)
979 {
980 if( GetDoc()->GetMasterSdPageCount(mePageKind) > nSelectedPage )
981 pNewPage = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
982
983 if( pNewPage )
984 {
985 SdrPageView* pPV = mpDrawView->GetSdrPageView();
986
987 String sPageText (pNewPage->GetLayoutName());
988 sPageText.Erase(sPageText.SearchAscii(SD_LT_SEPARATOR));
989 if (pPV
990 && pNewPage == dynamic_cast< SdPage* >( pPV->GetPage() )
991 && sPageText == maTabControl.GetPageText(nSelectedPage+1))
992 {
993 // this slide is already visible
994 return sal_True;
995 }
996 }
997 }
998 else
999 {
1000 OSL_ASSERT(mpFrameView!=NULL);
1001 mpFrameView->SetSelectedPage(nSelectedPage);
1002
1003 if (GetDoc()->GetSdPageCount(mePageKind) > nSelectedPage)
1004 pNewPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
1005
1006 if (mpActualPage == pNewPage)
1007 {
1008 SdrPageView* pPV = mpDrawView->GetSdrPageView();
1009
1010 SdPage* pCurrentPage = dynamic_cast< SdPage* >( pPV->GetPage());
1011 if (pPV
1012 && pNewPage == pCurrentPage
1013 && pNewPage->GetName() == maTabControl.GetPageText(nSelectedPage+1))
1014 {
1015 // this slide is already visible
1016 return sal_True;
1017 }
1018 }
1019 }
1020 }
1021
1022 if( mpDrawView )
1023 mpDrawView->SdrEndTextEdit();
1024
1025 mpActualPage = NULL;
1026
1027 if (meEditMode == EM_PAGE)
1028 {
1029 mpActualPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind);
1030 }
1031 else
1032 {
1033 SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
1034
1035 // Passt die selektierte Seite zur MasterPage?
1036 sal_uInt16 nPageCount = GetDoc()->GetSdPageCount(mePageKind);
1037 for (sal_uInt16 i = 0; i < nPageCount; i++)
1038 {
1039 SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
1040 if(pPage && pPage->IsSelected() && pMaster == &(pPage->TRG_GetMasterPage()))
1041 {
1042 mpActualPage = pPage;
1043 break;
1044 }
1045 }
1046
1047 if (!mpActualPage)
1048 {
1049 // Die erste Seite nehmen, welche zur MasterPage passt
1050 for (sal_uInt16 i = 0; i < nPageCount; i++)
1051 {
1052 SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind);
1053 if(pPage && pMaster == &(pPage->TRG_GetMasterPage()))
1054 {
1055 mpActualPage = pPage;
1056 break;
1057 }
1058 }
1059 }
1060 }
1061
1062 for (sal_uInt16 i = 0; i < GetDoc()->GetSdPageCount(mePageKind); i++)
1063 {
1064 // Alle Seiten deselektieren
1065 GetDoc()->SetSelected( GetDoc()->GetSdPage(i, mePageKind), sal_False);
1066 }
1067
1068 if (!mpActualPage)
1069 {
1070 // Sofern es keine mpActualPage gibt, wird die erste genommen
1071 mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
1072 }
1073
1074 // diese Seite auch selektieren (mpActualPage zeigt immer auf Zeichenseite,
1075 // nie auf eine Masterpage)
1076 GetDoc()->SetSelected(mpActualPage, sal_True);
1077
1078 rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) );
1079 if( !xSlideshow.is() || !xSlideshow->isRunning() || ( xSlideshow->getAnimationMode() != ANIMATIONMODE_SHOW ) )
1080 {
1081 // VisArea zuziehen, um ggf. Objekte zu deaktivieren
1082 // !!! only if we are not in presentation mode (#96279) !!!
1083 OSL_ASSERT (GetViewShell()!=NULL);
1084 GetViewShell()->DisconnectAllClients();
1085 VisAreaChanged(Rectangle(Point(), Size(1, 1)));
1086 }
1087
1088 if (meEditMode == EM_PAGE)
1089 {
1090 /**********************************************************************
1091 * PAGEMODE
1092 **********************************************************************/
1093 GetDoc()->SetSelected(mpActualPage, sal_True);
1094
1095 SdrPageView* pPageView = mpDrawView->GetSdrPageView();
1096
1097 if (pPageView)
1098 {
1099 mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
1100 mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
1101 mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
1102
1103 if (mePageKind == PK_NOTES)
1104 {
1105 mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
1106 }
1107 else if (mePageKind == PK_HANDOUT)
1108 {
1109 mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
1110 }
1111 else
1112 {
1113 mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
1114 }
1115 }
1116
1117 mpDrawView->HideSdrPage();
1118 mpDrawView->ShowSdrPage(mpActualPage);
1119 GetViewShellBase().GetDrawController().FireSwitchCurrentPage(mpActualPage);
1120
1121 SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
1122
1123 if (pNewPageView)
1124 {
1125 pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
1126 pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
1127 pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
1128
1129 if (mePageKind == PK_NOTES)
1130 {
1131 pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
1132 }
1133 else if (mePageKind == PK_HANDOUT)
1134 {
1135 pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
1136 }
1137 else
1138 {
1139 pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
1140 }
1141 }
1142
1143 maTabControl.SetCurPageId(nSelectedPage+1);
1144 String aPageName = mpActualPage->GetName();
1145
1146 if (maTabControl.GetPageText(nSelectedPage+1) != aPageName)
1147 {
1148 maTabControl.SetPageText(nSelectedPage+1, aPageName);
1149 }
1150 }
1151 else
1152 {
1153 /**********************************************************************
1154 * MASTERPAGE
1155 **********************************************************************/
1156 SdrPageView* pPageView = mpDrawView->GetSdrPageView();
1157
1158 if (pPageView)
1159 {
1160 mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() );
1161 mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() );
1162 mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() );
1163
1164 if (mePageKind == PK_NOTES)
1165 {
1166 mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() );
1167 }
1168 else if (mePageKind == PK_HANDOUT)
1169 {
1170 mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() );
1171 }
1172 else
1173 {
1174 mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() );
1175 }
1176 }
1177
1178 mpDrawView->HideSdrPage();
1179
1180 SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
1181
1182 if( !pMaster ) // Falls es diese Page nicht geben sollte
1183 pMaster = GetDoc()->GetMasterSdPage(0, mePageKind);
1184
1185 sal_uInt16 nNum = pMaster->GetPageNum();
1186 mpDrawView->ShowSdrPage(mpDrawView->GetModel()->GetMasterPage(nNum));
1187
1188 GetViewShellBase().GetDrawController().FireSwitchCurrentPage(pMaster);
1189
1190 SdrPageView* pNewPageView = mpDrawView->GetSdrPageView();
1191
1192 if (pNewPageView)
1193 {
1194 pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() );
1195 pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() );
1196 pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() );
1197
1198 if (mePageKind == PK_NOTES)
1199 {
1200 pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() );
1201 }
1202 else if (mePageKind == PK_HANDOUT)
1203 {
1204 pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() );
1205 }
1206 else
1207 {
1208 pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() );
1209 }
1210 }
1211
1212 String aLayoutName(pMaster->GetLayoutName());
1213 aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR));
1214
1215 maTabControl.SetCurPageId(nSelectedPage+1);
1216
1217 if (maTabControl.GetPageText(nSelectedPage+1) != aLayoutName)
1218 {
1219 maTabControl.SetPageText(nSelectedPage+1, aLayoutName);
1220 }
1221
1222 if( mePageKind == PK_HANDOUT )
1223 {
1224 // set pages for all available handout presentation objects
1225 sd::ShapeList& rShapeList = pMaster->GetPresentationShapeList();
1226 SdrObject* pObj = 0;
1227
1228 while( (pObj = rShapeList.getNextShape(pObj)) != 0 )
1229 {
1230 if( pMaster->GetPresObjKind(pObj) == PRESOBJ_HANDOUT )
1231 {
1232 // #i105146# We want no content to be displayed for PK_HANDOUT,
1233 // so just never set a page as content
1234 static_cast<SdrPageObj*>(pObj)->SetReferencedPage(0);
1235 }
1236 }
1237 }
1238 }
1239
1240 Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1241 Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1242 VisAreaChanged(aVisAreaWin);
1243 mpDrawView->VisAreaChanged(GetActiveWindow());
1244
1245 // Damit der Navigator (und das Effekte-Window) das mitbekommt (/-men)
1246 SfxBindings& rBindings = GetViewFrame()->GetBindings();
1247 rBindings.Invalidate(SID_NAVIGATOR_PAGENAME, sal_True, sal_False);
1248 rBindings.Invalidate(SID_STATUS_PAGE, sal_True, sal_False);
1249 rBindings.Invalidate(SID_DELETE_MASTER_PAGE, sal_True, sal_False);
1250 rBindings.Invalidate(SID_DELETE_PAGE, sal_True, sal_False);
1251 rBindings.Invalidate(SID_ASSIGN_LAYOUT,sal_True,sal_False);
1252 rBindings.Invalidate(SID_INSERTPAGE,sal_True,sal_False);
1253 UpdatePreview( mpActualPage );
1254
1255 mpDrawView->AdjustMarkHdl();
1256 }
1257
1258 return (bOK);
1259 }
1260
1261
1262 /*************************************************************************
1263 |*
1264 |* Pruefen, ob ein Seitenwechsel erlaubt ist
1265 |*
1266 \************************************************************************/
1267
IsSwitchPageAllowed() const1268 sal_Bool DrawViewShell::IsSwitchPageAllowed() const
1269 {
1270 bool bOK = true;
1271
1272 FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
1273 if (pFormShell!=NULL && !pFormShell->PrepareClose (sal_False))
1274 bOK = false;
1275
1276 return bOK;
1277 }
1278
1279 /*************************************************************************
1280 |*
1281 |* neue aktuelle Seite auswaehlen, falls sich die Seitenfolge geaendert
1282 |* hat (z. B. durch Undo)
1283 |*
1284 \************************************************************************/
1285
ResetActualLayer()1286 void DrawViewShell::ResetActualLayer()
1287 {
1288 LayerTabBar* pLayerBar = GetLayerTabControl();
1289 if (pLayerBar != NULL)
1290 {
1291 // remember old layer cound and current layer id
1292 // this is needed when one layer is renamed to
1293 // restore current layer
1294 sal_uInt16 nOldLayerCnt = pLayerBar->GetPageCount();
1295 sal_uInt16 nOldLayerId = pLayerBar->GetCurPageId();
1296
1297 /*************************************************************
1298 * Update fuer LayerTab
1299 *************************************************************/
1300 pLayerBar->Clear();
1301
1302 String aName;
1303 String aActiveLayer = mpDrawView->GetActiveLayer();
1304 String aBackgroundLayer( SdResId(STR_LAYER_BCKGRND) );
1305 String aBackgroundObjLayer( SdResId(STR_LAYER_BCKGRNDOBJ) );
1306 String aLayoutLayer( SdResId(STR_LAYER_LAYOUT) );
1307 String aControlsLayer( SdResId(STR_LAYER_CONTROLS) );
1308 String aMeasureLinesLayer( SdResId(STR_LAYER_MEASURELINES) );
1309 sal_uInt16 nActiveLayer = SDRLAYER_NOTFOUND;
1310 SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
1311 sal_uInt16 nLayerCnt = rLayerAdmin.GetLayerCount();
1312
1313 for ( sal_uInt16 nLayer = 0; nLayer < nLayerCnt; nLayer++ )
1314 {
1315 aName = rLayerAdmin.GetLayer(nLayer)->GetName();
1316
1317 if ( aName == aActiveLayer )
1318 {
1319 nActiveLayer = nLayer;
1320 }
1321
1322 if ( aName != aBackgroundLayer )
1323 {
1324 if (meEditMode == EM_MASTERPAGE)
1325 {
1326 // Layer der Page nicht auf MasterPage anzeigen
1327 if (aName != aLayoutLayer &&
1328 aName != aControlsLayer &&
1329 aName != aMeasureLinesLayer)
1330 {
1331 pLayerBar->InsertPage(nLayer+1, aName);
1332
1333 TabBarPageBits nBits = 0;
1334 SdrPageView* pPV = mpDrawView->GetSdrPageView();
1335
1336 if (pPV && !pPV->IsLayerVisible(aName))
1337 {
1338 // Unsichtbare Layer werden anders dargestellt
1339 nBits = TPB_SPECIAL;
1340 }
1341
1342 pLayerBar->SetPageBits(nLayer+1, nBits);
1343 }
1344 }
1345 else
1346 {
1347 // Layer der MasterPage nicht auf Page anzeigen
1348 if ( aName != aBackgroundObjLayer )
1349 {
1350 pLayerBar->InsertPage(nLayer+1, aName);
1351
1352 TabBarPageBits nBits = 0;
1353
1354 if (!mpDrawView->GetSdrPageView()->IsLayerVisible(aName))
1355 {
1356 // Unsichtbare Layer werden anders dargestellt
1357 nBits = TPB_SPECIAL;
1358 }
1359
1360 pLayerBar->SetPageBits(nLayer+1, nBits);
1361 }
1362 }
1363 }
1364 }
1365
1366 if ( nActiveLayer == SDRLAYER_NOTFOUND )
1367 {
1368 if( nOldLayerCnt == pLayerBar->GetPageCount() )
1369 {
1370 nActiveLayer = nOldLayerId - 1;
1371 }
1372 else
1373 {
1374 nActiveLayer = ( meEditMode == EM_MASTERPAGE ) ? 2 : 0;
1375 }
1376
1377 mpDrawView->SetActiveLayer( pLayerBar->GetPageText(nActiveLayer + 1) );
1378 }
1379
1380 pLayerBar->SetCurPageId(nActiveLayer + 1);
1381 GetViewFrame()->GetBindings().Invalidate( SID_MODIFYLAYER );
1382 GetViewFrame()->GetBindings().Invalidate( SID_DELETE_LAYER );
1383 }
1384 }
1385
1386 /*************************************************************************
1387 |*
1388 |* Verzoegertes Close ausfuehren
1389 |*
1390 \************************************************************************/
1391
IMPL_LINK(DrawViewShell,CloseHdl,Timer *,pTimer)1392 IMPL_LINK( DrawViewShell, CloseHdl, Timer*, pTimer )
1393 {
1394 pTimer->Stop();
1395 GetViewFrame()->GetBindings().Execute( SID_CLOSEWIN );
1396 return 0L;
1397 }
1398
1399 /*************************************************************************
1400 |*
1401 |* AcceptDrop
1402 |*
1403 \************************************************************************/
1404
AcceptDrop(const AcceptDropEvent & rEvt,DropTargetHelper & rTargetHelper,::sd::Window * pTargetWindow,sal_uInt16 nPage,sal_uInt16 nLayer)1405 sal_Int8 DrawViewShell::AcceptDrop (
1406 const AcceptDropEvent& rEvt,
1407 DropTargetHelper& rTargetHelper,
1408 ::sd::Window* pTargetWindow,
1409 sal_uInt16 nPage,
1410 sal_uInt16 nLayer )
1411 {
1412 if( nPage != SDRPAGE_NOTFOUND )
1413 nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1414
1415 if( SlideShow::IsRunning( GetViewShellBase() ) )
1416 return DND_ACTION_NONE;
1417
1418 return mpDrawView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer );
1419 }
1420
1421 /*************************************************************************
1422 |*
1423 |* ExecuteDrop
1424 |*
1425 \************************************************************************/
1426
ExecuteDrop(const ExecuteDropEvent & rEvt,DropTargetHelper & rTargetHelper,::sd::Window * pTargetWindow,sal_uInt16 nPage,sal_uInt16 nLayer)1427 sal_Int8 DrawViewShell::ExecuteDrop (
1428 const ExecuteDropEvent& rEvt,
1429 DropTargetHelper& rTargetHelper,
1430 ::sd::Window* pTargetWindow,
1431 sal_uInt16 nPage,
1432 sal_uInt16 nLayer)
1433 {
1434 if( nPage != SDRPAGE_NOTFOUND )
1435 nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1436
1437 if( SlideShow::IsRunning( GetViewShellBase() ) )
1438 return DND_ACTION_NONE;
1439
1440 Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START));
1441 sal_Int8 nResult (mpDrawView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ));
1442 Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END));
1443
1444 return nResult;
1445 }
1446
1447 } // end of namespace sd
1448
1449 #ifdef _MSC_VER
1450 #if (_MSC_VER < 1400)
1451 #pragma optimize ( "", on )
1452 #endif
1453 #endif
1454
1455