sd/source/ui/view/drviewsa.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: drviewsa.cxx,v $
  10  * $Revision: 1.49.70.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 <cppuhelper/implbase1.hxx>
  36 #include <comphelper/processfactory.hxx>
  37 #ifndef _SVX_SIZEITEM
  38 #include <svx/sizeitem.hxx>
  39 #endif
  40 #include <svx/svdlayer.hxx>
  41 #ifndef _SVX_ZOOMITEM
  42 #include <svx/zoomitem.hxx>
  43 #endif
  44 #include <svx/svdpagv.hxx>
  45 #include <svtools/ptitem.hxx>
  46 #include <svtools/stritem.hxx>
  47 #include <sfx2/request.hxx>
  48 #include <sfx2/dispatch.hxx>
  49 #include <svx/svdopath.hxx>
  50 #include <sfx2/docfile.hxx>
  51 #include <svx/zoomslideritem.hxx>
  52 #include <svtools/eitem.hxx>
  53
  54 #ifndef _SVX_DIALOGS_HRC
  55 #include <svx/dialogs.hrc>
  56 #endif
  57 #include <svx/extrusionbar.hxx>
  58 #include <svx/fontworkbar.hxx>
  59 #include <svx/clipfmtitem.hxx>
  60
  61
  62 #include <sfx2/viewfrm.hxx>
  63 #include <svx/fmshell.hxx>
  64 #include <sfx2/dispatch.hxx>
  65 #include <svtools/cliplistener.hxx>
  66 #include <svx/float3d.hxx>
  67
  68 #include "app.hrc"
  69 #include "helpids.h"
  70 #include "strings.hrc"
  71 #include "res_bmp.hrc"
  72 #include "sdpage.hxx"
  73 #include "FrameView.hxx"
  74 #include "drawdoc.hxx"
  75 #include "sdresid.hxx"
  76 #include "DrawDocShell.hxx"
  77 #include "Window.hxx"
  78 #include "fupoor.hxx"
  79 #include "fusel.hxx"
  80 #include "drawview.hxx"
  81 #include "SdUnoDrawView.hxx"
  82 #include "ViewShellBase.hxx"
  83 #include "SdUnoDrawView.hxx"
  84 #include "slideshow.hxx"
  85 #include "ToolBarManager.hxx"
  86 #include "annotationmanager.hxx"
  87
  88 using namespace ::rtl;
  89 using namespace ::com::sun::star;
  90 using namespace ::com::sun::star::uno;
  91
  92 namespace {
  93 static const ::rtl::OUString MASTER_VIEW_TOOL_BAR_NAME(
  94     ::rtl::OUString::createFromAscii("masterviewtoolbar"));
  95 }
  96
  97 namespace sd {
  98
  99 BOOL DrawViewShell::mbPipette = FALSE;
 100
 101 // ------------------------
 102 // - ScannerEventListener -
 103 // ------------------------
 104
 105 class ScannerEventListener : public ::cppu::WeakImplHelper1< ::com::sun::star::lang::XEventListener >
 106 {
 107 private:
 108
 109     DrawViewShell*              mpParent;
 110
 111 public:
 112
 113                             ScannerEventListener( DrawViewShell* pParent ) : mpParent( pParent )  {};
 114                             ~ScannerEventListener();
 115
 116     // XEventListener
 117     virtual void SAL_CALL       disposing( const ::com::sun::star::lang::EventObject& rEventObject ) throw (::com::sun::star::uno::RuntimeException);
 118
 119     void                                        ParentDestroyed() { mpParent = NULL; }
 120 };
 121
 122 // -----------------------------------------------------------------------------
 123
 124 ScannerEventListener::~ScannerEventListener()
 125 {
 126 }
 127
 128 // -----------------------------------------------------------------------------
 129
 130 void SAL_CALL ScannerEventListener::disposing( const ::com::sun::star::lang::EventObject& rEventObject ) throw (::com::sun::star::uno::RuntimeException)
 131 {
 132     if( mpParent )
 133         mpParent->ScannerEvent( rEventObject );
 134 }
 135
 136 /*************************************************************************
 137 |*
 138 |* Standard-Konstruktor
 139 |*
 140 \************************************************************************/
 141
 142 DrawViewShell::DrawViewShell( SfxViewFrame* pFrame, ViewShellBase& rViewShellBase, ::Window* pParentWindow, PageKind ePageKind, FrameView* pFrameViewArgument )
 143 : ViewShell (pFrame, pParentWindow, rViewShellBase)
 144 , maTabControl(this, pParentWindow)
 145 , mbIsInSwitchPage(false)
 146 {
 147     if (pFrameViewArgument != NULL)
 148         mpFrameView = pFrameViewArgument;
 149     else
 150         mpFrameView = new FrameView(GetDoc());
 151     Construct(GetDocSh(), ePageKind);
 152 }
 153
 154 /*************************************************************************
 155 |*
 156 |* Copy-Konstruktor
 157 |*
 158 \************************************************************************/
 159
 160 DrawViewShell::DrawViewShell( SfxViewFrame* pFrame, ::Window* pParentWindow, const DrawViewShell& rShell )
 161 : ViewShell(pFrame, pParentWindow, rShell)
 162 , maTabControl(this, pParentWindow)
 163 , mbIsInSwitchPage(false)
 164 {
 165     mpFrameView = new FrameView(GetDoc());
 166     Construct (GetDocSh(), PK_STANDARD);
 167 }
 168
 169 /*************************************************************************
 170 |*
 171 |* Destruktor
 172 |*
 173 \************************************************************************/
 174
 175 DrawViewShell::~DrawViewShell()
 176 {
 177     mpAnnotationManager.release();
 178
 179     OSL_ASSERT (GetViewShell()!=NULL);
 180
 181     if( mxScannerListener.is() )
 182         static_cast< ScannerEventListener* >( mxScannerListener.get() )->ParentDestroyed();
 183
 184     // #96642# Remove references to items within Svx3DWin
 185     // (maybe do a listening sometime in Svx3DWin)
 186     USHORT nId = Svx3DChildWindow::GetChildWindowId();
 187     SfxChildWindow* pWindow = GetViewFrame() ? GetViewFrame()->GetChildWindow(nId) : NULL;
 188     if(pWindow)
 189     {
 190         Svx3DWin* p3DWin = static_cast< Svx3DWin* > (pWindow->GetWindow());
 191         if(p3DWin)
 192             p3DWin->DocumentReload();
 193     }
 194
 195     EndListening (*GetDoc());
 196     EndListening (*GetDocSh());
 197
 198     if( SlideShow::IsRunning(*this) )
 199         StopSlideShow(false);
 200
 201     DisposeFunctions();
 202
 203     SdPage* pPage;
 204     USHORT aPageCnt = GetDoc()->GetSdPageCount(mePageKind);
 205
 206     for (USHORT i = 0; i < aPageCnt; i++)
 207     {
 208         pPage = GetDoc()->GetSdPage(i, mePageKind);
 209
 210         if (pPage == mpActualPage)
 211         {
 212             GetDoc()->SetSelected(pPage, TRUE);
 213         }
 214         else
 215         {
 216             GetDoc()->SetSelected(pPage, FALSE);
 217         }
 218     }
 219
 220     if ( mpClipEvtLstnr )
 221     {
 222         mpClipEvtLstnr->AddRemoveListener( GetActiveWindow(), FALSE );
 223         mpClipEvtLstnr->ClearCallbackLink();            // #103849# prevent callback if another thread is waiting
 224         mpClipEvtLstnr->release();
 225     }
 226
 227     delete mpDrawView;
 228     // Set mpView to NULL so that the destructor of the ViewShell base class
 229     // does not access it.
 230     mpView = mpDrawView = NULL;
 231
 232     mpFrameView->Disconnect();
 233     delete [] mpSlotArray;
 234 }
 235
 236 /*************************************************************************
 237 |*
 238 |* gemeinsamer Initialisierungsanteil der beiden Konstruktoren
 239 |*
 240 \************************************************************************/
 241
 242 void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
 243 {
 244     mpActualPage = 0;
 245     mbMousePosFreezed = FALSE;
 246     mbReadOnly = GetDocSh()->IsReadOnly();
 247     mpSlotArray = 0;
 248     mpClipEvtLstnr = 0;
 249     mbPastePossible = FALSE;
 250     mbIsLayerModeActive = false;
 251
 252     mpFrameView->Connect();
 253
 254     OSL_ASSERT (GetViewShell()!=NULL);
 255
 256     // Array fuer Slot-/ImageMapping:
 257     // Gerader Eintrag: Haupt-/ToolboxSlot
 258     // Ungerader Eintrag: gemappter Slot
 259     // Achtung: Anpassen von GetIdBySubId() !!!
 260     // Reihenfolge (insbesondere Zoom) darf nicht geaendert werden !!!
 261     mpSlotArray = new USHORT[ SLOTARRAY_COUNT ];
 262     mpSlotArray[ 0 ]  = SID_OBJECT_CHOOSE_MODE;
 263     mpSlotArray[ 1 ]  = SID_OBJECT_ROTATE;
 264     mpSlotArray[ 2 ]  = SID_OBJECT_ALIGN;
 265     mpSlotArray[ 3 ]  = SID_OBJECT_ALIGN_LEFT;
 266     mpSlotArray[ 4 ]  = SID_ZOOM_TOOLBOX;
 267     mpSlotArray[ 5 ]  = SID_ZOOM_TOOLBOX;
 268     mpSlotArray[ 6 ]  = SID_DRAWTBX_TEXT;
 269     mpSlotArray[ 7 ]  = SID_ATTR_CHAR;
 270     mpSlotArray[ 8 ]  = SID_DRAWTBX_RECTANGLES;
 271     mpSlotArray[ 9 ]  = SID_DRAW_RECT;
 272     mpSlotArray[ 10 ] = SID_DRAWTBX_ELLIPSES;
 273     mpSlotArray[ 11 ] = SID_DRAW_ELLIPSE;
 274     mpSlotArray[ 12 ] = SID_DRAWTBX_LINES;
 275     mpSlotArray[ 13 ] = SID_DRAW_FREELINE_NOFILL;
 276     mpSlotArray[ 14 ] = SID_DRAWTBX_3D_OBJECTS;
 277     mpSlotArray[ 15 ] = SID_3D_CUBE;
 278     mpSlotArray[ 16 ] = SID_DRAWTBX_INSERT;
 279     mpSlotArray[ 17 ] = SID_INSERT_DIAGRAM;
 280     mpSlotArray[ 18 ] = SID_POSITION;
 281     mpSlotArray[ 19 ] = SID_FRAME_TO_TOP;
 282     mpSlotArray[ 20 ] = SID_DRAWTBX_CONNECTORS;
 283     mpSlotArray[ 21 ] = SID_TOOL_CONNECTOR;
 284     mpSlotArray[ 22 ] = SID_DRAWTBX_ARROWS;
 285     mpSlotArray[ 23 ] = SID_LINE_ARROW_END;
 286
 287     SetPool( &GetDoc()->GetPool() );
 288
 289     GetDoc()->CreateFirstPages();
 290
 291     mpDrawView = new DrawView(pDocSh, GetActiveWindow(), this);
 292     mpView = mpDrawView;                         // Pointer der Basisklasse ViewShell
 293     mpDrawView->SetSwapAsynchron(TRUE); // Asynchrones Laden von Graphiken
 294
 295     // We do not read the page kind from the frame view anymore so we have
 296     // to set it in order to resync frame view and this view.
 297     mpFrameView->SetPageKind(eInitialPageKind);
 298     mePageKind = eInitialPageKind;
 299     meEditMode = EM_PAGE;
 300     DocumentType eDocType = GetDoc()->GetDocumentType(); // RTTI fasst hier noch nicht
 301     switch (mePageKind)
 302     {
 303         case PK_STANDARD:
 304             meShellType = ST_IMPRESS;
 305             break;
 306
 307         case PK_NOTES:
 308             meShellType = ST_NOTES;
 309             break;
 310
 311         case PK_HANDOUT:
 312             meShellType = ST_HANDOUT;
 313             break;
 314     }
 315
 316     Size aPageSize( GetDoc()->GetSdPage(0, mePageKind)->GetSize() );
 317     Point aPageOrg( aPageSize.Width(), aPageSize.Height() / 2);
 318     Size aSize(aPageSize.Width() * 3, aPageSize.Height() * 2);
 319     InitWindows(aPageOrg, aSize, Point(-1, -1));
 320
 321     Point aVisAreaPos;
 322
 323     if ( pDocSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
 324     {
 325         aVisAreaPos = pDocSh->GetVisArea(ASPECT_CONTENT).TopLeft();
 326     }
 327
 328     mpDrawView->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aSize));
 329
 330     // Objekte koennen max. so gross wie die ViewSize werden
 331     GetDoc()->SetMaxObjSize(aSize);
 332
 333     // Split-Handler fuer TabControls
 334     maTabControl.SetSplitHdl( LINK( this, DrawViewShell, TabSplitHdl ) );
 335
 336     // Damit der richtige EditMode von der FrameView komplett eingestellt
 337     // werden kann, wird hier ein aktuell anderer gewaehlt (kleiner Trick)
 338     if (mpFrameView->GetViewShEditMode(mePageKind) == EM_PAGE)
 339     {
 340         meEditMode = EM_MASTERPAGE;
 341     }
 342     else
 343     {
 344         meEditMode = EM_PAGE;
 345     }
 346
 347     // Einstellungen der FrameView uebernehmen
 348     ReadFrameViewData(mpFrameView);
 349
 350     if( eDocType == DOCUMENT_TYPE_DRAW )
 351     {
 352         SetHelpId( SD_IF_SDGRAPHICVIEWSHELL );
 353         GetActiveWindow()->SetHelpId( SD_IF_SDGRAPHICVIEWSHELL );
 354         GetActiveWindow()->SetUniqueId( SD_IF_SDGRAPHICVIEWSHELL );
 355     }
 356     else
 357     {
 358         if (mePageKind == PK_NOTES)
 359         {
 360             SetHelpId( SID_NOTESMODE );
 361             GetActiveWindow()->SetHelpId( SID_NOTESMODE );
 362             GetActiveWindow()->SetUniqueId( SID_NOTESMODE );
 363
 364             // AutoLayouts muessen erzeugt sein
 365             GetDoc()->StopWorkStartupDelay();
 366         }
 367         else if (mePageKind == PK_HANDOUT)
 368         {
 369             SetHelpId( SID_HANDOUTMODE );
 370             GetActiveWindow()->SetHelpId( SID_HANDOUTMODE );
 371             GetActiveWindow()->SetUniqueId( SID_HANDOUTMODE );
 372
 373             // AutoLayouts muessen erzeugt sein
 374             GetDoc()->StopWorkStartupDelay();
 375         }
 376         else
 377         {
 378             SetHelpId( SD_IF_SDDRAWVIEWSHELL );
 379             GetActiveWindow()->SetHelpId( SD_IF_SDDRAWVIEWSHELL );
 380             GetActiveWindow()->SetUniqueId( SD_IF_SDDRAWVIEWSHELL );
 381         }
 382     }
 383
 384     // Selektionsfunktion starten
 385     SfxRequest aReq(SID_OBJECT_SELECT, 0, GetDoc()->GetItemPool());
 386     FuPermanent(aReq);
 387     mpDrawView->SetFrameDragSingles(TRUE);
 388
 389     if (pDocSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED)
 390     {
 391         mbZoomOnPage = FALSE;
 392     }
 393     else
 394     {
 395         mbZoomOnPage = TRUE;
 396     }
 397
 398     mbIsRulerDrag = FALSE;
 399
 400     String aName( RTL_CONSTASCII_USTRINGPARAM("DrawViewShell"));
 401     SetName (aName);
 402
 403     mnLockCount = 0UL;
 404
 405     ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
 406
 407     if( xMgr.is() )
 408     {
 409         mxScannerManager = ::com::sun::star::uno::Reference< ::com::sun::star::scanner::XScannerManager >(
 410                            xMgr->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.scanner.ScannerManager" ) ),
 411                            ::com::sun::star::uno::UNO_QUERY );
 412
 413         if( mxScannerManager.is() )
 414         {
 415             mxScannerListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >(
 416                                 static_cast< ::cppu::OWeakObject* >( new ScannerEventListener( this ) ),
 417                                 ::com::sun::star::uno::UNO_QUERY );
 418         }
 419     }
 420
 421     mpAnnotationManager.reset( new AnnotationManager( GetViewShellBase() ) );
 422 }
 423
 424
 425
 426
 427 void DrawViewShell::Init (bool bIsMainViewShell)
 428 {
 429     ViewShell::Init(bIsMainViewShell);
 430
 431     StartListening (*GetDocSh());
 432 }
 433
 434
 435
 436
 437 void DrawViewShell::Shutdown (void)
 438 {
 439     ViewShell::Shutdown();
 440
 441     if(SlideShow::IsRunning( GetViewShellBase() ) )
 442     {
 443         // Turn off effects.
 444         GetDrawView()->SetAnimationMode(SDR_ANIMATION_DISABLE);
 445     }
 446 }
 447
 448
 449
 450
 451 css::uno::Reference<css::drawing::XDrawSubController> DrawViewShell::CreateSubController (void)
 452 {
 453     css::uno::Reference<css::drawing::XDrawSubController> xSubController;
 454
 455     if (IsMainViewShell())
 456     {
 457         // Create uno sub controller for the main view shell.
 458         xSubController = css::uno::Reference<css::drawing::XDrawSubController>(
 459             new SdUnoDrawView (
 460                 GetViewShellBase().GetDrawController(),
 461                 *this,
 462                 *GetView()));
 463     }
 464
 465     return xSubController;
 466 }
 467
 468
 469
 470
 471 bool DrawViewShell::RelocateToParentWindow (::Window* pParentWindow)
 472 {
 473     // DrawViewShells can not be relocated to a new parent window at the
 474     // moment, so return <FALSE/> except when the given parent window is the
 475     // parent window that is already in use.
 476     return pParentWindow==GetParentWindow();
 477 }
 478
 479
 480
 481
 482 /*************************************************************************
 483 |*
 484 |* pruefe ob linienzuege gezeichnet werden muessen
 485 |*
 486 \************************************************************************/
 487
 488 /*
 489     linienzuege werden ueber makros als folge von
 490         MoveTo (x, y)
 491         LineTo (x, y)   [oder BezierTo (x, y)]
 492         LineTo (x, y)
 493             :
 494     dargestellt. einen endbefehl fuer die linienzuege
 495     gibt es nicht, also muessen alle befehle in den
 496     requests nach LineTo (BezierTo) abgetestet und die
 497     punktparameter gesammelt werden.
 498     der erste nicht-LineTo fuehrt dann dazu, dass aus
 499     den gesammelten punkten der linienzug erzeugt wird
 500 */
 501
 502 void DrawViewShell::CheckLineTo(SfxRequest& rReq)
 503 {
 504     (void)rReq;
 505 #ifdef DBG_UTIL
 506     if(rReq.IsAPI())
 507     {
 508         if(SID_LINETO == rReq.GetSlot() || SID_BEZIERTO == rReq.GetSlot() || SID_MOVETO == rReq.GetSlot() )
 509         {
 510             DBG_ERROR("DrawViewShell::CheckLineTo: slots SID_LINETO, SID_BEZIERTO, SID_MOVETO no longer supported.");
 511         }
 512     }
 513 #endif
 514
 515     rReq.Ignore ();
 516 }
 517
 518 /*************************************************************************
 519 |*
 520 |* veraendere die seitemparameter, wenn SID_PAGESIZE oder SID_PAGEMARGIN
 521 |*
 522 \************************************************************************/
 523
 524 void DrawViewShell::SetupPage (Size &rSize,
 525                                  long nLeft,
 526                                  long nRight,
 527                                  long nUpper,
 528                                  long nLower,
 529                                  BOOL bSize,
 530                                  BOOL bMargin,
 531                                  BOOL bScaleAll)
 532 {
 533     USHORT nPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
 534     USHORT i;
 535
 536     for (i = 0; i < nPageCnt; i++)
 537     {
 538         /**********************************************************************
 539         * Erst alle MasterPages bearbeiten
 540         **********************************************************************/
 541         SdPage *pPage = GetDoc()->GetMasterSdPage(i, mePageKind);
 542
 543         if( pPage )
 544         {
 545             if( bSize )
 546             {
 547                 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
 548                 pPage->ScaleObjects(rSize, aBorderRect, bScaleAll);
 549                 pPage->SetSize(rSize);
 550
 551             }
 552             if( bMargin )
 553             {
 554                 pPage->SetLftBorder(nLeft);
 555                 pPage->SetRgtBorder(nRight);
 556                 pPage->SetUppBorder(nUpper);
 557                 pPage->SetLwrBorder(nLower);
 558             }
 559
 560             if ( mePageKind == PK_STANDARD )
 561             {
 562                 GetDoc()->GetMasterSdPage(i, PK_NOTES)->CreateTitleAndLayout();
 563             }
 564
 565             pPage->CreateTitleAndLayout();
 566         }
 567     }
 568
 569     nPageCnt = GetDoc()->GetSdPageCount(mePageKind);
 570
 571     for (i = 0; i < nPageCnt; i++)
 572     {
 573         /**********************************************************************
 574         * Danach alle Pages bearbeiten
 575         **********************************************************************/
 576         SdPage *pPage = GetDoc()->GetSdPage(i, mePageKind);
 577
 578         if( pPage )
 579         {
 580             if( bSize )
 581             {
 582                 Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
 583                 pPage->ScaleObjects(rSize, aBorderRect, bScaleAll);
 584                 pPage->SetSize(rSize);
 585             }
 586             if( bMargin )
 587             {
 588                 pPage->SetLftBorder(nLeft);
 589                 pPage->SetRgtBorder(nRight);
 590                 pPage->SetUppBorder(nUpper);
 591                 pPage->SetLwrBorder(nLower);
 592             }
 593
 594             if ( mePageKind == PK_STANDARD )
 595             {
 596                 SdPage* pNotesPage = GetDoc()->GetSdPage(i, PK_NOTES);
 597                 pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
 598             }
 599
 600             pPage->SetAutoLayout( pPage->GetAutoLayout() );
 601         }
 602     }
 603
 604     if ( mePageKind == PK_STANDARD )
 605     {
 606         SdPage* pHandoutPage = GetDoc()->GetSdPage(0, PK_HANDOUT);
 607         pHandoutPage->CreateTitleAndLayout(TRUE);
 608     }
 609
 610     long nWidth = mpActualPage->GetSize().Width();
 611     long nHeight = mpActualPage->GetSize().Height();
 612
 613     Point aPageOrg(nWidth, nHeight / 2);
 614     Size aSize( nWidth * 3, nHeight * 2);
 615
 616     InitWindows(aPageOrg, aSize, Point(-1, -1), TRUE);
 617
 618     Point aVisAreaPos;
 619
 620     if ( GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
 621     {
 622         aVisAreaPos = GetDocSh()->GetVisArea(ASPECT_CONTENT).TopLeft();
 623     }
 624
 625     GetView()->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aSize));
 626
 627     UpdateScrollBars();
 628
 629     Point aNewOrigin(mpActualPage->GetLftBorder(), mpActualPage->GetUppBorder());
 630     GetView()->GetSdrPageView()->SetPageOrigin(aNewOrigin);
 631
 632     GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
 633
 634     // auf (neue) Seitengroesse zoomen
 635     GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE,
 636                         SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
 637 }
 638
 639 /*************************************************************************
 640 |*
 641 |* Statuswerte der Statusbar zurueckgeben
 642 |*
 643 \************************************************************************/
 644
 645 void DrawViewShell::GetStatusBarState(SfxItemSet& rSet)
 646 {
 647     // Zoom-Item
 648     // Hier sollte der entsprechende Wert (Optimal ?, Seitenbreite oder
 649     // Seite) mit Hilfe des ZoomItems weitergegeben werden !!!
 650     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOM ) )
 651     {
 652         if (GetDocSh()->IsUIActive() || (SlideShow::IsRunning(GetViewShellBase())) )
 653         {
 654             rSet.DisableItem( SID_ATTR_ZOOM );
 655         }
 656         else
 657         {
 658             SvxZoomItem* pZoomItem;
 659             UINT16 nZoom = (UINT16) GetActiveWindow()->GetZoom();
 660
 661             if( mbZoomOnPage )
 662                 pZoomItem = new SvxZoomItem( SVX_ZOOM_WHOLEPAGE, nZoom );
 663             else
 664                 pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom );
 665
 666             // Bereich einschraenken
 667             USHORT nZoomValues = SVX_ZOOM_ENABLE_ALL;
 668             SdrPageView* pPageView = mpDrawView->GetSdrPageView();
 669
 670             if( ( pPageView && pPageView->GetObjList()->GetObjCount() == 0 ) )
 671                 // || ( mpDrawView->GetMarkedObjectList().GetMarkCount() == 0 ) )
 672             {
 673                 nZoomValues &= ~SVX_ZOOM_ENABLE_OPTIMAL;
 674             }
 675
 676             pZoomItem->SetValueSet( nZoomValues );
 677             rSet.Put( *pZoomItem );
 678             delete pZoomItem;
 679         }
 680     }
 681     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOMSLIDER ) )
 682     {
 683         rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) );
 684         if (GetDocSh()->IsUIActive() || (xSlideshow.is() && xSlideshow->isRunning()) || !GetActiveWindow() )
 685         {
 686             rSet.DisableItem( SID_ATTR_ZOOMSLIDER );
 687         }
 688         else
 689         {
 690             sd::Window * pActiveWindow = GetActiveWindow();
 691             SvxZoomSliderItem aZoomItem( (UINT16) pActiveWindow->GetZoom(), (USHORT)pActiveWindow->GetMinZoom(), (USHORT)pActiveWindow->GetMaxZoom() ) ;
 692
 693             SdrPageView* pPageView = mpDrawView->GetSdrPageView();
 694             if( pPageView )
 695             {
 696                 Point aPagePos(0, 0);
 697                 Size aPageSize = pPageView->GetPage()->GetSize();
 698
 699                 aPagePos.X() += aPageSize.Width()  / 2;
 700                 aPageSize.Width() = (long) (aPageSize.Width() * 1.03);
 701
 702                 aPagePos.Y() += aPageSize.Height() / 2;
 703                 aPageSize.Height() = (long) (aPageSize.Height() * 1.03);
 704                 aPagePos.Y() -= aPageSize.Height() / 2;
 705
 706                 aPagePos.X() -= aPageSize.Width()  / 2;
 707
 708                 Rectangle aFullPageZoomRect( aPagePos, aPageSize );
 709                 aZoomItem.AddSnappingPoint( pActiveWindow->GetZoomForRect( aFullPageZoomRect ) );
 710             }
 711             aZoomItem.AddSnappingPoint(100);
 712             rSet.Put( aZoomItem );
 713         }
 714     }
 715
 716     Point aPos = GetActiveWindow()->PixelToLogic(maMousePos);
 717     mpDrawView->GetSdrPageView()->LogicToPagePos(aPos);
 718     Fraction aUIScale(GetDoc()->GetUIScale());
 719     aPos.X() = Fraction(aPos.X()) / aUIScale;
 720     aPos.Y() = Fraction(aPos.Y()) / aUIScale;
 721
 722     // Position- und Groesse-Items
 723     if ( mpDrawView->IsAction() )
 724     {
 725         Rectangle aRect;
 726         mpDrawView->TakeActionRect( aRect );
 727
 728         if ( aRect.IsEmpty() )
 729             rSet.Put( SfxPointItem(SID_ATTR_POSITION, aPos) );
 730         else
 731         {
 732             mpDrawView->GetSdrPageView()->LogicToPagePos(aRect);
 733             aPos = aRect.TopLeft();
 734             aPos.X() = Fraction(aPos.X()) / aUIScale;
 735             aPos.Y() = Fraction(aPos.Y()) / aUIScale;
 736             rSet.Put( SfxPointItem( SID_ATTR_POSITION, aPos) );
 737             Size aSize( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() );
 738             aSize.Height() = Fraction(aSize.Height()) / aUIScale;
 739             aSize.Width()  = Fraction(aSize.Width())  / aUIScale;
 740             rSet.Put( SvxSizeItem( SID_ATTR_SIZE, aSize) );
 741         }
 742     }
 743     else
 744     {
 745         if ( mpDrawView->AreObjectsMarked() )
 746         {
 747             Rectangle aRect = mpDrawView->GetAllMarkedRect();
 748             mpDrawView->GetSdrPageView()->LogicToPagePos(aRect);
 749
 750             // Show the position of the selected shape(s)
 751             Point aShapePosition (aRect.TopLeft());
 752             aShapePosition.X() = Fraction(aShapePosition.X()) / aUIScale;
 753             aShapePosition.Y() = Fraction(aShapePosition.Y()) / aUIScale;
 754             rSet.Put (SfxPointItem(SID_ATTR_POSITION, aShapePosition));
 755
 756             Size aSize( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() );
 757             aSize.Height() = Fraction(aSize.Height()) / aUIScale;
 758             aSize.Width()  = Fraction(aSize.Width())  / aUIScale;
 759             rSet.Put( SvxSizeItem( SID_ATTR_SIZE, aSize) );
 760         }
 761         else
 762         {
 763             rSet.Put( SfxPointItem(SID_ATTR_POSITION, aPos) );
 764             rSet.Put( SvxSizeItem( SID_ATTR_SIZE, Size( 0, 0 ) ) );
 765         }
 766     }
 767
 768     // Display of current page and layer.
 769     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_PAGE ) )
 770     {
 771         // Allways show the slide/page number.
 772         String aString (SdResId( STR_SD_PAGE ));
 773         aString += sal_Unicode(' ');
 774         aString += UniString::CreateFromInt32( maTabControl.GetCurPageId() );
 775         aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " / " ));
 776         aString += UniString::CreateFromInt32( GetDoc()->GetSdPageCount( mePageKind ) );
 777
 778         // If in layer mode additionally show the layer that contains all
 779         // selected shapes of the page.  If the shapes are distributed on
 780         // more than one layer, no layer name is shown.
 781         if (IsLayerModeActive())
 782         {
 783             SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
 784             SdrLayerID nLayer = 0, nOldLayer = 0;
 785             SdrLayer*  pLayer = NULL;
 786             SdrObject* pObj = NULL;
 787             const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
 788             ULONG nMarkCount = rMarkList.GetMarkCount();
 789             FASTBOOL bOneLayer = TRUE;
 790
 791             // Use the first ten selected shapes as a (hopefully
 792             // representative) sample of all shapes of the current page.
 793             // Detect whether they belong to the same layer.
 794             for( ULONG j = 0; j < nMarkCount && bOneLayer && j < 10; j++ )
 795             {
 796                 pObj = rMarkList.GetMark( j )->GetMarkedSdrObj();
 797                 if( pObj )
 798                 {
 799                     nLayer = pObj->GetLayer();
 800
 801                     if( j != 0 && nLayer != nOldLayer )
 802                         bOneLayer = FALSE;
 803
 804                     nOldLayer = nLayer;
 805                 }
 806             }
 807
 808             // Append the layer name to the current page number.
 809             if( bOneLayer && nMarkCount )
 810             {
 811                 pLayer = rLayerAdmin.GetLayerPerID( nLayer );
 812                 if( pLayer )
 813                 {
 814                     aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " (" ));
 815                     aString += pLayer->GetName();
 816                     aString += sal_Unicode(')');
 817                 }
 818             }
 819         }
 820
 821         rSet.Put (SfxStringItem (SID_STATUS_PAGE, aString));
 822     }
 823     // Layout
 824     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_LAYOUT ) )
 825     {
 826         String aString = mpActualPage->GetLayoutName();
 827         aString.Erase( aString.SearchAscii( SD_LT_SEPARATOR ) );
 828         rSet.Put( SfxStringItem( SID_STATUS_LAYOUT, aString ) );
 829     }
 830 }
 831
 832
 833
 834 void DrawViewShell::Notify (SfxBroadcaster&, const SfxHint& rHint)
 835 {
 836     const SfxSimpleHint* pSimple = dynamic_cast< const SfxSimpleHint* >(&rHint);
 837     if (pSimple!=NULL && pSimple->GetId()==SFX_HINT_MODECHANGED)
 838     {
 839         // Change to selection when turning on read-only mode.
 840         if(GetDocSh()->IsReadOnly() && dynamic_cast< FuSelection* >( GetCurrentFunction().get() ) )
 841         {
 842             SfxRequest aReq(SID_OBJECT_SELECT, 0, GetDoc()->GetItemPool());
 843             FuPermanent(aReq);
 844         }
 845
 846         // Turn on design mode when document is not read-only.
 847         if (GetDocSh()->IsReadOnly() != mbReadOnly )
 848         {
 849             mbReadOnly = GetDocSh()->IsReadOnly();
 850
 851             SfxBoolItem aItem( SID_FM_DESIGN_MODE, !mbReadOnly );
 852             GetViewFrame()->GetDispatcher()->Execute( SID_FM_DESIGN_MODE,
 853                 SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
 854         }
 855     }
 856
 857 }
 858
 859 void DrawViewShell::ExecuteAnnotation (SfxRequest& rRequest)
 860 {
 861     if( mpAnnotationManager.get() )
 862         mpAnnotationManager->ExecuteAnnotation( rRequest );
 863 }
 864
 865 // --------------------------------------------------------------------
 866
 867 void DrawViewShell::GetAnnotationState (SfxItemSet& rItemSet )
 868 {
 869     if( mpAnnotationManager.get() )
 870         mpAnnotationManager->GetAnnotationState( rItemSet );
 871 }
 872
 873
 874 } // end of namespace sd