diff options
Diffstat (limited to 'sw/source/ui/uiview/pview.cxx')
| -rw-r--r-- | sw/source/ui/uiview/pview.cxx | 2718 |
1 files changed, 2718 insertions, 0 deletions
diff --git a/sw/source/ui/uiview/pview.cxx b/sw/source/ui/uiview/pview.cxx new file mode 100644 index 000000000000..801a5fa68f6a --- /dev/null +++ b/sw/source/ui/uiview/pview.cxx @@ -0,0 +1,2718 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: pview.cxx,v $ + * $Revision: 1.70 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sw.hxx" + + + +#include <sfx2/objface.hxx> +#include <vcl/timer.hxx> +#include <vcl/field.hxx> +#include <vcl/fixed.hxx> +#include <vcl/help.hxx> +#include <vcl/cmdevt.hxx> +#include <vcl/button.hxx> +#include <svtools/printdlg.hxx> +#include <svl/whiter.hxx> +#include <svl/stritem.hxx> +#include <svl/eitem.hxx> +#include <sfx2/printer.hxx> +#include <sfx2/progress.hxx> +#include <sfx2/app.hxx> +#include <sfx2/topfrm.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <vcl/msgbox.hxx> +#include <svx/stddlg.hxx> +#include <svx/paperinf.hxx> +#include <svx/srchitem.hxx> +#include <svx/svdview.hxx> +#include <svx/dlgutil.hxx> +#include <svx/zoomslideritem.hxx> +#ifndef _SVX_SVXIDS_HRC //autogen +#include <svx/svxids.hrc> +#endif + + +#include <swwait.hxx> +#include <globdoc.hxx> +#include <wdocsh.hxx> +#include <pvprtdat.hxx> +#include <swmodule.hxx> +#include <modcfg.hxx> +#include <wrtsh.hxx> +#include <docsh.hxx> +#include <viewopt.hxx> +#include <doc.hxx> +#include <pview.hxx> +#include <view.hxx> +#include <textsh.hxx> +#include <scroll.hxx> +#include <swprtopt.hxx> +#include <docstat.hxx> +#include <usrpref.hxx> +#include <viewfunc.hxx> + + +#ifndef _HELPID_H +#include <helpid.h> +#endif +#ifndef _CMDID_H +#include <cmdid.h> +#endif +#ifndef _GLOBALS_HRC +#include <globals.hrc> +#endif +#ifndef _POPUP_HRC +#include <popup.hrc> +#endif +#ifndef _PVIEW_HRC +#include <pview.hrc> +#endif + +#define SwPagePreView +#include <sfx2/msg.hxx> +#include <swslots.hxx> +// OD 12.12.2002 #103492# +#include <pagepreviewlayout.hxx> + +#include <svx/svxdlg.hxx> +#include <svx/dialogs.hrc> +#include <vos/mutex.hxx> + +using namespace ::com::sun::star; + + +SFX_IMPL_VIEWFACTORY(SwPagePreView, SW_RES(STR_NONAME)) +{ + SFX_VIEW_REGISTRATION(SwDocShell); + SFX_VIEW_REGISTRATION(SwWebDocShell); + SFX_VIEW_REGISTRATION(SwGlobalDocShell); +} + +SFX_IMPL_INTERFACE(SwPagePreView, SfxViewShell, SW_RES(RID_PVIEW_TOOLBOX)) +{ + SFX_POPUPMENU_REGISTRATION(SW_RES(MN_PPREVIEW_POPUPMENU)); + SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT|SFX_VISIBILITY_STANDARD| + SFX_VISIBILITY_CLIENT|SFX_VISIBILITY_FULLSCREEN| + SFX_VISIBILITY_READONLYDOC, + SW_RES(RID_PVIEW_TOOLBOX)); +} + + +TYPEINIT1(SwPagePreView,SfxViewShell) + +#define SWVIEWFLAGS ( SFX_VIEW_MAXIMIZE_FIRST|SFX_VIEW_OPTIMIZE_EACH| \ + SFX_VIEW_CAN_PRINT|SFX_VIEW_HAS_PRINTOPTIONS ) + +#define MIN_PREVIEW_ZOOM 25 +#define MAX_PREVIEW_ZOOM 600 +/* */ +/* -----------------26.11.2002 10:41----------------- + * + * --------------------------------------------------*/ +USHORT lcl_GetNextZoomStep(USHORT nCurrentZoom, BOOL bZoomIn) +{ + static USHORT aZoomArr[] = + { + 25, 50, 75, 100, 150, 200, 400, 600 + }; + const sal_uInt16 nZoomArrSize = sizeof(aZoomArr)/sizeof(USHORT); + if(bZoomIn) + for(int i = nZoomArrSize - 1; i >= 0; --i) + { + if(nCurrentZoom > aZoomArr[i] || !i) + return aZoomArr[i]; + } + else + for(int i = 0; i < nZoomArrSize; ++i) + { + if(nCurrentZoom < aZoomArr[i]) + return aZoomArr[i]; + } + return bZoomIn ? MAX_PREVIEW_ZOOM : MIN_PREVIEW_ZOOM; +}; +/* -----------------02.12.2002 09:11----------------- + * + * --------------------------------------------------*/ +void lcl_InvalidateZoomSlots(SfxBindings& rBindings) +{ + static USHORT __READONLY_DATA aInval[] = + { + SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN, SID_ATTR_ZOOMSLIDER, FN_PREVIEW_ZOOM, FN_STAT_ZOOM, + 0 + }; + rBindings.Invalidate( aInval ); +} +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + +// erstmal der Zoom-Dialog + +class SwPreViewZoomDlg : public SvxStandardDialog +{ + FixedText aRowLbl; + NumericField aRowEdit; + FixedText aColLbl; + NumericField aColEdit; + + OKButton aOkBtn; + CancelButton aCancelBtn; + HelpButton aHelpBtn; + + virtual void Apply(); + +public: + SwPreViewZoomDlg( SwPagePreViewWin& rParent ); + ~SwPreViewZoomDlg(); +}; + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +SwPreViewZoomDlg::SwPreViewZoomDlg( SwPagePreViewWin& rParent ) : + SvxStandardDialog( &rParent, SW_RES(DLG_PAGEPREVIEW_ZOOM) ), + aRowLbl(this,SW_RES(FT_ROW)), + aRowEdit(this,SW_RES(ED_ROW)), + aColLbl(this,SW_RES(FT_COL)), + aColEdit(this,SW_RES(ED_COL)), + aOkBtn(this,SW_RES(BT_OK)), + aCancelBtn(this,SW_RES(BT_CANCEL)), + aHelpBtn(this,SW_RES(BT_HELP)) +{ + FreeResource(); + + aRowEdit.SetValue( rParent.GetRow() ); + aColEdit.SetValue( rParent.GetCol() ); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + + SwPreViewZoomDlg::~SwPreViewZoomDlg() {} + + +void SwPreViewZoomDlg::Apply() +{ + ((SwPagePreViewWin*)GetParent())->CalcWish( + BYTE(aRowEdit.GetValue()), + BYTE(aColEdit.GetValue()) ); +} + +/* */ +/* -----------------20.08.98 15:25------------------- + * Vorschau fuer den Seitendruck + * --------------------------------------------------*/ +struct PrintSettingsStruct; +class PrtPrvWindow : public Window +{ + const PrintSettingsStruct& rSettings; + + virtual void Paint(const Rectangle&); +public : + PrtPrvWindow(Window* pParent, const ResId& rResId, const PrintSettingsStruct& rSett) : + Window(pParent, rResId), rSettings(rSett){} +}; +/*-------------------------------------------------------------------- + Beschreibung: Optionen fuer das Drucken der Preview + --------------------------------------------------------------------*/ +struct PrintSettingsStruct +{ + Size aPageMaxSize; // groesste Seite + Size aPrtSize; // Papiergroesse + Size aPrvPrtSize; // Groesse innerhalb der LRTB-Raender + Size aGridSize; // Groesse fuer jede Seite, enthaelt je + // die Haelfte von H- und V-Distance + + long nLeft; + long nRight; + long nTop; + long nBottom; + long nHori; + long nVert; + + USHORT nRows; + USHORT nCols; + + BOOL bPrinterLandscape; // Ausrichtung +}; + +class SwPreviewPrintOptionsDialog : public SvxStandardDialog +{ + FixedLine aRowColFL; + FixedText aRowsFT; + NumericField aRowsNF; + FixedText aColsFT; + NumericField aColsNF; + + FixedLine aMarginFL; + FixedText aLSpaceFT; + MetricField aLSpaceMF; + FixedText aRSpaceFT; + MetricField aRSpaceMF; + FixedText aTSpaceFT; + MetricField aTSpaceMF; + FixedText aBSpaceFT; + MetricField aBSpaceMF; + FixedLine aDistanceFL; + FixedText aHSpaceFT; + MetricField aHSpaceMF; + FixedText aVSpaceFT; + MetricField aVSpaceMF; + + RadioButton aLandscapeRB; + RadioButton aPortraitRB; + FixedLine aOrientationFL; + + PrtPrvWindow aPreviewWin; + + OKButton aOkBtn; + CancelButton aCancelBtn; + HelpButton aHelpBtn; + + PushButton aStandardPB; + + SwPagePreView& rPreView; + SwPagePreViewWin& rParentWin; + PrintSettingsStruct aSettings; +/* Size aPageMaxSize; + Size aPrtSize; + + BOOL bOrientation; +*/ + BOOL bStandard; + + virtual void Apply(); + void FillControls(SwPagePreViewPrtData& rData); + + DECL_LINK( ModifyHdl, Edit* ); + DECL_LINK( StandardHdl, PushButton* ); + +public: + SwPreviewPrintOptionsDialog(SwPagePreViewWin& rParent, SwPagePreView& rView); + ~SwPreviewPrintOptionsDialog(); +}; + +/* -----------------19.08.98 13:35------------------- + * + * --------------------------------------------------*/ +SwPreviewPrintOptionsDialog::SwPreviewPrintOptionsDialog( SwPagePreViewWin& rParent, SwPagePreView& rView ) : + SvxStandardDialog( &rParent, SW_RES(DLG_PAGEPREVIEW_PRINTOPTIONS) ), + aRowColFL(this,SW_RES( FL_ROWCOL)), + aRowsFT(this,SW_RES( FT_ROWS)), + aRowsNF(this,SW_RES( NF_ROWS)), + aColsFT(this,SW_RES( FT_COLS)), + aColsNF(this,SW_RES( NF_COLS)), + aMarginFL(this,SW_RES( FL_MARGINS)), + aLSpaceFT(this,SW_RES( FT_LMARGIN)), + aLSpaceMF(this,SW_RES( MF_LMARGIN)), + aRSpaceFT(this,SW_RES( FT_RMARGIN)), + aRSpaceMF(this,SW_RES( MF_RMARGIN)), + aTSpaceFT(this,SW_RES( FT_TMARGIN)), + aTSpaceMF(this,SW_RES( MF_TMARGIN)), + aBSpaceFT(this,SW_RES( FT_BMARGIN)), + aBSpaceMF(this,SW_RES( MF_BMARGIN)), + aDistanceFL(this,SW_RES(FL_DISTANCE)), + aHSpaceFT(this,SW_RES( FT_HMARGIN)), + aHSpaceMF(this,SW_RES( MF_HMARGIN)), + aVSpaceFT(this,SW_RES( FT_VMARGIN)), + aVSpaceMF(this,SW_RES( MF_VMARGIN)), + aLandscapeRB(this,SW_RES( RB_LANDSCAPE)), + aPortraitRB(this,SW_RES( RB_PORTRAIT)), + aOrientationFL(this,SW_RES( FL_ORIENTATION)), + aPreviewWin(this,SW_RES( WIN_PREVIEW), aSettings), + aOkBtn(this,SW_RES(BT_OK)), + aCancelBtn(this,SW_RES(BT_CANCEL)), + aHelpBtn(this,SW_RES(BT_HELP)), + aStandardPB(this,SW_RES(PB_STANDARD)), + rPreView(rView), + rParentWin(rParent), + bStandard(TRUE) +{ + FreeResource(); + ViewShell& rViewSh = *rPreView.GetViewShell(); + // OD 18.12.2002 #103492# + aSettings.aPageMaxSize = rViewSh.PagePreviewLayout()->GetMaxPageSize(); + SfxPrinter* pPrinter = rViewSh.getIDocumentDeviceAccess()->getPrinter( true ); + aSettings.aPrtSize = pPrinter->GetPaperSize(); + //#97682# make sure that no division by zero occurs + if(!aSettings.aPrtSize.Width() || !aSettings.aPrtSize.Height()) + aSettings.aPrtSize = SvxPaperInfo::GetPaperSize(PAPER_A4); + aSettings.bPrinterLandscape = pPrinter->GetOrientation() == ORIENTATION_LANDSCAPE; + + + SwDocShell* pDocShell = rPreView.GetDocShell(); + const SwMasterUsrPref *pUsrPref = SW_MOD()->GetUsrPref(0 != PTR_CAST(SwWebDocShell, pDocShell)); + FieldUnit eFieldUnit = pUsrPref->GetMetric(); + ::SetFieldUnit( aLSpaceMF, eFieldUnit ); + ::SetFieldUnit( aRSpaceMF, eFieldUnit ); + ::SetFieldUnit( aTSpaceMF, eFieldUnit ); + ::SetFieldUnit( aBSpaceMF, eFieldUnit ); + ::SetFieldUnit( aHSpaceMF, eFieldUnit ); + ::SetFieldUnit( aVSpaceMF, eFieldUnit ); + + SwDoc* pDoc = pDocShell->GetDoc(); + SwPagePreViewPrtData aData; + if(pDoc->GetPreViewPrtData()) + { + aData = *pDoc->GetPreViewPrtData(); + bStandard = FALSE; + } + else + { + // Orientation der PreviewData an den Drucker anpassen + aData.SetLandscape(aSettings.bPrinterLandscape); + aData.SetRow(rParent.GetRow()); + aData.SetCol(rParent.GetCol()); + } + FillControls(aData); + + aLSpaceMF.SaveValue(); + aRSpaceMF.SaveValue(); + aTSpaceMF.SaveValue(); + aBSpaceMF.SaveValue(); + aHSpaceMF.SaveValue(); + aVSpaceMF.SaveValue(); + aRowsNF.SaveValue(); + aColsNF.SaveValue(); + aLandscapeRB.SaveValue(); + aPortraitRB.SaveValue(); + + aStandardPB.SetClickHdl(LINK(this, SwPreviewPrintOptionsDialog, StandardHdl)); + Link aLk = LINK(this, SwPreviewPrintOptionsDialog, ModifyHdl); + aLSpaceMF.SetUpHdl(aLk); + aRSpaceMF.SetUpHdl(aLk); + aTSpaceMF.SetUpHdl(aLk); + aBSpaceMF.SetUpHdl(aLk); + aHSpaceMF.SetUpHdl(aLk); + aVSpaceMF.SetUpHdl(aLk); + aRowsNF.SetUpHdl(aLk); + aColsNF.SetUpHdl(aLk); + aLSpaceMF.SetDownHdl(aLk); + aRSpaceMF.SetDownHdl(aLk); + aTSpaceMF.SetDownHdl(aLk); + aBSpaceMF.SetDownHdl(aLk); + aHSpaceMF.SetDownHdl(aLk); + aVSpaceMF.SetDownHdl(aLk); + aRowsNF.SetDownHdl(aLk); + aColsNF.SetDownHdl(aLk); + aLSpaceMF.SetLoseFocusHdl(aLk); + aRSpaceMF.SetLoseFocusHdl(aLk); + aTSpaceMF.SetLoseFocusHdl(aLk); + aBSpaceMF.SetLoseFocusHdl(aLk); + aHSpaceMF.SetLoseFocusHdl(aLk); + aVSpaceMF.SetLoseFocusHdl(aLk); + aRowsNF.SetLoseFocusHdl(aLk); + aColsNF.SetLoseFocusHdl(aLk); + aLandscapeRB.SetClickHdl(aLk); + aPortraitRB.SetClickHdl(aLk); + + ModifyHdl(0); + if(bStandard) + StandardHdl(&aStandardPB); +} + + +/* -----------------19.08.98 13:36------------------- + * + * --------------------------------------------------*/ +SwPreviewPrintOptionsDialog::~SwPreviewPrintOptionsDialog() +{ +} +/* -----------------12.11.98 11:32------------------- + * + * --------------------------------------------------*/ +void SwPreviewPrintOptionsDialog::FillControls(SwPagePreViewPrtData& rData) +{ + aLSpaceMF.SetValue(aLSpaceMF.Normalize(rData.GetLeftSpace() ), FUNIT_TWIP); + aRSpaceMF.SetValue(aRSpaceMF.Normalize(rData.GetRightSpace() ), FUNIT_TWIP); + aTSpaceMF.SetValue(aTSpaceMF.Normalize(rData.GetTopSpace() ), FUNIT_TWIP); + aBSpaceMF.SetValue(aBSpaceMF.Normalize(rData.GetBottomSpace()), FUNIT_TWIP); + aHSpaceMF.SetValue(aHSpaceMF.Normalize(rData.GetHorzSpace() ), FUNIT_TWIP); + aVSpaceMF.SetValue(aVSpaceMF.Normalize(rData.GetVertSpace() ), FUNIT_TWIP); + aRowsNF.SetValue(rData.GetRow()); + aColsNF.SetValue(rData.GetCol()); + aSettings.bPrinterLandscape ? aLandscapeRB.Check() : aPortraitRB.Check(); + // wenn Drucker und Einstellungen nicht uebereinstimmen, dann Seiten tauschen + if( rData.GetLandscape() != aSettings.bPrinterLandscape ) + { + Size aTmp(aSettings.aPrtSize.Height(), aSettings.aPrtSize.Width()); + aSettings.aPrtSize = aTmp; + aSettings.bPrinterLandscape = !aSettings.bPrinterLandscape; + // nochmal setzen, denn auch wenn nur die Default-Orientierung dem Drucker + // angepasst wurde, sollen die Einstellungen gespeichert werden + aSettings.bPrinterLandscape ? aLandscapeRB.Check() : aPortraitRB.Check(); + } + aLandscapeRB.SaveValue(); + aPortraitRB.SaveValue(); + + aSettings.nLeft = rData.GetLeftSpace() ; + aSettings.nRight = rData.GetRightSpace() ; + aSettings.nTop = rData.GetTopSpace() ; + aSettings.nBottom = rData.GetBottomSpace(); + aSettings.nHori = rData.GetHorzSpace() ; + aSettings.nVert = rData.GetVertSpace() ; + aSettings.nRows = rData.GetRow() ; + aSettings.nCols = rData.GetCol() ; + aSettings.aPrvPrtSize = aSettings.aPrtSize ; +} + +/* -----------------19.08.98 14:31------------------- + * + * --------------------------------------------------*/ +void SwPreviewPrintOptionsDialog::Apply() +{ + + SwDoc* pDoc = rPreView.GetDocShell()->GetDoc(); + if(bStandard) + pDoc->SetPreViewPrtData(0); + else if( aLSpaceMF.GetSavedValue() != aLSpaceMF.GetText() || + aRSpaceMF.GetSavedValue() != aRSpaceMF.GetText() || + aTSpaceMF.GetSavedValue() != aTSpaceMF.GetText() || + aBSpaceMF.GetSavedValue() != aBSpaceMF.GetText() || + aHSpaceMF.GetSavedValue() != aHSpaceMF.GetText() || + aVSpaceMF.GetSavedValue() != aVSpaceMF.GetText() || + aRowsNF.GetSavedValue() != aRowsNF.GetText() || + aColsNF.GetSavedValue() != aColsNF.GetText() || + aLandscapeRB.GetSavedValue() != aLandscapeRB.IsChecked() || + aPortraitRB.GetSavedValue() != aPortraitRB.IsChecked() ) + { + SwPagePreViewPrtData aData; + if(pDoc->GetPreViewPrtData()) + aData = *pDoc->GetPreViewPrtData(); + aData.SetLeftSpace( static_cast< ULONG >(aLSpaceMF.Denormalize(aLSpaceMF.GetValue(FUNIT_TWIP))) ); + aData.SetRightSpace( static_cast< ULONG >(aRSpaceMF.Denormalize(aRSpaceMF.GetValue(FUNIT_TWIP))) ); + aData.SetTopSpace( static_cast< ULONG >(aTSpaceMF.Denormalize(aTSpaceMF.GetValue(FUNIT_TWIP))) ); + aData.SetBottomSpace( static_cast< ULONG >(aBSpaceMF.Denormalize(aBSpaceMF.GetValue(FUNIT_TWIP))) ); + + aData.SetHorzSpace( static_cast< ULONG >(aHSpaceMF.Denormalize(aHSpaceMF.GetValue(FUNIT_TWIP))) ); + aData.SetVertSpace( static_cast< ULONG >(aVSpaceMF.Denormalize(aVSpaceMF.GetValue(FUNIT_TWIP))) ); + aData.SetRow((BYTE)aRowsNF.GetValue()); + aData.SetCol((BYTE)aColsNF.GetValue()); + aData.SetLandscape(aLandscapeRB.IsChecked()); + + ViewShell& rViewSh = *rPreView.GetViewShell(); + SfxPrinter* pPrinter = rViewSh.getIDocumentDeviceAccess()->getPrinter( true ); + if((pPrinter->GetOrientation() == ORIENTATION_LANDSCAPE) + != aData.GetLandscape()) + pPrinter->SetOrientation(aData.GetLandscape() ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT); + + + pDoc->SetPreViewPrtData(&aData); + + } +} +/* -----------------20.08.98 08:48------------------- + * + * --------------------------------------------------*/ +IMPL_LINK( SwPreviewPrintOptionsDialog, ModifyHdl, Edit*, pEdit ) +{ + if(bStandard && pEdit) + { + aLSpaceMF.SetUserValue(aLSpaceMF.GetValue()); + aRSpaceMF.SetUserValue(aRSpaceMF.GetValue()); + aTSpaceMF.SetUserValue(aTSpaceMF.GetValue()); + aBSpaceMF.SetUserValue(aBSpaceMF.GetValue()); + aHSpaceMF.SetUserValue(aHSpaceMF.GetValue()); + aVSpaceMF.SetUserValue(aVSpaceMF.GetValue()); + aRowsNF. SetUserValue(aRowsNF .GetValue()); + aColsNF. SetUserValue(aColsNF .GetValue()); + + bStandard = FALSE; + } + BOOL bOrientChanged = aSettings.bPrinterLandscape != aLandscapeRB.IsChecked();; + if(pEdit == &aLSpaceMF) + aSettings.nLeft = static_cast< long >(aLSpaceMF.Denormalize(aLSpaceMF.GetValue(FUNIT_TWIP))); + else if(pEdit == &aRSpaceMF) + aSettings.nRight = static_cast< long >(aRSpaceMF.Denormalize(aRSpaceMF.GetValue(FUNIT_TWIP))); + else if(pEdit == &aTSpaceMF) + aSettings.nTop = static_cast< long >(aTSpaceMF.Denormalize(aTSpaceMF.GetValue(FUNIT_TWIP))); + else if(pEdit == &aBSpaceMF) + aSettings.nBottom = static_cast< long >(aBSpaceMF.Denormalize(aBSpaceMF.GetValue(FUNIT_TWIP))); + else if(pEdit == &aHSpaceMF) + aSettings.nHori = static_cast< long >(aHSpaceMF.Denormalize(aHSpaceMF.GetValue(FUNIT_TWIP))); + else if(pEdit == &aVSpaceMF) + aSettings.nVert = static_cast< long >(aVSpaceMF.Denormalize(aVSpaceMF.GetValue(FUNIT_TWIP))); + else if(pEdit == &aRowsNF) + aSettings.nRows = (USHORT)aRowsNF.GetValue(); + else if(pEdit == &aColsNF) + aSettings.nCols = (USHORT)aColsNF.GetValue(); + else if(pEdit == (Edit*)&aLandscapeRB) + aSettings.bPrinterLandscape = aLandscapeRB.IsChecked(); + else if(pEdit == (Edit*)&aPortraitRB) + aSettings.bPrinterLandscape = aLandscapeRB.IsChecked(); + + if(bOrientChanged) + { + Size aTmp(aSettings.aPrtSize.Height(), aSettings.aPrtSize.Width()); + aSettings.aPrtSize = aTmp; + } + + + aSettings.aPrvPrtSize = Size(aSettings.aPrtSize.Width() - aSettings.nRight - aSettings.nLeft, + aSettings.aPrtSize.Height() - aSettings.nTop - aSettings.nBottom); + aSettings.aGridSize = Size(aSettings.aPrvPrtSize.Width() / aSettings.nCols, + aSettings.aPrvPrtSize.Height() / aSettings.nRows ); + // was fehlt noch: Orientation auswerten, minimalrand ausrechnen, Beispiel fuettern + + + //am Ende Maximalwerte setzen + long n20Percent = aSettings.aPrtSize.Width() / 5; + aLSpaceMF.SetMax(aLSpaceMF.Normalize(aSettings.aPrtSize.Width() - aSettings.nRight - n20Percent), FUNIT_TWIP); + aRSpaceMF.SetMax(aRSpaceMF.Normalize(aSettings.aPrtSize.Width() - aSettings.nLeft - n20Percent), FUNIT_TWIP); + n20Percent = aSettings.aPrtSize.Height() / 5; + aTSpaceMF.SetMax(aTSpaceMF.Normalize(aSettings.aPrtSize.Height() - aSettings.nBottom - n20Percent), FUNIT_TWIP); + aBSpaceMF.SetMax(aBSpaceMF.Normalize(aSettings.aPrtSize.Height() - aSettings.nTop - n20Percent), FUNIT_TWIP); + + long n80Percent = aSettings.aPrvPrtSize.Width() * 4 / 5; + aHSpaceMF.SetMax(aHSpaceMF.Normalize(n80Percent / aSettings.nRows), FUNIT_TWIP); + n80Percent = aSettings.aPrvPrtSize.Height()* 4 / 5; + aVSpaceMF.SetMax(aVSpaceMF.Normalize(n80Percent / aSettings.nCols), FUNIT_TWIP); + aHSpaceMF.Enable(aSettings.nCols > 1); + aVSpaceMF.Enable(aSettings.nRows > 1); + aRowsNF.SetMin(1);// nur damit auch nach Standard wieder der Inhalt angezeigt wird + aColsNF.SetMin(1); + + + aPreviewWin.Invalidate(); + return 0; +} +/* -----------------28.08.98 14:59------------------- + * + * --------------------------------------------------*/ +IMPL_LINK( SwPreviewPrintOptionsDialog, StandardHdl, PushButton*, EMPTYARG ) +{ + SetUpdateMode(TRUE); + SwPagePreViewPrtData aData; + aData.SetRow(rParentWin.GetRow()); + aData.SetCol(rParentWin.GetCol()); + FillControls(aData); + bStandard = TRUE; + aLSpaceMF.SetText(aEmptyStr); + aRSpaceMF.SetText(aEmptyStr); + aTSpaceMF.SetText(aEmptyStr); + aBSpaceMF.SetText(aEmptyStr); + aHSpaceMF.SetText(aEmptyStr); + aVSpaceMF.SetText(aEmptyStr); + aPreviewWin.Invalidate(); + SetUpdateMode(FALSE); + return 0; +} +/* -----------------20.08.98 15:28------------------- + * Preview anzeigen + * --------------------------------------------------*/ +void PrtPrvWindow::Paint(const Rectangle&) +{ + Size aWinSize(GetOutputSizePixel()); + long nWidth = rSettings.aPrtSize.Width(); + long nHeight = rSettings.aPrtSize.Height(); + BOOL bHoriValid = (aWinSize.Width() * 100 / aWinSize.Height()) < + (rSettings.aPrtSize.Width() * 100/ rSettings.aPrtSize.Height()); + Fraction aXScale( aWinSize.Width(), Max( nWidth , 1L ) ); + Fraction aYScale( aWinSize.Height(), Max( nHeight, 1L ) ); + MapMode aMapMode( GetMapMode() ); + aMapMode.SetScaleX( bHoriValid ? aXScale : aYScale); + aMapMode.SetScaleY( bHoriValid ? aXScale : aYScale); + SetMapMode( aMapMode ); + + aWinSize = GetOutputSize(); + + Point aOffset(0,0); + if(bHoriValid) + aOffset.Y() = (aWinSize.Height() - rSettings.aPrtSize.Height()) / 2; + else + aOffset.X() = (aWinSize.Width() - rSettings.aPrtSize.Width()) / 2;; + + + BOOL bUseSystemColors = SvtAccessibilityOptions().GetIsForPagePreviews() + && GetSettings().GetStyleSettings().GetHighContrastMode(); + + //der weisse Seitenhintergrund + Rectangle aRect(aOffset, rSettings.aPrtSize); + if(bUseSystemColors) + { + SetFillColor( GetSettings().GetStyleSettings().GetWindowColor() ); + SetLineColor( SwViewOption::GetFontColor() ); + } + else + { + SetFillColor( Color( COL_WHITE ) ); + SetLineColor(Color( COL_BLACK ) ); + } + + DrawRect(aRect); + + Point aTL(aOffset); + aTL.X() += rSettings.nLeft; + aTL.Y() += rSettings.nTop; + + Size aPrvPageSize((rSettings.aPrvPrtSize.Width() - (rSettings.nCols - 1) * rSettings.nHori) / rSettings.nCols, + (rSettings.aPrvPrtSize.Height() - (rSettings.nRows - 1) * rSettings.nVert) / rSettings.nRows); + // jetzt muss noch das unterschiedliche Groessenverhaeltnis berechnet werden, um es an + // der richtigen Seite abzuziehen. + //... + long nSourceScale = rSettings.aPageMaxSize.Width() * 100 / rSettings.aPageMaxSize.Height(); + long nDestScale = aPrvPageSize.Width() * 100 / aPrvPageSize.Height() ; + if(nSourceScale > nDestScale) // die Seite ist relativ breiter als das vorhandene Rechteck + { + aPrvPageSize.Height() = aPrvPageSize.Width() * 100 / nSourceScale; + } + else + { + aPrvPageSize.Width() = aPrvPageSize.Height() * nSourceScale / 100; + } + + if(bUseSystemColors) + SetFillColor( GetSettings().GetStyleSettings().GetWindowColor() ); + else + SetFillColor( Color( COL_GRAY ) ); + + + aRect = Rectangle(aTL, aPrvPageSize); + for(USHORT i = 0; i < rSettings.nRows; i++) + { + for(USHORT j = 0; j < rSettings.nCols; j++) + { + DrawRect(aRect); + aRect.Move(aPrvPageSize.Width() + rSettings.nHori, 0); + } + + aRect.Move( 0, aPrvPageSize.Height() + rSettings.nVert); + aRect.SetPos(Point(aTL.X(), aRect.TopLeft().Y())); + } + //rSettings; +} + +/* */ +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + +// alles fuers SwPagePreViewWin + + +SwPagePreViewWin::SwPagePreViewWin( Window *pParent, SwPagePreView& rPView ) + : Window( pParent, WinBits( WB_CLIPCHILDREN) ), + mpViewShell( 0 ), + mrView( rPView ), + mbCalcScaleForPreviewLayout( true ), + maPaintedPreviewDocRect( Rectangle(0,0,0,0) ) +{ + SetOutDevViewType( OUTDEV_VIEWTYPE_PRINTPREVIEW ); //#106611# + SetHelpId(HID_PAGEPREVIEW); + SetFillColor( GetBackground().GetColor() ); + SetLineColor( GetBackground().GetColor()); + SetMapMode( MapMode(MAP_TWIP) ); + + const SwMasterUsrPref *pUsrPref = SW_MOD()->GetUsrPref(FALSE); + mnRow = pUsrPref->GetPagePrevRow(); // 1 Zeile + mnCol = pUsrPref->GetPagePrevCol(); // 1 Spalte + // OD 24.03.2003 #108282# - member <mnVirtPage> no longer exists. + mnSttPage = USHRT_MAX; +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +SwPagePreViewWin::~SwPagePreViewWin() +{ + if( mpViewShell ) + delete mpViewShell; +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreViewWin::Paint( const Rectangle& rRect ) +{ + if( !mpViewShell || !mpViewShell->GetLayout() ) + return; + + if( USHRT_MAX == mnSttPage ) // wurde noch nie berechnet ? (Init-Phase!) + { + // das ist die Size, auf die ich mich immer beziehe + if( !maPxWinSize.Height() || !maPxWinSize.Width() ) + maPxWinSize = GetOutputSizePixel(); + + Rectangle aRect( LogicToPixel( rRect )); + mpPgPrevwLayout->Prepare( 1, Point(0,0), maPxWinSize, + mnSttPage, maPaintedPreviewDocRect ); + SetSelectedPage( 1 ); + mpPgPrevwLayout->Paint( PixelToLogic( aRect ) ); + SetPagePreview(mnRow, mnCol); + } + else + { + MapMode aMM( GetMapMode() ); + aMM.SetScaleX( maScale ); + aMM.SetScaleY( maScale ); + SetMapMode( aMM ); + mpPgPrevwLayout->Paint( rRect ); + } +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ +void SwPagePreViewWin::CalcWish( BYTE nNewRow, BYTE nNewCol ) +{ + if( !mpViewShell || !mpViewShell->GetLayout() ) + return; + + USHORT nOldCol = mnCol; + // OD 02.12.2002 #103492# - update <mnRow> and <mnCol>. + mnRow = nNewRow; + mnCol = nNewCol; + USHORT nPages = mnRow * mnCol, + nLastSttPg = mrView.GetPageCount()+1 > nPages + ? mrView.GetPageCount()+1 - nPages : 0; + if( mnSttPage > nLastSttPg ) + mnSttPage = nLastSttPg; + + mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true ); + mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize, + mnSttPage, maPaintedPreviewDocRect ); + SetSelectedPage( mnSttPage ); + SetPagePreview(mnRow, mnCol); + maScale = GetMapMode().GetScaleX(); + + // falls an der Spaltigkeit gedreht wurde, so muss der Sonderfall + // Einspaltig beachtet und ggfs. der Scrollbar korrigiert werden + if( (1 == nOldCol) ^ (1 == mnCol) ) + mrView.ScrollDocSzChg(); + + // Sortierung muss eingehalten werden!! + // OD 24.03.2003 #108282# - additional invalidate page status. + static USHORT __READONLY_DATA aInval[] = + { + SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN, + FN_PREVIEW_ZOOM, + FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN, + FN_STAT_PAGE, FN_STAT_ZOOM, + FN_SHOW_TWO_PAGES, FN_SHOW_MULTIPLE_PAGES, + 0 + }; + SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings(); + rBindings.Invalidate( aInval ); + rBindings.Update( FN_SHOW_TWO_PAGES ); + rBindings.Update( FN_SHOW_MULTIPLE_PAGES ); + // OD 18.12.2002 #103492# - adjust scrollbars + mrView.ScrollViewSzChg(); +} +/*-------------------------------------------------------------------- + Beschreibung:, mnSttPage is Absolute + --------------------------------------------------------------------*/ + + +int SwPagePreViewWin::MovePage( int eMoveMode ) +{ + // soviele Seiten hoch + USHORT nPages = mnRow * mnCol; + USHORT nNewSttPage = mnSttPage; + // OD 04.12.2002 #103492# + USHORT nPageCount = mrView.GetPageCount(); + USHORT nDefSttPg = GetDefSttPage(); + // OD 06.12.2002 #103492# + bool bPaintPageAtFirstCol = true; + + switch( eMoveMode ) + { + case MV_PAGE_UP: + { + const sal_uInt16 nRelSttPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( mnSttPage ); + const sal_uInt16 nNewAbsSttPage = nRelSttPage - nPages > 0 ? + mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage - nPages ) : + nDefSttPg; + nNewSttPage = nNewAbsSttPage; + + const sal_uInt16 nRelSelPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() ); + const sal_uInt16 nNewRelSelPage = nRelSelPage - nPages > 0 ? + nRelSelPage - nPages : + 1; + SetSelectedPage( mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nNewRelSelPage ) ); + + break; + } + case MV_PAGE_DOWN: + { + const sal_uInt16 nRelSttPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( mnSttPage ); + const sal_uInt16 nNewAbsSttPage = mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage + nPages ); + nNewSttPage = nNewAbsSttPage < nPageCount ? nNewAbsSttPage : nPageCount; + + const sal_uInt16 nRelSelPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() ); + const sal_uInt16 nNewAbsSelPage = mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSelPage + nPages ); + SetSelectedPage( nNewAbsSelPage < nPageCount ? nNewAbsSelPage : nPageCount ); + + break; + } + case MV_DOC_STT: + nNewSttPage = nDefSttPg; + SetSelectedPage( mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nNewSttPage ? nNewSttPage : 1 ) ); + break; + case MV_DOC_END: + // OD 03.12.2002 #103492# - correct calculation of new start page. + nNewSttPage = nPageCount; + SetSelectedPage( nPageCount ); + break; + // OD 12.12.2002 #103492# - add new move mode + case MV_SELPAGE: + // <nNewSttPage> and <SelectedPage()> are already set. + // OD 20.02.2003 #107369# - not start at first column, only if the + // complete preview layout columns doesn't fit into window. + if ( !mpPgPrevwLayout->DoesPreviewLayoutColsFitIntoWindow() ) + bPaintPageAtFirstCol = false; + break; + case MV_SCROLL: + // OD 17.01.2003 #103492# - check, if paint page at first column + // has to be avoided + if ( !mpPgPrevwLayout->DoesPreviewLayoutRowsFitIntoWindow() || + !mpPgPrevwLayout->DoesPreviewLayoutColsFitIntoWindow() ) + bPaintPageAtFirstCol = false; + break; + case MV_NEWWINSIZE: + // OD 18.12.2002 #103492# - nothing special to do. + break; + case MV_CALC: + // OD 18.12.2002 #103492# - re-init page preview layout. + mpPgPrevwLayout->ReInit(); + + // OD 03.12.2002 #103492# - correct calculation of new start page. + if( nNewSttPage > nPageCount ) + nNewSttPage = nPageCount; + + // OD 18.12.2002 #103492# - correct selected page number + if( SelectedPage() > nPageCount ) + SetSelectedPage( nNewSttPage ? nNewSttPage : 1 ); + } + + mpPgPrevwLayout->Prepare( nNewSttPage, Point(0,0), maPxWinSize, + nNewSttPage, + maPaintedPreviewDocRect, bPaintPageAtFirstCol ); + if( nNewSttPage == mnSttPage && + eMoveMode != MV_SELPAGE ) + return FALSE; + + SetPagePreview(mnRow, mnCol); + mnSttPage = nNewSttPage; + + // OD 24.03.2003 #108282# - additional invalidate page status. + static USHORT __READONLY_DATA aInval[] = + { + FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN, + FN_STAT_PAGE, 0 + }; + + SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings(); + rBindings.Invalidate( aInval ); + + return TRUE; +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreViewWin::SetWinSize( const Size& rNewSize ) +{ + // die Size wollen wir aber immer in Pixel-Einheiten haben + maPxWinSize = LogicToPixel( rNewSize ); + + if( USHRT_MAX == mnSttPage ) + { + mnSttPage = GetDefSttPage(); + SetSelectedPage( GetDefSttPage() ); + } + + if ( mbCalcScaleForPreviewLayout ) + { + mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true ); + maScale = GetMapMode().GetScaleX(); + } + mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize, + mnSttPage, maPaintedPreviewDocRect ); + if ( mbCalcScaleForPreviewLayout ) + { + SetSelectedPage( mnSttPage ); + mbCalcScaleForPreviewLayout = false; + } + SetPagePreview(mnRow, mnCol); + maScale = GetMapMode().GetScaleX(); +} + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreViewWin::GetStatusStr( String& rStr, USHORT nPageCnt ) const +{ + // OD 24.03.2003 #108282# - show physical and virtual page number of + // selected page, if it's visible. + sal_uInt16 nPageNum; + if ( mpPgPrevwLayout->IsPageVisible( mpPgPrevwLayout->SelectedPage() ) ) + { + nPageNum = mpPgPrevwLayout->SelectedPage(); + } + else + { + nPageNum = mnSttPage > 1 ? mnSttPage : 1; + } + sal_uInt16 nVirtPageNum = mpPgPrevwLayout->GetVirtPageNumByPageNum( nPageNum ); + if( nVirtPageNum && nVirtPageNum != nPageNum ) + { + rStr += String::CreateFromInt32( nVirtPageNum ); + rStr += ' '; + } + rStr += String::CreateFromInt32( nPageNum ); + rStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM(" / ")); + rStr += String::CreateFromInt32( nPageCnt ); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreViewWin::KeyInput( const KeyEvent &rKEvt ) +{ + const KeyCode& rKeyCode = rKEvt.GetKeyCode(); + USHORT nKey = rKeyCode.GetCode(); + BOOL bHandled = FALSE; + if(!rKeyCode.GetModifier()) + { + USHORT nSlot = 0; + switch(nKey) + { + case KEY_ADD : nSlot = SID_ZOOM_OUT; break; + case KEY_ESCAPE: nSlot = FN_CLOSE_PAGEPREVIEW; break; + case KEY_SUBTRACT : nSlot = SID_ZOOM_IN; break; + } + if(nSlot) + { + bHandled = TRUE; + mrView.GetViewFrame()->GetDispatcher()->Execute( + nSlot, SFX_CALLMODE_ASYNCHRON ); + } + } + if( !bHandled && !mrView.KeyInput( rKEvt ) ) + Window::KeyInput( rKEvt ); +} + +/****************************************************************************** + * Beschreibung: + ******************************************************************************/ + +void SwPagePreViewWin::Command( const CommandEvent& rCEvt ) +{ + BOOL bCallBase = TRUE; + switch( rCEvt.GetCommand() ) + { + case COMMAND_CONTEXTMENU: + mrView.GetViewFrame()->GetDispatcher()->ExecutePopup(); + bCallBase = FALSE; + break; + + case COMMAND_WHEEL: + case COMMAND_STARTAUTOSCROLL: + case COMMAND_AUTOSCROLL: + { + const CommandWheelData* pData = rCEvt.GetWheelData(); + if( pData ) + { + const CommandWheelData aDataNew(pData->GetDelta(),pData->GetNotchDelta(),COMMAND_WHEEL_PAGESCROLL, + pData->GetMode(),pData->GetModifier(),pData->IsHorz()); + const CommandEvent aEvent( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),rCEvt.IsMouseEvent(),&aDataNew); + bCallBase = !mrView.HandleWheelCommands( aEvent ); + } + else + bCallBase = !mrView.HandleWheelCommands( rCEvt ); + } + break; + default: + // OD 17.12.2002 #103492# - delete assertion + ; + } + + if( bCallBase ) + Window::Command( rCEvt ); +} + +void SwPagePreViewWin::MouseButtonDown( const MouseEvent& rMEvt ) +{ + // OD 17.12.2002 #103492# - consider single-click to set selected page + if( MOUSE_LEFT == ( rMEvt.GetModifier() + rMEvt.GetButtons() ) ) + { + Point aPrevwPos( PixelToLogic( rMEvt.GetPosPixel() ) ); + Point aDocPos; + bool bPosInEmptyPage; + sal_uInt16 nNewSelectedPage; + bool bIsDocPos = + mpPgPrevwLayout->IsPrevwPosInDocPrevwPage( aPrevwPos, + aDocPos, bPosInEmptyPage, nNewSelectedPage ); + if ( bIsDocPos && rMEvt.GetClicks() == 2 ) + { + // close page preview, set new cursor position and switch to + // normal view. + String sNewCrsrPos( String::CreateFromInt32( aDocPos.X() )); + ((( sNewCrsrPos += ';' ) + += String::CreateFromInt32( aDocPos.Y() )) ) + += ';'; + mrView.SetNewCrsrPos( sNewCrsrPos ); + + SfxViewFrame *pTmpFrm = mrView.GetViewFrame(); + pTmpFrm->GetBindings().Execute( SID_VIEWSHELL0, NULL, 0, + SFX_CALLMODE_ASYNCHRON ); + } + else if ( bIsDocPos || bPosInEmptyPage ) + // OD 2004-03-04 #i20684# - add missing parenthesis + { + // show clicked page as the selected one + mpPgPrevwLayout->MarkNewSelectedPage( nNewSelectedPage ); + GetViewShell()->ShowPreViewSelection( nNewSelectedPage ); + // OD 19.02.2003 #107369# - adjust position at vertical scrollbar. + if ( mpPgPrevwLayout->DoesPreviewLayoutRowsFitIntoWindow() ) + { + mrView.SetVScrollbarThumbPos( nNewSelectedPage ); + } + // OD 24.03.2003 #108282# - invalidate page status. + static USHORT __READONLY_DATA aInval[] = + { + FN_STAT_PAGE, 0 + }; + SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings(); + rBindings.Invalidate( aInval ); + } + } +} + +/****************************************************************************** + * Beschreibung: Userprefs bzw Viewoptions setzen + ******************************************************************************/ + + +void SwPagePreViewWin::SetPagePreview( BYTE nRow, BYTE nCol ) +{ + SwMasterUsrPref *pOpt = (SwMasterUsrPref *)SW_MOD()->GetUsrPref(FALSE); + + if (nRow != pOpt->GetPagePrevRow() || nCol != pOpt->GetPagePrevCol()) + { + pOpt->SetPagePrevRow( nRow ); + pOpt->SetPagePrevCol( nCol ); + pOpt->SetModified(); + + //Scrollbar updaten! + mrView.ScrollViewSzChg(); + } +} + +/** get selected page in document preview + + OD 13.12.2002 #103492# + + @author OD +*/ +sal_uInt16 SwPagePreViewWin::SelectedPage() const +{ + return mpPgPrevwLayout->SelectedPage(); +} + +/** set selected page number in document preview + + OD 13.12.2002 #103492# + + @author OD +*/ +void SwPagePreViewWin::SetSelectedPage( sal_uInt16 _nSelectedPageNum ) +{ + mpPgPrevwLayout->SetSelectedPage( _nSelectedPageNum ); +} + +/** method to enable/disable book preview + + OD 2004-03-05 #i18143# + + @author OD +*/ +bool SwPagePreViewWin::SetBookPreviewMode( const bool _bBookPreview ) +{ + return mpPgPrevwLayout->SetBookPreviewMode( _bBookPreview, + mnSttPage, + maPaintedPreviewDocRect ); +} + +void SwPagePreViewWin::DataChanged( const DataChangedEvent& rDCEvt ) +{ + Window::DataChanged( rDCEvt ); + + switch( rDCEvt.GetType() ) + { + case DATACHANGED_SETTINGS: + // ScrollBars neu anordnen bzw. Resize ausloesen, da sich + // ScrollBar-Groesse geaendert haben kann. Dazu muss dann im + // Resize-Handler aber auch die Groesse der ScrollBars aus + // den Settings abgefragt werden. + if( rDCEvt.GetFlags() & SETTINGS_STYLE ) + mrView.InvalidateBorder(); //Scrollbarbreiten + //#106746# zoom has to be disabled if Accessibility support is switched on + lcl_InvalidateZoomSlots(mrView.GetViewFrame()->GetBindings()); + break; + + case DATACHANGED_PRINTER: + case DATACHANGED_DISPLAY: + case DATACHANGED_FONTS: + case DATACHANGED_FONTSUBSTITUTION: + mrView.GetDocShell()->UpdateFontList(); //Fontwechsel + if ( mpViewShell->GetWin() ) + mpViewShell->GetWin()->Invalidate(); + break; + } +} + +/** help method to execute SfxRequest FN_PAGEUP and FN_PAGEDOWN + + OD 04.03.2003 #107369# + + @author OD +*/ +void SwPagePreView::_ExecPgUpAndPgDown( const bool _bPgUp, + SfxRequest* _pReq ) +{ + SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout(); + // check, if top/bottom of preview is *not* already visible. + if( pPagePrevwLay->GetWinPagesScrollAmount( _bPgUp ? -1 : 1 ) != 0 ) + { + if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() && + pPagePrevwLay->DoesPreviewLayoutColsFitIntoWindow() ) + { + const int eMvMode = _bPgUp ? + SwPagePreViewWin::MV_PAGE_UP : + SwPagePreViewWin::MV_PAGE_DOWN; + if ( ChgPage( eMvMode, TRUE ) ) + aViewWin.Invalidate(); + } + else + { + SwTwips nScrollAmount; + sal_uInt16 nNewSelectedPageNum = 0; + const sal_uInt16 nVisPages = aViewWin.GetRow() * aViewWin.GetCol(); + if( _bPgUp ) + { + if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() ) + { + nScrollAmount = pPagePrevwLay->GetWinPagesScrollAmount( -1 ); + if ( (aViewWin.SelectedPage() - nVisPages) > 0 ) + nNewSelectedPageNum = aViewWin.SelectedPage() - nVisPages; + else + nNewSelectedPageNum = 1; + } + else + nScrollAmount = - Min( aViewWin.GetOutputSize().Height(), + aViewWin.GetPaintedPreviewDocRect().Top() ); + } + else + { + if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() ) + { + nScrollAmount = pPagePrevwLay->GetWinPagesScrollAmount( 1 ); + if ( (aViewWin.SelectedPage() + nVisPages) <= mnPageCount ) + nNewSelectedPageNum = aViewWin.SelectedPage() + nVisPages; + else + nNewSelectedPageNum = mnPageCount; + } + else + nScrollAmount = Min( aViewWin.GetOutputSize().Height(), + ( pPagePrevwLay->GetPrevwDocSize().Height() - + aViewWin.GetPaintedPreviewDocRect().Bottom() ) ); + } + aViewWin.Scroll( 0, nScrollAmount ); + if ( nNewSelectedPageNum != 0 ) + { + aViewWin.SetSelectedPage( nNewSelectedPageNum ); + } + ScrollViewSzChg(); + // OD 24.03.2003 #108282# - additional invalidate page status. + static USHORT __READONLY_DATA aInval[] = + { + FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN, + FN_STAT_PAGE, 0 + }; + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( aInval ); + aViewWin.Invalidate(); + } + } + + if ( _pReq ) + _pReq->Done(); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ +// dann mal alles fuer die SwPagePreView +void SwPagePreView::Execute( SfxRequest &rReq ) +{ + int eMvMode; + BYTE nRow = 1; + BOOL bRetVal = FALSE; + bool bRefresh = true; + + switch(rReq.GetSlot()) + { + case FN_REFRESH_VIEW: + case FN_STAT_PAGE: + case FN_STAT_ZOOM: + break; + + case FN_SHOW_MULTIPLE_PAGES: + { + const SfxItemSet *pArgs = rReq.GetArgs(); + if( pArgs && pArgs->Count() >= 2 ) + { + BYTE nCols = (BYTE)((SfxUInt16Item &)pArgs->Get( + SID_ATTR_TABLE_COLUMN)).GetValue(); + BYTE nRows = (BYTE)((SfxUInt16Item &)pArgs->Get( + SID_ATTR_TABLE_ROW)).GetValue(); + aViewWin.CalcWish( nRows, nCols ); + + } + else + SwPreViewZoomDlg( aViewWin ).Execute(); + + } + break; + case FN_SHOW_BOOKVIEW: + { + const SfxItemSet* pArgs = rReq.GetArgs(); + const SfxPoolItem* pItem; + bool bBookPreview = GetViewShell()->GetViewOptions()->IsPagePrevBookview(); + if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( FN_SHOW_BOOKVIEW, FALSE, &pItem ) ) + { + bBookPreview = static_cast< const SfxBoolItem* >( pItem )->GetValue(); + ( ( SwViewOption* ) GetViewShell()->GetViewOptions() )->SetPagePrevBookview( bBookPreview ); + // cast is not gentleman like, but it's common use in writer and in this case + } + if ( aViewWin.SetBookPreviewMode( bBookPreview ) ) + { + // book preview mode changed. Thus, adjust scrollbars and + // invalidate corresponding states. + ScrollViewSzChg(); + static USHORT __READONLY_DATA aInval[] = + { + FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN, + FN_STAT_PAGE, FN_SHOW_BOOKVIEW, 0 + }; + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( aInval ); + aViewWin.Invalidate(); + } + + } + break; + case FN_SHOW_TWO_PAGES: + aViewWin.CalcWish( nRow, 2 ); + break; + + case FN_PREVIEW_ZOOM: + case SID_ATTR_ZOOM: + { + const SfxItemSet *pArgs = rReq.GetArgs(); + const SfxPoolItem* pItem; + AbstractSvxZoomDialog *pDlg = 0; + if(!pArgs) + { + SfxItemSet aCoreSet(GetPool(), SID_ATTR_ZOOM, SID_ATTR_ZOOM); + const SwViewOption* pVOpt = GetViewShell()->GetViewOptions(); + SvxZoomItem aZoom( (SvxZoomType)pVOpt->GetZoomType(), + pVOpt->GetZoom() ); + aZoom.SetValueSet( + SVX_ZOOM_ENABLE_50| + SVX_ZOOM_ENABLE_75| + SVX_ZOOM_ENABLE_100| + SVX_ZOOM_ENABLE_150| + SVX_ZOOM_ENABLE_200| + SVX_ZOOM_ENABLE_WHOLEPAGE); + aCoreSet.Put( aZoom ); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + if(pFact) + { + pDlg = pFact->CreateSvxZoomDialog(&GetViewFrame()->GetWindow(), aCoreSet); + DBG_ASSERT(pDlg, "Dialogdiet fail!"); + } + + pDlg->SetLimits( MINZOOM, MAXZOOM ); + + if( pDlg->Execute() != RET_CANCEL ) + pArgs = pDlg->GetOutputItemSet(); + } + if( pArgs ) + { + enum SvxZoomType eType = SVX_ZOOM_PERCENT; + USHORT nZoomFactor = USHRT_MAX; + if(SFX_ITEM_SET == pArgs->GetItemState(SID_ATTR_ZOOM, TRUE, &pItem)) + { + eType = ((const SvxZoomItem *)pItem)->GetType(); + nZoomFactor = ((const SvxZoomItem *)pItem)->GetValue(); + } + else if(SFX_ITEM_SET == pArgs->GetItemState(FN_PREVIEW_ZOOM, TRUE, &pItem)) + nZoomFactor = ((const SfxUInt16Item *)pItem)->GetValue(); + if(USHRT_MAX != nZoomFactor) + SetZoom(eType, nZoomFactor); + } + delete pDlg; + } + break; + case SID_ATTR_ZOOMSLIDER : + { + const SfxItemSet *pArgs = rReq.GetArgs(); + const SfxPoolItem* pItem; + + if ( pArgs && SFX_ITEM_SET == pArgs->GetItemState(SID_ATTR_ZOOMSLIDER, TRUE, &pItem ) ) + { + const USHORT nCurrentZoom = ((const SvxZoomSliderItem *)pItem)->GetValue(); + SetZoom( SVX_ZOOM_PERCENT, nCurrentZoom ); + } + } + break; + case SID_ZOOM_IN: + case SID_ZOOM_OUT: + { + enum SvxZoomType eType = SVX_ZOOM_PERCENT; + const SwViewOption* pVOpt = GetViewShell()->GetViewOptions(); + SetZoom(eType, + lcl_GetNextZoomStep(pVOpt->GetZoom(), SID_ZOOM_IN == rReq.GetSlot())); + } + break; + case FN_CHAR_LEFT: + case FN_CHAR_RIGHT: + case FN_LINE_UP: + case FN_LINE_DOWN: + { + SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout(); + sal_uInt16 nNewSelectedPage; + sal_uInt16 nNewStartPage; + Point aNewStartPos; + sal_Int16 nHoriMove = 0; + sal_Int16 nVertMove = 0; + switch(rReq.GetSlot()) + { + case FN_CHAR_LEFT: nHoriMove = -1; break; + case FN_CHAR_RIGHT: nHoriMove = 1; break; + case FN_LINE_UP: nVertMove = -1; break; + case FN_LINE_DOWN: nVertMove = 1; break; + } + pPagePrevwLay->CalcStartValuesForSelectedPageMove( nHoriMove, nVertMove, + nNewSelectedPage, nNewStartPage, aNewStartPos ); + if ( aViewWin.SelectedPage() != nNewSelectedPage ) + { + if ( pPagePrevwLay->IsPageVisible( nNewSelectedPage ) ) + { + pPagePrevwLay->MarkNewSelectedPage( nNewSelectedPage ); + // OD 19.02.2003 #107369# - adjust position at vertical scrollbar. + SetVScrollbarThumbPos( nNewSelectedPage ); + bRefresh = false; + } + else + { + aViewWin.SetSelectedPage( nNewSelectedPage ); + aViewWin.SetSttPage( nNewStartPage ); + int nRet = ChgPage( SwPagePreViewWin::MV_SELPAGE, TRUE ); + bRefresh = 0 != nRet; + } + GetViewShell()->ShowPreViewSelection( nNewSelectedPage ); + // OD 24.03.2003 #108282# - invalidate page status. + static USHORT __READONLY_DATA aInval[] = + { + FN_STAT_PAGE, 0 + }; + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( aInval ); + rReq.Done(); + } + else + { + bRefresh = false; + } + break; + } + case FN_PAGEUP: + case FN_PAGEDOWN: + { + _ExecPgUpAndPgDown( rReq.GetSlot() == FN_PAGEUP, &rReq ); + break; + } + case FN_START_OF_LINE: + case FN_START_OF_DOCUMENT: + aViewWin.SetSelectedPage( 1 ); + eMvMode = SwPagePreViewWin::MV_DOC_STT; bRetVal = TRUE; goto MOVEPAGE; + case FN_END_OF_LINE: + case FN_END_OF_DOCUMENT: + aViewWin.SetSelectedPage( mnPageCount ); + eMvMode = SwPagePreViewWin::MV_DOC_END; bRetVal = TRUE; goto MOVEPAGE; +MOVEPAGE: + { + int nRet = ChgPage( eMvMode, TRUE ); + // return value fuer Basic + if(bRetVal) + rReq.SetReturnValue(SfxBoolItem(rReq.GetSlot(), nRet == 0)); + + bRefresh = 0 != nRet; + rReq.Done(); + } + break; + + case FN_PRINT_PAGEPREVIEW: + { + const SwPagePreViewPrtData* pPPVPD = aViewWin.GetViewShell()->GetDoc()->GetPreViewPrtData(); + // die Sache mit der Orientation + if(pPPVPD) + { + SfxPrinter* pPrinter = GetPrinter( TRUE ); + if((pPrinter->GetOrientation() == ORIENTATION_LANDSCAPE) + != pPPVPD->GetLandscape()) + pPrinter->SetOrientation(pPPVPD->GetLandscape() ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT); + } + ::SetAppPrintOptions( aViewWin.GetViewShell(), FALSE ); + bNormalPrint = FALSE; + USHORT nPrtSlot = SID_PRINTDOC; + rReq.SetSlot( nPrtSlot ); + SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() ); + rReq.SetSlot( FN_PRINT_PAGEPREVIEW ); + return; + } + case SID_PRINTDOCDIRECT: + case SID_PRINTDOC: + ::SetAppPrintOptions( aViewWin.GetViewShell(), FALSE ); + bNormalPrint = TRUE; + SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() ); + return; + case FN_CLOSE_PAGEPREVIEW: + case SID_PRINTPREVIEW: + // 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, 0, 0, SFX_CALLMODE_ASYNCHRON ); + break; + case FN_INSERT_BREAK: + { + USHORT nSelPage = aViewWin.SelectedPage(); + //if a dummy page is selected (e.g. a non-existing right/left page) + //the direct neighbor is used + if(GetViewShell()->IsDummyPage( nSelPage ) && GetViewShell()->IsDummyPage( --nSelPage )) + nSelPage +=2; + SetNewPage( nSelPage ); + SfxViewFrame *pTmpFrm = GetViewFrame(); + pTmpFrm->GetBindings().Execute( SID_VIEWSHELL0, NULL, 0, + SFX_CALLMODE_ASYNCHRON ); + } + break; + default: + ASSERT(!this, falscher Dispatcher); + return; + } + + if( bRefresh ) + aViewWin.Invalidate(); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::GetState( SfxItemSet& rSet ) +{ + SfxWhichIter aIter(rSet); + BYTE nRow = 1; + USHORT nWhich = aIter.FirstWhich(); + ASSERT(nWhich, leeres Set); + SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout(); + //#106746# zoom has to be disabled if Accessibility support is switched on + BOOL bZoomEnabled = !Application::GetSettings().GetMiscSettings().GetEnableATToolSupport(); + + while(nWhich) + { + switch(nWhich) + { + case SID_BROWSER_MODE: + case FN_PRINT_LAYOUT: + rSet.DisableItem(nWhich); + break; + case FN_START_OF_DOCUMENT: + { + if ( pPagePrevwLay->IsPageVisible( 1 ) ) + rSet.DisableItem(nWhich); + break; + } + case FN_END_OF_DOCUMENT: + { + if ( pPagePrevwLay->IsPageVisible( mnPageCount ) ) + rSet.DisableItem(nWhich); + break; + } + case FN_PAGEUP: + { + if( pPagePrevwLay->GetWinPagesScrollAmount( -1 ) == 0 ) + rSet.DisableItem(nWhich); + break; + } + case FN_PAGEDOWN: + { + if( pPagePrevwLay->GetWinPagesScrollAmount( 1 ) == 0 ) + rSet.DisableItem(nWhich); + break; + } + + case FN_STAT_PAGE: + { + String aStr( sPageStr ); + aViewWin.GetStatusStr( aStr, mnPageCount ); + rSet.Put( SfxStringItem( nWhich, aStr) ); + } + break; + + case SID_ATTR_ZOOM: + case FN_STAT_ZOOM: + { + if(bZoomEnabled) + { + const SwViewOption* pVOpt = GetViewShell()->GetViewOptions(); + SvxZoomItem aZoom((SvxZoomType)pVOpt->GetZoomType(), + pVOpt->GetZoom()); + aZoom.SetValueSet( + SVX_ZOOM_ENABLE_50| + SVX_ZOOM_ENABLE_75| + SVX_ZOOM_ENABLE_100| + SVX_ZOOM_ENABLE_150| + SVX_ZOOM_ENABLE_200); + rSet.Put( aZoom ); + } + else + rSet.DisableItem(nWhich); + } + break; + case SID_ATTR_ZOOMSLIDER : + { + if(bZoomEnabled) + { + const SwViewOption* pVOpt = GetViewShell()->GetViewOptions(); + const USHORT nCurrentZoom = pVOpt->GetZoom(); + SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM, MAXZOOM ); + aZoomSliderItem.AddSnappingPoint( 100 ); + rSet.Put( aZoomSliderItem ); + } + else + rSet.DisableItem(nWhich); + } + break; + case FN_PREVIEW_ZOOM: + { + if(bZoomEnabled) + { + const SwViewOption* pVOpt = GetViewShell()->GetViewOptions(); + rSet.Put(SfxUInt16Item(nWhich, pVOpt->GetZoom())); + } + else + rSet.DisableItem(nWhich); + } + break; + case SID_ZOOM_IN: + case SID_ZOOM_OUT: + { + const SwViewOption* pVOpt = GetViewShell()->GetViewOptions(); + if(!bZoomEnabled || (SID_ZOOM_OUT == nWhich && pVOpt->GetZoom() >= MAX_PREVIEW_ZOOM)|| + (SID_ZOOM_IN == nWhich && pVOpt->GetZoom() <= MIN_PREVIEW_ZOOM)) + { + rSet.DisableItem(nWhich); + } + } + break; + case FN_SHOW_MULTIPLE_PAGES: + //should never be disabled + break; + case FN_SHOW_BOOKVIEW: + { + BOOL b = GetViewShell()->GetViewOptions()->IsPagePrevBookview(); + rSet.Put(SfxBoolItem(nWhich, b)); + } + break; + + case FN_SHOW_TWO_PAGES: + if( 2 == aViewWin.GetCol() && nRow == aViewWin.GetRow() ) + rSet.DisableItem( nWhich ); + break; + + case FN_PRINT_PAGEPREVIEW: + // hat den gleichen Status wie das normale Drucken + { + const SfxPoolItem* pItem; + SfxItemSet aSet( *rSet.GetPool(), SID_PRINTDOC, SID_PRINTDOC ); + GetSlotState( SID_PRINTDOC, SfxViewShell::GetInterface(), &aSet ); + if( SFX_ITEM_DISABLED == aSet.GetItemState( SID_PRINTDOC, + FALSE, &pItem )) + rSet.DisableItem( nWhich ); + else if( SFX_ITEM_SET == aSet.GetItemState( SID_PRINTDOC, + FALSE, &pItem )) + { + ((SfxPoolItem*)pItem)->SetWhich( FN_PRINT_PAGEPREVIEW ); + rSet.Put( *pItem ); + } + } + break; + + case SID_PRINTPREVIEW: + rSet.Put( SfxBoolItem( nWhich, TRUE ) ); + break; + + case SID_PRINTDOC: + case SID_PRINTDOCDIRECT: + GetSlotState( nWhich, SfxViewShell::GetInterface(), &rSet ); + break; + } + nWhich = aIter.NextWhich(); + } +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::StateUndo(SfxItemSet& rSet) +{ + SfxWhichIter aIter(rSet); + USHORT nWhich = aIter.FirstWhich(); + + while (nWhich) + { + rSet.DisableItem(nWhich); + nWhich = aIter.NextWhich(); + } +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::Init(const SwViewOption * pPrefs) +{ + if ( GetViewShell()->HasDrawView() ) + GetViewShell()->GetDrawView()->SetAnimationEnabled( FALSE ); + + bNormalPrint = TRUE; + + // Die DocSize erfragen und verarbeiten. Ueber die Handler konnte + // die Shell nicht gefunden werden, weil die Shell innerhalb CTOR-Phase + // nicht in der SFX-Verwaltung bekannt ist. + + if( !pPrefs ) + pPrefs = SW_MOD()->GetUsrPref(FALSE); + + // die Felder aktualisieren + // ACHTUNG: hochcasten auf die EditShell, um die SS zu nutzen. + // In den Methoden wird auf die akt. Shell abgefragt! + SwEditShell* pESh = (SwEditShell*)GetViewShell(); + BOOL bIsModified = pESh->IsModified(); + + + SwViewOption aOpt( *pPrefs ); + aOpt.SetPagePreview(TRUE); + aOpt.SetTab( FALSE ); + aOpt.SetBlank( FALSE ); + aOpt.SetHardBlank( FALSE ); + aOpt.SetParagraph( FALSE ); + aOpt.SetLineBreak( FALSE ); + aOpt.SetPageBreak( FALSE ); + aOpt.SetColumnBreak( FALSE ); + aOpt.SetSoftHyph( FALSE ); + aOpt.SetFldName( FALSE ); + aOpt.SetPostIts( FALSE ); + aOpt.SetShowHiddenChar( FALSE ); + aOpt.SetShowHiddenField( FALSE ); + aOpt.SetShowHiddenPara( FALSE ); + aOpt.SetViewHRuler( FALSE ); + aOpt.SetViewVRuler( FALSE ); + aOpt.SetGraphic( TRUE ); + aOpt.SetTable( TRUE ); + aOpt.SetSnap( FALSE ); + aOpt.SetGridVisible( FALSE ); + GetViewShell()->ApplyViewOptions( aOpt ); + GetViewShell()->ApplyAccessiblityOptions(SW_MOD()->GetAccessibilityOptions()); + + // OD 09.01.2003 #i6467# - adjust view shell option to the same as for print + SwPrtOptions aPrintOptions( GetViewFrame()->GetObjectShell()->GetTitle(0) ); + aPrintOptions.MakeOptions( false ); + GetViewShell()->AdjustOptionsForPagePreview( aPrintOptions ); + + IDocumentSettingAccess* pIDSA = pESh->getIDocumentSettingAccess(); + if( pIDSA->get(IDocumentSettingAccess::BROWSE_MODE)) + { + pIDSA->set(IDocumentSettingAccess::BROWSE_MODE, false); + pESh->CheckBrowseView( TRUE ); + } + + GetViewShell()->CalcLayout(); + DocSzChgd( GetViewShell()->GetDocSize() ); + + if( !bIsModified ) + pESh->ResetModified(); + + pVScrollbar->ExtendedShow(pPrefs->IsViewVScrollBar()); + pHScrollbar->ExtendedShow(pPrefs->IsViewHScrollBar()); + pScrollFill->Show(pPrefs->IsViewVScrollBar() && pPrefs->IsViewHScrollBar()); +} + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +SwPagePreView::SwPagePreView(SfxViewFrame *pViewFrame, SfxViewShell* pOldSh): + SfxViewShell( pViewFrame, SWVIEWFLAGS ), + aViewWin( &pViewFrame->GetWindow(), *this ), + nNewPage(USHRT_MAX), + pHScrollbar(0), + pVScrollbar(0), + pPageUpBtn(0), + pPageDownBtn(0), + pScrollFill(new ScrollBarBox( &pViewFrame->GetWindow(), + pViewFrame->GetFrame()->GetParentFrame() ? 0 : WB_SIZEABLE )), + mnPageCount( 0 ), + // OD 09.01.2003 #106334# + mbResetFormDesignMode( false ), + mbFormDesignModeToReset( false ) +{ + SetName(String::CreateFromAscii("PageView" )); + SetWindow( &aViewWin ); + SetHelpId(SW_PAGEPREVIEW); + _CreateScrollbar( TRUE ); + _CreateScrollbar( FALSE ); + + SfxObjectShell* pObjShell = pViewFrame->GetObjectShell(); + if ( !pOldSh ) + { + //Gibt es schon eine Sicht auf das Dokument? + SfxViewFrame *pF = SfxViewFrame::GetFirst( pObjShell ); + if ( pF == pViewFrame ) + pF = SfxViewFrame::GetNext( *pF, pObjShell ); + if ( pF ) + pOldSh = pF->GetViewShell(); + } + + ViewShell *pVS, *pNew; + + if( pOldSh && pOldSh->IsA( TYPE( SwPagePreView ) ) ) + pVS = ((SwPagePreView*)pOldSh)->GetViewShell(); + else + { + if( pOldSh && pOldSh->IsA( TYPE( SwView ) ) ) + { + pVS = ((SwView*)pOldSh)->GetWrtShellPtr(); + // save the current ViewData of the previous SwView + pOldSh->WriteUserData( sSwViewData, FALSE ); + } + else + pVS = GetDocShell()->GetWrtShell(); + if( pVS ) + { + // setze die akt. Seite als die erste + USHORT nPhysPg, nVirtPg; + ((SwCrsrShell*)pVS)->GetPageNum( nPhysPg, nVirtPg, /*FALSE*/TRUE, FALSE ); + if( 1 != aViewWin.GetCol() && 1 == nPhysPg ) + --nPhysPg; + aViewWin.SetSttPage( nPhysPg ); + } + } + + // OD 09.01.2003 #106334# - for form shell remember design mode of draw view + // of previous view shell + if ( pVS && pVS->HasDrawView() ) + { + mbResetFormDesignMode = true; + mbFormDesignModeToReset = pVS->GetDrawView()->IsDesignMode(); + } + + if( pVS ) + pNew = new ViewShell( *pVS, &aViewWin, 0, VSHELLFLAG_ISPREVIEW ); + else + pNew = new ViewShell( + *((SwDocShell*)pViewFrame->GetObjectShell())->GetDoc(), + &aViewWin, 0, 0, VSHELLFLAG_ISPREVIEW ); + + aViewWin.SetViewShell( pNew ); + pNew->SetSfxViewShell( this ); + Init(); +} + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + + SwPagePreView::~SwPagePreView() +{ + SetWindow( 0 ); + + delete pScrollFill; + delete pHScrollbar; + delete pVScrollbar; + delete pPageUpBtn; + delete pPageDownBtn; + +/* SfxObjectShell* pDocSh = GetDocShell(); + TypeId aType = TYPE( SfxTopViewFrame ); + + for( SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pDocSh, aType ); + pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, pDocSh, aType ) ) + if( pFrame != GetViewFrame() ) + { + // es gibt noch eine weitere Sicht auf unser Dokument, also + // aktiviere dieses + pFrame->GetFrame()->Appear(); + break; + } +*/} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +SwDocShell* SwPagePreView::GetDocShell() +{ + return PTR_CAST(SwDocShell, GetViewFrame()->GetObjectShell()); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +int SwPagePreView::_CreateScrollbar( BOOL bHori ) +{ + Window *pMDI = &GetViewFrame()->GetWindow(); + SwScrollbar** ppScrollbar = bHori ? &pHScrollbar : &pVScrollbar; + + ASSERT( !*ppScrollbar, "vorher abpruefen!" ) + + if( !bHori ) + { + + pPageUpBtn = new ImageButton(pMDI, SW_RES( BTN_PAGEUP ) ); + pPageUpBtn->SetHelpId(FN_PAGEUP); + pPageDownBtn = new ImageButton(pMDI, SW_RES( BTN_PAGEDOWN ) ); + pPageDownBtn->SetHelpId(FN_PAGEDOWN); + Link aLk( LINK( this, SwPagePreView, BtnPage ) ); + pPageUpBtn->SetClickHdl( aLk ); + pPageDownBtn->SetClickHdl( aLk ); + pPageUpBtn->Show(); + pPageDownBtn->Show(); + } + + *ppScrollbar = new SwScrollbar( pMDI, bHori ); + + ScrollDocSzChg(); + (*ppScrollbar)->EnableDrag( TRUE ); + (*ppScrollbar)->SetEndScrollHdl( LINK( this, SwPagePreView, EndScrollHdl )); + + + (*ppScrollbar)->SetScrollHdl( LINK( this, SwPagePreView, ScrollHdl )); + + InvalidateBorder(); + (*ppScrollbar)->ExtendedShow(); + return 1; +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + +/* + * Button-Handler + */ +IMPL_LINK_INLINE_START( SwPagePreView, BtnPage, Button *, pButton ) +{ + // OD 04.03.2003 #107369# - use new helper method to perform page up + // respectively page down. + _ExecPgUpAndPgDown( pButton == pPageUpBtn ); + return 0; +} +IMPL_LINK_INLINE_END( SwPagePreView, BtnPage, Button *, pButton ) + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +int SwPagePreView::ChgPage( int eMvMode, int bUpdateScrollbar ) +{ + Rectangle aPixVisArea( aViewWin.LogicToPixel( aVisArea ) ); + int bChg = aViewWin.MovePage( eMvMode ) || + eMvMode == SwPagePreViewWin::MV_CALC || + eMvMode == SwPagePreViewWin::MV_NEWWINSIZE; + aVisArea = aViewWin.PixelToLogic( aPixVisArea ); + + if( bChg ) + { + // Statusleiste updaten + String aStr( sPageStr ); + aViewWin.GetStatusStr( aStr, mnPageCount ); + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + + if( bUpdateScrollbar ) + { + ScrollViewSzChg(); + + static USHORT __READONLY_DATA aInval[] = + { + FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, + FN_PAGEUP, FN_PAGEDOWN, 0 + }; + rBindings.Invalidate( aInval ); + } + rBindings.SetState( SfxStringItem( FN_STAT_PAGE, aStr ) ); + } + return bChg; +} + + +/* */ +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +// ab hier alles aus der SwView uebernommen + + +void SwPagePreView::CalcAndSetBorderPixel( SvBorder &rToFill, BOOL /*bInner*/ ) +{ +// const long nAdd = bInner ? 0 : ScrollBar::GetWindowOverlapPixel(); + const StyleSettings &rSet = aViewWin.GetSettings().GetStyleSettings(); + const long nTmp = rSet.GetScrollBarSize();// - nAdd; + if ( pVScrollbar->IsVisible( FALSE )) + rToFill.Right() = nTmp; + if ( pHScrollbar->IsVisible( FALSE ) ) + rToFill.Bottom() = nTmp; + SetBorderPixel( rToFill ); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::InnerResizePixel( const Point &rOfst, const Size &rSize ) +{ + SvBorder aBorder; + CalcAndSetBorderPixel( aBorder, TRUE ); + Rectangle aRect( rOfst, rSize ); + aRect += aBorder; + ViewResizePixel( aViewWin, aRect.TopLeft(), aRect.GetSize(), + aViewWin.GetOutputSizePixel(), + TRUE, + *pVScrollbar, *pHScrollbar, pPageUpBtn, pPageDownBtn, 0, + *pScrollFill ); + + //EditWin niemals einstellen! + //VisArea niemals einstellen! +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::OuterResizePixel( const Point &rOfst, const Size &rSize ) +{ + SvBorder aBorder; + CalcAndSetBorderPixel( aBorder, FALSE ); + ViewResizePixel( aViewWin, rOfst, rSize, aViewWin.GetOutputSizePixel(), + FALSE, *pVScrollbar, + *pHScrollbar, pPageUpBtn, pPageDownBtn, 0, *pScrollFill ); + + //EditWin niemals einstellen! + + Size aTmpSize( aViewWin.GetOutputSizePixel() ); + Point aBottomRight( aViewWin.PixelToLogic( Point( aTmpSize.Width(), aTmpSize.Height() ) ) ); + SetVisArea( Rectangle( Point(), aBottomRight ) ); + + //Aufruf der DocSzChgd-Methode der Scrollbars ist noetig, da vom maximalen + //Scrollrange immer die halbe Hoehe der VisArea abgezogen wird. + if ( pVScrollbar ) + ScrollDocSzChg(); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::SetVisArea( const Rectangle &rRect, BOOL bUpdateScrollbar ) +{ + const Point aTopLeft(AlignToPixel(rRect.TopLeft())); + const Point aBottomRight(AlignToPixel(rRect.BottomRight())); + Rectangle aLR(aTopLeft,aBottomRight); + + if(aLR == aVisArea) + return; + // keine negative Position, keine neg. Groesse + + if(aLR.Top() < 0) + { + aLR.Bottom() += Abs(aLR.Top()); + aLR.Top() = 0; + } + + if(aLR.Left() < 0) + { + aLR.Right() += Abs(aLR.Left()); + aLR.Left() = 0; + } + if(aLR.Right() < 0) aLR.Right() = 0; + if(aLR.Bottom() < 0) aLR.Bottom() = 0; + if(aLR == aVisArea || + // JP 29.10.97: Bug 45173 - Leeres Rechteck nicht beachten + ( 0 == aLR.Bottom() - aLR.Top() && 0 == aLR.Right() - aLR.Left() ) ) + return; + + if( aLR.Left() > aLR.Right() || aLR.Top() > aLR.Bottom() ) + return; + + //Bevor die Daten veraendert werden ggf. ein Update rufen. Dadurch wird + //sichergestellt, da? anliegende Paints korrekt in Dokumentkoordinaten + //umgerechnet werden. + //Vorsichtshalber tun wir das nur wenn an der Shell eine Action laeuft, + //denn dann wir nicht wirklich gepaintet sondern die Rechtecke werden + //lediglich (in Dokumentkoordinaten) vorgemerkt. + if( GetViewShell()->ActionPend() ) + aViewWin.Update(); + + // setze am View-Win die aktuelle Size + aVisArea = aLR; + aViewWin.SetWinSize( aLR.GetSize() ); + // OD 18.12.2002 #103492# - use new mode + ChgPage( SwPagePreViewWin::MV_NEWWINSIZE, bUpdateScrollbar ); + + aViewWin.Invalidate(); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +IMPL_LINK( SwPagePreView, ScrollHdl, SwScrollbar *, pScrollbar ) +{ + if(!GetViewShell()) + return 0; + if( !pScrollbar->IsHoriScroll() && + pScrollbar->GetType() == SCROLL_DRAG && + Help::IsQuickHelpEnabled() && + GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow()) + { + // wieviele Seiten scrollen ?? + String sStateStr(sPageStr); + USHORT nThmbPos = (USHORT)pScrollbar->GetThumbPos(); + if( 1 == aViewWin.GetCol() || !nThmbPos ) + ++nThmbPos; + sStateStr += String::CreateFromInt32( nThmbPos ); + Point aPos = pScrollbar->GetParent()->OutputToScreenPixel( + pScrollbar->GetPosPixel()); + aPos.Y() = pScrollbar->OutputToScreenPixel(pScrollbar->GetPointerPosPixel()).Y(); + Size aSize = pScrollbar->GetSizePixel(); + Rectangle aRect; + aRect.Left() = aPos.X() -8; + aRect.Right() = aRect.Left(); + aRect.Top() = aPos.Y(); + aRect.Bottom() = aRect.Top(); + + Help::ShowQuickHelp(pScrollbar, aRect, sStateStr, + QUICKHELP_RIGHT|QUICKHELP_VCENTER); + + } + else + EndScrollHdl( pScrollbar ); + return 0; +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +IMPL_LINK( SwPagePreView, EndScrollHdl, SwScrollbar *, pScrollbar ) +{ + if(!GetViewShell()) + return 0; + + // OD 04.03.2003 #107369# - boolean to avoid unnecessary invalidation of the window. + bool bInvalidateWin = true; + + if( !pScrollbar->IsHoriScroll() ) // scroll vertically + { + if ( Help::IsQuickHelpEnabled() ) + Help::ShowQuickHelp(pScrollbar, Rectangle(), aEmptyStr, 0); + if ( GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow() ) + { + // wieviele Seiten scrollen ?? + USHORT nThmbPos = (USHORT)pScrollbar->GetThumbPos(); + // OD 05.12.2002 #103492# - adjust to new preview functionality + if( nThmbPos != aViewWin.SelectedPage() ) + { + // OD 17.01.2003 #103492# - consider case that page <nThmbPos> + // is already visible + SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout(); + if ( pPagePrevwLay->IsPageVisible( nThmbPos ) ) + { + pPagePrevwLay->MarkNewSelectedPage( nThmbPos ); + // OD 04.03.2003 #107369# - invalidation of window is unnecessary + bInvalidateWin = false; + } + else + { + // OD 17.01.2003 #103492# - consider whether layout columns + // fit or not. + if ( !pPagePrevwLay->DoesPreviewLayoutColsFitIntoWindow() ) + { + aViewWin.SetSttPage( nThmbPos ); + aViewWin.SetSelectedPage( nThmbPos ); + ChgPage( SwPagePreViewWin::MV_SCROLL, FALSE ); + // OD 20.01.2003 #103492# - update scrollbars + ScrollViewSzChg(); + } + else + { + // OD 04.03.2003 #107369# - correct scroll amount + const sal_Int16 nPageDiff = nThmbPos - aViewWin.SelectedPage(); + const sal_uInt16 nVisPages = aViewWin.GetRow() * aViewWin.GetCol(); + sal_Int16 nWinPagesToScroll = nPageDiff / nVisPages; + if ( nPageDiff % nVisPages ) + { + // decrease/increase number of preview pages to scroll + nPageDiff < 0 ? --nWinPagesToScroll : ++nWinPagesToScroll; + } + aViewWin.SetSelectedPage( nThmbPos ); + aViewWin.Scroll( 0, pPagePrevwLay->GetWinPagesScrollAmount( nWinPagesToScroll ) ); + } + } + // OD 17.01.2003 #103492# - update accessibility + GetViewShell()->ShowPreViewSelection( nThmbPos ); + } + else + { + // OD 04.03.2003 #107369# - invalidation of window is unnecessary + bInvalidateWin = false; + } + } + else + { + long nThmbPos = pScrollbar->GetThumbPos(); + aViewWin.Scroll(0, nThmbPos - aViewWin.GetPaintedPreviewDocRect().Top()); + } + } + else + { + long nThmbPos = pScrollbar->GetThumbPos(); + aViewWin.Scroll(nThmbPos - aViewWin.GetPaintedPreviewDocRect().Left(), 0); + } + // OD 24.03.2003 #108282# - additional invalidate page status. + static USHORT __READONLY_DATA aInval[] = + { + FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN, + FN_STAT_PAGE, 0 + }; + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( aInval ); + // OD 04.03.2003 #107369# - control invalidation of window + if ( bInvalidateWin ) + { + aViewWin.Invalidate(); + } + return 0; +} +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +Point SwPagePreView::AlignToPixel(const Point &rPt) const +{ + return aViewWin.PixelToLogic( aViewWin.LogicToPixel( rPt ) ); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::DocSzChgd( const Size &rSz ) +{ + if( aDocSz == rSz ) + return; + + aDocSz = rSz; + + // --> OD 2009-08-20 #i96726# + // Due to the multiple page layout it is needed to trigger recalculation + // of the page preview layout, even if the count of pages is not changing. + mnPageCount = GetViewShell()->GetNumPages(); + + if( aVisArea.GetWidth() ) + { + ChgPage( SwPagePreViewWin::MV_CALC, TRUE ); + ScrollDocSzChg(); + + aViewWin.Invalidate(); + } + // <-- +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::ScrollViewSzChg() +{ + if(!GetViewShell()) + return ; + if(pVScrollbar) + { + if(GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow()) + { + //vertical scrolling by row + // OD 04.12.2002 #103492# - adjust to new preview functionality + USHORT nVisPages = aViewWin.GetRow() * aViewWin.GetCol(); + pVScrollbar->SetVisibleSize( nVisPages ); + // OD 19.02.2003 #107369# - set selected page as scroll bar position, + // if it is visible. + SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout(); + if ( pPagePrevwLay->IsPageVisible( aViewWin.SelectedPage() ) ) + { + pVScrollbar->SetThumbPos( aViewWin.SelectedPage() ); + } + else + { + pVScrollbar->SetThumbPos( aViewWin.GetSttPage() ); + } + pVScrollbar->SetLineSize( aViewWin.GetCol() ); + pVScrollbar->SetPageSize( nVisPages ); + // calculate and set scrollbar range + Range aScrollbarRange( 1, mnPageCount ); + // increase range by one, because left-top-corner is left blank. + ++aScrollbarRange.Max(); + // OD 17.01.2003 #103492# - increase range in order to access all pages + aScrollbarRange.Max() += ( nVisPages - 1 ); + pVScrollbar->SetRange( aScrollbarRange ); + } + else //vertical scrolling by pixel + { + const Rectangle& rDocRect = aViewWin.GetPaintedPreviewDocRect(); + const Size& rPreviewSize = + GetViewShell()->PagePreviewLayout()->GetPrevwDocSize(); + pVScrollbar->SetRangeMax(rPreviewSize.Height()) ; + long nVisHeight = rDocRect.GetHeight(); + pVScrollbar->SetVisibleSize( nVisHeight ); + pVScrollbar->SetThumbPos( rDocRect.Top() ); + pVScrollbar->SetLineSize( nVisHeight / 10 ); + pVScrollbar->SetPageSize( nVisHeight / 2 ); + } + } + if(pHScrollbar) + { + const Rectangle& rDocRect = aViewWin.GetPaintedPreviewDocRect(); + const Size& rPreviewSize = + GetViewShell()->PagePreviewLayout()->GetPrevwDocSize(); + long nVisWidth = 0; + long nThumb = 0; + Range aRange(0,0); + + if(rDocRect.GetWidth() < rPreviewSize.Width()) + { + nVisWidth = rDocRect.GetWidth(); + nThumb = rDocRect.Left(); + aRange = Range(0, rPreviewSize.Width()); + } + pHScrollbar->SetRange( aRange ); + pHScrollbar->SetVisibleSize( nVisWidth ); + pHScrollbar->SetThumbPos( nThumb ); + pHScrollbar->SetLineSize( nVisWidth / 10 ); + pHScrollbar->SetPageSize( nVisWidth / 2 ); + } +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +void SwPagePreView::ScrollDocSzChg() +{ + ScrollViewSzChg(); +} + + +/* */ +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +// alles zum Thema Drucken + +SfxPrinter* SwPagePreView::GetPrinter( BOOL bCreate ) +{ + return aViewWin.GetViewShell()->getIDocumentDeviceAccess()->getPrinter( bCreate ); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +USHORT SwPagePreView::SetPrinter( SfxPrinter *pNew, USHORT nDiffFlags, bool ) +{ + ViewShell &rSh = *GetViewShell(); + SfxPrinter* pOld = rSh.getIDocumentDeviceAccess()->getPrinter( false ); + if ( pOld && pOld->IsPrinting() ) + return SFX_PRINTERROR_BUSY; + + SwEditShell &rESh = (SwEditShell&)rSh; //Buh... + if( ( SFX_PRINTER_PRINTER | SFX_PRINTER_JOBSETUP ) & nDiffFlags ) + { + rSh.getIDocumentDeviceAccess()->setPrinter( pNew, true, true ); + if( nDiffFlags & SFX_PRINTER_PRINTER ) + rESh.SetModified(); + } + if ( ( nDiffFlags & SFX_PRINTER_OPTIONS ) == SFX_PRINTER_OPTIONS ) + ::SetPrinter( rSh.getIDocumentDeviceAccess(), pNew, FALSE ); + + const BOOL bChgOri = nDiffFlags & SFX_PRINTER_CHG_ORIENTATION ? TRUE : FALSE; + const BOOL bChgSize= nDiffFlags & SFX_PRINTER_CHG_SIZE ? TRUE : FALSE; + if ( bChgOri || bChgSize ) + { + rESh.StartAllAction(); + if ( bChgOri ) + rSh.ChgAllPageOrientation( USHORT(pNew->GetOrientation()) ); + if ( bChgSize ) + { + Size aSz( SvxPaperInfo::GetPaperSize( pNew ) ); + rSh.ChgAllPageSize( aSz ); + } + if( !bNormalPrint ) + aViewWin.CalcWish( aViewWin.GetRow(), aViewWin.GetCol() ); + rESh.SetModified(); + rESh.EndAllAction(); + + static USHORT __READONLY_DATA aInval[] = + { + SID_ATTR_LONG_ULSPACE, SID_ATTR_LONG_LRSPACE, + SID_RULER_BORDERS, SID_RULER_PAGE_POS, 0 + }; +#ifdef DBG_UTIL + { + const USHORT* pPtr = aInval + 1; + do { + ASSERT( *(pPtr - 1) < *pPtr, "falsche Sortierung!" ); + } while( *++pPtr ); + } +#endif + + GetViewFrame()->GetBindings().Invalidate(aInval); + } + + return 0; +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +SfxTabPage* SwPagePreView::CreatePrintOptionsPage( Window *pParent, + const SfxItemSet &rOptions ) +{ + return ::CreatePrintOptionsPage( pParent, rOptions, !bNormalPrint ); +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +PrintDialog* SwPagePreView::CreatePrintDialog( Window *pParent ) +{ + PrintDialog *pDlg = ::CreatePrintDialog( pParent, 1, 0 ); + pDlg->DisableRange( PRINTDIALOG_SELECTION ); + return pDlg; +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + + +// OD 18.12.2002 #103492# - no longer needed ?? +Size SwPagePreView::GetOptimalSizePixel() const +{ + ASSERT( false, "overloaded virtual method <SwPagePreView::GetOptimalSizePixel()> needed ??" ) + return Size( -1, -1 ); +/* + //JP 09.06.99: was wird hier errechnet ????? +// ALT: +// SfxApplicationWindow* pWin = SFX_APPWINDOW ; +// Rectangle aRect = pWin->GetClientAreaPixel(); + + Window& rWin = GetViewFrame()->GetWindow(); + Rectangle aRect( Point(0, 0), rWin.GetOutputSizePixel() ); + Size aMaxSize( aRect.GetWidth(), aRect.GetHeight() ); + Size aInSize = rWin.GetOutputSizePixel(); + Size aOutSize = rWin.GetSizePixel(); + USHORT nXBorder = USHORT(aOutSize.Width() - aInSize.Width()); + USHORT nYBorder = USHORT(aOutSize.Height() - aInSize.Height()); + aMaxSize.Width() -= nXBorder; + //'auf Verdacht' etwas vom Border abziehen (Menue) + nYBorder -= (nYBorder - nXBorder) / 2; + aMaxSize.Height() -= nYBorder; + //mit der max. moeglichen Outputsize guenstigstes Verhaeltnis ausrechnen + aViewWin.GetOptimalSize(aMaxSize); + // Border wieder dazuzaehlen + aMaxSize.Height() += nYBorder; + aMaxSize.Width() += nXBorder; + return aMaxSize; +*/ +} + +/*-------------------------------------------------------------------- + Beschreibung: + --------------------------------------------------------------------*/ + +// OD 12.12.2002 #103492# +void SwPagePreViewWin::SetViewShell( ViewShell* pShell ) +{ + mpViewShell = pShell; + if ( mpViewShell && mpViewShell->IsPreView() ) + { + mpPgPrevwLayout = mpViewShell->PagePreviewLayout(); + } +} + +void SwPagePreViewWin::RepaintCoreRect( const SwRect& rRect ) +{ + // OD 2004-03-04 #i24183# + if ( mpPgPrevwLayout->PreviewLayoutValid() ) + { + mpPgPrevwLayout->Repaint( Rectangle( rRect.Pos(), rRect.SSize() ) ); + } +} + +/** method to adjust preview to a new zoom factor + + OD 02.12.2002 #103492# + OD 24.09.2003 #i19975# - also consider zoom type - adding parameter <_eZoomType> +*/ +void SwPagePreViewWin::AdjustPreviewToNewZoom( const sal_uInt16 _nZoomFactor, + const SvxZoomType _eZoomType ) +{ + // OD 24.09.2003 #i19975# - consider zoom type + if ( _eZoomType == SVX_ZOOM_WHOLEPAGE ) + { + mnRow = 1; + mnCol = 1; + mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true ); + mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize, + mnSttPage, maPaintedPreviewDocRect ); + SetSelectedPage( mnSttPage ); + SetPagePreview(mnRow, mnCol); + maScale = GetMapMode().GetScaleX(); + } + else if ( _nZoomFactor != 0 ) + { + // calculate new scaling and set mapping mode appropriately. + Fraction aNewScale( _nZoomFactor, 100 ); + MapMode aNewMapMode = GetMapMode(); + aNewMapMode.SetScaleX( aNewScale ); + aNewMapMode.SetScaleY( aNewScale ); + SetMapMode( aNewMapMode ); + + // calculate new start position for preview paint + Size aNewWinSize = PixelToLogic( maPxWinSize ); + Point aNewPaintStartPos = + mpPgPrevwLayout->GetPreviewStartPosForNewScale( aNewScale, maScale, aNewWinSize ); + + // remember new scaling and prepare preview paint + // Note: paint of preview will be performed by a corresponding invalidate + // due to property changes. + maScale = aNewScale; + mpPgPrevwLayout->Prepare( 0, aNewPaintStartPos, maPxWinSize, + mnSttPage, maPaintedPreviewDocRect ); + } + +} +/* -----------------04.12.2002 10:46----------------- + * pixel scrolling - horizontally always or vertically + * when less than the desired number of rows fits into + * the view + * --------------------------------------------------*/ +void SwPagePreViewWin::Scroll(long nXMove, long nYMove, USHORT /*nFlags*/) +{ + maPaintedPreviewDocRect.Move(nXMove, nYMove); + mpPgPrevwLayout->Prepare( 0, maPaintedPreviewDocRect.TopLeft(), + maPxWinSize, mnSttPage, + maPaintedPreviewDocRect ); + +} + +BOOL SwPagePreView::HandleWheelCommands( const CommandEvent& rCEvt ) +{ + BOOL bOk = FALSE; + const CommandWheelData* pWData = rCEvt.GetWheelData(); + if( pWData && COMMAND_WHEEL_ZOOM == pWData->GetMode() ) + { + if(!Application::GetSettings().GetMiscSettings().GetEnableATToolSupport()) + { + USHORT nFactor = GetViewShell()->GetViewOptions()->GetZoom(); + const USHORT nOffset = 10; + if( 0L > pWData->GetDelta() ) + { + nFactor -= nOffset; + if(nFactor < MIN_PREVIEW_ZOOM) + nFactor = MIN_PREVIEW_ZOOM; + } + else + { + nFactor += nOffset; + if(nFactor > MAX_PREVIEW_ZOOM) + nFactor = MAX_PREVIEW_ZOOM; + } + SetZoom(SVX_ZOOM_PERCENT, nFactor); + } + bOk = TRUE; + } + else + bOk = aViewWin.HandleScrollCommand( rCEvt, pHScrollbar, pVScrollbar ); + return bOk; +} + + +uno::Reference< ::com::sun::star::accessibility::XAccessible > + SwPagePreViewWin::CreateAccessible() +{ + vos::OGuard aGuard(Application::GetSolarMutex()); // this should have + // happend already!!! + + DBG_ASSERT( GetViewShell() != NULL, "We need a view shell" ); + return GetViewShell()->CreateAccessiblePreview(); +} + +/* -----------------------------06.05.2002 13:18------------------------------ + + ---------------------------------------------------------------------------*/ +void SwPagePreView::ApplyAccessiblityOptions(SvtAccessibilityOptions& rAccessibilityOptions) +{ + GetViewShell()->ApplyAccessiblityOptions(rAccessibilityOptions); +} +/* -----------------------------2002/06/26 14:30------------------------------ + + ---------------------------------------------------------------------------*/ +void SwPagePreView::ShowHScrollbar(sal_Bool bShow) +{ + pHScrollbar->Show(bShow); + InvalidateBorder(); +} + +/* -----------------------------2002/06/26 14:30------------------------------ + + ---------------------------------------------------------------------------*/ +void SwPagePreView::ShowVScrollbar(sal_Bool bShow) +{ + pVScrollbar->Show(bShow); + InvalidateBorder(); +} + +/* -----------------25.11.2002 16:36----------------- + * + * --------------------------------------------------*/ +void SwPagePreView::SetZoom(SvxZoomType eType, USHORT nFactor) +{ + ViewShell& rSh = *GetViewShell(); + SwViewOption aOpt(*rSh.GetViewOptions()); + // OD 16.12.2002 #103492# - perform action only on changes of zoom or zoom type. + if ( aOpt.GetZoom() != nFactor || + aOpt.GetZoomType() != eType ) + { + aOpt.SetZoom(nFactor); + aOpt.SetZoomType(eType); + rSh.ApplyViewOptions( aOpt ); + lcl_InvalidateZoomSlots(GetViewFrame()->GetBindings()); + // OD 02.12.2002 #103492# + // OD 24.09.2003 #i19975# - also consider zoom type + aViewWin.AdjustPreviewToNewZoom( nFactor, eType ); + ScrollViewSzChg(); + } +} + +/** adjust position of vertical scrollbar + + OD 19.02.2003 #107369 + + @author OD +*/ +void SwPagePreView::SetVScrollbarThumbPos( const sal_uInt16 _nNewThumbPos ) +{ + if ( pVScrollbar ) + { + pVScrollbar->SetThumbPos( _nNewThumbPos ); + } +} |