sd/source/ui/view/drviews1.cxx

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