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     Invalidate();
 169
 170     //Update3DWindow(); // 3D-Controller
 171     SfxBoolItem aItem( SID_3D_STATE, TRUE );
 172     GetViewFrame()->GetDispatcher()->Execute(
 173         SID_3D_STATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
 174
 175     SdrOle2Obj* pOleObj = NULL;
 176     SdrGrafObj* pGrafObj = NULL;
 177
 178     if ( mpDrawView->AreObjectsMarked() )
 179     {
 180         const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
 181
 182         if (rMarkList.GetMarkCount() == 1)
 183         {
 184             SdrMark* pMark = rMarkList.GetMark(0);
 185             SdrObject* pObj = pMark->GetMarkedSdrObj();
 186
 187             UINT32 nInv = pObj->GetObjInventor();
 188             UINT16 nSdrObjKind = pObj->GetObjIdentifier();
 189
 190             if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2)
 191             {
 192                 pOleObj = (SdrOle2Obj*) pObj;
 193                 UpdateIMapDlg( pObj );
 194             }
 195             else if (nSdrObjKind == OBJ_GRAF)
 196             {
 197                 pGrafObj = (SdrGrafObj*) pObj;
 198                 UpdateIMapDlg( pObj );
 199             }
 200         }
 201     }
 202
 203     ViewShellBase& rBase = GetViewShellBase();
 204     rBase.SetVerbs(0);
 205
 206     try
 207     {
 208         Client* pIPClient = static_cast<Client*>(rBase.GetIPClient());
 209         if ( pIPClient && pIPClient->IsObjectInPlaceActive() )
 210         {
 211             /**********************************************************************
 212             * Ggf. OLE-Objekt beruecksichtigen und deaktivieren
 213             **********************************************************************/
 214
 215             // this means we recently deselected an inplace active ole object so
 216             // we need to deselect it now
 217             if (!pOleObj)
 218             {
 219                 pIPClient->DeactivateObject();
 220                 //HMHmpDrView->ShowMarkHdl();
 221             }
 222             else
 223             {
 224                 uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
 225                 if ( xObj.is() )
 226                 {
 227                     rBase.SetVerbs( xObj->getSupportedVerbs() );
 228                 }
 229                 else
 230                 {
 231                     rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
 232                 }
 233             }
 234         }
 235         else
 236         {
 237             if ( pOleObj )
 238             {
 239                 uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
 240                 if ( xObj.is() )
 241                 {
 242                     rBase.SetVerbs( xObj->getSupportedVerbs() );
 243                 }
 244                 else
 245                 {
 246                     rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
 247                 }
 248             }
 249             else
 250             {
 251                 rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() );
 252             }
 253         }
 254     }
 255     catch( ::com::sun::star::uno::Exception& e )
 256     {
 257         (void)e;
 258         DBG_ERROR(
 259             (rtl::OString("sd::DrawViewShell::SelectionHasChanged(), "
 260                     "exception caught: ") +
 261             rtl::OUStringToOString(
 262                 comphelper::anyToString( cppu::getCaughtException() ),
 263                 RTL_TEXTENCODING_UTF8 )).getStr() );
 264     }
 265
 266     if( HasCurrentFunction() )
 267     {
 268         GetCurrentFunction()->SelectionHasChanged();
 269     }
 270     else
 271     {
 272         GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this,*mpDrawView);
 273     }
 274
 275     // #96124# Invalidate for every subshell
 276     GetViewShellBase().GetViewShellManager()->InvalidateAllSubShells(this);
 277
 278     mpDrawView->UpdateSelectionClipboard( FALSE );
 279
 280     GetViewShellBase().GetDrawController().FireSelectionChangeListener();
 281 }
 282
 283
 284 /*************************************************************************
 285 |*
 286 |* Zoomfaktor setzen
 287 |*
 288 \************************************************************************/
 289
 290 void DrawViewShell::SetZoom( long nZoom )
 291 {
 292     // Make sure that the zoom factor will not be recalculated on
 293     // following window resizings.
 294     mbZoomOnPage = FALSE;
 295     ViewShell::SetZoom( nZoom );
 296     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
 297     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
 298 }
 299
 300 /*************************************************************************
 301 |*
 302 |* Zoomrechteck fuer aktives Fenster einstellen
 303 |*
 304 \************************************************************************/
 305
 306 void DrawViewShell::SetZoomRect( const Rectangle& rZoomRect )
 307 {
 308     ViewShell::SetZoomRect( rZoomRect );
 309     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
 310     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
 311 }
 312
 313 /*************************************************************************
 314 |*
 315 |* PrepareClose, ggfs. Texteingabe beenden, damit andere Viewshells ein
 316 |* aktualisiertes Textobjekt vorfinden
 317 |*
 318 \************************************************************************/
 319
 320 USHORT DrawViewShell::PrepareClose( BOOL bUI, BOOL bForBrowsing )
 321 {
 322     if ( ViewShell::PrepareClose(bUI, bForBrowsing) != TRUE )
 323         return FALSE;
 324
 325     BOOL                        bRet = TRUE;
 326
 327     if( bRet && HasCurrentFunction() )
 328     {
 329         USHORT nID = GetCurrentFunction()->GetSlotID();
 330         if (nID == SID_TEXTEDIT || nID == SID_ATTR_CHAR)
 331         {
 332             mpDrawView->SdrEndTextEdit();
 333         }
 334     }
 335     else if( !bRet )
 336     {
 337         maCloseTimer.SetTimeoutHdl( LINK( this, DrawViewShell, CloseHdl ) );
 338         maCloseTimer.SetTimeout( 20 );
 339         maCloseTimer.Start();
 340     }
 341
 342     return bRet;
 343 }
 344
 345 /*************************************************************************
 346 |*
 347 |* Status (Enabled/Disabled) von Menue-SfxSlots setzen
 348 |*
 349 \************************************************************************/
 350
 351 void DrawViewShell::ChangeEditMode(EditMode eEMode, bool bIsLayerModeActive)
 352 {
 353     if (meEditMode != eEMode || mbIsLayerModeActive != bIsLayerModeActive)
 354     {
 355         ViewShellManager::UpdateLock aLock (GetViewShellBase().GetViewShellManager());
 356
 357         USHORT nActualPageNum = 0;
 358
 359         GetViewShellBase().GetDrawController().FireChangeEditMode (eEMode == EM_MASTERPAGE);
 360         GetViewShellBase().GetDrawController().FireChangeLayerMode (bIsLayerModeActive);
 361
 362         if ( mpDrawView->IsTextEdit() )
 363         {
 364             mpDrawView->SdrEndTextEdit();
 365         }
 366
 367         LayerTabBar* pLayerBar = GetLayerTabControl();
 368         if (pLayerBar != NULL)
 369             pLayerBar->EndEditMode();
 370         maTabControl.EndEditMode();
 371
 372         if (mePageKind == PK_HANDOUT)
 373         {
 374             // Bei Handzetteln nur MasterPage zulassen
 375             eEMode = EM_MASTERPAGE;
 376         }
 377
 378         meEditMode = eEMode;
 379         mbIsLayerModeActive = bIsLayerModeActive;
 380
 381         // Determine whether to show the master view toolbar.  The master
 382         // page mode has to be active and the shell must not be a handout
 383         // view.
 384         bool bShowMasterViewToolbar (meEditMode == EM_MASTERPAGE
 385              && GetShellType() != ViewShell::ST_HANDOUT);
 386
 387         // If the master view toolbar is not shown we hide it before
 388         // switching the edit mode.
 389         if (::sd::ViewShell::mpImpl->mbIsInitialized
 390             && IsMainViewShell()
 391             && ! bShowMasterViewToolbar)
 392         {
 393             GetViewShellBase().GetToolBarManager()->ResetToolBars(ToolBarManager::TBG_MASTER_MODE);
 394         }
 395
 396         if (meEditMode == EM_PAGE)
 397         {
 398             /******************************************************************
 399             * PAGEMODE
 400             ******************************************************************/
 401
 402             maTabControl.Clear();
 403
 404             SdPage* pPage;
 405             String aPageName;
 406             USHORT nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
 407
 408             for (USHORT i = 0; i < nPageCnt; i++)
 409             {
 410                 pPage = GetDoc()->GetSdPage(i, mePageKind);
 411                 aPageName = pPage->GetName();
 412                 maTabControl.InsertPage(i + 1, aPageName);
 413
 414                 if ( pPage->IsSelected() && nActualPageNum == 0 )
 415                 {
 416                     nActualPageNum = i;
 417                 }
 418             }
 419
 420             maTabControl.SetCurPageId(nActualPageNum + 1);
 421
 422             SwitchPage(nActualPageNum);
 423         }
 424         else
 425         {
 426             /******************************************************************
 427             * MASTERPAGE
 428             ******************************************************************/
 429             GetViewFrame()->SetChildWindow(
 430                 AnimationChildWindow::GetChildWindowId(), FALSE );
 431
 432             if (!mpActualPage)
 433             {
 434                 // Sofern es keine mpActualPage gibt, wird die erste genommen
 435                 mpActualPage = GetDoc()->GetSdPage(0, mePageKind);
 436             }
 437
 438             maTabControl.Clear();
 439             USHORT nActualMasterPageNum = 0;
 440             USHORT nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
 441
 442             for (USHORT i = 0; i < nMasterPageCnt; i++)
 443             {
 444                 SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind);
 445                 String aLayoutName(pMaster->GetLayoutName());
 446                 aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR));
 447
 448                 maTabControl.InsertPage(i + 1, aLayoutName);
 449
 450                 if (&(mpActualPage->TRG_GetMasterPage()) == pMaster)
 451                 {
 452                     nActualMasterPageNum = i;
 453                 }
 454             }
 455
 456             maTabControl.SetCurPageId(nActualMasterPageNum + 1);
 457             SwitchPage(nActualMasterPageNum);
 458         }
 459
 460         // If the master view toolbar is to be shown we turn it on after the
 461         // edit mode has been changed.
 462         if (::sd::ViewShell::mpImpl->mbIsInitialized
 463             && IsMainViewShell()
 464             && bShowMasterViewToolbar)
 465         {
 466             GetViewShellBase().GetToolBarManager()->SetToolBar(
 467                 ToolBarManager::TBG_MASTER_MODE,
 468                 ToolBarManager::msMasterViewToolBar);
 469         }
 470
 471         if ( ! mbIsLayerModeActive)
 472         {
 473             maTabControl.Show();
 474             // Set the tab control only for draw pages.  For master page
 475             // this has been done already above.
 476             if (meEditMode == EM_PAGE)
 477                 maTabControl.SetCurPageId (nActualPageNum + 1);
 478         }
 479         /*AF: The LayerDialogChildWindow is not used anymore (I hope).
 480         if (GetViewFrame()->KnowsChildWindow(
 481             LayerDialogChildWindow::GetChildWindowId()))
 482         {
 483             GetViewFrame()->SetChildWindow(
 484                 LayerDialogChildWindow::GetChildWindowId(),
 485                 IsLayerModeActive());
 486         }
 487         */
 488         ResetActualLayer();
 489
 490         Invalidate( SID_PAGEMODE );
 491         Invalidate( SID_LAYERMODE );
 492         Invalidate( SID_MASTERPAGE );
 493         Invalidate( SID_DELETE_MASTER_PAGE );
 494         Invalidate( SID_DELETE_PAGE );
 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         rBindings.Invalidate(SID_DELETE_MASTER_PAGE, TRUE, FALSE);
1233         rBindings.Invalidate(SID_DELETE_PAGE, TRUE, FALSE);
1234         UpdatePreview( mpActualPage );
1235
1236         mpDrawView->AdjustMarkHdl();
1237     }
1238
1239     return (bOK);
1240 }
1241
1242
1243 /*************************************************************************
1244 |*
1245 |* Pruefen, ob ein Seitenwechsel erlaubt ist
1246 |*
1247 \************************************************************************/
1248
1249 BOOL DrawViewShell::IsSwitchPageAllowed() const
1250 {
1251     bool bOK = true;
1252
1253     FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell();
1254     if (pFormShell!=NULL && !pFormShell->PrepareClose (FALSE))
1255         bOK = false;
1256
1257     return bOK;
1258 }
1259
1260 /*************************************************************************
1261 |*
1262 |* neue aktuelle Seite auswaehlen, falls sich die Seitenfolge geaendert
1263 |* hat (z. B. durch Undo)
1264 |*
1265 \************************************************************************/
1266
1267 void DrawViewShell::ResetActualLayer()
1268 {
1269     LayerTabBar* pLayerBar = GetLayerTabControl();
1270     if (pLayerBar != NULL)
1271     {
1272         // remember old layer cound and current layer id
1273         // this is needed when one layer is renamed to
1274         // restore current layer
1275         USHORT nOldLayerCnt = pLayerBar->GetPageCount();
1276         USHORT nOldLayerId = pLayerBar->GetCurPageId();
1277
1278         /*************************************************************
1279             * Update fuer LayerTab
1280             *************************************************************/
1281         pLayerBar->Clear();
1282
1283         String aName;
1284         String aActiveLayer = mpDrawView->GetActiveLayer();
1285         String aBackgroundLayer( SdResId(STR_LAYER_BCKGRND) );
1286         String aBackgroundObjLayer( SdResId(STR_LAYER_BCKGRNDOBJ) );
1287         String aLayoutLayer( SdResId(STR_LAYER_LAYOUT) );
1288         String aControlsLayer( SdResId(STR_LAYER_CONTROLS) );
1289         String aMeasureLinesLayer( SdResId(STR_LAYER_MEASURELINES) );
1290         USHORT nActiveLayer = SDRLAYER_NOTFOUND;
1291         SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
1292         USHORT nLayerCnt = rLayerAdmin.GetLayerCount();
1293
1294         for ( USHORT nLayer = 0; nLayer < nLayerCnt; nLayer++ )
1295         {
1296             aName = rLayerAdmin.GetLayer(nLayer)->GetName();
1297
1298             if ( aName == aActiveLayer )
1299             {
1300                 nActiveLayer = nLayer;
1301             }
1302
1303             if ( aName != aBackgroundLayer )
1304             {
1305                 if (meEditMode == EM_MASTERPAGE)
1306                 {
1307                     // Layer der Page nicht auf MasterPage anzeigen
1308                     if (aName != aLayoutLayer   &&
1309                         aName != aControlsLayer &&
1310                         aName != aMeasureLinesLayer)
1311                     {
1312                         pLayerBar->InsertPage(nLayer+1, aName);
1313
1314                         TabBarPageBits nBits = 0;
1315                         SdrPageView* pPV = mpDrawView->GetSdrPageView();
1316
1317                         if (pPV && !pPV->IsLayerVisible(aName))
1318                         {
1319                             // Unsichtbare Layer werden anders dargestellt
1320                             nBits = TPB_SPECIAL;
1321                         }
1322
1323                         pLayerBar->SetPageBits(nLayer+1, nBits);
1324                     }
1325                 }
1326                 else
1327                 {
1328                     // Layer der MasterPage nicht auf Page anzeigen
1329                     if ( aName != aBackgroundObjLayer )
1330                     {
1331                         pLayerBar->InsertPage(nLayer+1, aName);
1332
1333                         TabBarPageBits nBits = 0;
1334
1335                         if (!mpDrawView->GetSdrPageView()->IsLayerVisible(aName))
1336                         {
1337                             // Unsichtbare Layer werden anders dargestellt
1338                             nBits = TPB_SPECIAL;
1339                         }
1340
1341                         pLayerBar->SetPageBits(nLayer+1, nBits);
1342                     }
1343                 }
1344             }
1345         }
1346
1347         if ( nActiveLayer == SDRLAYER_NOTFOUND )
1348         {
1349             if( nOldLayerCnt == pLayerBar->GetPageCount() )
1350             {
1351                 nActiveLayer = nOldLayerId - 1;
1352             }
1353             else
1354             {
1355                 nActiveLayer = ( meEditMode == EM_MASTERPAGE ) ? 2 : 0;
1356             }
1357
1358             mpDrawView->SetActiveLayer( pLayerBar->GetPageText(nActiveLayer + 1) );
1359         }
1360
1361         pLayerBar->SetCurPageId(nActiveLayer + 1);
1362         GetViewFrame()->GetBindings().Invalidate( SID_MODIFYLAYER );
1363         GetViewFrame()->GetBindings().Invalidate( SID_DELETE_LAYER );
1364     }
1365 }
1366
1367 /*************************************************************************
1368 |*
1369 |* Verzoegertes Close ausfuehren
1370 |*
1371 \************************************************************************/
1372
1373 IMPL_LINK( DrawViewShell, CloseHdl, Timer*, pTimer )
1374 {
1375     pTimer->Stop();
1376     GetViewFrame()->GetBindings().Execute( SID_CLOSEWIN );
1377     return 0L;
1378 }
1379
1380 /*************************************************************************
1381 |*
1382 |* AcceptDrop
1383 |*
1384 \************************************************************************/
1385
1386 sal_Int8 DrawViewShell::AcceptDrop (
1387     const AcceptDropEvent& rEvt,
1388     DropTargetHelper& rTargetHelper,
1389     ::sd::Window* pTargetWindow,
1390     USHORT nPage,
1391     USHORT nLayer )
1392 {
1393     if( nPage != SDRPAGE_NOTFOUND )
1394         nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1395
1396     if( SlideShow::IsRunning( GetViewShellBase() ) )
1397         return DND_ACTION_NONE;
1398
1399     return mpDrawView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer );
1400 }
1401
1402 /*************************************************************************
1403 |*
1404 |* ExecuteDrop
1405 |*
1406 \************************************************************************/
1407
1408 sal_Int8 DrawViewShell::ExecuteDrop (
1409     const ExecuteDropEvent& rEvt,
1410     DropTargetHelper& rTargetHelper,
1411     ::sd::Window* pTargetWindow,
1412     USHORT nPage,
1413     USHORT nLayer)
1414 {
1415     if( nPage != SDRPAGE_NOTFOUND )
1416         nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum();
1417
1418     if( SlideShow::IsRunning( GetViewShellBase() ) )
1419         return DND_ACTION_NONE;
1420
1421     Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START));
1422     sal_Int8 nResult (mpDrawView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ));
1423     Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END));
1424
1425     return nResult;
1426 }
1427
1428 } // end of namespace sd
1429
1430 #ifdef _MSC_VER
1431 #if (_MSC_VER < 1400)
1432 #pragma optimize ( "", on )
1433 #endif
1434 #endif
1435