xref: /trunk/main/sd/source/ui/view/drviewsa.cxx (revision 30acf5e8)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"

#include "DrawViewShell.hxx"
#include <cppuhelper/implbase1.hxx>
#include <comphelper/processfactory.hxx>
#ifndef _SVX_SIZEITEM
#include <editeng/sizeitem.hxx>
#endif
#include <svx/svdlayer.hxx>
#ifndef _SVX_ZOOMITEM
#include <svx/zoomitem.hxx>
#endif
#include <svx/svdpagv.hxx>
#include <svl/ptitem.hxx>
#include <svl/stritem.hxx>
#include <sfx2/request.hxx>
#include <sfx2/dispatch.hxx>
#include <svx/svdopath.hxx>
#include <sfx2/docfile.hxx>
#include <svx/zoomslideritem.hxx>
#include <svl/eitem.hxx>

#ifndef _SVX_DIALOGS_HRC
#include <svx/dialogs.hrc>
#endif
#include <svx/extrusionbar.hxx>
#include <svx/fontworkbar.hxx>
#include <svx/clipfmtitem.hxx>


#include <sfx2/viewfrm.hxx>
#include <svx/fmshell.hxx>
#include <sfx2/dispatch.hxx>
#include <svtools/cliplistener.hxx>
#include <svx/float3d.hxx>
#include <svx/sidebar/SelectionAnalyzer.hxx>
#include "helpids.h"

#include "view/viewoverlaymanager.hxx"
#include "app.hrc"
#include "helpids.h"
#include "strings.hrc"
#include "res_bmp.hrc"
#include "sdpage.hxx"
#include "FrameView.hxx"
#include "drawdoc.hxx"
#include "sdresid.hxx"
#include "DrawDocShell.hxx"
#include "Window.hxx"
#include "fupoor.hxx"
#include "fusel.hxx"
#include "drawview.hxx"
#include "SdUnoDrawView.hxx"
#include "ViewShellBase.hxx"
#include "SdUnoDrawView.hxx"
#include "slideshow.hxx"
#include "ToolBarManager.hxx"
#include "annotationmanager.hxx"

#include <boost/bind.hpp>

using namespace ::rtl;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using sfx2::sidebar::EnumContext;

namespace {
static const ::rtl::OUString MASTER_VIEW_TOOL_BAR_NAME(
    ::rtl::OUString::createFromAscii("masterviewtoolbar"));
}

namespace sd {

sal_Bool DrawViewShell::mbPipette = sal_False;

// ------------------------
// - ScannerEventListener -
// ------------------------

class ScannerEventListener : public ::cppu::WeakImplHelper1< ::com::sun::star::lang::XEventListener >
{
private:

	DrawViewShell*		mpParent;

public:

							ScannerEventListener( DrawViewShell* pParent ) : mpParent( pParent )  {};
							~ScannerEventListener();

	// XEventListener
	virtual void SAL_CALL 	disposing( const ::com::sun::star::lang::EventObject& rEventObject ) throw (::com::sun::star::uno::RuntimeException);

	void					ParentDestroyed() { mpParent = NULL; }
};

// -----------------------------------------------------------------------------

ScannerEventListener::~ScannerEventListener()
{
}

// -----------------------------------------------------------------------------

void SAL_CALL ScannerEventListener::disposing( const ::com::sun::star::lang::EventObject& rEventObject ) throw (::com::sun::star::uno::RuntimeException)
{
	if( mpParent )
		mpParent->ScannerEvent( rEventObject );
}

/*************************************************************************
|*
|* Standard-Konstruktor
|*
\************************************************************************/

DrawViewShell::DrawViewShell( SfxViewFrame* pFrame, ViewShellBase& rViewShellBase, ::Window* pParentWindow, PageKind ePageKind, FrameView* pFrameViewArgument )
: ViewShell (pFrame, pParentWindow, rViewShellBase)
, maTabControl(this, pParentWindow)
, mbIsInSwitchPage(false),
  mpSelectionChangeHandler(new svx::sidebar::SelectionChangeHandler(
          ::boost::bind(&DrawViewShell::GetSidebarContextName, this),
          uno::Reference<frame::XController>(&rViewShellBase.GetDrawController()),
          sfx2::sidebar::EnumContext::Context_Default))

{
	if (pFrameViewArgument != NULL)
		mpFrameView = pFrameViewArgument;
	else
        mpFrameView = new FrameView(GetDoc());
    Construct(GetDocSh(), ePageKind);

    mpSelectionChangeHandler->Connect();

    SetContextName(GetSidebarContextName());
}

/*************************************************************************
|*
|* Destruktor
|*
\************************************************************************/

DrawViewShell::~DrawViewShell()
{
    mpSelectionChangeHandler->Disconnect();

    mpAnnotationManager.reset();
    mpViewOverlayManager.reset();

    OSL_ASSERT (GetViewShell()!=NULL);

    if( mxScannerListener.is() )
		static_cast< ScannerEventListener* >( mxScannerListener.get() )->ParentDestroyed();

    // #96642# Remove references to items within Svx3DWin
    // (maybe do a listening sometime in Svx3DWin)
    sal_uInt16 nId = Svx3DChildWindow::GetChildWindowId();
    SfxChildWindow* pWindow = GetViewFrame() ? GetViewFrame()->GetChildWindow(nId) : NULL;
    if(pWindow)
    {
        Svx3DWin* p3DWin = static_cast< Svx3DWin* > (pWindow->GetWindow());
        if(p3DWin)
            p3DWin->DocumentReload();
    }

    EndListening (*GetDoc());
    EndListening (*GetDocSh());

	if( SlideShow::IsRunning(*this) )
        StopSlideShow(false);

	DisposeFunctions();

	SdPage* pPage;
	sal_uInt16 aPageCnt = GetDoc()->GetSdPageCount(mePageKind);

	for (sal_uInt16 i = 0; i < aPageCnt; i++)
	{
		pPage = GetDoc()->GetSdPage(i, mePageKind);

		if (pPage == mpActualPage)
		{
			GetDoc()->SetSelected(pPage, sal_True);
		}
		else
		{
			GetDoc()->SetSelected(pPage, sal_False);
		}
	}

	if ( mpClipEvtLstnr )
	{
		mpClipEvtLstnr->AddRemoveListener( GetActiveWindow(), sal_False );
		mpClipEvtLstnr->ClearCallbackLink();		// #103849# prevent callback if another thread is waiting
		mpClipEvtLstnr->release();
	}

	delete mpDrawView;
    // Set mpView to NULL so that the destructor of the ViewShell base class
    // does not access it.
	mpView = mpDrawView = NULL;

	mpFrameView->Disconnect();
	delete [] mpSlotArray;
}

/*************************************************************************
|*
|* gemeinsamer Initialisierungsanteil der beiden Konstruktoren
|*
\************************************************************************/

void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
{
	mpActualPage = 0;
	mbMousePosFreezed = sal_False;
	mbReadOnly = GetDocSh()->IsReadOnly();
	mpSlotArray = 0;
	mpClipEvtLstnr = 0;
	mbPastePossible = sal_False;
	mbIsLayerModeActive = false;

	mpFrameView->Connect();

    OSL_ASSERT (GetViewShell()!=NULL);

	// Array fuer Slot-/ImageMapping:
	// Gerader Eintrag: Haupt-/ToolboxSlot
	// Ungerader Eintrag: gemappter Slot
	// Achtung: Anpassen von GetIdBySubId() !!!
	// Reihenfolge (insbesondere Zoom) darf nicht geaendert werden !!!
	mpSlotArray = new sal_uInt16[ SLOTARRAY_COUNT ];
	mpSlotArray[ 0 ]  = SID_OBJECT_CHOOSE_MODE;
	mpSlotArray[ 1 ]  = SID_OBJECT_ROTATE;
	mpSlotArray[ 2 ]  = SID_OBJECT_ALIGN;
	mpSlotArray[ 3 ]  = SID_OBJECT_ALIGN_LEFT;
	mpSlotArray[ 4 ]  = SID_ZOOM_TOOLBOX;
	mpSlotArray[ 5 ]  = SID_ZOOM_TOOLBOX;
	mpSlotArray[ 6 ]  = SID_DRAWTBX_TEXT;
	mpSlotArray[ 7 ]  = SID_ATTR_CHAR;
	mpSlotArray[ 8 ]  = SID_DRAWTBX_RECTANGLES;
	mpSlotArray[ 9 ]  = SID_DRAW_RECT;
	mpSlotArray[ 10 ] = SID_DRAWTBX_ELLIPSES;
	mpSlotArray[ 11 ] = SID_DRAW_ELLIPSE;
	mpSlotArray[ 12 ] = SID_DRAWTBX_LINES;
	mpSlotArray[ 13 ] = SID_DRAW_FREELINE_NOFILL;
	mpSlotArray[ 14 ] = SID_DRAWTBX_3D_OBJECTS;
	mpSlotArray[ 15 ] = SID_3D_CUBE;
	mpSlotArray[ 16 ] = SID_DRAWTBX_INSERT;
	mpSlotArray[ 17 ] = SID_INSERT_DIAGRAM;
	mpSlotArray[ 18 ] = SID_POSITION;
	mpSlotArray[ 19 ] = SID_FRAME_TO_TOP;
	mpSlotArray[ 20 ] = SID_DRAWTBX_CONNECTORS;
	mpSlotArray[ 21 ] = SID_TOOL_CONNECTOR;
	mpSlotArray[ 22 ] = SID_DRAWTBX_ARROWS;
	mpSlotArray[ 23 ] = SID_LINE_ARROW_END;

	SetPool( &GetDoc()->GetPool() );

	GetDoc()->CreateFirstPages();

	mpDrawView = new DrawView(pDocSh, GetActiveWindow(), this);
	mpView = mpDrawView;			 // Pointer der Basisklasse ViewShell
	mpDrawView->SetSwapAsynchron(sal_True); // Asynchrones Laden von Graphiken

    // We do not read the page kind from the frame view anymore so we have
    // to set it in order to resync frame view and this view.
    mpFrameView->SetPageKind(eInitialPageKind);
	mePageKind = eInitialPageKind;
	meEditMode = EM_PAGE;
	DocumentType eDocType = GetDoc()->GetDocumentType(); // RTTI fasst hier noch nicht
    switch (mePageKind)
    {
        case PK_STANDARD:
            meShellType = ST_IMPRESS;
            break;

        case PK_NOTES:
            meShellType = ST_NOTES;
            break;

        case PK_HANDOUT:
            meShellType = ST_HANDOUT;
            break;
    }

	Size aPageSize( GetDoc()->GetSdPage(0, mePageKind)->GetSize() );
	Point aPageOrg( aPageSize.Width(), aPageSize.Height() / 2);
	Size aSize(aPageSize.Width() * 3, aPageSize.Height() * 2);
	InitWindows(aPageOrg, aSize, Point(-1, -1));

	Point aVisAreaPos;

	if ( pDocSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
	{
		aVisAreaPos = pDocSh->GetVisArea(ASPECT_CONTENT).TopLeft();
	}

	mpDrawView->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aSize));

	// Objekte koennen max. so gross wie die ViewSize werden
	GetDoc()->SetMaxObjSize(aSize);

	// Split-Handler fuer TabControls
	maTabControl.SetSplitHdl( LINK( this, DrawViewShell, TabSplitHdl ) );

	// Damit der richtige EditMode von der FrameView komplett eingestellt
	// werden kann, wird hier ein aktuell anderer gewaehlt (kleiner Trick)
	if (mpFrameView->GetViewShEditMode(mePageKind) == EM_PAGE)
	{
		meEditMode = EM_MASTERPAGE;
	}
	else
	{
		meEditMode = EM_PAGE;
	}

	// Einstellungen der FrameView uebernehmen
	ReadFrameViewData(mpFrameView);

	if( eDocType == DOCUMENT_TYPE_DRAW )
	{
		SetHelpId( SD_IF_SDGRAPHICVIEWSHELL );
		GetActiveWindow()->SetHelpId( HID_SDGRAPHICVIEWSHELL );
		GetActiveWindow()->SetUniqueId( HID_SDGRAPHICVIEWSHELL );
	}
	else
	{
		if (mePageKind == PK_NOTES)
		{
			SetHelpId( SID_NOTESMODE );
			GetActiveWindow()->SetHelpId( CMD_SID_NOTESMODE );
			GetActiveWindow()->SetUniqueId( CMD_SID_NOTESMODE );

			// AutoLayouts muessen erzeugt sein
			GetDoc()->StopWorkStartupDelay();
		}
		else if (mePageKind == PK_HANDOUT)
		{
			SetHelpId( SID_HANDOUTMODE );
			GetActiveWindow()->SetHelpId( CMD_SID_HANDOUTMODE );
			GetActiveWindow()->SetUniqueId( CMD_SID_HANDOUTMODE );

			// AutoLayouts muessen erzeugt sein
			GetDoc()->StopWorkStartupDelay();
		}
		else
		{
			SetHelpId( SD_IF_SDDRAWVIEWSHELL );
			GetActiveWindow()->SetHelpId( HID_SDDRAWVIEWSHELL );
			GetActiveWindow()->SetUniqueId( HID_SDDRAWVIEWSHELL );
		}
	}

	// Selektionsfunktion starten
	SfxRequest aReq(SID_OBJECT_SELECT, 0, GetDoc()->GetItemPool());
	FuPermanent(aReq);
	mpDrawView->SetFrameDragSingles(sal_True);

	if (pDocSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED)
	{
		mbZoomOnPage = sal_False;
	}
	else
	{
		mbZoomOnPage = sal_True;
	}

	mbIsRulerDrag = sal_False;

	String aName( RTL_CONSTASCII_USTRINGPARAM("DrawViewShell"));
	SetName (aName);

	mnLockCount = 0UL;

	::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );

	if( xMgr.is() )
	{
		mxScannerManager = ::com::sun::star::uno::Reference< ::com::sun::star::scanner::XScannerManager >(
						   xMgr->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.scanner.ScannerManager" ) ),
						   ::com::sun::star::uno::UNO_QUERY );

		if( mxScannerManager.is() )
		{
			mxScannerListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >(
								static_cast< ::cppu::OWeakObject* >( new ScannerEventListener( this ) ),
								::com::sun::star::uno::UNO_QUERY );
		}
	}

    mpAnnotationManager.reset( new AnnotationManager( GetViewShellBase() ) );
    mpViewOverlayManager.reset( new ViewOverlayManager( GetViewShellBase() ) );
}




void DrawViewShell::Init (bool bIsMainViewShell)
{
    ViewShell::Init(bIsMainViewShell);

    StartListening (*GetDocSh());
}




void DrawViewShell::Shutdown (void)
{
    ViewShell::Shutdown();

	if(SlideShow::IsRunning( GetViewShellBase() ) )
    {
        // Turn off effects.
        GetDrawView()->SetAnimationMode(SDR_ANIMATION_DISABLE);
    }
}




css::uno::Reference<css::drawing::XDrawSubController> DrawViewShell::CreateSubController (void)
{
    css::uno::Reference<css::drawing::XDrawSubController> xSubController;

    if (IsMainViewShell())
    {
        // Create uno sub controller for the main view shell.
        xSubController = css::uno::Reference<css::drawing::XDrawSubController>(
            new SdUnoDrawView (
                GetViewShellBase().GetDrawController(),
                *this,
                *GetView()));
    }

    return xSubController;
}




bool DrawViewShell::RelocateToParentWindow (::Window* pParentWindow)
{
    // DrawViewShells can not be relocated to a new parent window at the
    // moment, so return <FALSE/> except when the given parent window is the
    // parent window that is already in use.
    return pParentWindow==GetParentWindow();
}




/*************************************************************************
|*
|* pruefe ob linienzuege gezeichnet werden muessen
|*
\************************************************************************/

/*
	linienzuege werden ueber makros als folge von
		MoveTo (x, y)
		LineTo (x, y)	[oder BezierTo (x, y)]
		LineTo (x, y)
			:
	dargestellt. einen endbefehl fuer die linienzuege
	gibt es nicht, also muessen alle befehle in den
	requests nach LineTo (BezierTo) abgetestet und die
	punktparameter gesammelt werden.
	der erste nicht-LineTo fuehrt dann dazu, dass aus
	den gesammelten punkten der linienzug erzeugt wird
*/

void DrawViewShell::CheckLineTo(SfxRequest& rReq)
{
	(void)rReq;
#ifdef DBG_UTIL
	if(rReq.IsAPI())
	{
		if(SID_LINETO == rReq.GetSlot() || SID_BEZIERTO == rReq.GetSlot() || SID_MOVETO == rReq.GetSlot() )
		{
			DBG_ERROR("DrawViewShell::CheckLineTo: slots SID_LINETO, SID_BEZIERTO, SID_MOVETO no longer supported.");
		}
	}
#endif

	rReq.Ignore ();
}

/*************************************************************************
|*
|* veraendere die seitemparameter, wenn SID_PAGESIZE oder SID_PAGEMARGIN
|*
\************************************************************************/

void DrawViewShell::SetupPage (Size &rSize,
								 long nLeft,
								 long nRight,
								 long nUpper,
								 long nLower,
								 sal_Bool bSize,
								 sal_Bool bMargin,
								 sal_Bool bScaleAll)
{
	sal_uInt16 nPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind);
	sal_uInt16 i;

	for (i = 0; i < nPageCnt; i++)
	{
		/**********************************************************************
		* Erst alle MasterPages bearbeiten
		**********************************************************************/
		SdPage *pPage = GetDoc()->GetMasterSdPage(i, mePageKind);

		if( pPage )
		{
			if( bSize )
			{
				Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
				pPage->ScaleObjects(rSize, aBorderRect, bScaleAll);
				pPage->SetSize(rSize);

			}
			if( bMargin )
			{
				pPage->SetLftBorder(nLeft);
				pPage->SetRgtBorder(nRight);
				pPage->SetUppBorder(nUpper);
				pPage->SetLwrBorder(nLower);
			}

			if ( mePageKind == PK_STANDARD )
			{
				GetDoc()->GetMasterSdPage(i, PK_NOTES)->CreateTitleAndLayout();
			}

			pPage->CreateTitleAndLayout();
		}
	}

	nPageCnt = GetDoc()->GetSdPageCount(mePageKind);

	for (i = 0; i < nPageCnt; i++)
	{
		/**********************************************************************
		* Danach alle Pages bearbeiten
		**********************************************************************/
		SdPage *pPage = GetDoc()->GetSdPage(i, mePageKind);

		if( pPage )
		{
			if( bSize )
			{
				Rectangle aBorderRect(nLeft, nUpper, nRight, nLower);
				pPage->ScaleObjects(rSize, aBorderRect, bScaleAll);
				pPage->SetSize(rSize);
			}
			if( bMargin )
			{
				pPage->SetLftBorder(nLeft);
				pPage->SetRgtBorder(nRight);
				pPage->SetUppBorder(nUpper);
				pPage->SetLwrBorder(nLower);
			}

			if ( mePageKind == PK_STANDARD )
			{
				SdPage* pNotesPage = GetDoc()->GetSdPage(i, PK_NOTES);
				pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
			}

			pPage->SetAutoLayout( pPage->GetAutoLayout() );
		}
	}

	if ( mePageKind == PK_STANDARD )
	{
		SdPage* pHandoutPage = GetDoc()->GetSdPage(0, PK_HANDOUT);
		pHandoutPage->CreateTitleAndLayout(sal_True);
	}

	long nWidth = mpActualPage->GetSize().Width();
	long nHeight = mpActualPage->GetSize().Height();

	Point aPageOrg(nWidth, nHeight / 2);
	Size aSize( nWidth * 3, nHeight * 2);

	InitWindows(aPageOrg, aSize, Point(-1, -1), sal_True);

	Point aVisAreaPos;

	if ( GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
	{
		aVisAreaPos = GetDocSh()->GetVisArea(ASPECT_CONTENT).TopLeft();
	}

	GetView()->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aSize));

	UpdateScrollBars();

	Point aNewOrigin(mpActualPage->GetLftBorder(), mpActualPage->GetUppBorder());
	GetView()->GetSdrPageView()->SetPageOrigin(aNewOrigin);

	GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);

	// auf (neue) Seitengroesse zoomen
	GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE,
						SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
}

/*************************************************************************
|*
|* Statuswerte der Statusbar zurueckgeben
|*
\************************************************************************/

void DrawViewShell::GetStatusBarState(SfxItemSet& rSet)
{
	// Zoom-Item
	// Hier sollte der entsprechende Wert (Optimal ?, Seitenbreite oder
	// Seite) mit Hilfe des ZoomItems weitergegeben werden !!!
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOM ) )
	{
		if (GetDocSh()->IsUIActive() || (SlideShow::IsRunning(GetViewShellBase())) )
		{
			rSet.DisableItem( SID_ATTR_ZOOM );
		}
		else
		{
			SvxZoomItem* pZoomItem;
			sal_uInt16 nZoom = (sal_uInt16) GetActiveWindow()->GetZoom();

			if( mbZoomOnPage )
				pZoomItem = new SvxZoomItem( SVX_ZOOM_WHOLEPAGE, nZoom );
			else
				pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom );

			// Bereich einschraenken
			sal_uInt16 nZoomValues = SVX_ZOOM_ENABLE_ALL;
			SdrPageView* pPageView = mpDrawView->GetSdrPageView();

			if( ( pPageView && pPageView->GetObjList()->GetObjCount() == 0 ) )
				// || ( mpDrawView->GetMarkedObjectList().GetMarkCount() == 0 ) )
			{
				nZoomValues &= ~SVX_ZOOM_ENABLE_OPTIMAL;
			}

			pZoomItem->SetValueSet( nZoomValues );
			rSet.Put( *pZoomItem );
			delete pZoomItem;
		}
	}
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOMSLIDER ) )
	{
        rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) );
		if (GetDocSh()->IsUIActive() || (xSlideshow.is() && xSlideshow->isRunning()) || !GetActiveWindow() )
		{
			rSet.DisableItem( SID_ATTR_ZOOMSLIDER );
		}
		else
		{
			sd::Window * pActiveWindow = GetActiveWindow();
			SvxZoomSliderItem aZoomItem( (sal_uInt16) pActiveWindow->GetZoom(), (sal_uInt16)pActiveWindow->GetMinZoom(), (sal_uInt16)pActiveWindow->GetMaxZoom() ) ;

            SdrPageView* pPageView = mpDrawView->GetSdrPageView();
            if( pPageView )
            {
                Point aPagePos(0, 0);
				Size aPageSize = pPageView->GetPage()->GetSize();

				aPagePos.X() += aPageSize.Width()  / 2;
                aPageSize.Width() = (long) (aPageSize.Width() * 1.03);

				aPagePos.Y() += aPageSize.Height() / 2;
                aPageSize.Height() = (long) (aPageSize.Height() * 1.03);
				aPagePos.Y() -= aPageSize.Height() / 2;

				aPagePos.X() -= aPageSize.Width()  / 2;

                Rectangle aFullPageZoomRect( aPagePos, aPageSize );
                aZoomItem.AddSnappingPoint( pActiveWindow->GetZoomForRect( aFullPageZoomRect ) );
            }
			aZoomItem.AddSnappingPoint(100);
			rSet.Put( aZoomItem );
		}
	}

	Point aPos = GetActiveWindow()->PixelToLogic(maMousePos);
	mpDrawView->GetSdrPageView()->LogicToPagePos(aPos);
	Fraction aUIScale(GetDoc()->GetUIScale());
	aPos.X() = Fraction(aPos.X()) / aUIScale;
	aPos.Y() = Fraction(aPos.Y()) / aUIScale;

	// Position- und Groesse-Items
	if ( mpDrawView->IsAction() )
	{
		Rectangle aRect;
		mpDrawView->TakeActionRect( aRect );

		if ( aRect.IsEmpty() )
			rSet.Put( SfxPointItem(SID_ATTR_POSITION, aPos) );
		else
		{
			mpDrawView->GetSdrPageView()->LogicToPagePos(aRect);
			aPos = aRect.TopLeft();
			aPos.X() = Fraction(aPos.X()) / aUIScale;
			aPos.Y() = Fraction(aPos.Y()) / aUIScale;
			rSet.Put( SfxPointItem( SID_ATTR_POSITION, aPos) );
			Size aSize( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() );
			aSize.Height() = Fraction(aSize.Height()) / aUIScale;
			aSize.Width()  = Fraction(aSize.Width())  / aUIScale;
			rSet.Put( SvxSizeItem( SID_ATTR_SIZE, aSize) );
		}
	}
	else
	{
		if ( mpDrawView->AreObjectsMarked() )
		{
			Rectangle aRect = mpDrawView->GetAllMarkedRect();
			mpDrawView->GetSdrPageView()->LogicToPagePos(aRect);

            // Show the position of the selected shape(s)
            Point aShapePosition (aRect.TopLeft());
            aShapePosition.X() = Fraction(aShapePosition.X()) / aUIScale;
            aShapePosition.Y() = Fraction(aShapePosition.Y()) / aUIScale;
            rSet.Put (SfxPointItem(SID_ATTR_POSITION, aShapePosition));

			Size aSize( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() );
			aSize.Height() = Fraction(aSize.Height()) / aUIScale;
			aSize.Width()  = Fraction(aSize.Width())  / aUIScale;
			rSet.Put( SvxSizeItem( SID_ATTR_SIZE, aSize) );
		}
		else
        {
            rSet.Put( SfxPointItem(SID_ATTR_POSITION, aPos) );
			rSet.Put( SvxSizeItem( SID_ATTR_SIZE, Size( 0, 0 ) ) );
        }
	}

	// Display of current page and layer.
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_PAGE ) )
	{
        // Always show the slide/page number.
		String aString (SdResId( STR_SD_PAGE ));
        aString += sal_Unicode(' ');
        aString += UniString::CreateFromInt32( maTabControl.GetCurPageId() );
        aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " / " ));
        aString += UniString::CreateFromInt32( GetDoc()->GetSdPageCount( mePageKind ) );

        // If in layer mode additionally show the layer that contains all
        // selected shapes of the page.  If the shapes are distributed on
        // more than one layer, no layer name is shown.
		if (IsLayerModeActive())
		{
			SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
			SdrLayerID nLayer = 0, nOldLayer = 0;
			SdrLayer*  pLayer = NULL;
			SdrObject* pObj = NULL;
			const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
			sal_uLong nMarkCount = rMarkList.GetMarkCount();
			FASTBOOL bOneLayer = sal_True;

            // Use the first ten selected shapes as a (hopefully
            // representative) sample of all shapes of the current page.
            // Detect whether they belong to the same layer.
			for( sal_uLong j = 0; j < nMarkCount && bOneLayer && j < 10; j++ )
			{
				pObj = rMarkList.GetMark( j )->GetMarkedSdrObj();
				if( pObj )
				{
					nLayer = pObj->GetLayer();

					if( j != 0 && nLayer != nOldLayer )
						bOneLayer = sal_False;

					nOldLayer = nLayer;
				}
			}

            // Append the layer name to the current page number.
			if( bOneLayer && nMarkCount )
			{
				pLayer = rLayerAdmin.GetLayerPerID( nLayer );
				if( pLayer )
                {
                    aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " (" ));
					aString += pLayer->GetName();
                    aString += sal_Unicode(')');
                }
			}
		}

		rSet.Put (SfxStringItem (SID_STATUS_PAGE, aString));
	}
	// Layout
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_LAYOUT ) )
	{
		String aString = mpActualPage->GetLayoutName();
		aString.Erase( aString.SearchAscii( SD_LT_SEPARATOR ) );
		rSet.Put( SfxStringItem( SID_STATUS_LAYOUT, aString ) );
	}
}



void DrawViewShell::Notify (SfxBroadcaster&, const SfxHint& rHint)
{
	const SfxSimpleHint* pSimple = dynamic_cast< const SfxSimpleHint* >(&rHint);
	if (pSimple!=NULL && pSimple->GetId()==SFX_HINT_MODECHANGED)
	{
        // Change to selection when turning on read-only mode.
		if(GetDocSh()->IsReadOnly() && dynamic_cast< FuSelection* >( GetCurrentFunction().get() ) )
		{
			SfxRequest aReq(SID_OBJECT_SELECT, 0, GetDoc()->GetItemPool());
			FuPermanent(aReq);
		}

        // Turn on design mode when document is not read-only.
		if (GetDocSh()->IsReadOnly() != mbReadOnly )
		{
			mbReadOnly = GetDocSh()->IsReadOnly();

			SfxBoolItem aItem( SID_FM_DESIGN_MODE, !mbReadOnly );
			GetViewFrame()->GetDispatcher()->Execute( SID_FM_DESIGN_MODE,
                SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
		}
	}

}

void DrawViewShell::ExecuteAnnotation (SfxRequest& rRequest)
{
    if( mpAnnotationManager.get() )
        mpAnnotationManager->ExecuteAnnotation( rRequest );
}

// --------------------------------------------------------------------

void DrawViewShell::GetAnnotationState (SfxItemSet& rItemSet )
{
    if( mpAnnotationManager.get() )
        mpAnnotationManager->GetAnnotationState( rItemSet );
}




::rtl::OUString DrawViewShell::GetSidebarContextName (void) const
{
    ::svx::sidebar::SelectionAnalyzer::ViewType eViewType (::svx::sidebar::SelectionAnalyzer::VT_Standard);
    switch (mePageKind)
    {
        case PK_HANDOUT:
            eViewType = ::svx::sidebar::SelectionAnalyzer::VT_Handout;
            break;
        case PK_NOTES:
            eViewType = ::svx::sidebar::SelectionAnalyzer::VT_Notes;
            break;
        case PK_STANDARD:
            if (meEditMode == EM_MASTERPAGE)
                eViewType = ::svx::sidebar::SelectionAnalyzer::VT_Master;
            else
                eViewType = ::svx::sidebar::SelectionAnalyzer::VT_Standard;
            break;
    }
    return EnumContext::GetContextName(
        ::svx::sidebar::SelectionAnalyzer::GetContextForSelection_SD(
            mpDrawView->GetMarkedObjectList(),
            eViewType));
}


} // end of namespace sd