xref: /aoo42x/main/sc/source/ui/view/prevwsh.cxx (revision b3f79822)

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



// INCLUDE ---------------------------------------------------------------

#include "scitems.hxx"
#include <editeng/eeitem.hxx>

#include <sfx2/app.hxx>
#include <editeng/sizeitem.hxx>
#include <svl/srchitem.hxx>
#include <svx/zoomslideritem.hxx>
#include <svx/svdview.hxx>
//CHINA001 #include <svx/zoom.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/objface.hxx>
#include <sfx2/request.hxx>
#include <svl/stritem.hxx>
#include <svl/whiter.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/help.hxx>
#include <tools/urlobj.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/printer.hxx>

#ifndef _SVX_ZOOMSLIDERITEM_HXX
#include <svx/zoomslideritem.hxx>
#endif
#include "prevwsh.hxx"
#include "preview.hxx"
#include "printfun.hxx"
#include "attrib.hxx"
#include "scmod.hxx"
#include "inputhdl.hxx"
#include "docsh.hxx"
#include "tabvwsh.hxx"
#include "stlpool.hxx"
#include "editutil.hxx"
#include "scresid.hxx"
#include "globstr.hrc"
#include "sc.hrc"
#include "ViewSettingsSequenceDefines.hxx"
#include "tpprint.hxx"
#include "printopt.hxx"
#include <xmloff/xmluconv.hxx>
#include <rtl/ustrbuf.hxx>

#include <svx/svxdlg.hxx> //CHINA001
#include <svx/dialogs.hrc> //CHINA001

#ifndef _SVX_ZOOM_HXX
#include <svx/zoom_def.hxx>
#endif

#include "sc.hrc" //CHINA001
#include "scabstdlg.hxx" //CHINA001
//	fuer Rad-Maus
#define SC_DELTA_ZOOM	10
#define MINZOOM_SLIDER 10
#define MAXZOOM_SLIDER 400

#define SC_USERDATA_SEP	';'

using namespace com::sun::star;

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

#define ScPreviewShell
#include "scslots.hxx"

TYPEINIT1( ScPreviewShell, SfxViewShell );

SFX_IMPL_INTERFACE( ScPreviewShell, SfxViewShell, ScResId(SCSTR_PREVIEWSHELL) )
{
	SFX_OBJECTBAR_REGISTRATION(SFX_OBJECTBAR_OBJECT|SFX_VISIBILITY_STANDARD|
								SFX_VISIBILITY_SERVER|SFX_VISIBILITY_READONLYDOC,
								ScResId(RID_OBJECTBAR_PREVIEW));
	SFX_POPUPMENU_REGISTRATION(ScResId(RID_POPUP_PREVIEW));
}

SFX_IMPL_NAMED_VIEWFACTORY( ScPreviewShell, "PrintPreview" )
{
	SFX_VIEW_REGISTRATION(ScDocShell);
}

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

void ScPreviewShell::Construct( Window* pParent )
{
	eZoom = SVX_ZOOM_WHOLEPAGE;

	pCorner = new ScrollBarBox( pParent, WB_SIZEABLE );

	pHorScroll = new ScrollBar(pParent, WB_HSCROLL );
	pVerScroll = new ScrollBar(pParent, WB_VSCROLL);

    // SSA: --- RTL --- no mirroring for horizontal scrollbars
    pHorScroll->EnableRTL( sal_False );

	pHorScroll->SetEndScrollHdl( LINK( this, ScPreviewShell, ScrollHandler ) );
	pVerScroll->SetEndScrollHdl( LINK( this, ScPreviewShell, ScrollHandler ) );

	pPreview = new ScPreview( pParent, pDocShell, this );

	SetPool( &SC_MOD()->GetPool() );
	SetWindow( pPreview );
    StartListening(*pDocShell,sal_True);
    StartListening(*SFX_APP(),sal_True);        // #i62045# #i62046# application is needed for Calc's own hints
	SfxBroadcaster* pDrawBC = pDocShell->GetDocument()->GetDrawBroadcaster();
	if (pDrawBC)
		StartListening(*pDrawBC);

	pHorScroll->Show();
	pVerScroll->Show();
	pCorner->Show();
	SetHelpId( HID_SCSHELL_PREVWSH );
	SetName(String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("Preview")));
}

ScPreviewShell::ScPreviewShell( SfxViewFrame* pViewFrame,
								SfxViewShell* pOldSh ) :
	SfxViewShell( pViewFrame, SFX_VIEW_CAN_PRINT | SFX_VIEW_HAS_PRINTOPTIONS ),
	pDocShell( (ScDocShell*)pViewFrame->GetObjectShell() ),
	nSourceDesignMode( SC_FORCEMODE_NONE ),
	pAccessibilityBroadcaster( NULL )
{
	Construct( &pViewFrame->GetWindow() );

	if ( pOldSh && pOldSh->ISA( ScTabViewShell ) )
	{
		//	store view settings, show table from TabView
		//!	store live ScViewData instead, and update on ScTablesHint?
		//!	or completely forget aSourceData on ScTablesHint?

		ScTabViewShell* pTabViewShell = ((ScTabViewShell*)pOldSh);
		ScViewData* pData = pTabViewShell->GetViewData();
		pData->WriteUserDataSequence( aSourceData );
		InitStartTable( pData->GetTabNo() );

		//	#106334# also have to store the TabView's DesignMode state
		//	(only if draw view exists)
		SdrView* pDrawView = pTabViewShell->GetSdrView();
		if ( pDrawView )
			nSourceDesignMode = pDrawView->IsDesignMode();
	}
}

__EXPORT ScPreviewShell::~ScPreviewShell()
{
    // #108333#; notify Accessibility that Shell is dying and before destroy all
    BroadcastAccessibility( SfxSimpleHint( SFX_HINT_DYING ) );
    DELETEZ(pAccessibilityBroadcaster);

    SfxBroadcaster* pDrawBC = pDocShell->GetDocument()->GetDrawBroadcaster();
	if (pDrawBC)
		EndListening(*pDrawBC);
	EndListening(*SFX_APP());
	EndListening(*pDocShell);

	SetWindow(0);
	delete pPreview;
	delete pHorScroll;
	delete pVerScroll;
	delete pCorner;

	//	#97612# normal mode of operation is switching back to default view in the same frame,
	//	so there's no need to activate any other window here anymore
}

void ScPreviewShell::InitStartTable(SCTAB nTab)
{
	pPreview->SetPageNo( pPreview->GetFirstPage(nTab) );
}

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

String __EXPORT ScPreviewShell::GetDescription() const
{
	return String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(" ** Test ** "));
}

Size __EXPORT ScPreviewShell::GetOptimalSizePixel() const
{
	Size aOptSize(100,100);

	ScTabViewShell*     pViewSh = pDocShell->GetBestViewShell();

	if ( pViewSh )
	{
		ScViewData*			pViewData	= pViewSh->GetViewData();
		SCTAB				nCurTab		= pViewData->GetTabNo();
		ScDocument*			pDoc		= pDocShell->GetDocument();
		ScStyleSheetPool*	pStylePool  = pDoc->GetStyleSheetPool();
		SfxStyleSheetBase*	pStyleSheet = pStylePool->Find(
											pDoc->GetPageStyle( nCurTab ),
											SFX_STYLE_FAMILY_PAGE );

		DBG_ASSERT( pStyleSheet, "PageStyle not found :-/" );

		if ( pStyleSheet )
		{
			const SfxItemSet&  rSet 	 = pStyleSheet->GetItemSet();
			const SvxSizeItem& rItem	 = (const SvxSizeItem&)rSet.Get( ATTR_PAGE_SIZE );
			const Size&		   rPageSize = rItem.GetSize();

			aOptSize.Width()  = (long) (rPageSize.Width()  * pViewData->GetPPTX());
			aOptSize.Height() = (long) (rPageSize.Height() * pViewData->GetPPTY());
		}
	}
	else
	{
		DBG_ERROR( "TabViewShell not found :-/" );
	}

	return aOptSize;
}

void __EXPORT ScPreviewShell::AdjustPosSizePixel( const Point &rPos, const Size &rSize )
{
	long nBarW = GetViewFrame()->GetWindow().GetSettings().GetStyleSettings().GetScrollBarSize();
	long nBarH = nBarW;
//	long nBarW = pVerScroll->GetSizePixel().Width();
//	long nBarH = pHorScroll->GetSizePixel().Height();

	Size aOutSize( rSize.Width()-nBarW, rSize.Height()-nBarH );
	pPreview->SetPosSizePixel( rPos, aOutSize );
	pHorScroll->SetPosSizePixel( Point( rPos.X(), rPos.Y() + aOutSize.Height() ),
								 Size( aOutSize.Width(), nBarH ) );
	pVerScroll->SetPosSizePixel( Point( rPos.X() + aOutSize.Width(), rPos.Y() ),
								 Size( nBarW, aOutSize.Height() ) );
	pCorner->SetPosSizePixel( Point( rPos.X() + aOutSize.Width(), rPos.Y() + aOutSize.Height() ),
							  Size( nBarW, nBarH ) );

	if ( SVX_ZOOM_WHOLEPAGE == eZoom )
		pPreview->SetZoom( pPreview->GetOptimalZoom(sal_False) );
	else if ( SVX_ZOOM_PAGEWIDTH == eZoom )
		pPreview->SetZoom( pPreview->GetOptimalZoom(sal_True) );

	UpdateScrollBars();
}

void __EXPORT ScPreviewShell::InnerResizePixel( const Point &rOfs, const Size &rSize )
{
	AdjustPosSizePixel( rOfs,rSize );
}

void __EXPORT ScPreviewShell::OuterResizePixel( const Point &rOfs, const Size &rSize )
{
	AdjustPosSizePixel( rOfs,rSize );
}

void ScPreviewShell::UpdateScrollBars()
{
	ScDocument* pDoc = pDocShell->GetDocument();
	SCTAB nTab = pPreview->GetTab();

	ScStyleSheetPool*	pStylePool	= pDoc->GetStyleSheetPool();
	SfxStyleSheetBase*	pStyleSheet = pStylePool->Find( pDoc->GetPageStyle( nTab ),
														SFX_STYLE_FAMILY_PAGE );
	DBG_ASSERT(pStyleSheet,"StyleSheet nicht gefunden");
	if (!pStyleSheet) return;
	const SfxItemSet* pParamSet = &pStyleSheet->GetItemSet();

	Size aPageSize = ((const SvxSizeItem&) pParamSet->Get(ATTR_PAGE_SIZE)).GetSize();
	aPageSize.Width()  = (long) (aPageSize.Width()  * HMM_PER_TWIPS );
	aPageSize.Height() = (long) (aPageSize.Height() * HMM_PER_TWIPS );

	//	for centering, page size without the shadow is used

	Size aWindowSize = pPreview->GetOutputSize();

	Point aOfs = pPreview->GetOffset();
	long nMaxPos;

    if( pHorScroll )
    {
        pHorScroll->SetRange( Range( 0, aPageSize.Width() ) );
        pHorScroll->SetLineSize( aWindowSize.Width() / 16 );
        pHorScroll->SetPageSize( aWindowSize.Width() );
        pHorScroll->SetVisibleSize( aWindowSize.Width() );
        nMaxPos = aPageSize.Width() - aWindowSize.Width();
        if ( nMaxPos<0 )
        {
            //	page smaller than window -> center (but put scrollbar to 0)
            aOfs.X() = 0;
            pPreview->SetXOffset( nMaxPos / 2 );
        }
        else if (aOfs.X() < 0)
        {
            //	page larger than window -> never use negative offset
            aOfs.X() = 0;
            pPreview->SetXOffset( 0 );
        }
        else if (aOfs.X() > nMaxPos)
        {
            //	limit offset to align with right edge of window
            aOfs.X() = nMaxPos;
            pPreview->SetXOffset(nMaxPos);
        }
        pHorScroll->SetThumbPos( aOfs.X() );
    }

    if( pVerScroll )
    {
        long nPageNo     = pPreview->GetPageNo();
        long nTotalPages = pPreview->GetTotalPages();

        nMaxVertPos = aPageSize.Height() - aWindowSize.Height();
        pVerScroll->SetLineSize( aWindowSize.Height() / 16  );
        pVerScroll->SetPageSize( aWindowSize.Height() );
        pVerScroll->SetVisibleSize( aWindowSize.Height() );
        if ( nMaxVertPos < 0 )
        {
            //	page smaller than window -> center (but put scrollbar to 0)
            aOfs.Y() = 0;
            pPreview->SetYOffset( nMaxVertPos / 2 );
            pVerScroll->SetThumbPos( nPageNo * aWindowSize.Height() );
            pVerScroll->SetRange( Range( 0, aWindowSize.Height() * nTotalPages ));
        }
        else if (aOfs.Y() < 0)
        {
            //	page larger than window -> never use negative offset
            pVerScroll->SetRange( Range( 0, aPageSize.Height() ) );
            aOfs.Y() = 0;
            pPreview->SetYOffset( 0 );
            pVerScroll->SetThumbPos( aOfs.Y() );
        }
        else if (aOfs.Y() > nMaxVertPos )
        {
            //	limit offset to align with window bottom
            pVerScroll->SetRange( Range( 0, aPageSize.Height() ) );
            aOfs.Y() = nMaxVertPos;
            pPreview->SetYOffset( nMaxVertPos );
            pVerScroll->SetThumbPos( aOfs.Y() );
        }
    }
}

IMPL_LINK (ScPreviewShell,ScrollHandler, ScrollBar* ,pScroll )
{
    long nPos           = pScroll->GetThumbPos();
    long nDelta         = pScroll->GetDelta();
    long nMaxRange      = pScroll->GetRangeMax();
    long nTotalPages    = pPreview->GetTotalPages();
    long nPageNo        = 0;
    long nPerPageLength = 0;
    sal_Bool bIsDivide      = sal_True;

    if( nTotalPages )
        nPerPageLength = nMaxRange / nTotalPages;

    if( nPerPageLength )
    {
        nPageNo = nPos / nPerPageLength;
        if( nPos % nPerPageLength )
        {
            bIsDivide = sal_False;
            nPageNo ++;
        }
    }

    sal_Bool bHoriz = ( pScroll == pHorScroll );

    if( bHoriz )
        pPreview->SetXOffset( nPos );
    else
    {
        if( nMaxVertPos > 0 )
            pPreview->SetYOffset( nPos );
        else
        {
            Point  aMousePos = pScroll->OutputToNormalizedScreenPixel( pScroll->GetPointerPosPixel() );
            Point  aPos      = pScroll->GetParent()->OutputToNormalizedScreenPixel( pScroll->GetPosPixel() );
            String aHelpStr;
            Rectangle aRect;
            sal_uInt16   nAlign;

            if( nDelta < 0 )
            {
                if ( nTotalPages && nPageNo > 0 && !bIsDivide )
                    pPreview->SetPageNo( nPageNo-1 );
                if( bIsDivide )
                    pPreview->SetPageNo( nPageNo );

                aHelpStr = ScGlobal::GetRscString( STR_PAGE );
                aHelpStr += ' ';
                aHelpStr += String::CreateFromInt32( nPageNo );

                aHelpStr.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " / " ));
                aHelpStr += String::CreateFromInt32( nTotalPages );
            }
            else if( nDelta > 0 )
            {
                sal_Bool bAllTested	= pPreview->AllTested();
                if ( nTotalPages && ( nPageNo < nTotalPages || !bAllTested ) )
                    pPreview->SetPageNo( nPageNo );

                aHelpStr = ScGlobal::GetRscString( STR_PAGE );
                aHelpStr += ' ';
                aHelpStr += String::CreateFromInt32( nPageNo+1 );

                aHelpStr.AppendAscii(RTL_CONSTASCII_STRINGPARAM( " / " ));
                aHelpStr += String::CreateFromInt32( nTotalPages );
            }

            aRect.Left()    = aPos.X() - 8;
            aRect.Top()	    = aMousePos.Y();
            aRect.Right() 	= aRect.Left();
            aRect.Top()		= aRect.Top();
            nAlign		    = QUICKHELP_BOTTOM|QUICKHELP_CENTER;
            Help::ShowQuickHelp( pScroll->GetParent(), aRect, aHelpStr, nAlign );
        }
    }

	return 0;
}

sal_Bool ScPreviewShell::ScrollCommand( const CommandEvent& rCEvt )
{
	sal_Bool bDone = sal_False;
	const CommandWheelData* pData = rCEvt.GetWheelData();
	if ( pData && pData->GetMode() == COMMAND_WHEEL_ZOOM )
	{
		long nOld = pPreview->GetZoom();
		long nNew = nOld;
		if ( pData->GetDelta() < 0 )
			nNew = Max( (long) MINZOOM, (long)( nOld - SC_DELTA_ZOOM ) );
		else
			nNew = Min( (long) MAXZOOM, (long)( nOld + SC_DELTA_ZOOM ) );

		if ( nNew != nOld )
		{
			eZoom = SVX_ZOOM_PERCENT;
			pPreview->SetZoom( (sal_uInt16)nNew );
		}

		bDone = sal_True;
	}
	else
	{
		bDone = pPreview->HandleScrollCommand( rCEvt, pHorScroll, pVerScroll );
	}

	return bDone;
}

SfxPrinter* __EXPORT ScPreviewShell::GetPrinter( sal_Bool bCreate )
{
	return pDocShell->GetPrinter(bCreate);
}

sal_uInt16 __EXPORT ScPreviewShell::SetPrinter( SfxPrinter *pNewPrinter, sal_uInt16 nDiffFlags, bool )
{
	return pDocShell->SetPrinter( pNewPrinter, nDiffFlags );
}

SfxTabPage* ScPreviewShell::CreatePrintOptionsPage( Window *pParent, const SfxItemSet &rOptions )
{
	ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
	DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001
	//CHINA001 return ScTpPrintOptions::Create( pParent, rOptions );
	::CreateTabPage ScTpPrintOptionsCreate = 	pFact->GetTabPageCreatorFunc( RID_SCPAGE_PRINT );
	if ( ScTpPrintOptionsCreate )
		return  (*ScTpPrintOptionsCreate)( pParent, rOptions);
	return 0;
}

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

void __EXPORT ScPreviewShell::Activate(sal_Bool bMDI)
{
	SfxViewShell::Activate(bMDI);

	//!	Basic etc. -> auslagern in eigene Datei (s. tabvwsh4)

	if (bMDI)
	{
		// InputHdl ist jetzt meistens Null, keine Assertion mehr!
		ScInputHandler*	pInputHdl = SC_MOD()->GetInputHdl();
		if ( pInputHdl )
			pInputHdl->NotifyChange( NULL );
	}
}

void __EXPORT ScPreviewShell::Deactivate(sal_Bool bMDI)
{
	SfxViewShell::Deactivate(bMDI);

	if (bMDI)
	{
	}
}

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

void __EXPORT ScPreviewShell::Execute( SfxRequest& rReq )
{
	sal_uInt16 nSlot = rReq.GetSlot();
	const SfxItemSet* pReqArgs = rReq.GetArgs();

	switch ( nSlot )
	{
		case SID_FORMATPAGE:
		case SID_STATUS_PAGESTYLE:
		case SID_HFEDIT:
			pDocShell->ExecutePageStyle( *this, rReq, pPreview->GetTab() );
			break;
		case SID_REPAINT:
			pPreview->Invalidate();
			rReq.Done();
			break;
		case SID_PREV_TABLE: // Accelerator
		case SID_PREVIEW_PREVIOUS:
			{
				long nPage = pPreview->GetPageNo();
				long nTotal = pPreview->GetTotalPages();
				if (nTotal && nPage > 0)
					pPreview->SetPageNo( nPage-1 );
			}
			break;
		case SID_NEXT_TABLE: // Accelerator
		case SID_PREVIEW_NEXT:
			{
				sal_Bool bAllTested	= pPreview->AllTested();
				long nPage = pPreview->GetPageNo();
				long nTotal = pPreview->GetTotalPages();
				if (nTotal && (nPage+1 < nTotal || !bAllTested))
					pPreview->SetPageNo( nPage+1 );
			}
			break;
		case SID_CURSORTOPOFFILE: // Accelerator
		case SID_PREVIEW_FIRST:
			{
				long nPage = pPreview->GetPageNo();
				long nTotal = pPreview->GetTotalPages();
				if (nTotal && nPage != 0)
					pPreview->SetPageNo( 0 );
			}
			break;
		case SID_CURSORENDOFFILE: // Accelerator
		case SID_PREVIEW_LAST:
			{
				if (!pPreview->AllTested())
					pPreview->CalcAll();

				long nPage = pPreview->GetPageNo();
				long nTotal = pPreview->GetTotalPages();
				if (nTotal && nPage+1 != nTotal)
					pPreview->SetPageNo( nTotal-1 );
			}
			break;
		case SID_ATTR_ZOOM:
		case FID_SCALE:
			{
				sal_uInt16		nZoom		= 100;
				sal_Bool		bCancel		= sal_False;

				eZoom = SVX_ZOOM_PERCENT;

				if ( pReqArgs )
				{

					const SvxZoomItem& rZoomItem = (const SvxZoomItem&)
												   pReqArgs->Get(SID_ATTR_ZOOM);

					eZoom = rZoomItem.GetType();
					nZoom = rZoomItem.GetValue();
				}
				else
				{
					SfxItemSet		aSet	 ( GetPool(), SID_ATTR_ZOOM, SID_ATTR_ZOOM );
					SvxZoomItem		aZoomItem( SVX_ZOOM_PERCENT, pPreview->GetZoom(), SID_ATTR_ZOOM );

					aSet.Put( aZoomItem );
					//CHINA001 SvxZoomDialog* pDlg = pDlg = new SvxZoomDialog( NULL, aSet );
					SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
					if(pFact)
					{
						AbstractSvxZoomDialog* pDlg = pFact->CreateSvxZoomDialog(NULL, aSet);
						DBG_ASSERT(pDlg, "Dialogdiet fail!");//CHINA001
						pDlg->SetLimits( 20, 400 );
						pDlg->HideButton( ZOOMBTN_OPTIMAL );
						bCancel = ( RET_CANCEL == pDlg->Execute() );

						if ( !bCancel )
						{
							const SvxZoomItem&	rZoomItem = (const SvxZoomItem&)
													pDlg->GetOutputItemSet()->
														Get( SID_ATTR_ZOOM );

							eZoom = rZoomItem.GetType();
							nZoom = rZoomItem.GetValue();
						}

						delete pDlg;
					}
				}

				if ( !bCancel )
				{
					switch ( eZoom )
					{
						case SVX_ZOOM_OPTIMAL:
						case SVX_ZOOM_WHOLEPAGE:
							nZoom = pPreview->GetOptimalZoom(sal_False);
							break;
						case SVX_ZOOM_PAGEWIDTH:
							nZoom = pPreview->GetOptimalZoom(sal_True);
							break;
                        default:
                        {
                            // added to avoid warnings
                        }
					}

					pPreview->SetZoom( nZoom );
					rReq.Done();
				}
			}
			break;
		case SID_PREVIEW_ZOOMIN:
			{
				sal_uInt16 nNew = pPreview->GetZoom() + 20 ;
				nNew -= nNew % 20;
				pPreview->SetZoom( nNew );
				eZoom = SVX_ZOOM_PERCENT;
				rReq.Done();
			}
			break;
		case SID_PREVIEW_ZOOMOUT:
			{
				sal_uInt16 nNew = pPreview->GetZoom() - 1;
				nNew -= nNew % 20;
				pPreview->SetZoom( nNew );
				eZoom = SVX_ZOOM_PERCENT;
				rReq.Done();
			}
			break;
        case SID_PREVIEW_MARGIN:
            {
                sal_Bool bMargin = pPreview->GetPageMargins();
                pPreview->SetPageMargins( !bMargin );
                pPreview->Invalidate();
                rReq.Done();
            }
            break;
        case SID_ATTR_ZOOMSLIDER:
            {
                const SfxPoolItem* pItem;
                eZoom = SVX_ZOOM_PERCENT;
                if( pReqArgs && SFX_ITEM_SET == pReqArgs->GetItemState( SID_ATTR_ZOOMSLIDER, sal_True, &pItem ) )
                {
                    const sal_uInt16 nCurrentZoom = ((const SvxZoomSliderItem*)pItem)->GetValue();
                    if( nCurrentZoom )
                    {
                        pPreview->SetZoom( nCurrentZoom );
                        rReq.Done();
                    }
                }
            }
            break;
        case SID_PREVIEW_SCALINGFACTOR:
            {
                const SfxPoolItem* pItem;
                SCTAB nTab                      = pPreview->GetTab();
                String aOldName                 = pDocShell->GetDocument()->GetPageStyle( pPreview->GetTab() );
                ScStyleSheetPool* pStylePool    = pDocShell->GetDocument()->GetStyleSheetPool();
                SfxStyleSheetBase* pStyleSheet  = pStylePool->Find( aOldName, SFX_STYLE_FAMILY_PAGE );
                DBG_ASSERT( pStyleSheet, "PageStyle not found! :-/" );

                if ( pReqArgs && pStyleSheet && SFX_ITEM_SET == pReqArgs->GetItemState( SID_PREVIEW_SCALINGFACTOR, sal_True, &pItem ) )
                {
                    const sal_uInt16 nCurrentZoom   = ((const SvxZoomSliderItem *)pItem)->GetValue();
                    SfxItemSet& rSet            = pStyleSheet->GetItemSet();
                    rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALE, nCurrentZoom ) );
                    ScPrintFunc aPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab );
                    aPrintFunc.UpdatePages();
                    rReq.Done();
                }
                GetViewFrame()->GetBindings().Invalidate( nSlot );
            }
            break;
		case SID_PRINTPREVIEW:
		case SID_PREVIEW_CLOSE:
			//	print preview is now always in the same frame as the tab view
			//	-> always switch this frame back to normal view
			//	(ScTabViewShell ctor reads stored view data)

            GetViewFrame()->GetDispatcher()->Execute( SID_VIEWSHELL0, SFX_CALLMODE_ASYNCHRON );
			break;
		case SID_CURSORPAGEUP:
		case SID_CURSORPAGEDOWN:
		case SID_CURSORHOME:
		case SID_CURSOREND:
		case SID_CURSORUP:
		case SID_CURSORDOWN:
		case SID_CURSORLEFT:
		case SID_CURSORRIGHT:
			DoScroll( nSlot );
			break;
        case SID_CANCEL:
            if( ScViewUtil::IsFullScreen( *this ) )
                ScViewUtil::SetFullScreen( *this, false );
            break;

		default:
			break;
	}
}

void __EXPORT ScPreviewShell::GetState( SfxItemSet& rSet )
{
	pPreview->SetInGetState(sal_True);

	SCTAB nTab		= pPreview->GetTab();
	long nPage		= pPreview->GetPageNo();
	long nTotal		= pPreview->GetTotalPages();
	sal_uInt16 nZoom	= pPreview->GetZoom();
	sal_Bool bAllTested	= pPreview->AllTested();

	SfxWhichIter aIter(rSet);
	sal_uInt16 nWhich = aIter.FirstWhich();
	while ( nWhich )
	{
		switch (nWhich)
		{
			case SID_STATUS_PAGESTYLE:
			case SID_HFEDIT:
				pDocShell->GetStatePageStyle( *this, rSet, nTab );
				break;
			case SID_UNDO:
			case SID_REDO:
			case SID_REPEAT:
				rSet.DisableItem(nWhich);
				break;
			case SID_PREVIEW_PREVIOUS:
			case SID_PREVIEW_FIRST:
				if (!nTotal || nPage==0)
					rSet.DisableItem(nWhich);
				break;
			case SID_PREVIEW_NEXT:
			case SID_PREVIEW_LAST:
				if (bAllTested)
					if (!nTotal || nPage==nTotal-1)
						rSet.DisableItem(nWhich);
				break;
			case SID_PREVIEW_ZOOMIN:
				if (nZoom >= 400)
					rSet.DisableItem(nWhich);
				break;
			case SID_PREVIEW_ZOOMOUT:
				if (nZoom <= 20)
					rSet.DisableItem(nWhich);
				break;
			case SID_ATTR_ZOOM:
				{
					SvxZoomItem aZoom( eZoom, nZoom, nWhich );
					aZoom.SetValueSet( SVX_ZOOM_ENABLE_ALL & ~SVX_ZOOM_ENABLE_OPTIMAL );
					rSet.Put( aZoom );
				}
				break;
            case SID_ATTR_ZOOMSLIDER:
                {
                    SvxZoomSliderItem aZoomSliderItem( nZoom, MINZOOM, MAXZOOM, SID_ATTR_ZOOMSLIDER );
                    aZoomSliderItem.AddSnappingPoint( 100 );
                    rSet.Put( aZoomSliderItem );
                }
                break;
            case SID_PREVIEW_SCALINGFACTOR:
                {
                    if( pDocShell->IsReadOnly() )
                        rSet.DisableItem( nWhich );
                    else
                    {
                        String aOldName                 = pDocShell->GetDocument()->GetPageStyle( pPreview->GetTab() );
                        ScStyleSheetPool* pStylePool    = pDocShell->GetDocument()->GetStyleSheetPool();
                        SfxStyleSheetBase* pStyleSheet  = pStylePool->Find( aOldName, SFX_STYLE_FAMILY_PAGE );
                        DBG_ASSERT( pStyleSheet, "PageStyle not found! :-/" );

                        if ( pStyleSheet )
                        {
                            SfxItemSet& rStyleSet   = pStyleSheet->GetItemSet();
                            sal_uInt16 nCurrentZoom     = ((const SfxUInt16Item&)rStyleSet.Get(ATTR_PAGE_SCALE)).GetValue();
                            if( nCurrentZoom )
                            {
                                SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM_SLIDER, MAXZOOM_SLIDER, SID_PREVIEW_SCALINGFACTOR );
                                aZoomSliderItem.AddSnappingPoint( 100 );
                                rSet.Put( aZoomSliderItem );
                            }
                            else
                                rSet.DisableItem( nWhich );
                        }
                    }
                }
                break;
			case SID_STATUS_DOCPOS:
				rSet.Put( SfxStringItem( nWhich, pPreview->GetPosString() ) );
				break;
			case SID_PRINTPREVIEW:
				rSet.Put( SfxBoolItem( nWhich, sal_True ) );
				break;
			case SID_FORMATPAGE:
            case SID_PREVIEW_MARGIN:
                if( pDocShell->IsReadOnly() )
					rSet.DisableItem( nWhich );
				break;
		}

		nWhich = aIter.NextWhich();
	}

	pPreview->SetInGetState(sal_False);
}

void ScPreviewShell::FillFieldData( ScHeaderFieldData& rData )
{
	ScDocument* pDoc = pDocShell->GetDocument();
	SCTAB nTab = pPreview->GetTab();
	pDoc->GetName( nTab, rData.aTabName );

	rData.aTitle		= pDocShell->GetTitle();
	const INetURLObject& rURLObj = pDocShell->GetMedium()->GetURLObject();
	rData.aLongDocName	= rURLObj.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
	if ( rData.aLongDocName.Len() )
		rData.aShortDocName = rURLObj.GetName( INetURLObject::DECODE_UNAMBIGUOUS );
	else
		rData.aShortDocName = rData.aLongDocName = rData.aTitle;
	rData.nPageNo		= pPreview->GetPageNo() + 1;

	sal_Bool bAllTested	= pPreview->AllTested();
	if (bAllTested)
		rData.nTotalPages = pPreview->GetTotalPages();
	else
		rData.nTotalPages = 99;

	//	eNumType kennt der Dialog selber
}

void __EXPORT ScPreviewShell::WriteUserData(String& rData, sal_Bool /* bBrowse */)
{
	//	nZoom
	//	nPageNo

	rData =  String::CreateFromInt32(pPreview->GetZoom());
	rData += (sal_Unicode) SC_USERDATA_SEP;
	rData += String::CreateFromInt32(pPreview->GetPageNo());
}

void __EXPORT ScPreviewShell::ReadUserData(const String& rData, sal_Bool /* bBrowse */)
{
	xub_StrLen nCount = rData.GetTokenCount();
	if (nCount)
	{
		xub_StrLen nIndex = 0;
		pPreview->SetZoom((sal_uInt16)rData.GetToken( 0, SC_USERDATA_SEP, nIndex ).ToInt32());
		pPreview->SetPageNo(rData.GetToken( 0, SC_USERDATA_SEP, nIndex ).ToInt32());
		eZoom = SVX_ZOOM_PERCENT;
	}
}

void __EXPORT ScPreviewShell::WriteUserDataSequence(uno::Sequence < beans::PropertyValue >& rSeq, sal_Bool /* bBrowse */)
{
	rSeq.realloc(3);
	beans::PropertyValue* pSeq = rSeq.getArray();
	if(pSeq)
	{
		sal_uInt16 nViewID(GetViewFrame()->GetCurViewId());
		pSeq[0].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_VIEWID));
		rtl::OUStringBuffer sBuffer(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_VIEW)));
		SvXMLUnitConverter::convertNumber(sBuffer, static_cast<sal_Int32>(nViewID));
		pSeq[0].Value <<= sBuffer.makeStringAndClear();
		pSeq[1].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_ZOOMVALUE));
		pSeq[1].Value <<= sal_Int32 (pPreview->GetZoom());
		pSeq[2].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PageNumber"));
		pSeq[2].Value <<= pPreview->GetPageNo();
	}
}

void __EXPORT ScPreviewShell::ReadUserDataSequence(const uno::Sequence < beans::PropertyValue >& rSeq, sal_Bool /* bBrowse */)
{
	sal_Int32 nCount(rSeq.getLength());
	if (nCount)
	{
		sal_Int32 nTemp = 0;
		const beans::PropertyValue* pSeq = rSeq.getConstArray();
		if(pSeq)
		{
			for(sal_Int32 i = 0; i < nCount; i++, pSeq++)
			{
				rtl::OUString sName(pSeq->Name);
				if(sName.compareToAscii(SC_ZOOMVALUE) == 0)
				{
					if (pSeq->Value >>= nTemp)
						pPreview->SetZoom(sal_uInt16(nTemp));
				}
				else if (sName.compareToAscii("PageNumber") == 0)
				{
					if (pSeq->Value >>= nTemp)
						pPreview->SetPageNo(nTemp);
				}
			}
		}
	}
}

void ScPreviewShell::DoScroll( sal_uInt16 nMode )
{
	Point	aCurPos, aPrevPos;

	long nHRange	= pHorScroll->GetRange().Max();
	long nHLine		= pHorScroll->GetLineSize();
	long nHPage		= pHorScroll->GetPageSize();
	long nVRange	= pVerScroll->GetRange().Max();
	long nVLine		= pVerScroll->GetLineSize();
	long nVPage		= pVerScroll->GetPageSize();

	aCurPos.X() = pHorScroll->GetThumbPos();
	aCurPos.Y() = pVerScroll->GetThumbPos();
	aPrevPos = aCurPos;

	long nThumbPos	= pVerScroll->GetThumbPos();
	long nRangeMax	= pVerScroll->GetRangeMax();

	switch( nMode )
	{
        case SID_CURSORUP:
            if( nMaxVertPos<0 )
            {
                long nPage = pPreview->GetPageNo();

                if( nPage>0 )
                {
                    SfxViewFrame* pSfxViewFrame = GetViewFrame();
                    SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_PREVIOUS );
                    Execute( aSfxRequest );
                }
            }
            else
                aCurPos.Y() -= nVLine;
            break;
        case SID_CURSORDOWN:
            if( nMaxVertPos<0 )
            {
                long nPage = pPreview->GetPageNo();
                long nTotal = pPreview->GetTotalPages();

                // before testing for last page, make sure all page counts are calculated
                if ( nPage+1 == nTotal && !pPreview->AllTested() )
                {
                    pPreview->CalcAll();
                    nTotal = pPreview->GetTotalPages();
                }

                if( nPage<nTotal-1 )
                {
                    SfxViewFrame* pSfxViewFrame = GetViewFrame();
                    SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_NEXT );
                    Execute( aSfxRequest );
                }
            }
            else
                aCurPos.Y() += nVLine;
            break;
        case SID_CURSORLEFT:
            aCurPos.X() -= nHLine;
            break;
        case SID_CURSORRIGHT:
            aCurPos.X() += nHLine;
            break;
        case SID_CURSORPAGEUP:
            if( nThumbPos==0 || nMaxVertPos<0 )
            {
                long nPage = pPreview->GetPageNo();

                if( nPage>0 )
                {
                    SfxViewFrame* pSfxViewFrame = GetViewFrame();
                    SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_PREVIOUS );
                    Execute( aSfxRequest );
                    aCurPos.Y() = nVRange;
                }
            }
            else
                aCurPos.Y() -= nVPage;
            break;
        case SID_CURSORPAGEDOWN:
            if( (abs(nVPage+nThumbPos-nRangeMax)<10) || nMaxVertPos<0 )
            {
                long nPage = pPreview->GetPageNo();
                long nTotal = pPreview->GetTotalPages();

                // before testing for last page, make sure all page counts are calculated
                if ( nPage+1 == nTotal && !pPreview->AllTested() )
                {
                    pPreview->CalcAll();
                    nTotal = pPreview->GetTotalPages();
                }
                if( nPage<nTotal-1 )
                {
                    SfxViewFrame* pSfxViewFrame = GetViewFrame();
                    SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_NEXT );
                    Execute( aSfxRequest );
                    aCurPos.Y() = 0;
                }
            }
            else
                aCurPos.Y() += nVPage;
            break;
        case SID_CURSORHOME:
            if( nMaxVertPos<0 )
            {
                long nPage  = pPreview->GetPageNo();
                long nTotal = pPreview->GetTotalPages();
                if( nTotal && nPage != 0 )
                {
                    SfxViewFrame* pSfxViewFrame = GetViewFrame();
                    SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_FIRST );
                    Execute( aSfxRequest );
                }
            }
            else
            {
                aCurPos.Y() = 0;
                aCurPos.X() = 0;
            }
            break;
        case SID_CURSOREND:
            if( nMaxVertPos<0 )
            {
                if( !pPreview->AllTested() )
                    pPreview->CalcAll();
                long nPage  = pPreview->GetPageNo();
                long nTotal = pPreview->GetTotalPages();
                if( nTotal && nPage+1 != nTotal )
                {
                    SfxViewFrame* pSfxViewFrame = GetViewFrame();
                    SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_LAST );
                    Execute( aSfxRequest );
                }
            }
            else
            {
                aCurPos.Y() = nVRange;
                aCurPos.X() = nHRange;
            }
            break;
	}

		// nHRange-nHPage kann negativ sein, deshalb Abfrage auf < 0 hinterher

    if( aCurPos.Y() > (nVRange-nVPage) )
        aCurPos.Y() = (nVRange-nVPage);
    if( aCurPos.Y() < 0 )
        aCurPos.Y() = 0;
    if( aCurPos.X() > (nHRange-nHPage) )
        aCurPos.X() = (nHRange-nHPage);
    if( aCurPos.X() < 0 )
        aCurPos.X() = 0;

    if( nMaxVertPos>=0 )
    {
	    if( aCurPos.Y() != aPrevPos.Y() )
	    {
	    	pVerScroll->SetThumbPos( aCurPos.Y() );
	        pPreview->SetYOffset( aCurPos.Y() );
	    }
    }

	if( aCurPos.X() != aPrevPos.X() )
	{
		pHorScroll->SetThumbPos( aCurPos.X() );
		pPreview->SetXOffset( aCurPos.X() );
	}

}

void ScPreviewShell::AddAccessibilityObject( SfxListener& rObject )
{
	if (!pAccessibilityBroadcaster)
		pAccessibilityBroadcaster = new SfxBroadcaster;

	rObject.StartListening( *pAccessibilityBroadcaster );
}

void ScPreviewShell::RemoveAccessibilityObject( SfxListener& rObject )
{
	if (pAccessibilityBroadcaster)
		rObject.EndListening( *pAccessibilityBroadcaster );
	else
	{
		DBG_ERROR("kein Accessibility-Broadcaster?");
	}
}

void ScPreviewShell::BroadcastAccessibility( const SfxHint &rHint )
{
	if (pAccessibilityBroadcaster)
		pAccessibilityBroadcaster->Broadcast( rHint );
}

sal_Bool ScPreviewShell::HasAccessibilityObjects()
{
	return pAccessibilityBroadcaster && pAccessibilityBroadcaster->HasListeners();
}

const ScPreviewLocationData& ScPreviewShell::GetLocationData()
{
	return pPreview->GetLocationData();
}

ScDocument* ScPreviewShell::GetDocument()
{
	return pDocShell->GetDocument();
}