xref: /AOO41X/main/sd/source/ui/view/outlnvsh.cxx (revision 4d7c9de063a797b8b4f3d45e3561e82ad1f8ef1f)

/**************************************************************
 *
 * 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 "OutlineViewShell.hxx"

#include "ViewShellImplementation.hxx"
#include <memory>
#include "helpids.h"
#include "app.hrc"
#include <svx/hyprlink.hxx>
#include <svx/hyperdlg.hxx>
#include <svx/zoomslideritem.hxx>

#include <sfx2/objface.hxx>
#include <sot/exchange.hxx>
#include <svx/ruler.hxx>
#include <svx/zoomitem.hxx>
#include <editeng/eeitem.hxx>
#include <editeng/flditem.hxx>
#include <sfx2/shell.hxx>
#include <sfx2/templdlg.hxx>
#include <sfx2/viewfac.hxx>
#include <sfx2/request.hxx>
#include <svx/hlnkitem.hxx>
#include <svx/svdotext.hxx>
#include <sfx2/dispatch.hxx>
#include <vcl/scrbar.hxx>
#include <svl/whiter.hxx>
#include <editeng/editstat.hxx>
#include <svl/itempool.hxx>
#include <sfx2/tplpitem.hxx>
#include <sfx2/sidebar/SidebarChildWindow.hxx>
#include <sfx2/sidebar/EnumContext.hxx>
#include <svx/svdorect.hxx>
#include <sot/formats.hxx>
#include <com/sun/star/linguistic2/XThesaurus.hpp>
#include <com/sun/star/i18n/TransliterationModules.hpp>
#include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
#include <editeng/unolingu.hxx>
#include <comphelper/processfactory.hxx>
#include <editeng/outlobj.hxx>
#include <svl/cjkoptions.hxx>
#include <svtools/cliplistener.hxx>
#include <svl/srchitem.hxx>
#include <editeng/editobj.hxx>
#include "fubullet.hxx"
#include "optsitem.hxx"

#include "strings.hrc"
#include "glob.hrc"
#include "res_bmp.hrc"
#include "Outliner.hxx"
#include "Window.hxx"
#include "TextObjectBar.hxx"
#include "drawdoc.hxx"
#include "sdresid.hxx"
#include "sdpage.hxx"
#include "fuoltext.hxx"
#include "FrameView.hxx"
#include "zoomlist.hxx"
#include "stlsheet.hxx"
#include "slideshow.hxx"
#include "SdUnoOutlineView.hxx"
#include "SpellDialogChildWindow.hxx"

#include "AccessibleOutlineView.hxx"
#include "ViewShellBase.hxx"
#include "ViewShellManager.hxx"
#include "DrawController.hxx"
#include "framework/FrameworkHelper.hxx"

using ::rtl::OUString;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::linguistic2;

using namespace sd;
#define OutlineViewShell
#include "sdslots.hxx"

namespace sd {

#define MIN_ZOOM	       10       // Minimaler Zoomfaktor
#define MAX_ZOOM	     1000	    // Maximaler Zoomfaktor

/************************************************************************/


/*************************************************************************
|*
|* SFX-Slotmap und Standardinterface deklarieren
|*
\************************************************************************/


SFX_IMPL_INTERFACE(OutlineViewShell, SfxShell, SdResId(STR_OUTLINEVIEWSHELL))
{
	SFX_POPUPMENU_REGISTRATION( SdResId(RID_OUTLINE_POPUP) );
	SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_TOOLS | SFX_VISIBILITY_STANDARD |
								SFX_VISIBILITY_FULLSCREEN | SFX_VISIBILITY_SERVER,
								SdResId(RID_OUTLINE_TOOLBOX) );
    SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_APPLICATION | SFX_VISIBILITY_DESKTOP | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_CLIENT | SFX_VISIBILITY_VIEWER | SFX_VISIBILITY_READONLYDOC,
            					SdResId(RID_DRAW_VIEWER_TOOLBOX) );
	SFX_CHILDWINDOW_REGISTRATION( SfxTemplateDialogWrapper::GetChildWindowId() );
	SFX_CHILDWINDOW_REGISTRATION( SvxHyperlinkDlgWrapper::GetChildWindowId() );
	SFX_CHILDWINDOW_REGISTRATION( SvxHlinkDlgWrapper::GetChildWindowId() );
	SFX_CHILDWINDOW_REGISTRATION( ::sd::SpellDialogChildWindow::GetChildWindowId() );
	SFX_CHILDWINDOW_REGISTRATION( SID_SEARCH_DLG );
	SFX_CHILDWINDOW_REGISTRATION(::sfx2::sidebar::SidebarChildWindow::GetChildWindowId());
}


TYPEINIT1( OutlineViewShell, ViewShell );


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

void OutlineViewShell::Construct(DrawDocShell* )
{
	sal_Bool bModified = GetDoc()->IsChanged();

    meShellType = ST_OUTLINE;
	Size aSize(29700, 21000);
	Point aWinPos (0, 0);
	Point aViewOrigin(0, 0);
	GetActiveWindow()->SetMinZoomAutoCalc(sal_False);
	GetActiveWindow()->SetMinZoom( MIN_ZOOM );
	GetActiveWindow()->SetMaxZoom( MAX_ZOOM );
	InitWindows(aViewOrigin, aSize, aWinPos);
	pOlView = new OutlineView(GetDocSh(), GetActiveWindow(), this);
	mpView = pOlView;			 // Pointer der Basisklasse ViewShell

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

	SetZoom(69);

	// Einstellungen der FrameView uebernehmen
	ReadFrameViewData(mpFrameView);

	::Outliner* pOutl = pOlView->GetOutliner();
	pOutl->SetUpdateMode(sal_True);

	if (!bModified)
	{
		pOutl->ClearModifyFlag();
	}

	pLastPage = GetActualPage();

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

	SetHelpId( SD_IF_SDOUTLINEVIEWSHELL );
	GetActiveWindow()->SetHelpId( HID_SDOUTLINEVIEWSHELL );
	GetActiveWindow()->SetUniqueId( HID_SDOUTLINEVIEWSHELL );
}




Reference<drawing::XDrawSubController> OutlineViewShell::CreateSubController (void)
{
    Reference<drawing::XDrawSubController> xSubController;

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

    return xSubController;
}




/*************************************************************************
|*
|* Standard-Konstruktor, Fenster duerfen nicht automatisch zentrieren
|*
\************************************************************************/

OutlineViewShell::OutlineViewShell (
    SfxViewFrame* pFrame,
    ViewShellBase& rViewShellBase,
    ::Window* pParentWindow,
    FrameView* pFrameViewArgument)
    : ViewShell(pFrame, pParentWindow, rViewShellBase),
      pOlView(NULL),
      pLastPage( NULL ),
      pClipEvtLstnr(NULL),
      bPastePossible(false),
      mbInitialized(false)

{
	if (pFrameViewArgument != NULL)
		mpFrameView = pFrameViewArgument;
	else
        mpFrameView = new FrameView(GetDoc());

	mpFrameView->Connect();

	Construct(GetDocSh());

    SetContextName(sfx2::sidebar::EnumContext::GetContextName(sfx2::sidebar::EnumContext::Context_OutlineText));
	m_StrOldPageName.EmptyString();
}

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

OutlineViewShell::~OutlineViewShell()
{
	DisposeFunctions();

	delete pOlView;

	mpFrameView->Disconnect();

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




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

    PrepareClose();
}




/*************************************************************************
|*
|* Paint-Methode: das Ereignis wird vom Fenster pWindow an
|* die Viewshell und die aktuelle Funktion weitergeleitet
|*
\************************************************************************/

void OutlineViewShell::Paint(const Rectangle& rRect, ::sd::Window* pWin)
{
	if (pOlView)
	{
		pOlView->Paint(rRect, pWin);
	}

	if(HasCurrentFunction())
	{
		GetCurrentFunction()->Paint(rRect, pWin);
	}
}

void OutlineViewShell::ArrangeGUIElements ()
{
    // Retrieve the current size (thickness) of the scroll bars.  That is
    // the width of the vertical and the height of the horizontal scroll
    // bar.
    int nScrollBarSize =
        GetParentWindow()->GetSettings().GetStyleSettings().GetScrollBarSize();
	maScrBarWH = Size (nScrollBarSize, nScrollBarSize);

	ViewShell::ArrangeGUIElements ();

    ::sd::Window* pWindow = mpContentWindow.get();
    if (pWindow != NULL)
    {
        pWindow->SetMinZoomAutoCalc(sal_False);

        // pWindow->SetPosSizePixel(rNewPos, Size(nSizeX, nSizeY));

        // OutputArea der OutlinerView aendern
        OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);

        Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
//		aWin.nLeft = pOlView->GetPageNumberWidthPixel();

        aWin = pWindow->PixelToLogic(aWin);
        pOutlinerView->SetOutputArea(aWin);

        Rectangle aVis = pOutlinerView->GetVisArea();

        Rectangle aText = Rectangle(Point(0,0),
            Size(pOlView->GetPaperWidth(),
                pOlView->GetOutliner()->GetTextHeight()));
        aText.Bottom() += aWin.GetHeight();

        if (!aWin.IsEmpty())			// nicht beim Oeffnen
        {
            InitWindows(Point(0,0), aText.GetSize(), Point(aVis.TopLeft()));
            UpdateScrollBars();
        }
    }
}

/*************************************************************************
|*
|* SfxRequests fuer Controller bearbeiten
|*
\************************************************************************/

void OutlineViewShell::ExecCtrl(SfxRequest &rReq)
{
	sal_uInt16 nSlot = rReq.GetSlot();
	switch ( nSlot )
	{
		case SID_MAIL_SCROLLBODY_PAGEDOWN:
		{
            ExecReq( rReq );
			break;
		}

		case SID_OPT_LOCALE_CHANGED:
		{
			pOlView->GetOutliner()->UpdateFields();
			UpdatePreview( GetActualPage() );
			rReq.Done();
            break;
		}

		default:
		break;
	}
}




void OutlineViewShell::AddWindow (::sd::Window* pWin)
{
    pOlView->AddWindowToPaintView(pWin);
}




void OutlineViewShell::RemoveWindow (::sd::Window* pWin)
{
    pOlView->DeleteWindowFromPaintView(pWin);
}




/*************************************************************************
|*
|* Activate(), beim ersten Aufruf erfolgt ein Update der Felder
|*
\************************************************************************/
void OutlineViewShell::Activate( sal_Bool bIsMDIActivate )
{
    if ( ! mbInitialized)
    {
        mbInitialized = true;
    	SfxRequest aRequest (SID_EDIT_OUTLINER, 0, GetDoc()->GetItemPool());
        FuPermanent (aRequest);
    }

    ViewShell::Activate( bIsMDIActivate );
    SfxShell::BroadcastContextForActivation(true);

    pOlView->SetLinks();
    pOlView->ConnectToApplication();

    if( bIsMDIActivate )
    {
        OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() );
        ::Outliner* pOutl = pOutlinerView->GetOutliner();
        pOutl->UpdateFields();
    }
}

/*************************************************************************
|*
|* Deactivate()
|*
\************************************************************************/
void OutlineViewShell::Deactivate( sal_Bool bIsMDIActivate )
{
    pOlView->DisconnectFromApplication();

    // #96416# Links must be kept also on deactivated viewshell, to allow drag'n'drop
    // to function properly
    // pOlView->ResetLinks();

    ViewShell::Deactivate( bIsMDIActivate );
}

/*************************************************************************
|*
|* Status von Controller-SfxSlots setzen
|*
\************************************************************************/
void OutlineViewShell::GetCtrlState(SfxItemSet &rSet)
{
	if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_HYPERLINK_GETLINK))
	{
		SvxHyperlinkItem aHLinkItem;

		OutlinerView* pOLV = pOlView->GetViewByWindow(GetActiveWindow());
		if (pOLV)
		{
			const SvxFieldItem* pFieldItem = pOLV->GetFieldAtSelection();
			if (pFieldItem)
			{
                ESelection aSel = pOLV->GetSelection();
                if ( abs( aSel.nEndPos - aSel.nStartPos ) == 1 )
                {
				    const SvxFieldData* pField = pFieldItem->GetField();
				    if ( pField->ISA(SvxURLField) )
				    {
					    aHLinkItem.SetName(((const SvxURLField*) pField)->GetRepresentation());
					    aHLinkItem.SetURL(((const SvxURLField*) pField)->GetURL());
					    aHLinkItem.SetTargetFrame(((const SvxURLField*) pField)->GetTargetFrame());
				    }
                }
			}
		}
		rSet.Put(aHLinkItem);
	}
    rSet.Put( SfxBoolItem( SID_READONLY_MODE, GetDocSh()->IsReadOnly() ) );

	if ( SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_MAIL_SCROLLBODY_PAGEDOWN) )
		rSet.Put( SfxBoolItem( SID_MAIL_SCROLLBODY_PAGEDOWN, sal_True ) );

	if ( SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_HALFWIDTH) ||
		 SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_FULLWIDTH) ||
		 SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_HIRAGANA) ||
		 SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_KATAGANA) )
	{
        SvtCJKOptions aCJKOptions;
		if( !aCJKOptions.IsChangeCaseMapEnabled() )
		{
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_False );
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_False );
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_False );
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_False );
			rSet.DisableItem( SID_TRANSLITERATE_HALFWIDTH );
			rSet.DisableItem( SID_TRANSLITERATE_FULLWIDTH );
			rSet.DisableItem( SID_TRANSLITERATE_HIRAGANA );
			rSet.DisableItem( SID_TRANSLITERATE_KATAGANA );
		}
        else
        {
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_True );
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_True );
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_True );
            GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_True );
        }
	}
}

/*************************************************************************
|*
|* SfxRequests fuer Support-Funktionen
|*
\************************************************************************/

void OutlineViewShell::FuSupport(SfxRequest &rReq)
{
	if( rReq.GetSlot() == SID_STYLE_FAMILY && rReq.GetArgs())
		GetDocSh()->SetStyleFamily(((SfxUInt16Item&)rReq.GetArgs()->Get( SID_STYLE_FAMILY )).GetValue());

	sal_Bool bPreviewState = sal_False;
	sal_uLong nSlot = rReq.GetSlot();

	std::auto_ptr< OutlineViewModelChangeGuard > aGuard;
	if( pOlView && (
        (nSlot == SID_TRANSLITERATE_SENTENCE_CASE) ||
        (nSlot == SID_TRANSLITERATE_TITLE_CASE) ||
        (nSlot == SID_TRANSLITERATE_TOGGLE_CASE) ||
		(nSlot == SID_TRANSLITERATE_UPPER) ||
		(nSlot == SID_TRANSLITERATE_LOWER) ||
		(nSlot == SID_TRANSLITERATE_HALFWIDTH) ||
		(nSlot == SID_TRANSLITERATE_FULLWIDTH) ||
		(nSlot == SID_TRANSLITERATE_HIRAGANA) ||
		(nSlot == SID_TRANSLITERATE_KATAGANA) ||
		(nSlot == SID_CUT) ||
//		(nSlot == SID_COPY) ||
		(nSlot == SID_PASTE) ||
		(nSlot == SID_DELETE)))
	{
		aGuard.reset( new OutlineViewModelChangeGuard( *pOlView ) );
	}

	switch ( nSlot )
	{
		case SID_CUT:
		{
			if(HasCurrentFunction())
			{
				GetCurrentFunction()->DoCut();
			}
			else if (pOlView)
			{
				pOlView->DoCut();
			}
			rReq.Done();
			bPreviewState = sal_True;
		}
		break;

		case SID_COPY:
		{
			if(HasCurrentFunction())
			{
				GetCurrentFunction()->DoCopy();
			}
			else if (pOlView)
			{
				pOlView->DoCopy();
			}
			rReq.Done();
			bPreviewState = sal_True;
		}
		break;

		case SID_PASTE:
		{
            OutlineViewPageChangesGuard aGuard2(pOlView);

			if(HasCurrentFunction())
			{
				GetCurrentFunction()->DoPaste();
			}
			else if (pOlView)
			{
				pOlView->DoPaste();
			}
			rReq.Done();
			bPreviewState = sal_True;
		}
		break;

		case SID_DELETE:
		{
			if( pOlView )
			{
				OutlinerView* pOutlView = pOlView->GetViewByWindow(GetActiveWindow());
				if (pOutlView)
				{
					OutlineViewPageChangesGuard aGuard2(pOlView);

					KeyCode  aKCode(KEY_DELETE);
					KeyEvent aKEvt( 0, aKCode );
					pOutlView->PostKeyEvent(aKEvt);

					FunctionReference xFunc( GetCurrentFunction() );
					FuOutlineText* pFuOutlineText = dynamic_cast< FuOutlineText* >( xFunc.get() );
                    if( pFuOutlineText )
                        pFuOutlineText->UpdateForKeyPress (aKEvt);
				}
			}
			rReq.Done();
			bPreviewState = sal_True;
		}
		break;

		case SID_DRAWINGMODE:
		case SID_NOTESMODE:
		case SID_HANDOUTMODE:
		case SID_DIAMODE:
		case SID_OUTLINEMODE:
            framework::FrameworkHelper::Instance(GetViewShellBase())->HandleModeChangeSlot(
                nSlot,
                rReq);
			rReq.Done();
			break;

		case SID_RULER:
			SetRuler( !HasRuler() );
			Invalidate( SID_RULER );
			rReq.Done();
		break;

		case SID_ZOOM_PREV:
		{
			if (mpZoomList->IsPreviousPossible())
			{
				// Vorheriges ZoomRect einstellen
				SetZoomRect(mpZoomList->GetPreviousZoomRect());
			}
			rReq.Done ();
		}
		break;

		case SID_ZOOM_NEXT:
		{
			if (mpZoomList->IsNextPossible())
			{
				// Naechstes ZoomRect einstellen
				SetZoomRect(mpZoomList->GetNextZoomRect());
			}
			rReq.Done ();
		}
		break;

		case SID_AUTOSPELL_CHECK:
		{
			GetDoc()->SetOnlineSpell(!GetDoc()->GetOnlineSpell());
			rReq.Done ();
		}
		break;

        case SID_TRANSLITERATE_SENTENCE_CASE:
        case SID_TRANSLITERATE_TITLE_CASE:
        case SID_TRANSLITERATE_TOGGLE_CASE:
		case SID_TRANSLITERATE_UPPER:
		case SID_TRANSLITERATE_LOWER:
		case SID_TRANSLITERATE_HALFWIDTH:
		case SID_TRANSLITERATE_FULLWIDTH:
		case SID_TRANSLITERATE_HIRAGANA:
		case SID_TRANSLITERATE_KATAGANA:
		{
			OutlinerView* pOLV = pOlView->GetViewByWindow( GetActiveWindow() );
			if( pOLV )
			{
				using namespace ::com::sun::star::i18n;
				sal_Int32 nType = 0;

				switch( nSlot )
				{
                    case SID_TRANSLITERATE_SENTENCE_CASE:
                        nType = TransliterationModulesExtra::SENTENCE_CASE;
                        break;
                    case SID_TRANSLITERATE_TITLE_CASE:
                        nType = TransliterationModulesExtra::TITLE_CASE;
                        break;
                    case SID_TRANSLITERATE_TOGGLE_CASE:
                        nType = TransliterationModulesExtra::TOGGLE_CASE;
                        break;
                    case SID_TRANSLITERATE_UPPER:
						nType = TransliterationModules_LOWERCASE_UPPERCASE;
						break;
					case SID_TRANSLITERATE_LOWER:
						nType = TransliterationModules_UPPERCASE_LOWERCASE;
						break;
					case SID_TRANSLITERATE_HALFWIDTH:
						nType = TransliterationModules_FULLWIDTH_HALFWIDTH;
						break;
					case SID_TRANSLITERATE_FULLWIDTH:
						nType = TransliterationModules_HALFWIDTH_FULLWIDTH;
						break;
					case SID_TRANSLITERATE_HIRAGANA:
						nType = TransliterationModules_KATAKANA_HIRAGANA;
						break;
					case SID_TRANSLITERATE_KATAGANA:
						nType = TransliterationModules_HIRAGANA_KATAKANA;
						break;
				}

				pOLV->TransliterateText( nType );
			}

			rReq.Done();
			bPreviewState = sal_True;
		}
		break;

		// #96090# added Undo/Redo handling
		case SID_UNDO :
		{
			OutlineViewPageChangesGuard aGuard2(pOlView);
			ImpSidUndo(sal_False, rReq);
		}
		break;
		case SID_REDO :
		{
			OutlineViewPageChangesGuard aGuard2(pOlView);
			ImpSidRedo(sal_False, rReq);
		}
		break;

		default:
		break;
	}

	if( bPreviewState )
		Invalidate( SID_PREVIEW_STATE );

	Invalidate(SID_CUT);
	Invalidate(SID_COPY);
	Invalidate(SID_PASTE);
}

/*************************************************************************
|*
|* SfxRequests fuer permanente Funktionen
|*
\************************************************************************/

void OutlineViewShell::FuPermanent(SfxRequest &rReq)
{
	if(HasCurrentFunction())
	{
		DeactivateCurrentFunction(true);
	}

	switch ( rReq.GetSlot() )
	{
		case SID_EDIT_OUTLINER:
		{
			::Outliner* pOutl = pOlView->GetOutliner();
			if( pOutl )
			{
				pOutl->GetUndoManager().Clear();
				pOutl->UpdateFields();
			}

			SetCurrentFunction( FuOutlineText::Create(this,GetActiveWindow(),pOlView,GetDoc(),rReq) );

			rReq.Done();
		}
		break;

	  default:
	  break;
	}

	if(HasOldFunction())
	{
		GetOldFunction()->Deactivate();
		SetOldFunction(0);
	}

	if(HasCurrentFunction())
	{
		GetCurrentFunction()->Activate();
		SetOldFunction(GetCurrentFunction());
	}
}


IMPL_LINK( OutlineViewShell, ClipboardChanged, TransferableDataHelper*, pDataHelper )
{
	if ( pDataHelper )
	{
		bPastePossible = ( pDataHelper->GetFormatCount() != 0 &&
							( pDataHelper->HasFormat( FORMAT_STRING ) ||
							  pDataHelper->HasFormat( FORMAT_RTF ) ||
							  pDataHelper->HasFormat( SOT_FORMATSTR_ID_HTML ) ) );

		SfxBindings& rBindings = GetViewFrame()->GetBindings();
		rBindings.Invalidate( SID_PASTE );
        rBindings.Invalidate( SID_PASTE_SPECIAL );
		rBindings.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS );
	}
	return 0;
}

/*************************************************************************
|*
|* Status (Enabled/Disabled) von Menue-SfxSlots setzen
|*
\************************************************************************/

void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
{
	ViewShell::GetMenuState(rSet);

	// Vorlagenkatalog darf nicht aufgerufen werden
	rSet.DisableItem( SID_STYLE_CATALOG );

	rSet.Put(SfxBoolItem(SID_DIAMODE, sal_False));
	rSet.Put(SfxBoolItem(SID_DRAWINGMODE, sal_False));
	rSet.Put(SfxBoolItem(SID_OUTLINEMODE, sal_True));
	rSet.Put(SfxBoolItem(SID_NOTESMODE, sal_False));
	rSet.Put(SfxBoolItem(SID_HANDOUTMODE, sal_False));

	if (!mpZoomList->IsNextPossible())
	{
	   rSet.DisableItem(SID_ZOOM_NEXT);
	}
	if (!mpZoomList->IsPreviousPossible())
	{
	   rSet.DisableItem(SID_ZOOM_PREV);
	}

	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_IN ) ||
		SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_OUT ) )
	{
		if( GetActiveWindow()->GetZoom() <= GetActiveWindow()->GetMinZoom() || GetDocSh()->IsUIActive() )
			rSet.DisableItem( SID_ZOOM_IN );
		if( GetActiveWindow()->GetZoom() >= GetActiveWindow()->GetMaxZoom() || GetDocSh()->IsUIActive() )
			rSet.DisableItem( SID_ZOOM_OUT );
	}

	::Outliner* pOutl = pOlView->GetOutliner();
	DBG_ASSERT(pOutl, "OutlineViewShell::GetMenuState(), no outliner? Fatality!");
	if( !pOutl )
		return;

	// 'Alles auswaehlen' zulassen?
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_SELECTALL ) )
	{
		sal_uLong nParaCount = pOutl->GetParagraphCount();
		sal_Bool bDisable = nParaCount == 0;
		if (!bDisable && nParaCount == 1)
		{
			String aTest( pOutl->GetText( pOutl->GetParagraph( 0 ) ) );
			if (aTest.Len() == 0)
			{
				bDisable = sal_True;
			}
		}
		if (bDisable)
			rSet.DisableItem(SID_SELECTALL);
	}

	// Status des Lineals setzen
	rSet.Put( SfxBoolItem( SID_RULER, HasRuler() ) );

	// Formatierung ein oder aus?
	rSet.Put( SfxBoolItem( SID_OUTLINE_FORMAT, !pOutl->IsFlatMode() ) );

	if( pOutl->IsFlatMode() )
		rSet.DisableItem( SID_COLORVIEW );
	else
	{
		// Farbansicht ein/aus
		sal_uLong nCntrl = pOutl->GetControlWord();
		sal_Bool bNoColor = sal_False;
		if (nCntrl & EE_CNTRL_NOCOLORS)
			bNoColor = sal_True;

		rSet.Put( SfxBoolItem( SID_COLORVIEW, bNoColor ) );
	}

	// Buttons der Werkzeugleiste
	// zunaechst selektionsabhaengige: COLLAPSE, EXPAND
	sal_Bool bDisableCollapse = sal_True;
	sal_Bool bDisableExpand   = sal_True;
	sal_Bool bUnique		  = sal_True;
	OutlinerView* pOutlinerView = pOlView->GetViewByWindow(GetActiveWindow());
	List* pList = pOutlinerView->CreateSelectionList();
	Paragraph* pPara = (Paragraph*)pList->First();

	sal_Int16 nDepth;
	sal_Int16 nTmpDepth = pOutl->GetDepth( (sal_uInt16) pOutl->GetAbsPos( pPara ) );
	bool bPage = pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE );
	while (pPara)
	{
		nDepth = pOutl->GetDepth( (sal_uInt16) pOutl->GetAbsPos( pPara ) );

		if( nDepth != nTmpDepth )
			bUnique = sal_False;
		if( bPage != pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE ) )
			bUnique = sal_False;
		if (!pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara))
			bDisableExpand = sal_False;
		if (pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara))
			bDisableCollapse = sal_False;

		pPara = (Paragraph*)pList->Next();
	}

	delete pList;

	if (bDisableExpand)
		rSet.DisableItem(SID_OUTLINE_EXPAND);
	if (bDisableCollapse)
		rSet.DisableItem(SID_OUTLINE_COLLAPSE);

	// ergibt die Selektion ein eindeutiges Praesentationslayout?
	// wenn nicht, duerfen die Vorlagen nicht bearbeitet werden
	SfxItemSet aSet(*rSet.GetPool(), SID_STATUS_LAYOUT, SID_STATUS_LAYOUT);
	GetStatusBarState(aSet);
	String aTest(((SfxStringItem&)aSet.Get(SID_STATUS_LAYOUT)).GetValue());
	if (aTest.Len() == 0)
	{
		bUnique = sal_False;
		rSet.DisableItem(SID_PRESENTATION_TEMPLATES);
	}

	if (!bUnique)
		rSet.DisableItem( SID_PRESENTATIONOBJECT );

	// jetzt die selektionsunabhaengigen: COLLAPSE_ALL, EXPAND_ALL
	sal_Bool bDisableCollapseAll = sal_True;
	sal_Bool bDisableExpandAll	 = sal_True;

	// wenn schon die Selektion etwas kollabierbares/expandierbares enthaelt
	if (!bDisableCollapse)
		bDisableCollapseAll = sal_False;
	if (!bDisableExpand)
		bDisableExpandAll = sal_False;

	// schade, so billig kommen wir nicht davon; alle Absaetze durchsuchen
	if (bDisableCollapseAll || bDisableExpandAll)
	{
		sal_uLong nParaPos = 0;
		pPara = pOutl->GetParagraph( nParaPos );
		while (pPara && (bDisableCollapseAll || bDisableExpandAll))
		{
			if (!pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara))
				bDisableExpandAll = sal_False;

			if (pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara))
				bDisableCollapseAll = sal_False;

			pPara = pOutl->GetParagraph( ++nParaPos );
		}
	}

	if (bDisableExpandAll)
		rSet.DisableItem(SID_OUTLINE_EXPAND_ALL);
	if (bDisableCollapseAll)
		rSet.DisableItem(SID_OUTLINE_COLLAPSE_ALL);

	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PASTE ) )
	{
		if ( !pClipEvtLstnr )
		{
			// create listener
			pClipEvtLstnr = new TransferableClipboardListener( LINK( this, OutlineViewShell, ClipboardChanged ) );
			pClipEvtLstnr->acquire();
			pClipEvtLstnr->AddRemoveListener( GetActiveWindow(), sal_True );

			// get initial state
			TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( GetActiveWindow() ) );
			bPastePossible = ( aDataHelper.GetFormatCount() != 0 &&
								( aDataHelper.HasFormat( FORMAT_STRING ) ||
								  aDataHelper.HasFormat( FORMAT_RTF ) ||
								  aDataHelper.HasFormat( SOT_FORMATSTR_ID_HTML ) ) );
		}

		if( !bPastePossible )
		{
			rSet.DisableItem( SID_PASTE );
		}
	}

	if (!pOlView->GetViewByWindow(GetActiveWindow())->HasSelection())
	{
		rSet.DisableItem(SID_CUT);
		rSet.DisableItem(SID_COPY);
	}

	if (pOlView->GetOutliner()->IsModified())
	{
		GetDoc()->SetChanged(sal_True);
	}

	// Da �berladen, muss hier der Status gesetzt werden
	if( !GetDocSh()->IsModified() )
	{
		rSet.DisableItem( SID_SAVEDOC );
	}

	if ( GetDocSh()->IsReadOnly() )
	{
		rSet.DisableItem( SID_AUTOSPELL_CHECK );
	}
	else
	{
		if (GetDoc()->GetOnlineSpell())
		{
			rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, sal_True));
		}
		else
		{
			rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, sal_False));
		}
	}

	// Feldbefehle
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MODIFY_FIELD ) )
	{
		const SvxFieldItem* pFldItem = pOutlinerView->GetFieldAtSelection();

		if( !( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) ||
							pFldItem->GetField()->ISA( SvxAuthorField ) ||
							pFldItem->GetField()->ISA( SvxExtFileField ) ||
							pFldItem->GetField()->ISA( SvxExtTimeField ) ) ) )
		{
			rSet.DisableItem( SID_MODIFY_FIELD );
		}
	}

	if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_EXPAND_PAGE))
	{
		sal_Bool bDisable = sal_True;
		sal_uInt16 i = 0;
		sal_uInt16 nCount = GetDoc()->GetSdPageCount(PK_STANDARD);
		pOlView->SetSelectedPages();

		while (i < nCount && bDisable)
		{
			SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD);

			if (pPage->IsSelected())
			{
				SdrObject* pObj = pPage->GetPresObj(PRESOBJ_OUTLINE);

                if (pObj!=NULL )
				{
					if( !pObj->IsEmptyPresObj() )
					{
						bDisable = false;
					}
					else
					{
						// check if the object is in edit, than its temporarely not empty
						SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj );
						if( pTextObj )
						{
							OutlinerParaObject* pParaObj = pTextObj->GetEditOutlinerParaObject();
							if( pParaObj )
							{
								delete pParaObj;
								bDisable = false;
							}
						}
					}
				}
			}

			i++;
		}

		if (bDisable)
		{
			rSet.DisableItem(SID_EXPAND_PAGE);
		}
	}

	if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_SUMMARY_PAGE))
	{
		sal_Bool bDisable = sal_True;
		sal_uInt16 i = 0;
		sal_uInt16 nCount = GetDoc()->GetSdPageCount(PK_STANDARD);
		pOlView->SetSelectedPages();

		while (i < nCount && bDisable)
		{
			SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD);

			if (pPage->IsSelected())
			{
				SdrObject* pObj = pPage->GetPresObj(PRESOBJ_TITLE);

				if (pObj && !pObj->IsEmptyPresObj())
				{
					bDisable = sal_False;
				}
			}

			i++;
		}

		if (bDisable)
		{
			rSet.DisableItem(SID_SUMMARY_PAGE);
		}
	}

    if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_THESAURUS ) )
	{
		if ( !pOlView->IsTextEdit() )
		{
			rSet.DisableItem( SID_THESAURUS );
		}
		else
		{
			LanguageType            eLang = GetDoc()->GetLanguage( EE_CHAR_LANGUAGE );
	        Reference< XThesaurus > xThesaurus( LinguMgr::GetThesaurus() );
			Locale                  aLocale;

			SvxLanguageToLocale( aLocale, eLang );

            if (!xThesaurus.is() || eLang == LANGUAGE_NONE || !xThesaurus->hasLocale(aLocale))
				rSet.DisableItem( SID_THESAURUS );
		}
	}

	// Starten der Praesentation moeglich?
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PRESENTATION ) )
	{
		sal_Bool bDisable = sal_True;
		sal_uInt16 nCount = GetDoc()->GetSdPageCount( PK_STANDARD );

		for( sal_uInt16 i = 0; i < nCount && bDisable; i++ )
		{
			SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD);

			if( !pPage->IsExcluded() )
				bDisable = sal_False;
		}
		if( bDisable || GetDocSh()->IsPreview())
		{
			rSet.DisableItem( SID_PRESENTATION );
		}
	}

	FuBullet::GetSlotState( rSet, this, GetViewFrame() );

	//rSet.DisableItem( SID_PRINTDOC );
	//rSet.DisableItem( SID_PRINTDOCDIRECT );
	//rSet.DisableItem( SID_SETUPPRINTER );
}

/*************************************************************************
|*
|* wird gerufen, wenn ScrollBar benutzt wird
|*
\************************************************************************/

long OutlineViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
{
	long   nThumb = pHScroll->GetThumbPos();
	long   nRange = pHScroll->GetRange().Len();
	double fX	  = (double) nThumb / nRange;

    Window* 	  pWin			= mpContentWindow.get();
    OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWin);
    long		  nViewWidth	= pWin->PixelToLogic(
        pWin->GetSizePixel()).Width();
    long		  nTextWidth	= pOlView->GetPaperWidth();
    nViewWidth					= Max(nViewWidth, nTextWidth);
    long		  nCurrentPos	= pOutlinerView->GetVisArea().Left();
    long		  nTargetPos	= (long)(fX * nViewWidth);
    long		  nDelta		= nTargetPos - nCurrentPos;

    pOutlinerView->HideCursor();
    pOutlinerView->Scroll(-nDelta, 0);
    pOutlinerView->ShowCursor(sal_False);

    pOlView->InvalidateSlideNumberArea();
	return 0;
}

/*************************************************************************
|*
|* wird gerufen, wenn ScrollBar benutzt wird
|*
\************************************************************************/

long OutlineViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
{
	long nThumb = pVScroll->GetThumbPos();
	long nRange = pVScroll->GetRange().Len();
	double fY = (double) nThumb / nRange;

    Window* 	  pWin			= mpContentWindow.get();
    OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWin);
    long		  nViewHeight	= pWin->PixelToLogic(
        pWin->GetSizePixel()).Height();
    long		  nTextHeight	= pOlView->GetOutliner()->GetTextHeight();
    nViewHeight 			   += nTextHeight;
    long		  nCurrentPos	= pOutlinerView->GetVisArea().Top();
    long		  nTargetPos	= (long)(fY * nViewHeight);
    long		  nDelta		= nTargetPos - nCurrentPos;

    pOutlinerView->HideCursor();
    pOutlinerView->Scroll(0, -nDelta);
    pOutlinerView->ShowCursor(sal_False);

    pOlView->InvalidateSlideNumberArea();

	return 0;
}

/*************************************************************************
|*
|* PrepareClose, wird gerufen, wenn die Shell zestoert werden soll,
|* leitet den Aufruf an die View weiter
|*
\************************************************************************/

sal_uInt16 OutlineViewShell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing )
{
	if( ViewShell::PrepareClose(bUI, bForBrowsing) != sal_True )
		return sal_False;

	return pOlView == NULL || pOlView->PrepareClose(bUI);
}


/*************************************************************************
|*
|* Zoomen mit Zoomfaktor, OutlinerView informieren
|*
\************************************************************************/

void OutlineViewShell::SetZoom(long nZoom)
{
	ViewShell::SetZoom(nZoom);

    ::sd::Window* pWindow = mpContentWindow.get();
    if (pWindow)
    {
        // OutputArea der OutlinerView aendern
        OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
        Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
        aWin = pWindow->PixelToLogic(aWin);
        pOutlinerView->SetOutputArea(aWin);
    }

	// #106268#
	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
}

/*************************************************************************
|*
|* Zoomen mit Zoomrechteck, OutlinerView informieren
|*
\************************************************************************/

void OutlineViewShell::SetZoomRect(const Rectangle& rZoomRect)
{
	ViewShell::SetZoomRect(rZoomRect);

    ::sd::Window* pWindow = mpContentWindow.get();
    if (pWindow)
    {
        // OutputArea der OutlinerView aendern
        OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
        Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
        aWin = pWindow->PixelToLogic(aWin);
        pOutlinerView->SetOutputArea(aWin);
    }

	// #106268#
	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
	GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
}

/*************************************************************************
|*
|* Vorm Speichern das Model der Drawing Engine aktualisieren, dann den
|* Call weiterleiten an die ObjectShell.
|*
\************************************************************************/

void OutlineViewShell::Execute(SfxRequest& rReq)
{
    bool bForwardCall = true;

	switch(rReq.GetSlot())
	{
		case SID_SAVEDOC:
		case SID_SAVEASDOC:
			PrepareClose();
            break;

		case SID_SEARCH_ITEM:
            // Forward this request to the the common (old) code of the
            // document shell.
            GetDocSh()->Execute (rReq);
            bForwardCall = false;
            break;

        case SID_SPELL_DIALOG:
        {
            SfxViewFrame* pViewFrame = GetViewFrame();
            if (rReq.GetArgs() != NULL)
                pViewFrame->SetChildWindow (SID_SPELL_DIALOG,
                    ((const SfxBoolItem&) (rReq.GetArgs()->
                        Get(SID_SPELL_DIALOG))).GetValue());
            else
                pViewFrame->ToggleChildWindow(SID_SPELL_DIALOG);

            pViewFrame->GetBindings().Invalidate(SID_SPELL_DIALOG);
            rReq.Done ();

            bForwardCall = false;
        }
        break;

		default:
            OSL_TRACE ("OutlineViewShell::Execute(): can not handle slot %d", rReq.GetSlot());
            break;

	}

    if (bForwardCall)
        ((DrawDocShell*)GetViewFrame()->GetObjectShell())->ExecuteSlot( rReq );
}

/*************************************************************************
|*
|* Read FrameViews data and set actual views data
|*
\************************************************************************/

void OutlineViewShell::ReadFrameViewData(FrameView* pView)
{
	::Outliner* pOutl = pOlView->GetOutliner();

	if ( pView->IsNoAttribs() )
		pOutl->SetFlatMode( sal_True );   // Attribut-Darstellung ausschalten
	else
		pOutl->SetFlatMode( sal_False );  // Attribut-Darstellung einschalten

	sal_uLong nCntrl = pOutl->GetControlWord();

	if ( pView->IsNoColors() )
		pOutl->SetControlWord(nCntrl | EE_CNTRL_NOCOLORS);   // Farbansicht ausschalten
	else
		pOutl->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS);  // Farbansicht einschalten

	sal_uInt16 nPage = mpFrameView->GetSelectedPage();
	pLastPage = GetDoc()->GetSdPage( nPage, PK_STANDARD );
    pOlView->SetActualPage(pLastPage);
}



/*************************************************************************
|*
|* Write actual views data to FrameView
|*
\************************************************************************/

void OutlineViewShell::WriteFrameViewData()
{
	::Outliner* pOutl = pOlView->GetOutliner();

	sal_uLong nCntrl = pOutl->GetControlWord();
	sal_Bool bNoColor = sal_False;
	if (nCntrl & EE_CNTRL_NOCOLORS)
		bNoColor = sal_True;
	mpFrameView->SetNoColors(bNoColor);
	mpFrameView->SetNoAttribs( pOutl->IsFlatMode() );
	SdPage* pActualPage = pOlView->GetActualPage();
    DBG_ASSERT(pActualPage, "No current page");
	if( pActualPage )
        mpFrameView->SetSelectedPage((pActualPage->GetPageNum() - 1) / 2);
}


/*************************************************************************
|*
|* SfxRequests fuer StatusBar bearbeiten
|*
\************************************************************************/

void OutlineViewShell::ExecStatusBar(SfxRequest&)
{
}

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

void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet)
{
	// Zoom-Item
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOM ) )
	{
		SvxZoomItem* pZoomItem;
		sal_uInt16 nZoom = (sal_uInt16) GetActiveWindow()->GetZoom();

		pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom );

		// Bereich einschraenken
		sal_uInt16 nZoomValues = SVX_ZOOM_ENABLE_ALL;
		nZoomValues &= ~SVX_ZOOM_ENABLE_OPTIMAL;
		nZoomValues &= ~SVX_ZOOM_ENABLE_WHOLEPAGE;
		nZoomValues &= ~SVX_ZOOM_ENABLE_PAGEWIDTH;

		pZoomItem->SetValueSet( nZoomValues );
		rSet.Put( *pZoomItem );
		delete pZoomItem;
	}

	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOMSLIDER ) )
	{
		if (GetDocSh()->IsUIActive() || !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() ) ;
			aZoomItem.AddSnappingPoint(100);
			rSet.Put( aZoomItem );
		}
	}


	// Seitenanzeige und Layout
	/*
	if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_PAGE ) ||
		SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_LAYOUT ) )
	*/
	sal_uInt16	nPageCount = GetDoc()->GetSdPageCount( PK_STANDARD );
	String	aPageStr, aLayoutStr;

	::sd::Window*		pWin		= GetActiveWindow();
	OutlinerView*	pActiveView = pOlView->GetViewByWindow( pWin );
	::Outliner*     pOutliner   = pOlView->GetOutliner();
	List*			pSelList	= (List*)pActiveView->CreateSelectionList();
	Paragraph*		pFirstPara	= (Paragraph*)pSelList->First();
	Paragraph*		pLastPara	= (Paragraph*)pSelList->Last();

	if( !pOutliner->HasParaFlag(pFirstPara,PARAFLAG_ISPAGE) )
		pFirstPara = pOlView->GetPrevTitle( pFirstPara );

	if( !pOutliner->HasParaFlag(pLastPara, PARAFLAG_ISPAGE) )
		pLastPara = pOlView->GetPrevTitle( pLastPara );

	delete pSelList;				// die wurde extra fuer uns erzeugt

	// nur eine Seite selektiert?
	if( pFirstPara == pLastPara )
	{
		// wieviele Seiten sind vor der selektierten Seite?
		sal_uLong nPos = 0L;
		while( pFirstPara )
		{
			pFirstPara = pOlView->GetPrevTitle( pFirstPara );
			if( pFirstPara )
				nPos++;
		}

		if( nPos >= GetDoc()->GetSdPageCount( PK_STANDARD ) )
			nPos = 0;

		SdrPage* pPage = GetDoc()->GetSdPage( (sal_uInt16) nPos, PK_STANDARD );

		aPageStr = String(SdResId( STR_SD_PAGE ));
		aPageStr += sal_Unicode(' ');
		aPageStr += String::CreateFromInt32( (sal_Int32)(nPos + 1) );	// sal_uLong -> sal_Int32
		aPageStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " / " ));
		aPageStr += String::CreateFromInt32( nPageCount );

		aLayoutStr = pPage->GetLayoutName();
		aLayoutStr.Erase( aLayoutStr.SearchAscii( SD_LT_SEPARATOR ) );
			//Now, CurrentPage property change is already sent for DrawView and OutlineView, so it is not necessary to send again here
			if(m_StrOldPageName!=aPageStr)
			{
				GetViewShellBase().GetDrawController().fireSwitchCurrentPage(nPos);
				m_StrOldPageName = aPageStr;
			}
	}
	rSet.Put( SfxStringItem( SID_STATUS_PAGE, aPageStr ) );
	rSet.Put( SfxStringItem( SID_STATUS_LAYOUT, aLayoutStr ) );
}

/*************************************************************************
|*
|* Command event
|*
\************************************************************************/

void OutlineViewShell::Command( const CommandEvent& rCEvt, ::sd::Window* pWin )
{
	if ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU )
	{
		GetActiveWindow()->ReleaseMouse();

		OutlinerView* pOLV = pOlView->GetViewByWindow(GetActiveWindow());
		Point aPos(rCEvt.GetMousePosPixel());

		if (pOLV && pOLV->IsWrongSpelledWordAtPos(aPos))
		{
			// #91457# Popup for Online-Spelling now handled by DrawDocShell
			// Link aLink = LINK(GetDoc(), SdDrawDocument, OnlineSpellCallback);
			Link aLink = LINK(GetDocSh(), DrawDocShell, OnlineSpellCallback);

			pOLV->ExecuteSpellPopup(aPos, &aLink);
		}
		else
		{
		   GetViewFrame()->GetDispatcher()->ExecutePopup(SdResId(RID_OUTLINE_POPUP));
		}
	}
	else
	{
		ViewShell::Command( rCEvt, pWin );

		// ggfs. Preview den neuen Kontext mitteilen
		Invalidate( SID_PREVIEW_STATE );

	}
}


/*************************************************************************
|*
|* Keyboard event
|*
\************************************************************************/

sal_Bool OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
{
	sal_Bool bReturn = sal_False;
	OutlineViewPageChangesGuard aGuard(pOlView);

	if (pWin == NULL && HasCurrentFunction())
	{
		bReturn = GetCurrentFunction()->KeyInput(rKEvt);
	}

	// nein, weiterleiten an Basisklasse
	else
	{
		bReturn = ViewShell::KeyInput(rKEvt, pWin);
	}

	Invalidate(SID_STYLE_EDIT);
	Invalidate(SID_STYLE_NEW);
	Invalidate(SID_STYLE_DELETE);
	Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE);
	Invalidate(SID_STYLE_NEW_BY_EXAMPLE);
	Invalidate(SID_STYLE_WATERCAN);
	Invalidate(SID_STYLE_FAMILY5);

	// Pruefen und Unterscheiden von CursorBewegungs- oder Eingabe-Keys
	KeyCode aKeyGroup( rKEvt.GetKeyCode().GetGroup() );
	if( (aKeyGroup != KEYGROUP_CURSOR && aKeyGroup != KEYGROUP_FKEYS) ||
		(GetActualPage() != pLastPage) )
	{
		Invalidate( SID_PREVIEW_STATE );
	}

	return(bReturn);
}


/*************************************************************************
|*
|* Optimale Groesse zurueckgeben
|*
\************************************************************************/

Size OutlineViewShell::GetOptimalSizePixel() const
{
	Size aResult(200, 200);
	if (pOlView)
	{
		::Outliner* pOutliner = pOlView->GetOutliner();
		if (pOutliner)
		{
			Size aTemp = pOutliner->CalcTextSize();
			aTemp = GetActiveWindow()->LogicToPixel(aTemp);
			aResult.Width() = Max(aResult.Width(), aTemp.Width());
			aResult.Height() = Max(aResult.Height(), aTemp.Height());
			if (4 * aResult.Height() > 3 * aResult.Width())
			{
				aResult.Height() = 3 * aResult.Width() / 4;
			}
		}
	}

	// und jetzt jetzt das Standardgelumpe draufaddieren
	aResult.Width()  += mpVerticalScrollBar->GetSizePixel().Width();
	aResult.Height() += mpHorizontalScrollBar->GetSizePixel().Height();
		//!!! +	System::GetMenuBarHeightPixel();  // statt Titlebar
	return aResult;
}


/*************************************************************************
|*
|* Text der Selektion zurueckgeben
|*
\************************************************************************/

String OutlineViewShell::GetSelectionText(sal_Bool bCompleteWords)
{
	String aStrSelection;
	::Outliner* pOl = pOlView->GetOutliner();
	OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() );

	if (pOl && pOlView)
	{
		if (bCompleteWords)
		{
			ESelection aSel = pOutlinerView->GetSelection();
			String aStrCurrentDelimiters = pOl->GetWordDelimiters();

			pOl->SetWordDelimiters( String( RTL_CONSTASCII_USTRINGPARAM( " .,;\"'" )));
			aStrSelection = pOl->GetWord( aSel.nEndPara, aSel.nEndPos );
			pOl->SetWordDelimiters( aStrCurrentDelimiters );
		}
		else
		{
			aStrSelection = pOutlinerView->GetSelected();
		}
	}

	return (aStrSelection);
}


/*************************************************************************
|*
|* Ist etwas selektiert?
|*
\************************************************************************/

sal_Bool OutlineViewShell::HasSelection(sal_Bool bText) const
{
	sal_Bool bReturn = sal_False;

	if (bText)
	{
		OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() );

		if (pOutlinerView && pOutlinerView->GetSelected().Len() != 0)
		{
			bReturn = sal_True;
		}
	}

	return bReturn;
}


/*************************************************************************
|*
|* Status der Attribut-Items
|*
\************************************************************************/

void OutlineViewShell::GetAttrState( SfxItemSet& rSet )
{
	SfxWhichIter  aIter( rSet );
	sal_uInt16        nWhich = aIter.FirstWhich();
	SfxAllItemSet aAllSet( *rSet.GetPool() );

	while ( nWhich )
	{
		sal_uInt16 nSlotId = SfxItemPool::IsWhich(nWhich)
			? GetPool().GetSlotId(nWhich)
			: nWhich;

		switch ( nSlotId )
		{
			case SID_STYLE_FAMILY2:
			case SID_STYLE_FAMILY3:
			{
				rSet.DisableItem( nWhich );
			}
			break;

			case SID_STYLE_FAMILY5:
			{
				SfxStyleSheet* pStyleSheet = pOlView->GetViewByWindow(GetActiveWindow())->GetStyleSheet();

				if( pStyleSheet )
				{
					pStyleSheet = ((SdStyleSheet*)pStyleSheet)->GetPseudoStyleSheet();

					if (pStyleSheet)
					{
						SfxTemplateItem aItem( nWhich, pStyleSheet->GetName() );
						aAllSet.Put( aItem, aItem.Which()  );
					}
				}

				if( !pStyleSheet )
				{
					SfxTemplateItem aItem( nWhich, String() );
					aAllSet.Put( aItem, aItem.Which() );
					// rSet.DisableItem( nWhich );
				}
			}
			break;

			case SID_STYLE_EDIT:
			{
				ISfxTemplateCommon* pTmplCommon = SFX_APP()->GetCurrentTemplateCommon(GetViewFrame()->GetBindings());

				if (pTmplCommon && pTmplCommon->GetActualFamily() == SD_STYLE_FAMILY_PSEUDO)
				{
					SfxItemSet aSet(*rSet.GetPool(), SID_STATUS_LAYOUT, SID_STATUS_LAYOUT);
					GetStatusBarState(aSet);
					String aRealStyle(((SfxStringItem&) aSet.Get(SID_STATUS_LAYOUT)).GetValue());

					if (!aRealStyle.Len())
					{
						// Kein eindeutiger Layoutname gefunden
						rSet.DisableItem(nWhich);
					}
				}
			}
			break;

			case SID_STYLE_UPDATE_BY_EXAMPLE:
			{
				::sd::Window*     pActWin = GetActiveWindow();
				OutlinerView* pOV = pOlView->GetViewByWindow(pActWin);
				ESelection aESel(pOV->GetSelection());

				if (aESel.nStartPara != aESel.nEndPara ||
					aESel.nStartPos  != aESel.nEndPos)
					// aufgespannte Selektion, also StyleSheet und/oder
					// Attributierung nicht zwingend eindeutig
					rSet.DisableItem(nWhich);
			}
			break;

			case SID_STYLE_NEW:
			case SID_STYLE_DELETE:
			case SID_STYLE_NEW_BY_EXAMPLE:
			case SID_STYLE_WATERCAN:
			{
				rSet.DisableItem(nWhich);
			}
			break;
		}

		nWhich = aIter.NextWhich();
	}

	rSet.Put( aAllSet, sal_False );
}



/*************************************************************************
|*
|* MouseButtonUp event
|*
\************************************************************************/

void OutlineViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
{
	// Zuerst die Basisklasse
	ViewShell::MouseButtonUp(rMEvt, pWin);

	Invalidate(SID_STYLE_EDIT);
	Invalidate(SID_STYLE_NEW);
	Invalidate(SID_STYLE_DELETE);
	Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE);
	Invalidate(SID_STYLE_NEW_BY_EXAMPLE);
	Invalidate(SID_STYLE_WATERCAN);
	Invalidate(SID_STYLE_FAMILY5);

	// ggfs. Preview den neuen Kontext mitteilen
	if( GetActualPage() != pLastPage )
		Invalidate( SID_PREVIEW_STATE );
}



SdPage* OutlineViewShell::getCurrentPage() const
{
	// since there are no master pages in outline view, we can
	// for now use the GetActualPage method
	return const_cast<OutlineViewShell*>(this)->GetActualPage();
}

/*************************************************************************
|*
|* Liefert die erste selektierte Seite zurueck.
|* Wenn nichts selektiert ist, wird die erste Seite zurueckgeliefert.
|*
\************************************************************************/
SdPage* OutlineViewShell::GetActualPage()
{
	return pOlView->GetActualPage();
}


void OutlineViewShell::UpdatePreview( SdPage* pPage, sal_Bool )
{
	const bool bNewPage = pPage != pLastPage;
	pLastPage = pPage;
	if (bNewPage)
	{
		OutlineViewPageChangesGuard aGuard(pOlView);
        SetCurrentPage(pPage);
    }
}

/*************************************************************************
|*
|* Update Title
|*
\************************************************************************/

bool OutlineViewShell::UpdateTitleObject( SdPage* pPage, Paragraph* pPara )
{
	DBG_ASSERT( pPage, "sd::OutlineViewShell::UpdateTitleObject(), pPage == 0?" );
	DBG_ASSERT( pPara, "sd::OutlineViewShell::UpdateTitleObject(), pPara == 0?" );

	if( !pPage || !pPara )
		return false;

	::Outliner* 			pOutliner = pOlView->GetOutliner();
	SdrTextObj* 		pTO  = pOlView->GetTitleTextObject( pPage );
	OutlinerParaObject* pOPO = NULL;

	String	aTest( pOutliner->GetText( pPara ) );
	bool 	bText = aTest.Len() > 0;
	bool 	bNewObject = false;

	if( bText )
	{
		// create a title object if we don't have one but have text
		if( !pTO )
		{
			DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );
			pTO = pOlView->CreateTitleTextObject(pPage);
			bNewObject = sal_True;
		}

		// if we have a title object and a text, set the text
		if( pTO )
		{
			pOPO = pOutliner->CreateParaObject( (sal_uInt16) pOutliner->GetAbsPos( pPara ), 1 );
			pOPO->SetOutlinerMode( OUTLINERMODE_TITLEOBJECT );
			pOPO->SetVertical( pTO->IsVerticalWriting() );
			if( pTO->GetOutlinerParaObject() && (pOPO->GetTextObject() == pTO->GetOutlinerParaObject()->GetTextObject()) )
			{
				// do nothing, same text already set
				delete pOPO;
			}
			else
			{
				DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );
				if( !bNewObject && pOlView->isRecordingUndo() )
					pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));

				pTO->SetOutlinerParaObject( pOPO );
				pTO->SetEmptyPresObj( sal_False );
				pTO->ActionChanged();
			}
		}
	}
	else if( pTO )
	{
		// no text but object available?
		// outline object available, but we have no text
		if(pPage->IsPresObj(pTO))
		{
			// if it is not already empty
			if( !pTO->IsEmptyPresObj() )
			{
				DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );

				// make it empty
				if( pOlView->isRecordingUndo() )
					pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));
				pPage->RestoreDefaultText( pTO );
				pTO->SetEmptyPresObj(sal_True);
				pTO->ActionChanged();
			}
		}
		else
		{
			DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );
			// outline object is not part of the layout, delete it
			if( pOlView->isRecordingUndo() )
				pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoRemoveObject(*pTO));
			pPage->RemoveObject(pTO->GetOrdNum());
		}
	}

	return bNewObject;
}

/*************************************************************************
|*
|* Update LayoutObject
|*
\************************************************************************/

bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
{
	DBG_ASSERT( pPage, "sd::OutlineViewShell::UpdateOutlineObject(), pPage == 0?" );
	DBG_ASSERT( pPara, "sd::OutlineViewShell::UpdateOutlineObject(), pPara == 0?" );

	if( !pPage || !pPara )
		return false;

	::Outliner* 		pOutliner = pOlView->GetOutliner();
	OutlinerParaObject* pOPO = NULL;
	SdrTextObj* 		pTO  = NULL;

	sal_Bool bNewObject = sal_False;

	sal_uInt16 eOutlinerMode = OUTLINERMODE_TITLEOBJECT;
	pTO = (SdrTextObj*)pPage->GetPresObj( PRESOBJ_TEXT );
	if( !pTO )
	{
		eOutlinerMode = OUTLINERMODE_OUTLINEOBJECT;
		pTO = pOlView->GetOutlineTextObject( pPage );
	}

	// wieviele Absaetze in der Gliederung?
	sal_uLong nTitlePara	 = pOutliner->GetAbsPos( pPara );
	sal_uLong nPara          = nTitlePara + 1;
	sal_uLong nParasInLayout = 0L;
	pPara = pOutliner->GetParagraph( nPara );
	while( pPara && !pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) )
	{
		nParasInLayout++;
		pPara = pOutliner->GetParagraph( ++nPara );
	}
	if( nParasInLayout )
	{
		// ein OutlinerParaObject erzeugen
		pPara = pOutliner->GetParagraph( nTitlePara + 1 );
		pOPO  = pOutliner->CreateParaObject( (sal_uInt16) nTitlePara + 1, (sal_uInt16) nParasInLayout );
	}

	if( pOPO )
	{
		DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" );

		// do we need an outline text object?
		if( !pTO )
		{
			pTO = pOlView->CreateOutlineTextObject( pPage );
			bNewObject = sal_True;
		}

		// Seitenobjekt, Gliederungstext im Outliner:
		// Text uebernehmen
		if( pTO )
		{
			pOPO->SetVertical( pTO->IsVerticalWriting() );
			pOPO->SetOutlinerMode( eOutlinerMode );
			if( pTO->GetOutlinerParaObject() && (pOPO->GetTextObject() == pTO->GetOutlinerParaObject()->GetTextObject()) )
			{
				// do nothing, same text already set
				delete pOPO;
			}
			else
			{
				if( !bNewObject && pOlView->isRecordingUndo() )
					pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));

				pTO->SetOutlinerParaObject( pOPO );
				pTO->SetEmptyPresObj( sal_False );
				pTO->ActionChanged();
			}
		}
	}
	else if( pTO )
	{
		// Seitenobjekt, aber kein Gliederungstext:
		// wenn Objekt in Praesentationsliste der Seite ist -> Defaulttext,
		// sonst Objekt loeschen
		if( pPage->IsPresObj(pTO) )
		{
			if( !pTO->IsEmptyPresObj() )
			{
				DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" );

				// loescht auch altes OutlinerParaObject
				if( pOlView->isRecordingUndo() )
					pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));
				pPage->RestoreDefaultText( pTO );
				pTO->SetEmptyPresObj(sal_True);
				pTO->ActionChanged();
			}
		}
		else
		{
			DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" );
			if( pOlView->isRecordingUndo() )
				pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoRemoveObject(*pTO));
			pPage->RemoveObject(pTO->GetOrdNum());
		}
	}

	return bNewObject;
}


/*************************************************************************
|*
|* Outliner aus Stream fuellen
|*
\************************************************************************/

sal_uLong OutlineViewShell::Read(SvStream& rInput, const String& rBaseURL, sal_uInt16 eFormat)
{
	sal_uLong bRet = 0;

	::Outliner* pOutl = pOlView->GetOutliner();

	{
	OutlineViewPageChangesGuard aGuard( pOlView );
	OutlineViewModelChangeGuard aGuard2( *pOlView );

    bRet = pOutl->Read( rInput, rBaseURL, eFormat, GetDocSh()->GetHeaderAttributes() );

	SdPage* pPage = GetDoc()->GetSdPage( GetDoc()->GetSdPageCount(PK_STANDARD) - 1, PK_STANDARD );;
	SfxStyleSheet* pTitleSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_TITLE );
	SfxStyleSheet* pOutlSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_OUTLINE );

	sal_uInt16 nParaCount = (sal_uInt16)pOutl->GetParagraphCount();
	if ( nParaCount > 0 )
	{
		for ( sal_uInt16 nPara = 0; nPara < nParaCount; nPara++ )
		{
			pOlView->UpdateParagraph( nPara );

			sal_Int16 nDepth = pOutl->GetDepth( nPara );

			if( (nDepth == 0) || !nPara )
			{
				Paragraph* pPara = pOutl->GetParagraph( nPara );
				pOutl->SetDepth(pPara, -1);
				pOutl->SetParaFlag(pPara, PARAFLAG_ISPAGE);

				pOutl->SetStyleSheet( nPara, pTitleSheet );

				if( nPara ) // first slide already exists
					pOlView->InsertSlideForParagraph( pPara );
			}
			else
			{
				pOutl->SetDepth( pOutl->GetParagraph( nPara ), nDepth - 1 );
				String aStyleSheetName( pOutlSheet->GetName() );
				aStyleSheetName.Erase( aStyleSheetName.Len() - 1, 1 );
				aStyleSheetName += String::CreateFromInt32( nDepth );
				SfxStyleSheetBasePool* pStylePool = GetDoc()->GetStyleSheetPool();
				SfxStyleSheet* pStyle = (SfxStyleSheet*) pStylePool->Find( aStyleSheetName, pOutlSheet->GetFamily() );
				DBG_ASSERT( pStyle, "AutoStyleSheetName - Style not found!" );
				if ( pStyle )
					pOutl->SetStyleSheet( nPara, pStyle );
			}
		}
	}
	}

	pOutl->GetUndoManager().Clear();

	return( bRet );
}

void OutlineViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse )
{
	WriteFrameViewData();

	ViewShell::WriteUserDataSequence( rSequence, bBrowse );
}

void OutlineViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse )
{
	WriteFrameViewData();

	ViewShell::ReadUserDataSequence( rSequence, bBrowse );

	ReadFrameViewData( mpFrameView );
}

void OutlineViewShell::VisAreaChanged(const Rectangle& rRect)
{
	ViewShell::VisAreaChanged( rRect );

	GetViewShellBase().GetDrawController().FireVisAreaChanged(rRect);
}

/** If there is a valid controller then create a new instance of
    <type>AccessibleDrawDocumentView</type>.  Otherwise delegate this call
    to the base class to return a default object (probably an empty
    reference).
*/
::com::sun::star::uno::Reference<
    ::com::sun::star::accessibility::XAccessible>
    OutlineViewShell::CreateAccessibleDocumentView (::sd::Window* pWindow)
{
    OSL_ASSERT (GetViewShell()!=NULL);
    if (GetViewShell()->GetController() != NULL)
    {
        ::accessibility::AccessibleOutlineView* pDocumentView =
            new ::accessibility::AccessibleOutlineView (
                pWindow,
                this,
                GetViewShell()->GetController(),
                pWindow->GetAccessibleParentWindow()->GetAccessible());
        pDocumentView->Init();
        return ::com::sun::star::uno::Reference<
            ::com::sun::star::accessibility::XAccessible>
            (static_cast< ::com::sun::star::uno::XWeak*>(pDocumentView),
                ::com::sun::star::uno::UNO_QUERY);
    }
    else
    {
        OSL_TRACE ("OutlineViewShell::CreateAccessibleDocumentView: no controller");
        return ViewShell::CreateAccessibleDocumentView (pWindow);
    }
}




void OutlineViewShell::GetState (SfxItemSet& rSet)
{
    // Iterate over all requested items in the set.
	SfxWhichIter aIter( rSet );
	sal_uInt16 nWhich = aIter.FirstWhich();
	while (nWhich)
	{
		switch (nWhich)
		{
			case SID_SEARCH_ITEM:
			case SID_SEARCH_OPTIONS:
                // Call common (old) implementation in the document shell.
                GetDocSh()->GetState (rSet);
                break;
			default:
                OSL_TRACE ("OutlineViewShell::GetState(): can not handle which id %d", nWhich);
                break;
        }
		nWhich = aIter.NextWhich();
	}
}




void OutlineViewShell::SetCurrentPage (SdPage* pPage)
{
    // Adapt the selection of the model.
    for (sal_uInt16 i=0; i<GetDoc()->GetSdPageCount(PK_STANDARD); i++)
        GetDoc()->SetSelected(
            GetDoc()->GetSdPage(i, PK_STANDARD),
            sal_False);
    GetDoc()->SetSelected (pPage, sal_True);

    DrawController& rController(GetViewShellBase().GetDrawController());
    rController.FireSelectionChangeListener();
    rController.FireSwitchCurrentPage (pPage);

    pOlView->SetActualPage(pPage);
}


} // end of namespace sd