?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update ooo310-m15
[ooovba.git] / sw / source / ui / uiview / pview.cxx
blobcf5b51d02c927379243fbe12f0a268aede153872
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: pview.cxx,v $
10 * $Revision: 1.70 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33
34
35
36 #include <sfx2/objface.hxx>
37 #include <vcl/timer.hxx>
38 #include <vcl/field.hxx>
39 #include <vcl/fixed.hxx>
40 #include <vcl/help.hxx>
41 #include <vcl/cmdevt.hxx>
42 #ifndef _SV_BUTTON_HXX //autogen
43 #include <vcl/button.hxx>
44 #endif
45 #include <svtools/printdlg.hxx>
46 #include <svtools/whiter.hxx>
47 #include <svtools/stritem.hxx>
48 #include <svtools/eitem.hxx>
49 #include <sfx2/printer.hxx>
50 #include <sfx2/app.hxx>
51 #include <sfx2/topfrm.hxx>
52 #include <sfx2/bindings.hxx>
53 #include <sfx2/request.hxx>
54 #include <sfx2/dispatch.hxx>
55 #include <vcl/msgbox.hxx>
56 #include <svx/stddlg.hxx>
57 #include <svx/paperinf.hxx>
58 #include <svx/srchitem.hxx>
59 #include <svx/svdview.hxx>
60 #include <svx/dlgutil.hxx>
61 #include <svx/zoomslideritem.hxx>
62 #ifndef _SVX_SVXIDS_HRC //autogen
63 #include <svx/svxids.hrc>
64 #endif
65
66
67 #include <swwait.hxx>
68 #include <globdoc.hxx>
69 #include <wdocsh.hxx>
70 #include <pvprtdat.hxx>
71 #include <swmodule.hxx>
72 #include <modcfg.hxx>
73 #include <wrtsh.hxx>
74 #ifndef _DOCSH_HXX
75 #include <docsh.hxx>
76 #endif
77 #include <viewopt.hxx>
78 #include <doc.hxx>
79 #ifndef _PVIEW_HXX
80 #include <pview.hxx>
81 #endif
82 #ifndef _VIEW_HXX
83 #include <view.hxx>
84 #endif
85 #ifndef _TEXTSH_HXX
86 #include <textsh.hxx>
87 #endif
88 #include <scroll.hxx>
89 #include <swprtopt.hxx>
90 #include <docstat.hxx>
91 #include <usrpref.hxx>
92 #include <viewfunc.hxx>
93
94
95 #ifndef _HELPID_H
96 #include <helpid.h>
97 #endif
98 #ifndef _CMDID_H
99 #include <cmdid.h>
100 #endif
101 #ifndef _GLOBALS_HRC
102 #include <globals.hrc>
103 #endif
104 #ifndef _POPUP_HRC
105 #include <popup.hrc>
106 #endif
107 #ifndef _PVIEW_HRC
108 #include <pview.hrc>
109 #endif
110
111 #define SwPagePreView
112 #ifndef _ITEMDEF_HXX
113 #include <itemdef.hxx>
114 #endif
115 #ifndef _SWSLOTS_HXX
116 #include <swslots.hxx>
117 #endif
118 // OD 12.12.2002 #103492#
119 #include <pagepreviewlayout.hxx>
120
121 #include <svx/svxdlg.hxx>
122 #include <svx/dialogs.hrc>
123 #include <vos/mutex.hxx>
124
125 using namespace ::com::sun::star;
126
127
128 SFX_IMPL_VIEWFACTORY(SwPagePreView, SW_RES(STR_NONAME))
129 {
130 SFX_VIEW_REGISTRATION(SwDocShell);
131 SFX_VIEW_REGISTRATION(SwWebDocShell);
132 SFX_VIEW_REGISTRATION(SwGlobalDocShell);
133 }
134
135 SFX_IMPL_INTERFACE(SwPagePreView, SfxViewShell, SW_RES(RID_PVIEW_TOOLBOX))
136 {
137 SFX_POPUPMENU_REGISTRATION(SW_RES(MN_PPREVIEW_POPUPMENU));
138 SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT|SFX_VISIBILITY_STANDARD|
139 SFX_VISIBILITY_CLIENT|SFX_VISIBILITY_FULLSCREEN|
140 SFX_VISIBILITY_READONLYDOC,
141 SW_RES(RID_PVIEW_TOOLBOX));
142 }
143
144
145 TYPEINIT1(SwPagePreView,SfxViewShell)
146
147 #define SWVIEWFLAGS ( SFX_VIEW_MAXIMIZE_FIRST|SFX_VIEW_OPTIMIZE_EACH| \
148 SFX_VIEW_CAN_PRINT|SFX_VIEW_HAS_PRINTOPTIONS )
149
150 #define MIN_PREVIEW_ZOOM 25
151 #define MAX_PREVIEW_ZOOM 600
152 /* \f */
153 /* -----------------26.11.2002 10:41-----------------
154 *
155 * --------------------------------------------------*/
156 USHORT lcl_GetNextZoomStep(USHORT nCurrentZoom, BOOL bZoomIn)
157 {
158 static USHORT aZoomArr[] =
159 {
160 25, 50, 75, 100, 150, 200, 400, 600
161 };
162 const sal_uInt16 nZoomArrSize = sizeof(aZoomArr)/sizeof(USHORT);
163 if(bZoomIn)
164 for(int i = nZoomArrSize - 1; i >= 0; --i)
165 {
166 if(nCurrentZoom > aZoomArr[i] || !i)
167 return aZoomArr[i];
168 }
169 else
170 for(int i = 0; i < nZoomArrSize; ++i)
171 {
172 if(nCurrentZoom < aZoomArr[i])
173 return aZoomArr[i];
174 }
175 return bZoomIn ? MAX_PREVIEW_ZOOM : MIN_PREVIEW_ZOOM;
176 };
177 /* -----------------02.12.2002 09:11-----------------
178 *
179 * --------------------------------------------------*/
180 void lcl_InvalidateZoomSlots(SfxBindings& rBindings)
181 {
182 static USHORT __READONLY_DATA aInval[] =
183 {
184 SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN, SID_ATTR_ZOOMSLIDER, FN_PREVIEW_ZOOM, FN_STAT_ZOOM,
185 0
186 };
187 rBindings.Invalidate( aInval );
188 }
189 /*--------------------------------------------------------------------
190 Beschreibung:
191 --------------------------------------------------------------------*/
192
193 // erstmal der Zoom-Dialog
194
195 class SwPreViewZoomDlg : public SvxStandardDialog
196 {
197 FixedText aRowLbl;
198 NumericField aRowEdit;
199 FixedText aColLbl;
200 NumericField aColEdit;
201
202 OKButton aOkBtn;
203 CancelButton aCancelBtn;
204 HelpButton aHelpBtn;
205
206 virtual void Apply();
207
208 public:
209 SwPreViewZoomDlg( SwPagePreViewWin& rParent );
210 ~SwPreViewZoomDlg();
211 };
212
213 /*--------------------------------------------------------------------
214 Beschreibung:
215 --------------------------------------------------------------------*/
216
217
218 SwPreViewZoomDlg::SwPreViewZoomDlg( SwPagePreViewWin& rParent ) :
219 SvxStandardDialog( &rParent, SW_RES(DLG_PAGEPREVIEW_ZOOM) ),
220 aRowLbl(this,SW_RES(FT_ROW)),
221 aRowEdit(this,SW_RES(ED_ROW)),
222 aColLbl(this,SW_RES(FT_COL)),
223 aColEdit(this,SW_RES(ED_COL)),
224 aOkBtn(this,SW_RES(BT_OK)),
225 aCancelBtn(this,SW_RES(BT_CANCEL)),
226 aHelpBtn(this,SW_RES(BT_HELP))
227 {
228 FreeResource();
229
230 aRowEdit.SetValue( rParent.GetRow() );
231 aColEdit.SetValue( rParent.GetCol() );
232 }
233
234 /*--------------------------------------------------------------------
235 Beschreibung:
236 --------------------------------------------------------------------*/
237
238
239 SwPreViewZoomDlg::~SwPreViewZoomDlg() {}
240
241
242 void SwPreViewZoomDlg::Apply()
243 {
244 ((SwPagePreViewWin*)GetParent())->CalcWish(
245 BYTE(aRowEdit.GetValue()),
246 BYTE(aColEdit.GetValue()) );
247 }
248
249 /* \f */
250 /* -----------------20.08.98 15:25-------------------
251 * Vorschau fuer den Seitendruck
252 * --------------------------------------------------*/
253 struct PrintSettingsStruct;
254 class PrtPrvWindow : public Window
255 {
256 const PrintSettingsStruct& rSettings;
257
258 virtual void Paint(const Rectangle&);
259 public :
260 PrtPrvWindow(Window* pParent, const ResId& rResId, const PrintSettingsStruct& rSett) :
261 Window(pParent, rResId), rSettings(rSett){}
262 };
263 /*--------------------------------------------------------------------
264 Beschreibung: Optionen fuer das Drucken der Preview
265 --------------------------------------------------------------------*/
266 struct PrintSettingsStruct
267 {
268 Size aPageMaxSize; // groesste Seite
269 Size aPrtSize; // Papiergroesse
270 Size aPrvPrtSize; // Groesse innerhalb der LRTB-Raender
271 Size aGridSize; // Groesse fuer jede Seite, enthaelt je
272 // die Haelfte von H- und V-Distance
273
274 long nLeft;
275 long nRight;
276 long nTop;
277 long nBottom;
278 long nHori;
279 long nVert;
280
281 USHORT nRows;
282 USHORT nCols;
283
284 BOOL bPrinterLandscape; // Ausrichtung
285 };
286
287 class SwPreviewPrintOptionsDialog : public SvxStandardDialog
288 {
289 FixedLine aRowColFL;
290 FixedText aRowsFT;
291 NumericField aRowsNF;
292 FixedText aColsFT;
293 NumericField aColsNF;
294
295 FixedLine aMarginFL;
296 FixedText aLSpaceFT;
297 MetricField aLSpaceMF;
298 FixedText aRSpaceFT;
299 MetricField aRSpaceMF;
300 FixedText aTSpaceFT;
301 MetricField aTSpaceMF;
302 FixedText aBSpaceFT;
303 MetricField aBSpaceMF;
304 FixedLine aDistanceFL;
305 FixedText aHSpaceFT;
306 MetricField aHSpaceMF;
307 FixedText aVSpaceFT;
308 MetricField aVSpaceMF;
309
310 RadioButton aLandscapeRB;
311 RadioButton aPortraitRB;
312 FixedLine aOrientationFL;
313
314 PrtPrvWindow aPreviewWin;
315
316 OKButton aOkBtn;
317 CancelButton aCancelBtn;
318 HelpButton aHelpBtn;
319
320 PushButton aStandardPB;
321
322 SwPagePreView& rPreView;
323 SwPagePreViewWin& rParentWin;
324 PrintSettingsStruct aSettings;
325 /* Size aPageMaxSize;
326 Size aPrtSize;
327
328 BOOL bOrientation;
329 */
330 BOOL bStandard;
331
332 virtual void Apply();
333 void FillControls(SwPagePreViewPrtData& rData);
334
335 DECL_LINK( ModifyHdl, Edit* );
336 DECL_LINK( StandardHdl, PushButton* );
337
338 public:
339 SwPreviewPrintOptionsDialog(SwPagePreViewWin& rParent, SwPagePreView& rView);
340 ~SwPreviewPrintOptionsDialog();
341 };
342
343 /* -----------------19.08.98 13:35-------------------
344 *
345 * --------------------------------------------------*/
346 SwPreviewPrintOptionsDialog::SwPreviewPrintOptionsDialog( SwPagePreViewWin& rParent, SwPagePreView& rView ) :
347 SvxStandardDialog( &rParent, SW_RES(DLG_PAGEPREVIEW_PRINTOPTIONS) ),
348 aRowColFL(this,SW_RES( FL_ROWCOL)),
349 aRowsFT(this,SW_RES( FT_ROWS)),
350 aRowsNF(this,SW_RES( NF_ROWS)),
351 aColsFT(this,SW_RES( FT_COLS)),
352 aColsNF(this,SW_RES( NF_COLS)),
353 aMarginFL(this,SW_RES( FL_MARGINS)),
354 aLSpaceFT(this,SW_RES( FT_LMARGIN)),
355 aLSpaceMF(this,SW_RES( MF_LMARGIN)),
356 aRSpaceFT(this,SW_RES( FT_RMARGIN)),
357 aRSpaceMF(this,SW_RES( MF_RMARGIN)),
358 aTSpaceFT(this,SW_RES( FT_TMARGIN)),
359 aTSpaceMF(this,SW_RES( MF_TMARGIN)),
360 aBSpaceFT(this,SW_RES( FT_BMARGIN)),
361 aBSpaceMF(this,SW_RES( MF_BMARGIN)),
362 aDistanceFL(this,SW_RES(FL_DISTANCE)),
363 aHSpaceFT(this,SW_RES( FT_HMARGIN)),
364 aHSpaceMF(this,SW_RES( MF_HMARGIN)),
365 aVSpaceFT(this,SW_RES( FT_VMARGIN)),
366 aVSpaceMF(this,SW_RES( MF_VMARGIN)),
367 aLandscapeRB(this,SW_RES( RB_LANDSCAPE)),
368 aPortraitRB(this,SW_RES( RB_PORTRAIT)),
369 aOrientationFL(this,SW_RES( FL_ORIENTATION)),
370 aPreviewWin(this,SW_RES( WIN_PREVIEW), aSettings),
371 aOkBtn(this,SW_RES(BT_OK)),
372 aCancelBtn(this,SW_RES(BT_CANCEL)),
373 aHelpBtn(this,SW_RES(BT_HELP)),
374 aStandardPB(this,SW_RES(PB_STANDARD)),
375 rPreView(rView),
376 rParentWin(rParent),
377 bStandard(TRUE)
378 {
379 FreeResource();
380 ViewShell& rViewSh = *rPreView.GetViewShell();
381 // OD 18.12.2002 #103492#
382 aSettings.aPageMaxSize = rViewSh.PagePreviewLayout()->GetMaxPageSize();
383 SfxPrinter* pPrinter = rViewSh.getIDocumentDeviceAccess()->getPrinter( true );
384 aSettings.aPrtSize = pPrinter->GetPaperSize();
385 //#97682# make sure that no division by zero occurs
386 if(!aSettings.aPrtSize.Width() || !aSettings.aPrtSize.Height())
387 aSettings.aPrtSize = Size(lA4Width, lA4Height);
388 aSettings.bPrinterLandscape = pPrinter->GetOrientation() == ORIENTATION_LANDSCAPE;
389
390
391 SwDocShell* pDocShell = rPreView.GetDocShell();
392 const SwMasterUsrPref *pUsrPref = SW_MOD()->GetUsrPref(0 != PTR_CAST(SwWebDocShell, pDocShell));
393 FieldUnit eFieldUnit = pUsrPref->GetMetric();
394 ::SetFieldUnit( aLSpaceMF, eFieldUnit );
395 ::SetFieldUnit( aRSpaceMF, eFieldUnit );
396 ::SetFieldUnit( aTSpaceMF, eFieldUnit );
397 ::SetFieldUnit( aBSpaceMF, eFieldUnit );
398 ::SetFieldUnit( aHSpaceMF, eFieldUnit );
399 ::SetFieldUnit( aVSpaceMF, eFieldUnit );
400
401 SwDoc* pDoc = pDocShell->GetDoc();
402 SwPagePreViewPrtData aData;
403 if(pDoc->GetPreViewPrtData())
404 {
405 aData = *pDoc->GetPreViewPrtData();
406 bStandard = FALSE;
407 }
408 else
409 {
410 // Orientation der PreviewData an den Drucker anpassen
411 aData.SetLandscape(aSettings.bPrinterLandscape);
412 aData.SetRow(rParent.GetRow());
413 aData.SetCol(rParent.GetCol());
414 }
415 FillControls(aData);
416
417 aLSpaceMF.SaveValue();
418 aRSpaceMF.SaveValue();
419 aTSpaceMF.SaveValue();
420 aBSpaceMF.SaveValue();
421 aHSpaceMF.SaveValue();
422 aVSpaceMF.SaveValue();
423 aRowsNF.SaveValue();
424 aColsNF.SaveValue();
425 aLandscapeRB.SaveValue();
426 aPortraitRB.SaveValue();
427
428 aStandardPB.SetClickHdl(LINK(this, SwPreviewPrintOptionsDialog, StandardHdl));
429 Link aLk = LINK(this, SwPreviewPrintOptionsDialog, ModifyHdl);
430 aLSpaceMF.SetUpHdl(aLk);
431 aRSpaceMF.SetUpHdl(aLk);
432 aTSpaceMF.SetUpHdl(aLk);
433 aBSpaceMF.SetUpHdl(aLk);
434 aHSpaceMF.SetUpHdl(aLk);
435 aVSpaceMF.SetUpHdl(aLk);
436 aRowsNF.SetUpHdl(aLk);
437 aColsNF.SetUpHdl(aLk);
438 aLSpaceMF.SetDownHdl(aLk);
439 aRSpaceMF.SetDownHdl(aLk);
440 aTSpaceMF.SetDownHdl(aLk);
441 aBSpaceMF.SetDownHdl(aLk);
442 aHSpaceMF.SetDownHdl(aLk);
443 aVSpaceMF.SetDownHdl(aLk);
444 aRowsNF.SetDownHdl(aLk);
445 aColsNF.SetDownHdl(aLk);
446 aLSpaceMF.SetLoseFocusHdl(aLk);
447 aRSpaceMF.SetLoseFocusHdl(aLk);
448 aTSpaceMF.SetLoseFocusHdl(aLk);
449 aBSpaceMF.SetLoseFocusHdl(aLk);
450 aHSpaceMF.SetLoseFocusHdl(aLk);
451 aVSpaceMF.SetLoseFocusHdl(aLk);
452 aRowsNF.SetLoseFocusHdl(aLk);
453 aColsNF.SetLoseFocusHdl(aLk);
454 aLandscapeRB.SetClickHdl(aLk);
455 aPortraitRB.SetClickHdl(aLk);
456
457 ModifyHdl(0);
458 if(bStandard)
459 StandardHdl(&aStandardPB);
460 }
461
462
463 /* -----------------19.08.98 13:36-------------------
464 *
465 * --------------------------------------------------*/
466 SwPreviewPrintOptionsDialog::~SwPreviewPrintOptionsDialog()
467 {
468 }
469 /* -----------------12.11.98 11:32-------------------
470 *
471 * --------------------------------------------------*/
472 void SwPreviewPrintOptionsDialog::FillControls(SwPagePreViewPrtData& rData)
473 {
474 aLSpaceMF.SetValue(aLSpaceMF.Normalize(rData.GetLeftSpace() ), FUNIT_TWIP);
475 aRSpaceMF.SetValue(aRSpaceMF.Normalize(rData.GetRightSpace() ), FUNIT_TWIP);
476 aTSpaceMF.SetValue(aTSpaceMF.Normalize(rData.GetTopSpace() ), FUNIT_TWIP);
477 aBSpaceMF.SetValue(aBSpaceMF.Normalize(rData.GetBottomSpace()), FUNIT_TWIP);
478 aHSpaceMF.SetValue(aHSpaceMF.Normalize(rData.GetHorzSpace() ), FUNIT_TWIP);
479 aVSpaceMF.SetValue(aVSpaceMF.Normalize(rData.GetVertSpace() ), FUNIT_TWIP);
480 aRowsNF.SetValue(rData.GetRow());
481 aColsNF.SetValue(rData.GetCol());
482 aSettings.bPrinterLandscape ? aLandscapeRB.Check() : aPortraitRB.Check();
483 // wenn Drucker und Einstellungen nicht uebereinstimmen, dann Seiten tauschen
484 if( rData.GetLandscape() != aSettings.bPrinterLandscape )
485 {
486 Size aTmp(aSettings.aPrtSize.Height(), aSettings.aPrtSize.Width());
487 aSettings.aPrtSize = aTmp;
488 aSettings.bPrinterLandscape = !aSettings.bPrinterLandscape;
489 // nochmal setzen, denn auch wenn nur die Default-Orientierung dem Drucker
490 // angepasst wurde, sollen die Einstellungen gespeichert werden
491 aSettings.bPrinterLandscape ? aLandscapeRB.Check() : aPortraitRB.Check();
492 }
493 aLandscapeRB.SaveValue();
494 aPortraitRB.SaveValue();
495
496 aSettings.nLeft = rData.GetLeftSpace() ;
497 aSettings.nRight = rData.GetRightSpace() ;
498 aSettings.nTop = rData.GetTopSpace() ;
499 aSettings.nBottom = rData.GetBottomSpace();
500 aSettings.nHori = rData.GetHorzSpace() ;
501 aSettings.nVert = rData.GetVertSpace() ;
502 aSettings.nRows = rData.GetRow() ;
503 aSettings.nCols = rData.GetCol() ;
504 aSettings.aPrvPrtSize = aSettings.aPrtSize ;
505 }
506
507 /* -----------------19.08.98 14:31-------------------
508 *
509 * --------------------------------------------------*/
510 void SwPreviewPrintOptionsDialog::Apply()
511 {
512
513 SwDoc* pDoc = rPreView.GetDocShell()->GetDoc();
514 if(bStandard)
515 pDoc->SetPreViewPrtData(0);
516 else if( aLSpaceMF.GetSavedValue() != aLSpaceMF.GetText() ||
517 aRSpaceMF.GetSavedValue() != aRSpaceMF.GetText() ||
518 aTSpaceMF.GetSavedValue() != aTSpaceMF.GetText() ||
519 aBSpaceMF.GetSavedValue() != aBSpaceMF.GetText() ||
520 aHSpaceMF.GetSavedValue() != aHSpaceMF.GetText() ||
521 aVSpaceMF.GetSavedValue() != aVSpaceMF.GetText() ||
522 aRowsNF.GetSavedValue() != aRowsNF.GetText() ||
523 aColsNF.GetSavedValue() != aColsNF.GetText() ||
524 aLandscapeRB.GetSavedValue() != aLandscapeRB.IsChecked() ||
525 aPortraitRB.GetSavedValue() != aPortraitRB.IsChecked() )
526 {
527 SwPagePreViewPrtData aData;
528 if(pDoc->GetPreViewPrtData())
529 aData = *pDoc->GetPreViewPrtData();
530 aData.SetLeftSpace( static_cast< ULONG >(aLSpaceMF.Denormalize(aLSpaceMF.GetValue(FUNIT_TWIP))) );
531 aData.SetRightSpace( static_cast< ULONG >(aRSpaceMF.Denormalize(aRSpaceMF.GetValue(FUNIT_TWIP))) );
532 aData.SetTopSpace( static_cast< ULONG >(aTSpaceMF.Denormalize(aTSpaceMF.GetValue(FUNIT_TWIP))) );
533 aData.SetBottomSpace( static_cast< ULONG >(aBSpaceMF.Denormalize(aBSpaceMF.GetValue(FUNIT_TWIP))) );
534
535 aData.SetHorzSpace( static_cast< ULONG >(aHSpaceMF.Denormalize(aHSpaceMF.GetValue(FUNIT_TWIP))) );
536 aData.SetVertSpace( static_cast< ULONG >(aVSpaceMF.Denormalize(aVSpaceMF.GetValue(FUNIT_TWIP))) );
537 aData.SetRow((BYTE)aRowsNF.GetValue());
538 aData.SetCol((BYTE)aColsNF.GetValue());
539 aData.SetLandscape(aLandscapeRB.IsChecked());
540
541 ViewShell& rViewSh = *rPreView.GetViewShell();
542 SfxPrinter* pPrinter = rViewSh.getIDocumentDeviceAccess()->getPrinter( true );
543 if((pPrinter->GetOrientation() == ORIENTATION_LANDSCAPE)
544 != aData.GetLandscape())
545 pPrinter->SetOrientation(aData.GetLandscape() ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT);
546
547
548 pDoc->SetPreViewPrtData(&aData);
549
550 }
551 }
552 /* -----------------20.08.98 08:48-------------------
553 *
554 * --------------------------------------------------*/
555 IMPL_LINK( SwPreviewPrintOptionsDialog, ModifyHdl, Edit*, pEdit )
556 {
557 if(bStandard && pEdit)
558 {
559 aLSpaceMF.SetUserValue(aLSpaceMF.GetValue());
560 aRSpaceMF.SetUserValue(aRSpaceMF.GetValue());
561 aTSpaceMF.SetUserValue(aTSpaceMF.GetValue());
562 aBSpaceMF.SetUserValue(aBSpaceMF.GetValue());
563 aHSpaceMF.SetUserValue(aHSpaceMF.GetValue());
564 aVSpaceMF.SetUserValue(aVSpaceMF.GetValue());
565 aRowsNF. SetUserValue(aRowsNF .GetValue());
566 aColsNF. SetUserValue(aColsNF .GetValue());
567
568 bStandard = FALSE;
569 }
570 BOOL bOrientChanged = aSettings.bPrinterLandscape != aLandscapeRB.IsChecked();;
571 if(pEdit == &aLSpaceMF)
572 aSettings.nLeft = static_cast< long >(aLSpaceMF.Denormalize(aLSpaceMF.GetValue(FUNIT_TWIP)));
573 else if(pEdit == &aRSpaceMF)
574 aSettings.nRight = static_cast< long >(aRSpaceMF.Denormalize(aRSpaceMF.GetValue(FUNIT_TWIP)));
575 else if(pEdit == &aTSpaceMF)
576 aSettings.nTop = static_cast< long >(aTSpaceMF.Denormalize(aTSpaceMF.GetValue(FUNIT_TWIP)));
577 else if(pEdit == &aBSpaceMF)
578 aSettings.nBottom = static_cast< long >(aBSpaceMF.Denormalize(aBSpaceMF.GetValue(FUNIT_TWIP)));
579 else if(pEdit == &aHSpaceMF)
580 aSettings.nHori = static_cast< long >(aHSpaceMF.Denormalize(aHSpaceMF.GetValue(FUNIT_TWIP)));
581 else if(pEdit == &aVSpaceMF)
582 aSettings.nVert = static_cast< long >(aVSpaceMF.Denormalize(aVSpaceMF.GetValue(FUNIT_TWIP)));
583 else if(pEdit == &aRowsNF)
584 aSettings.nRows = (USHORT)aRowsNF.GetValue();
585 else if(pEdit == &aColsNF)
586 aSettings.nCols = (USHORT)aColsNF.GetValue();
587 else if(pEdit == (Edit*)&aLandscapeRB)
588 aSettings.bPrinterLandscape = aLandscapeRB.IsChecked();
589 else if(pEdit == (Edit*)&aPortraitRB)
590 aSettings.bPrinterLandscape = aLandscapeRB.IsChecked();
591
592 if(bOrientChanged)
593 {
594 Size aTmp(aSettings.aPrtSize.Height(), aSettings.aPrtSize.Width());
595 aSettings.aPrtSize = aTmp;
596 }
597
598
599 aSettings.aPrvPrtSize = Size(aSettings.aPrtSize.Width() - aSettings.nRight - aSettings.nLeft,
600 aSettings.aPrtSize.Height() - aSettings.nTop - aSettings.nBottom);
601 aSettings.aGridSize = Size(aSettings.aPrvPrtSize.Width() / aSettings.nCols,
602 aSettings.aPrvPrtSize.Height() / aSettings.nRows );
603 // was fehlt noch: Orientation auswerten, minimalrand ausrechnen, Beispiel fuettern
604
605
606 //am Ende Maximalwerte setzen
607 long n20Percent = aSettings.aPrtSize.Width() / 5;
608 aLSpaceMF.SetMax(aLSpaceMF.Normalize(aSettings.aPrtSize.Width() - aSettings.nRight - n20Percent), FUNIT_TWIP);
609 aRSpaceMF.SetMax(aRSpaceMF.Normalize(aSettings.aPrtSize.Width() - aSettings.nLeft - n20Percent), FUNIT_TWIP);
610 n20Percent = aSettings.aPrtSize.Height() / 5;
611 aTSpaceMF.SetMax(aTSpaceMF.Normalize(aSettings.aPrtSize.Height() - aSettings.nBottom - n20Percent), FUNIT_TWIP);
612 aBSpaceMF.SetMax(aBSpaceMF.Normalize(aSettings.aPrtSize.Height() - aSettings.nTop - n20Percent), FUNIT_TWIP);
613
614 long n80Percent = aSettings.aPrvPrtSize.Width() * 4 / 5;
615 aHSpaceMF.SetMax(aHSpaceMF.Normalize(n80Percent / aSettings.nRows), FUNIT_TWIP);
616 n80Percent = aSettings.aPrvPrtSize.Height()* 4 / 5;
617 aVSpaceMF.SetMax(aVSpaceMF.Normalize(n80Percent / aSettings.nCols), FUNIT_TWIP);
618 aHSpaceMF.Enable(aSettings.nCols > 1);
619 aVSpaceMF.Enable(aSettings.nRows > 1);
620 aRowsNF.SetMin(1);// nur damit auch nach Standard wieder der Inhalt angezeigt wird
621 aColsNF.SetMin(1);
622
623
624 aPreviewWin.Invalidate();
625 return 0;
626 }
627 /* -----------------28.08.98 14:59-------------------
628 *
629 * --------------------------------------------------*/
630 IMPL_LINK( SwPreviewPrintOptionsDialog, StandardHdl, PushButton*, EMPTYARG )
631 {
632 SetUpdateMode(TRUE);
633 SwPagePreViewPrtData aData;
634 aData.SetRow(rParentWin.GetRow());
635 aData.SetCol(rParentWin.GetCol());
636 FillControls(aData);
637 bStandard = TRUE;
638 aLSpaceMF.SetText(aEmptyStr);
639 aRSpaceMF.SetText(aEmptyStr);
640 aTSpaceMF.SetText(aEmptyStr);
641 aBSpaceMF.SetText(aEmptyStr);
642 aHSpaceMF.SetText(aEmptyStr);
643 aVSpaceMF.SetText(aEmptyStr);
644 aPreviewWin.Invalidate();
645 SetUpdateMode(FALSE);
646 return 0;
647 }
648 /* -----------------20.08.98 15:28-------------------
649 * Preview anzeigen
650 * --------------------------------------------------*/
651 void PrtPrvWindow::Paint(const Rectangle&)
652 {
653 Size aWinSize(GetOutputSizePixel());
654 long nWidth = rSettings.aPrtSize.Width();
655 long nHeight = rSettings.aPrtSize.Height();
656 BOOL bHoriValid = (aWinSize.Width() * 100 / aWinSize.Height()) <
657 (rSettings.aPrtSize.Width() * 100/ rSettings.aPrtSize.Height());
658 Fraction aXScale( aWinSize.Width(), Max( nWidth , 1L ) );
659 Fraction aYScale( aWinSize.Height(), Max( nHeight, 1L ) );
660 MapMode aMapMode( GetMapMode() );
661 aMapMode.SetScaleX( bHoriValid ? aXScale : aYScale);
662 aMapMode.SetScaleY( bHoriValid ? aXScale : aYScale);
663 SetMapMode( aMapMode );
664
665 aWinSize = GetOutputSize();
666
667 Point aOffset(0,0);
668 if(bHoriValid)
669 aOffset.Y() = (aWinSize.Height() - rSettings.aPrtSize.Height()) / 2;
670 else
671 aOffset.X() = (aWinSize.Width() - rSettings.aPrtSize.Width()) / 2;;
672
673
674 BOOL bUseSystemColors = SvtAccessibilityOptions().GetIsForPagePreviews()
675 && GetSettings().GetStyleSettings().GetHighContrastMode();
676
677 //der weisse Seitenhintergrund
678 Rectangle aRect(aOffset, rSettings.aPrtSize);
679 if(bUseSystemColors)
680 {
681 SetFillColor( GetSettings().GetStyleSettings().GetWindowColor() );
682 SetLineColor( SwViewOption::GetFontColor() );
683 }
684 else
685 {
686 SetFillColor( Color( COL_WHITE ) );
687 SetLineColor(Color( COL_BLACK ) );
688 }
689
690 DrawRect(aRect);
691
692 Point aTL(aOffset);
693 aTL.X() += rSettings.nLeft;
694 aTL.Y() += rSettings.nTop;
695
696 Size aPrvPageSize((rSettings.aPrvPrtSize.Width() - (rSettings.nCols - 1) * rSettings.nHori) / rSettings.nCols,
697 (rSettings.aPrvPrtSize.Height() - (rSettings.nRows - 1) * rSettings.nVert) / rSettings.nRows);
698 // jetzt muss noch das unterschiedliche Groessenverhaeltnis berechnet werden, um es an
699 // der richtigen Seite abzuziehen.
700 //...
701 long nSourceScale = rSettings.aPageMaxSize.Width() * 100 / rSettings.aPageMaxSize.Height();
702 long nDestScale = aPrvPageSize.Width() * 100 / aPrvPageSize.Height() ;
703 if(nSourceScale > nDestScale) // die Seite ist relativ breiter als das vorhandene Rechteck
704 {
705 aPrvPageSize.Height() = aPrvPageSize.Width() * 100 / nSourceScale;
706 }
707 else
708 {
709 aPrvPageSize.Width() = aPrvPageSize.Height() * nSourceScale / 100;
710 }
711
712 if(bUseSystemColors)
713 SetFillColor( GetSettings().GetStyleSettings().GetWindowColor() );
714 else
715 SetFillColor( Color( COL_GRAY ) );
716
717
718 aRect = Rectangle(aTL, aPrvPageSize);
719 for(USHORT i = 0; i < rSettings.nRows; i++)
720 {
721 for(USHORT j = 0; j < rSettings.nCols; j++)
722 {
723 DrawRect(aRect);
724 aRect.Move(aPrvPageSize.Width() + rSettings.nHori, 0);
725 }
726
727 aRect.Move( 0, aPrvPageSize.Height() + rSettings.nVert);
728 aRect.SetPos(Point(aTL.X(), aRect.TopLeft().Y()));
729 }
730 //rSettings;
731 }
732
733 /* \f */
734 /*--------------------------------------------------------------------
735 Beschreibung:
736 --------------------------------------------------------------------*/
737
738 // alles fuers SwPagePreViewWin
739
740
741 SwPagePreViewWin::SwPagePreViewWin( Window *pParent, SwPagePreView& rPView )
742 : Window( pParent, WinBits( WB_CLIPCHILDREN) ),
743 mpViewShell( 0 ),
744 mrView( rPView ),
745 mbCalcScaleForPreviewLayout( true ),
746 maPaintedPreviewDocRect( Rectangle(0,0,0,0) )
747 {
748 SetOutDevViewType( OUTDEV_VIEWTYPE_PRINTPREVIEW ); //#106611#
749 SetHelpId(HID_PAGEPREVIEW);
750 SetFillColor( GetBackground().GetColor() );
751 SetLineColor( GetBackground().GetColor());
752 SetMapMode( MapMode(MAP_TWIP) );
753
754 const SwMasterUsrPref *pUsrPref = SW_MOD()->GetUsrPref(FALSE);
755 mnRow = pUsrPref->GetPagePrevRow(); // 1 Zeile
756 mnCol = pUsrPref->GetPagePrevCol(); // 1 Spalte
757 // OD 24.03.2003 #108282# - member <mnVirtPage> no longer exists.
758 mnSttPage = USHRT_MAX;
759 }
760
761 /*--------------------------------------------------------------------
762 Beschreibung:
763 --------------------------------------------------------------------*/
764
765
766 SwPagePreViewWin::~SwPagePreViewWin()
767 {
768 if( mpViewShell )
769 delete mpViewShell;
770 }
771
772 /*--------------------------------------------------------------------
773 Beschreibung:
774 --------------------------------------------------------------------*/
775
776
777 void SwPagePreViewWin::Paint( const Rectangle& rRect )
778 {
779 if( !mpViewShell || !mpViewShell->GetLayout() )
780 return;
781
782 if( USHRT_MAX == mnSttPage ) // wurde noch nie berechnet ? (Init-Phase!)
783 {
784 // das ist die Size, auf die ich mich immer beziehe
785 if( !maPxWinSize.Height() || !maPxWinSize.Width() )
786 maPxWinSize = GetOutputSizePixel();
787
788 Rectangle aRect( LogicToPixel( rRect ));
789 mpPgPrevwLayout->Prepare( 1, Point(0,0), maPxWinSize,
790 mnSttPage, maPaintedPreviewDocRect );
791 SetSelectedPage( 1 );
792 mpPgPrevwLayout->Paint( PixelToLogic( aRect ) );
793 SetPagePreview(mnRow, mnCol);
794 }
795 else
796 {
797 MapMode aMM( GetMapMode() );
798 aMM.SetScaleX( maScale );
799 aMM.SetScaleY( maScale );
800 SetMapMode( aMM );
801 mpPgPrevwLayout->Paint( rRect );
802 }
803 }
804
805 /*--------------------------------------------------------------------
806 Beschreibung:
807 --------------------------------------------------------------------*/
808 void SwPagePreViewWin::CalcWish( BYTE nNewRow, BYTE nNewCol )
809 {
810 if( !mpViewShell || !mpViewShell->GetLayout() )
811 return;
812
813 USHORT nOldCol = mnCol;
814 // OD 02.12.2002 #103492# - update <mnRow> and <mnCol>.
815 mnRow = nNewRow;
816 mnCol = nNewCol;
817 USHORT nPages = mnRow * mnCol,
818 nLastSttPg = mrView.GetPageCount()+1 > nPages
819 ? mrView.GetPageCount()+1 - nPages : 0;
820 if( mnSttPage > nLastSttPg )
821 mnSttPage = nLastSttPg;
822
823 mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true );
824 mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
825 mnSttPage, maPaintedPreviewDocRect );
826 SetSelectedPage( mnSttPage );
827 SetPagePreview(mnRow, mnCol);
828 maScale = GetMapMode().GetScaleX();
829
830 // falls an der Spaltigkeit gedreht wurde, so muss der Sonderfall
831 // Einspaltig beachtet und ggfs. der Scrollbar korrigiert werden
832 if( (1 == nOldCol) ^ (1 == mnCol) )
833 mrView.ScrollDocSzChg();
834
835 // Sortierung muss eingehalten werden!!
836 // OD 24.03.2003 #108282# - additional invalidate page status.
837 static USHORT __READONLY_DATA aInval[] =
838 {
839 SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN,
840 FN_PREVIEW_ZOOM,
841 FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
842 FN_STAT_PAGE, FN_STAT_ZOOM,
843 FN_SHOW_TWO_PAGES, FN_SHOW_MULTIPLE_PAGES,
844 0
845 };
846 SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings();
847 rBindings.Invalidate( aInval );
848 rBindings.Update( FN_SHOW_TWO_PAGES );
849 rBindings.Update( FN_SHOW_MULTIPLE_PAGES );
850 // OD 18.12.2002 #103492# - adjust scrollbars
851 mrView.ScrollViewSzChg();
852 }
853 /*--------------------------------------------------------------------
854 Beschreibung:, mnSttPage is Absolute
855 --------------------------------------------------------------------*/
856
857
858 int SwPagePreViewWin::MovePage( int eMoveMode )
859 {
860 // soviele Seiten hoch
861 USHORT nPages = mnRow * mnCol;
862 USHORT nNewSttPage = mnSttPage;
863 // OD 04.12.2002 #103492#
864 USHORT nPageCount = mrView.GetPageCount();
865 USHORT nDefSttPg = GetDefSttPage();
866 // OD 06.12.2002 #103492#
867 bool bPaintPageAtFirstCol = true;
868
869 switch( eMoveMode )
870 {
871 case MV_PAGE_UP:
872 {
873 const sal_uInt16 nRelSttPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( mnSttPage );
874 const sal_uInt16 nNewAbsSttPage = nRelSttPage - nPages > 0 ?
875 mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage - nPages ) :
876 nDefSttPg;
877 nNewSttPage = nNewAbsSttPage;
878
879 const sal_uInt16 nRelSelPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() );
880 const sal_uInt16 nNewRelSelPage = nRelSelPage - nPages > 0 ?
881 nRelSelPage - nPages :
882 1;
883 SetSelectedPage( mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nNewRelSelPage ) );
884
885 break;
886 }
887 case MV_PAGE_DOWN:
888 {
889 const sal_uInt16 nRelSttPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( mnSttPage );
890 const sal_uInt16 nNewAbsSttPage = mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage + nPages );
891 nNewSttPage = nNewAbsSttPage < nPageCount ? nNewAbsSttPage : nPageCount;
892
893 const sal_uInt16 nRelSelPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() );
894 const sal_uInt16 nNewAbsSelPage = mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSelPage + nPages );
895 SetSelectedPage( nNewAbsSelPage < nPageCount ? nNewAbsSelPage : nPageCount );
896
897 break;
898 }
899 case MV_DOC_STT:
900 nNewSttPage = nDefSttPg;
901 SetSelectedPage( mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nNewSttPage ? nNewSttPage : 1 ) );
902 break;
903 case MV_DOC_END:
904 // OD 03.12.2002 #103492# - correct calculation of new start page.
905 nNewSttPage = nPageCount;
906 SetSelectedPage( nPageCount );
907 break;
908 // OD 12.12.2002 #103492# - add new move mode
909 case MV_SELPAGE:
910 // <nNewSttPage> and <SelectedPage()> are already set.
911 // OD 20.02.2003 #107369# - not start at first column, only if the
912 // complete preview layout columns doesn't fit into window.
913 if ( !mpPgPrevwLayout->DoesPreviewLayoutColsFitIntoWindow() )
914 bPaintPageAtFirstCol = false;
915 break;
916 case MV_SCROLL:
917 // OD 17.01.2003 #103492# - check, if paint page at first column
918 // has to be avoided
919 if ( !mpPgPrevwLayout->DoesPreviewLayoutRowsFitIntoWindow() ||
920 !mpPgPrevwLayout->DoesPreviewLayoutColsFitIntoWindow() )
921 bPaintPageAtFirstCol = false;
922 break;
923 case MV_NEWWINSIZE:
924 // OD 18.12.2002 #103492# - nothing special to do.
925 break;
926 case MV_CALC:
927 // OD 18.12.2002 #103492# - re-init page preview layout.
928 mpPgPrevwLayout->ReInit();
929
930 // OD 03.12.2002 #103492# - correct calculation of new start page.
931 if( nNewSttPage > nPageCount )
932 nNewSttPage = nPageCount;
933
934 // OD 18.12.2002 #103492# - correct selected page number
935 if( SelectedPage() > nPageCount )
936 SetSelectedPage( nNewSttPage ? nNewSttPage : 1 );
937 }
938
939 mpPgPrevwLayout->Prepare( nNewSttPage, Point(0,0), maPxWinSize,
940 nNewSttPage,
941 maPaintedPreviewDocRect, bPaintPageAtFirstCol );
942 if( nNewSttPage == mnSttPage &&
943 eMoveMode != MV_SELPAGE )
944 return FALSE;
945
946 SetPagePreview(mnRow, mnCol);
947 mnSttPage = nNewSttPage;
948
949 // OD 24.03.2003 #108282# - additional invalidate page status.
950 static USHORT __READONLY_DATA aInval[] =
951 {
952 FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
953 FN_STAT_PAGE, 0
954 };
955
956 SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings();
957 rBindings.Invalidate( aInval );
958
959 return TRUE;
960 }
961
962 /*--------------------------------------------------------------------
963 Beschreibung:
964 --------------------------------------------------------------------*/
965
966
967 void SwPagePreViewWin::SetWinSize( const Size& rNewSize )
968 {
969 // die Size wollen wir aber immer in Pixel-Einheiten haben
970 maPxWinSize = LogicToPixel( rNewSize );
971
972 if( USHRT_MAX == mnSttPage )
973 {
974 mnSttPage = GetDefSttPage();
975 SetSelectedPage( GetDefSttPage() );
976 }
977
978 if ( mbCalcScaleForPreviewLayout )
979 {
980 mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true );
981 maScale = GetMapMode().GetScaleX();
982 }
983 mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
984 mnSttPage, maPaintedPreviewDocRect );
985 if ( mbCalcScaleForPreviewLayout )
986 {
987 SetSelectedPage( mnSttPage );
988 mbCalcScaleForPreviewLayout = false;
989 }
990 SetPagePreview(mnRow, mnCol);
991 maScale = GetMapMode().GetScaleX();
992 }
993
994
995 /*--------------------------------------------------------------------
996 Beschreibung:
997 --------------------------------------------------------------------*/
998
999
1000 void SwPagePreViewWin::GetStatusStr( String& rStr, USHORT nPageCnt ) const
1001 {
1002 // OD 24.03.2003 #108282# - show physical and virtual page number of
1003 // selected page, if it's visible.
1004 sal_uInt16 nPageNum;
1005 if ( mpPgPrevwLayout->IsPageVisible( mpPgPrevwLayout->SelectedPage() ) )
1006 {
1007 nPageNum = mpPgPrevwLayout->SelectedPage();
1008 }
1009 else
1010 {
1011 nPageNum = mnSttPage > 1 ? mnSttPage : 1;
1012 }
1013 sal_uInt16 nVirtPageNum = mpPgPrevwLayout->GetVirtPageNumByPageNum( nPageNum );
1014 if( nVirtPageNum && nVirtPageNum != nPageNum )
1015 {
1016 rStr += String::CreateFromInt32( nVirtPageNum );
1017 rStr += ' ';
1018 }
1019 rStr += String::CreateFromInt32( nPageNum );
1020 rStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM(" / "));
1021 rStr += String::CreateFromInt32( nPageCnt );
1022 }
1023
1024 /*--------------------------------------------------------------------
1025 Beschreibung:
1026 --------------------------------------------------------------------*/
1027
1028
1029 void SwPagePreViewWin::KeyInput( const KeyEvent &rKEvt )
1030 {
1031 const KeyCode& rKeyCode = rKEvt.GetKeyCode();
1032 USHORT nKey = rKeyCode.GetCode();
1033 BOOL bHandled = FALSE;
1034 if(!rKeyCode.GetModifier())
1035 {
1036 USHORT nSlot = 0;
1037 switch(nKey)
1038 {
1039 case KEY_ADD : nSlot = SID_ZOOM_OUT; break;
1040 case KEY_ESCAPE: nSlot = FN_CLOSE_PAGEPREVIEW; break;
1041 case KEY_SUBTRACT : nSlot = SID_ZOOM_IN; break;
1042 }
1043 if(nSlot)
1044 {
1045 bHandled = TRUE;
1046 mrView.GetViewFrame()->GetDispatcher()->Execute(
1047 nSlot, SFX_CALLMODE_ASYNCHRON );
1048 }
1049 }
1050 if( !bHandled && !mrView.KeyInput( rKEvt ) )
1051 Window::KeyInput( rKEvt );
1052 }
1053
1054 /******************************************************************************
1055 * Beschreibung:
1056 ******************************************************************************/
1057
1058 void SwPagePreViewWin::Command( const CommandEvent& rCEvt )
1059 {
1060 BOOL bCallBase = TRUE;
1061 switch( rCEvt.GetCommand() )
1062 {
1063 case COMMAND_CONTEXTMENU:
1064 mrView.GetViewFrame()->GetDispatcher()->ExecutePopup();
1065 bCallBase = FALSE;
1066 break;
1067
1068 case COMMAND_WHEEL:
1069 case COMMAND_STARTAUTOSCROLL:
1070 case COMMAND_AUTOSCROLL:
1071 {
1072 const CommandWheelData* pData = rCEvt.GetWheelData();
1073 if( pData )
1074 {
1075 const CommandWheelData aDataNew(pData->GetDelta(),pData->GetNotchDelta(),COMMAND_WHEEL_PAGESCROLL,
1076 pData->GetMode(),pData->GetModifier(),pData->IsHorz());
1077 const CommandEvent aEvent( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),rCEvt.IsMouseEvent(),&aDataNew);
1078 bCallBase = !mrView.HandleWheelCommands( aEvent );
1079 }
1080 else
1081 bCallBase = !mrView.HandleWheelCommands( rCEvt );
1082 }
1083 break;
1084 default:
1085 // OD 17.12.2002 #103492# - delete assertion
1086 ;
1087 }
1088
1089 if( bCallBase )
1090 Window::Command( rCEvt );
1091 }
1092
1093 void SwPagePreViewWin::MouseButtonDown( const MouseEvent& rMEvt )
1094 {
1095 // OD 17.12.2002 #103492# - consider single-click to set selected page
1096 if( MOUSE_LEFT == ( rMEvt.GetModifier() + rMEvt.GetButtons() ) )
1097 {
1098 Point aPrevwPos( PixelToLogic( rMEvt.GetPosPixel() ) );
1099 Point aDocPos;
1100 bool bPosInEmptyPage;
1101 sal_uInt16 nNewSelectedPage;
1102 bool bIsDocPos =
1103 mpPgPrevwLayout->IsPrevwPosInDocPrevwPage( aPrevwPos,
1104 aDocPos, bPosInEmptyPage, nNewSelectedPage );
1105 if ( bIsDocPos && rMEvt.GetClicks() == 2 )
1106 {
1107 // close page preview, set new cursor position and switch to
1108 // normal view.
1109 String sNewCrsrPos( String::CreateFromInt32( aDocPos.X() ));
1110 ((( sNewCrsrPos += ';' )
1111 += String::CreateFromInt32( aDocPos.Y() )) )
1112 += ';';
1113 mrView.SetNewCrsrPos( sNewCrsrPos );
1114
1115 SfxViewFrame *pTmpFrm = mrView.GetViewFrame();
1116 pTmpFrm->GetBindings().Execute( SID_VIEWSHELL0, NULL, 0,
1117 SFX_CALLMODE_ASYNCHRON );
1118 }
1119 else if ( bIsDocPos || bPosInEmptyPage )
1120 // OD 2004-03-04 #i20684# - add missing parenthesis
1121 {
1122 // show clicked page as the selected one
1123 mpPgPrevwLayout->MarkNewSelectedPage( nNewSelectedPage );
1124 GetViewShell()->ShowPreViewSelection( nNewSelectedPage );
1125 // OD 19.02.2003 #107369# - adjust position at vertical scrollbar.
1126 if ( mpPgPrevwLayout->DoesPreviewLayoutRowsFitIntoWindow() )
1127 {
1128 mrView.SetVScrollbarThumbPos( nNewSelectedPage );
1129 }
1130 // OD 24.03.2003 #108282# - invalidate page status.
1131 static USHORT __READONLY_DATA aInval[] =
1132 {
1133 FN_STAT_PAGE, 0
1134 };
1135 SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings();
1136 rBindings.Invalidate( aInval );
1137 }
1138 }
1139 }
1140
1141 /******************************************************************************
1142 * Beschreibung: Userprefs bzw Viewoptions setzen
1143 ******************************************************************************/
1144
1145
1146 void SwPagePreViewWin::SetPagePreview( BYTE nRow, BYTE nCol )
1147 {
1148 SwMasterUsrPref *pOpt = (SwMasterUsrPref *)SW_MOD()->GetUsrPref(FALSE);
1149
1150 if (nRow != pOpt->GetPagePrevRow() || nCol != pOpt->GetPagePrevCol())
1151 {
1152 pOpt->SetPagePrevRow( nRow );
1153 pOpt->SetPagePrevCol( nCol );
1154 pOpt->SetModified();
1155
1156 //Scrollbar updaten!
1157 mrView.ScrollViewSzChg();
1158 }
1159 }
1160
1161 /** get selected page in document preview
1162
1163 OD 13.12.2002 #103492#
1164
1165 @author OD
1166 */
1167 sal_uInt16 SwPagePreViewWin::SelectedPage() const
1168 {
1169 return mpPgPrevwLayout->SelectedPage();
1170 }
1171
1172 /** set selected page number in document preview
1173
1174 OD 13.12.2002 #103492#
1175
1176 @author OD
1177 */
1178 void SwPagePreViewWin::SetSelectedPage( sal_uInt16 _nSelectedPageNum )
1179 {
1180 mpPgPrevwLayout->SetSelectedPage( _nSelectedPageNum );
1181 }
1182
1183 /** method to enable/disable book preview
1184
1185 OD 2004-03-05 #i18143#
1186
1187 @author OD
1188 */
1189 bool SwPagePreViewWin::SetBookPreviewMode( const bool _bBookPreview )
1190 {
1191 return mpPgPrevwLayout->SetBookPreviewMode( _bBookPreview,
1192 mnSttPage,
1193 maPaintedPreviewDocRect );
1194 }
1195
1196 void SwPagePreViewWin::DataChanged( const DataChangedEvent& rDCEvt )
1197 {
1198 Window::DataChanged( rDCEvt );
1199
1200 switch( rDCEvt.GetType() )
1201 {
1202 case DATACHANGED_SETTINGS:
1203 // ScrollBars neu anordnen bzw. Resize ausloesen, da sich
1204 // ScrollBar-Groesse geaendert haben kann. Dazu muss dann im
1205 // Resize-Handler aber auch die Groesse der ScrollBars aus
1206 // den Settings abgefragt werden.
1207 if( rDCEvt.GetFlags() & SETTINGS_STYLE )
1208 mrView.InvalidateBorder(); //Scrollbarbreiten
1209 //#106746# zoom has to be disabled if Accessibility support is switched on
1210 lcl_InvalidateZoomSlots(mrView.GetViewFrame()->GetBindings());
1211 break;
1212
1213 case DATACHANGED_PRINTER:
1214 case DATACHANGED_DISPLAY:
1215 case DATACHANGED_FONTS:
1216 case DATACHANGED_FONTSUBSTITUTION:
1217 mrView.GetDocShell()->UpdateFontList(); //Fontwechsel
1218 if ( mpViewShell->GetWin() )
1219 mpViewShell->GetWin()->Invalidate();
1220 break;
1221 }
1222 }
1223
1224 /** help method to execute SfxRequest FN_PAGEUP and FN_PAGEDOWN
1225
1226 OD 04.03.2003 #107369#
1227
1228 @author OD
1229 */
1230 void SwPagePreView::_ExecPgUpAndPgDown( const bool _bPgUp,
1231 SfxRequest* _pReq )
1232 {
1233 SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
1234 // check, if top/bottom of preview is *not* already visible.
1235 if( pPagePrevwLay->GetWinPagesScrollAmount( _bPgUp ? -1 : 1 ) != 0 )
1236 {
1237 if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() &&
1238 pPagePrevwLay->DoesPreviewLayoutColsFitIntoWindow() )
1239 {
1240 const int eMvMode = _bPgUp ?
1241 SwPagePreViewWin::MV_PAGE_UP :
1242 SwPagePreViewWin::MV_PAGE_DOWN;
1243 if ( ChgPage( eMvMode, TRUE ) )
1244 aViewWin.Invalidate();
1245 }
1246 else
1247 {
1248 SwTwips nScrollAmount;
1249 sal_uInt16 nNewSelectedPageNum = 0;
1250 const sal_uInt16 nVisPages = aViewWin.GetRow() * aViewWin.GetCol();
1251 if( _bPgUp )
1252 {
1253 if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() )
1254 {
1255 nScrollAmount = pPagePrevwLay->GetWinPagesScrollAmount( -1 );
1256 if ( (aViewWin.SelectedPage() - nVisPages) > 0 )
1257 nNewSelectedPageNum = aViewWin.SelectedPage() - nVisPages;
1258 else
1259 nNewSelectedPageNum = 1;
1260 }
1261 else
1262 nScrollAmount = - Min( aViewWin.GetOutputSize().Height(),
1263 aViewWin.GetPaintedPreviewDocRect().Top() );
1264 }
1265 else
1266 {
1267 if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() )
1268 {
1269 nScrollAmount = pPagePrevwLay->GetWinPagesScrollAmount( 1 );
1270 if ( (aViewWin.SelectedPage() + nVisPages) <= mnPageCount )
1271 nNewSelectedPageNum = aViewWin.SelectedPage() + nVisPages;
1272 else
1273 nNewSelectedPageNum = mnPageCount;
1274 }
1275 else
1276 nScrollAmount = Min( aViewWin.GetOutputSize().Height(),
1277 ( pPagePrevwLay->GetPrevwDocSize().Height() -
1278 aViewWin.GetPaintedPreviewDocRect().Bottom() ) );
1279 }
1280 aViewWin.Scroll( 0, nScrollAmount );
1281 if ( nNewSelectedPageNum != 0 )
1282 {
1283 aViewWin.SetSelectedPage( nNewSelectedPageNum );
1284 }
1285 ScrollViewSzChg();
1286 // OD 24.03.2003 #108282# - additional invalidate page status.
1287 static USHORT __READONLY_DATA aInval[] =
1288 {
1289 FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
1290 FN_STAT_PAGE, 0
1291 };
1292 SfxBindings& rBindings = GetViewFrame()->GetBindings();
1293 rBindings.Invalidate( aInval );
1294 aViewWin.Invalidate();
1295 }
1296 }
1297
1298 if ( _pReq )
1299 _pReq->Done();
1300 }
1301
1302 /*--------------------------------------------------------------------
1303 Beschreibung:
1304 --------------------------------------------------------------------*/
1305 // dann mal alles fuer die SwPagePreView
1306 void SwPagePreView::Execute( SfxRequest &rReq )
1307 {
1308 int eMvMode;
1309 BYTE nRow = 1;
1310 BOOL bRetVal = FALSE;
1311 bool bRefresh = true;
1312
1313 switch(rReq.GetSlot())
1314 {
1315 case FN_REFRESH_VIEW:
1316 case FN_STAT_PAGE:
1317 case FN_STAT_ZOOM:
1318 break;
1319
1320 case FN_SHOW_MULTIPLE_PAGES:
1321 {
1322 const SfxItemSet *pArgs = rReq.GetArgs();
1323 if( pArgs && pArgs->Count() >= 2 )
1324 {
1325 BYTE nCols = (BYTE)((SfxUInt16Item &)pArgs->Get(
1326 SID_ATTR_TABLE_COLUMN)).GetValue();
1327 BYTE nRows = (BYTE)((SfxUInt16Item &)pArgs->Get(
1328 SID_ATTR_TABLE_ROW)).GetValue();
1329 aViewWin.CalcWish( nRows, nCols );
1330
1331 }
1332 else
1333 SwPreViewZoomDlg( aViewWin ).Execute();
1334
1335 }
1336 break;
1337 case FN_SHOW_BOOKVIEW:
1338 {
1339 const SfxItemSet* pArgs = rReq.GetArgs();
1340 const SfxPoolItem* pItem;
1341 bool bBookPreview = GetViewShell()->GetViewOptions()->IsPagePrevBookview();
1342 if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( FN_SHOW_BOOKVIEW, FALSE, &pItem ) )
1343 {
1344 bBookPreview = static_cast< const SfxBoolItem* >( pItem )->GetValue();
1345 ( ( SwViewOption* ) GetViewShell()->GetViewOptions() )->SetPagePrevBookview( bBookPreview );
1346 // cast is not gentleman like, but it's common use in writer and in this case
1347 }
1348 if ( aViewWin.SetBookPreviewMode( bBookPreview ) )
1349 {
1350 // book preview mode changed. Thus, adjust scrollbars and
1351 // invalidate corresponding states.
1352 ScrollViewSzChg();
1353 static USHORT __READONLY_DATA aInval[] =
1354 {
1355 FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
1356 FN_STAT_PAGE, FN_SHOW_BOOKVIEW, 0
1357 };
1358 SfxBindings& rBindings = GetViewFrame()->GetBindings();
1359 rBindings.Invalidate( aInval );
1360 aViewWin.Invalidate();
1361 }
1362
1363 }
1364 break;
1365 case FN_SHOW_TWO_PAGES:
1366 aViewWin.CalcWish( nRow, 2 );
1367 break;
1368
1369 case FN_PREVIEW_ZOOM:
1370 case SID_ATTR_ZOOM:
1371 {
1372 const SfxItemSet *pArgs = rReq.GetArgs();
1373 const SfxPoolItem* pItem;
1374 AbstractSvxZoomDialog *pDlg = 0;
1375 if(!pArgs)
1376 {
1377 SfxItemSet aCoreSet(GetPool(), SID_ATTR_ZOOM, SID_ATTR_ZOOM);
1378 const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1379 SvxZoomItem aZoom( (SvxZoomType)pVOpt->GetZoomType(),
1380 pVOpt->GetZoom() );
1381 aZoom.SetValueSet(
1382 SVX_ZOOM_ENABLE_50|
1383 SVX_ZOOM_ENABLE_75|
1384 SVX_ZOOM_ENABLE_100|
1385 SVX_ZOOM_ENABLE_150|
1386 SVX_ZOOM_ENABLE_200|
1387 SVX_ZOOM_ENABLE_WHOLEPAGE);
1388 aCoreSet.Put( aZoom );
1389
1390 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1391 if(pFact)
1392 {
1393 pDlg = pFact->CreateSvxZoomDialog(&GetViewFrame()->GetWindow(), aCoreSet, RID_SVXDLG_ZOOM);
1394 DBG_ASSERT(pDlg, "Dialogdiet fail!");
1395 }
1396
1397 pDlg->SetLimits( MINZOOM, MAXZOOM );
1398
1399 if( pDlg->Execute() != RET_CANCEL )
1400 pArgs = pDlg->GetOutputItemSet();
1401 }
1402 if( pArgs )
1403 {
1404 enum SvxZoomType eType = SVX_ZOOM_PERCENT;
1405 USHORT nZoomFactor = USHRT_MAX;
1406 if(SFX_ITEM_SET == pArgs->GetItemState(SID_ATTR_ZOOM, TRUE, &pItem))
1407 {
1408 eType = ((const SvxZoomItem *)pItem)->GetType();
1409 nZoomFactor = ((const SvxZoomItem *)pItem)->GetValue();
1410 }
1411 else if(SFX_ITEM_SET == pArgs->GetItemState(FN_PREVIEW_ZOOM, TRUE, &pItem))
1412 nZoomFactor = ((const SfxUInt16Item *)pItem)->GetValue();
1413 if(USHRT_MAX != nZoomFactor)
1414 SetZoom(eType, nZoomFactor);
1415 }
1416 delete pDlg;
1417 }
1418 break;
1419 case SID_ATTR_ZOOMSLIDER :
1420 {
1421 const SfxItemSet *pArgs = rReq.GetArgs();
1422 const SfxPoolItem* pItem;
1423
1424 if ( pArgs && SFX_ITEM_SET == pArgs->GetItemState(SID_ATTR_ZOOMSLIDER, TRUE, &pItem ) )
1425 {
1426 const USHORT nCurrentZoom = ((const SvxZoomSliderItem *)pItem)->GetValue();
1427 SetZoom( SVX_ZOOM_PERCENT, nCurrentZoom );
1428 }
1429 }
1430 break;
1431 case SID_ZOOM_IN:
1432 case SID_ZOOM_OUT:
1433 {
1434 enum SvxZoomType eType = SVX_ZOOM_PERCENT;
1435 const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1436 SetZoom(eType,
1437 lcl_GetNextZoomStep(pVOpt->GetZoom(), SID_ZOOM_IN == rReq.GetSlot()));
1438 }
1439 break;
1440 case FN_CHAR_LEFT:
1441 case FN_CHAR_RIGHT:
1442 case FN_LINE_UP:
1443 case FN_LINE_DOWN:
1444 {
1445 SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
1446 sal_uInt16 nNewSelectedPage;
1447 sal_uInt16 nNewStartPage;
1448 Point aNewStartPos;
1449 sal_Int16 nHoriMove = 0;
1450 sal_Int16 nVertMove = 0;
1451 switch(rReq.GetSlot())
1452 {
1453 case FN_CHAR_LEFT: nHoriMove = -1; break;
1454 case FN_CHAR_RIGHT: nHoriMove = 1; break;
1455 case FN_LINE_UP: nVertMove = -1; break;
1456 case FN_LINE_DOWN: nVertMove = 1; break;
1457 }
1458 pPagePrevwLay->CalcStartValuesForSelectedPageMove( nHoriMove, nVertMove,
1459 nNewSelectedPage, nNewStartPage, aNewStartPos );
1460 if ( aViewWin.SelectedPage() != nNewSelectedPage )
1461 {
1462 if ( pPagePrevwLay->IsPageVisible( nNewSelectedPage ) )
1463 {
1464 pPagePrevwLay->MarkNewSelectedPage( nNewSelectedPage );
1465 // OD 19.02.2003 #107369# - adjust position at vertical scrollbar.
1466 SetVScrollbarThumbPos( nNewSelectedPage );
1467 bRefresh = false;
1468 }
1469 else
1470 {
1471 aViewWin.SetSelectedPage( nNewSelectedPage );
1472 aViewWin.SetSttPage( nNewStartPage );
1473 int nRet = ChgPage( SwPagePreViewWin::MV_SELPAGE, TRUE );
1474 bRefresh = 0 != nRet;
1475 }
1476 GetViewShell()->ShowPreViewSelection( nNewSelectedPage );
1477 // OD 24.03.2003 #108282# - invalidate page status.
1478 static USHORT __READONLY_DATA aInval[] =
1479 {
1480 FN_STAT_PAGE, 0
1481 };
1482 SfxBindings& rBindings = GetViewFrame()->GetBindings();
1483 rBindings.Invalidate( aInval );
1484 rReq.Done();
1485 }
1486 else
1487 {
1488 bRefresh = false;
1489 }
1490 break;
1491 }
1492 case FN_PAGEUP:
1493 case FN_PAGEDOWN:
1494 {
1495 _ExecPgUpAndPgDown( rReq.GetSlot() == FN_PAGEUP, &rReq );
1496 break;
1497 }
1498 case FN_START_OF_LINE:
1499 case FN_START_OF_DOCUMENT:
1500 aViewWin.SetSelectedPage( 1 );
1501 eMvMode = SwPagePreViewWin::MV_DOC_STT; bRetVal = TRUE; goto MOVEPAGE;
1502 case FN_END_OF_LINE:
1503 case FN_END_OF_DOCUMENT:
1504 aViewWin.SetSelectedPage( mnPageCount );
1505 eMvMode = SwPagePreViewWin::MV_DOC_END; bRetVal = TRUE; goto MOVEPAGE;
1506 MOVEPAGE:
1507 {
1508 int nRet = ChgPage( eMvMode, TRUE );
1509 // return value fuer Basic
1510 if(bRetVal)
1511 rReq.SetReturnValue(SfxBoolItem(rReq.GetSlot(), nRet == 0));
1512
1513 bRefresh = 0 != nRet;
1514 rReq.Done();
1515 }
1516 break;
1517
1518 case FN_PRINT_PAGEPREVIEW:
1519 {
1520 const SwPagePreViewPrtData* pPPVPD = aViewWin.GetViewShell()->GetDoc()->GetPreViewPrtData();
1521 // die Sache mit der Orientation
1522 if(pPPVPD)
1523 {
1524 SfxPrinter* pPrinter = GetPrinter( TRUE );
1525 if((pPrinter->GetOrientation() == ORIENTATION_LANDSCAPE)
1526 != pPPVPD->GetLandscape())
1527 pPrinter->SetOrientation(pPPVPD->GetLandscape() ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT);
1528 }
1529 ::SetAppPrintOptions( aViewWin.GetViewShell(), FALSE );
1530 bNormalPrint = FALSE;
1531 USHORT nPrtSlot = SID_PRINTDOC;
1532 rReq.SetSlot( nPrtSlot );
1533 SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() );
1534 rReq.SetSlot( FN_PRINT_PAGEPREVIEW );
1535 return;
1536 }
1537 case FN_PREVIEW_PRINT_OPTIONS :
1538 {
1539 SwPreviewPrintOptionsDialog aDlg(aViewWin, *this);
1540 aDlg.Execute();
1541 }
1542 break;
1543 case SID_PRINTDOCDIRECT:
1544 case SID_PRINTDOC:
1545 ::SetAppPrintOptions( aViewWin.GetViewShell(), FALSE );
1546 bNormalPrint = TRUE;
1547 SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() );
1548 return;
1549 case FN_CLOSE_PAGEPREVIEW:
1550 case SID_PRINTPREVIEW:
1551 // print preview is now always in the same frame as the tab view
1552 // -> always switch this frame back to normal view
1553 // (ScTabViewShell ctor reads stored view data)
1554 GetViewFrame()->GetDispatcher()->Execute( SID_VIEWSHELL0, 0, 0, SFX_CALLMODE_ASYNCHRON );
1555 break;
1556 case FN_INSERT_BREAK:
1557 {
1558 USHORT nSelPage = aViewWin.SelectedPage();
1559 //if a dummy page is selected (e.g. a non-existing right/left page)
1560 //the direct neighbor is used
1561 if(GetViewShell()->IsDummyPage( nSelPage ) && GetViewShell()->IsDummyPage( --nSelPage ))
1562 nSelPage +=2;
1563 SetNewPage( nSelPage );
1564 SfxViewFrame *pTmpFrm = GetViewFrame();
1565 pTmpFrm->GetBindings().Execute( SID_VIEWSHELL0, NULL, 0,
1566 SFX_CALLMODE_ASYNCHRON );
1567 }
1568 break;
1569 default:
1570 ASSERT(!this, falscher Dispatcher);
1571 return;
1572 }
1573
1574 if( bRefresh )
1575 aViewWin.Invalidate();
1576 }
1577
1578 /*--------------------------------------------------------------------
1579 Beschreibung:
1580 --------------------------------------------------------------------*/
1581
1582
1583 void SwPagePreView::GetState( SfxItemSet& rSet )
1584 {
1585 SfxWhichIter aIter(rSet);
1586 BYTE nRow = 1;
1587 USHORT nWhich = aIter.FirstWhich();
1588 ASSERT(nWhich, leeres Set);
1589 SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
1590 //#106746# zoom has to be disabled if Accessibility support is switched on
1591 BOOL bZoomEnabled = !Application::GetSettings().GetMiscSettings().GetEnableATToolSupport();
1592
1593 while(nWhich)
1594 {
1595 switch(nWhich)
1596 {
1597 case FN_START_OF_DOCUMENT:
1598 {
1599 if ( pPagePrevwLay->IsPageVisible( 1 ) )
1600 rSet.DisableItem(nWhich);
1601 break;
1602 }
1603 case FN_END_OF_DOCUMENT:
1604 {
1605 if ( pPagePrevwLay->IsPageVisible( mnPageCount ) )
1606 rSet.DisableItem(nWhich);
1607 break;
1608 }
1609 case FN_PAGEUP:
1610 {
1611 if( pPagePrevwLay->GetWinPagesScrollAmount( -1 ) == 0 )
1612 rSet.DisableItem(nWhich);
1613 break;
1614 }
1615 case FN_PAGEDOWN:
1616 {
1617 if( pPagePrevwLay->GetWinPagesScrollAmount( 1 ) == 0 )
1618 rSet.DisableItem(nWhich);
1619 break;
1620 }
1621
1622 case FN_STAT_PAGE:
1623 {
1624 String aStr( sPageStr );
1625 aViewWin.GetStatusStr( aStr, mnPageCount );
1626 rSet.Put( SfxStringItem( nWhich, aStr) );
1627 }
1628 break;
1629
1630 case SID_ATTR_ZOOM:
1631 case FN_STAT_ZOOM:
1632 {
1633 if(bZoomEnabled)
1634 {
1635 const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1636 SvxZoomItem aZoom((SvxZoomType)pVOpt->GetZoomType(),
1637 pVOpt->GetZoom());
1638 aZoom.SetValueSet(
1639 SVX_ZOOM_ENABLE_50|
1640 SVX_ZOOM_ENABLE_75|
1641 SVX_ZOOM_ENABLE_100|
1642 SVX_ZOOM_ENABLE_150|
1643 SVX_ZOOM_ENABLE_200);
1644 rSet.Put( aZoom );
1645 }
1646 else
1647 rSet.DisableItem(nWhich);
1648 }
1649 break;
1650 case SID_ATTR_ZOOMSLIDER :
1651 {
1652 if(bZoomEnabled)
1653 {
1654 const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1655 const USHORT nCurrentZoom = pVOpt->GetZoom();
1656 SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM, MAXZOOM );
1657 aZoomSliderItem.AddSnappingPoint( 100 );
1658 rSet.Put( aZoomSliderItem );
1659 }
1660 else
1661 rSet.DisableItem(nWhich);
1662 }
1663 break;
1664 case FN_PREVIEW_ZOOM:
1665 {
1666 if(bZoomEnabled)
1667 {
1668 const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1669 rSet.Put(SfxUInt16Item(nWhich, pVOpt->GetZoom()));
1670 }
1671 else
1672 rSet.DisableItem(nWhich);
1673 }
1674 break;
1675 case SID_ZOOM_IN:
1676 case SID_ZOOM_OUT:
1677 {
1678 const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1679 if(!bZoomEnabled || (SID_ZOOM_OUT == nWhich && pVOpt->GetZoom() >= MAX_PREVIEW_ZOOM)||
1680 (SID_ZOOM_IN == nWhich && pVOpt->GetZoom() <= MIN_PREVIEW_ZOOM))
1681 {
1682 rSet.DisableItem(nWhich);
1683 }
1684 }
1685 break;
1686 case FN_SHOW_MULTIPLE_PAGES:
1687 //should never be disabled
1688 break;
1689 case FN_SHOW_BOOKVIEW:
1690 {
1691 BOOL b = GetViewShell()->GetViewOptions()->IsPagePrevBookview();
1692 rSet.Put(SfxBoolItem(nWhich, b));
1693 }
1694 break;
1695
1696 case FN_SHOW_TWO_PAGES:
1697 if( 2 == aViewWin.GetCol() && nRow == aViewWin.GetRow() )
1698 rSet.DisableItem( nWhich );
1699 break;
1700
1701 case FN_PRINT_PAGEPREVIEW:
1702 // hat den gleichen Status wie das normale Drucken
1703 {
1704 const SfxPoolItem* pItem;
1705 SfxItemSet aSet( *rSet.GetPool(), SID_PRINTDOC, SID_PRINTDOC );
1706 GetSlotState( SID_PRINTDOC, SfxViewShell::GetInterface(), &aSet );
1707 if( SFX_ITEM_DISABLED == aSet.GetItemState( SID_PRINTDOC,
1708 FALSE, &pItem ))
1709 rSet.DisableItem( nWhich );
1710 else if( SFX_ITEM_SET == aSet.GetItemState( SID_PRINTDOC,
1711 FALSE, &pItem ))
1712 {
1713 ((SfxPoolItem*)pItem)->SetWhich( FN_PRINT_PAGEPREVIEW );
1714 rSet.Put( *pItem );
1715 }
1716 }
1717 break;
1718
1719 case SID_PRINTPREVIEW:
1720 rSet.Put( SfxBoolItem( nWhich, TRUE ) );
1721 break;
1722
1723 case SID_PRINTDOC:
1724 case SID_PRINTDOCDIRECT:
1725 GetSlotState( nWhich, SfxViewShell::GetInterface(), &rSet );
1726 break;
1727 }
1728 nWhich = aIter.NextWhich();
1729 }
1730 }
1731
1732 /*--------------------------------------------------------------------
1733 Beschreibung:
1734 --------------------------------------------------------------------*/
1735
1736
1737 void SwPagePreView::StateUndo(SfxItemSet& rSet)
1738 {
1739 SfxWhichIter aIter(rSet);
1740 USHORT nWhich = aIter.FirstWhich();
1741
1742 while (nWhich)
1743 {
1744 rSet.DisableItem(nWhich);
1745 nWhich = aIter.NextWhich();
1746 }
1747 }
1748
1749 /*--------------------------------------------------------------------
1750 Beschreibung:
1751 --------------------------------------------------------------------*/
1752
1753
1754 void SwPagePreView::Init(const SwViewOption * pPrefs)
1755 {
1756 if ( GetViewShell()->HasDrawView() )
1757 GetViewShell()->GetDrawView()->SetAnimationEnabled( FALSE );
1758
1759 bNormalPrint = TRUE;
1760
1761 // Die DocSize erfragen und verarbeiten. Ueber die Handler konnte
1762 // die Shell nicht gefunden werden, weil die Shell innerhalb CTOR-Phase
1763 // nicht in der SFX-Verwaltung bekannt ist.
1764
1765 if( !pPrefs )
1766 pPrefs = SW_MOD()->GetUsrPref(FALSE);
1767
1768 // die Felder aktualisieren
1769 // ACHTUNG: hochcasten auf die EditShell, um die SS zu nutzen.
1770 // In den Methoden wird auf die akt. Shell abgefragt!
1771 SwEditShell* pESh = (SwEditShell*)GetViewShell();
1772 BOOL bIsModified = pESh->IsModified();
1773
1774
1775 SwViewOption aOpt( *pPrefs );
1776 aOpt.SetPagePreview(TRUE);
1777 aOpt.SetTab( FALSE );
1778 aOpt.SetBlank( FALSE );
1779 aOpt.SetHardBlank( FALSE );
1780 aOpt.SetParagraph( FALSE );
1781 aOpt.SetLineBreak( FALSE );
1782 aOpt.SetPageBreak( FALSE );
1783 aOpt.SetColumnBreak( FALSE );
1784 aOpt.SetSoftHyph( FALSE );
1785 aOpt.SetFldName( FALSE );
1786 aOpt.SetPostIts( FALSE );
1787 aOpt.SetShowHiddenChar( FALSE );
1788 aOpt.SetShowHiddenField( FALSE );
1789 aOpt.SetShowHiddenPara( FALSE );
1790 aOpt.SetViewHRuler( FALSE );
1791 aOpt.SetViewVRuler( FALSE );
1792 aOpt.SetGraphic( TRUE );
1793 aOpt.SetTable( TRUE );
1794 aOpt.SetSnap( FALSE );
1795 aOpt.SetGridVisible( FALSE );
1796 GetViewShell()->ApplyViewOptions( aOpt );
1797 GetViewShell()->ApplyAccessiblityOptions(SW_MOD()->GetAccessibilityOptions());
1798
1799 // OD 09.01.2003 #i6467# - adjust view shell option to the same as for print
1800 SwPrtOptions aPrintOptions( GetViewFrame()->GetObjectShell()->GetTitle(0) );
1801 SwView::MakeOptions( 0, aPrintOptions, 0, 0, false, 0, 0 );
1802 GetViewShell()->AdjustOptionsForPagePreview( aPrintOptions );
1803
1804 IDocumentSettingAccess* pIDSA = pESh->getIDocumentSettingAccess();
1805 if( pIDSA->get(IDocumentSettingAccess::BROWSE_MODE))
1806 {
1807 pIDSA->set(IDocumentSettingAccess::BROWSE_MODE, false);
1808 pESh->CheckBrowseView( TRUE );
1809 }
1810
1811 GetViewShell()->CalcLayout();
1812 DocSzChgd( GetViewShell()->GetDocSize() );
1813
1814 if( !bIsModified )
1815 pESh->ResetModified();
1816
1817 pVScrollbar->ExtendedShow(pPrefs->IsViewVScrollBar());
1818 pHScrollbar->ExtendedShow(pPrefs->IsViewHScrollBar());
1819 pScrollFill->Show(pPrefs->IsViewVScrollBar() && pPrefs->IsViewHScrollBar());
1820 }
1821
1822
1823 /*--------------------------------------------------------------------
1824 Beschreibung:
1825 --------------------------------------------------------------------*/
1826
1827
1828 SwPagePreView::SwPagePreView(SfxViewFrame *pViewFrame, SfxViewShell* pOldSh):
1829 SfxViewShell( pViewFrame, SWVIEWFLAGS ),
1830 aViewWin( &pViewFrame->GetWindow(), *this ),
1831 nNewPage(USHRT_MAX),
1832 pHScrollbar(0),
1833 pVScrollbar(0),
1834 pPageUpBtn(0),
1835 pPageDownBtn(0),
1836 pScrollFill(new ScrollBarBox( &pViewFrame->GetWindow(),
1837 pViewFrame->GetFrame()->GetParentFrame() ? 0 : WB_SIZEABLE )),
1838 mnPageCount( 0 ),
1839 // OD 09.01.2003 #106334#
1840 mbResetFormDesignMode( false ),
1841 mbFormDesignModeToReset( false )
1842 {
1843 SetName(String::CreateFromAscii("PageView" ));
1844 SetWindow( &aViewWin );
1845 SetHelpId(SW_PAGEPREVIEW);
1846 _CreateScrollbar( TRUE );
1847 _CreateScrollbar( FALSE );
1848
1849 SfxObjectShell* pObjShell = pViewFrame->GetObjectShell();
1850 if ( !pOldSh )
1851 {
1852 //Gibt es schon eine Sicht auf das Dokument?
1853 SfxViewFrame *pF = SfxViewFrame::GetFirst( pObjShell );
1854 if ( pF == pViewFrame )
1855 pF = SfxViewFrame::GetNext( *pF, pObjShell );
1856 if ( pF )
1857 pOldSh = pF->GetViewShell();
1858 }
1859
1860 ViewShell *pVS, *pNew;
1861
1862 if( pOldSh && pOldSh->IsA( TYPE( SwPagePreView ) ) )
1863 pVS = ((SwPagePreView*)pOldSh)->GetViewShell();
1864 else
1865 {
1866 if( pOldSh && pOldSh->IsA( TYPE( SwView ) ) )
1867 {
1868 pVS = ((SwView*)pOldSh)->GetWrtShellPtr();
1869 // save the current ViewData of the previous SwView
1870 pOldSh->WriteUserData( sSwViewData, FALSE );
1871 }
1872 else
1873 pVS = GetDocShell()->GetWrtShell();
1874 if( pVS )
1875 {
1876 // setze die akt. Seite als die erste
1877 USHORT nPhysPg, nVirtPg;
1878 ((SwCrsrShell*)pVS)->GetPageNum( nPhysPg, nVirtPg, /*FALSE*/TRUE, FALSE );
1879 if( 1 != aViewWin.GetCol() && 1 == nPhysPg )
1880 --nPhysPg;
1881 aViewWin.SetSttPage( nPhysPg );
1882 }
1883 }
1884
1885 // OD 09.01.2003 #106334# - for form shell remember design mode of draw view
1886 // of previous view shell
1887 if ( pVS && pVS->HasDrawView() )
1888 {
1889 mbResetFormDesignMode = true;
1890 mbFormDesignModeToReset = pVS->GetDrawView()->IsDesignMode();
1891 }
1892
1893 if( pVS )
1894 pNew = new ViewShell( *pVS, &aViewWin, 0, VSHELLFLAG_ISPREVIEW );
1895 else
1896 pNew = new ViewShell(
1897 *((SwDocShell*)pViewFrame->GetObjectShell())->GetDoc(),
1898 &aViewWin, 0, 0, VSHELLFLAG_ISPREVIEW );
1899
1900 aViewWin.SetViewShell( pNew );
1901 pNew->SetSfxViewShell( this );
1902 Init();
1903 }
1904
1905
1906 /*--------------------------------------------------------------------
1907 Beschreibung:
1908 --------------------------------------------------------------------*/
1909
1910
1911 SwPagePreView::~SwPagePreView()
1912 {
1913 SetWindow( 0 );
1914
1915 delete pScrollFill;
1916 delete pHScrollbar;
1917 delete pVScrollbar;
1918 delete pPageUpBtn;
1919 delete pPageDownBtn;
1920
1921 /* SfxObjectShell* pDocSh = GetDocShell();
1922 TypeId aType = TYPE( SfxTopViewFrame );
1923
1924 for( SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pDocSh, aType );
1925 pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, pDocSh, aType ) )
1926 if( pFrame != GetViewFrame() )
1927 {
1928 // es gibt noch eine weitere Sicht auf unser Dokument, also
1929 // aktiviere dieses
1930 pFrame->GetFrame()->Appear();
1931 break;
1932 }
1933 */}
1934
1935 /*--------------------------------------------------------------------
1936 Beschreibung:
1937 --------------------------------------------------------------------*/
1938
1939
1940 SwDocShell* SwPagePreView::GetDocShell()
1941 {
1942 return PTR_CAST(SwDocShell, GetViewFrame()->GetObjectShell());
1943 }
1944
1945 /*--------------------------------------------------------------------
1946 Beschreibung:
1947 --------------------------------------------------------------------*/
1948
1949
1950 int SwPagePreView::_CreateScrollbar( BOOL bHori )
1951 {
1952 Window *pMDI = &GetViewFrame()->GetWindow();
1953 SwScrollbar** ppScrollbar = bHori ? &pHScrollbar : &pVScrollbar;
1954
1955 ASSERT( !*ppScrollbar, "vorher abpruefen!" )
1956
1957 if( !bHori )
1958 {
1959
1960 pPageUpBtn = new ImageButton(pMDI, SW_RES( BTN_PAGEUP ) );
1961 pPageUpBtn->SetHelpId(FN_PAGEUP);
1962 pPageDownBtn = new ImageButton(pMDI, SW_RES( BTN_PAGEDOWN ) );
1963 pPageDownBtn->SetHelpId(FN_PAGEDOWN);
1964 Link aLk( LINK( this, SwPagePreView, BtnPage ) );
1965 pPageUpBtn->SetClickHdl( aLk );
1966 pPageDownBtn->SetClickHdl( aLk );
1967 pPageUpBtn->Show();
1968 pPageDownBtn->Show();
1969 }
1970
1971 *ppScrollbar = new SwScrollbar( pMDI, bHori );
1972
1973 ScrollDocSzChg();
1974 (*ppScrollbar)->EnableDrag( TRUE );
1975 (*ppScrollbar)->SetEndScrollHdl( LINK( this, SwPagePreView, EndScrollHdl ));
1976
1977
1978 (*ppScrollbar)->SetScrollHdl( LINK( this, SwPagePreView, ScrollHdl ));
1979
1980 InvalidateBorder();
1981 (*ppScrollbar)->ExtendedShow();
1982 return 1;
1983 }
1984
1985 /*--------------------------------------------------------------------
1986 Beschreibung:
1987 --------------------------------------------------------------------*/
1988
1989
1990
1991 /*--------------------------------------------------------------------
1992 Beschreibung:
1993 --------------------------------------------------------------------*/
1994
1995 /*
1996 * Button-Handler
1997 */
1998 IMPL_LINK_INLINE_START( SwPagePreView, BtnPage, Button *, pButton )
1999 {
2000 // OD 04.03.2003 #107369# - use new helper method to perform page up
2001 // respectively page down.
2002 _ExecPgUpAndPgDown( pButton == pPageUpBtn );
2003 return 0;
2004 }
2005 IMPL_LINK_INLINE_END( SwPagePreView, BtnPage, Button *, pButton )
2006
2007 /*--------------------------------------------------------------------
2008 Beschreibung:
2009 --------------------------------------------------------------------*/
2010
2011
2012 int SwPagePreView::ChgPage( int eMvMode, int bUpdateScrollbar )
2013 {
2014 Rectangle aPixVisArea( aViewWin.LogicToPixel( aVisArea ) );
2015 int bChg = aViewWin.MovePage( eMvMode ) ||
2016 eMvMode == SwPagePreViewWin::MV_CALC ||
2017 eMvMode == SwPagePreViewWin::MV_NEWWINSIZE;
2018 aVisArea = aViewWin.PixelToLogic( aPixVisArea );
2019
2020 if( bChg )
2021 {
2022 // Statusleiste updaten
2023 String aStr( sPageStr );
2024 aViewWin.GetStatusStr( aStr, mnPageCount );
2025 SfxBindings& rBindings = GetViewFrame()->GetBindings();
2026
2027 if( bUpdateScrollbar )
2028 {
2029 ScrollViewSzChg();
2030
2031 static USHORT __READONLY_DATA aInval[] =
2032 {
2033 FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT,
2034 FN_PAGEUP, FN_PAGEDOWN, 0
2035 };
2036 rBindings.Invalidate( aInval );
2037 }
2038 rBindings.SetState( SfxStringItem( FN_STAT_PAGE, aStr ) );
2039 }
2040 return bChg;
2041 }
2042
2043
2044 /* \f */
2045 /*--------------------------------------------------------------------
2046 Beschreibung:
2047 --------------------------------------------------------------------*/
2048
2049
2050 // ab hier alles aus der SwView uebernommen
2051
2052
2053 void SwPagePreView::CalcAndSetBorderPixel( SvBorder &rToFill, BOOL /*bInner*/ )
2054 {
2055 // const long nAdd = bInner ? 0 : ScrollBar::GetWindowOverlapPixel();
2056 const StyleSettings &rSet = aViewWin.GetSettings().GetStyleSettings();
2057 const long nTmp = rSet.GetScrollBarSize();// - nAdd;
2058 if ( pVScrollbar->IsVisible( FALSE ))
2059 rToFill.Right() = nTmp;
2060 if ( pHScrollbar->IsVisible( FALSE ) )
2061 rToFill.Bottom() = nTmp;
2062 SetBorderPixel( rToFill );
2063 }
2064
2065 /*--------------------------------------------------------------------
2066 Beschreibung:
2067 --------------------------------------------------------------------*/
2068
2069
2070 void SwPagePreView::InnerResizePixel( const Point &rOfst, const Size &rSize )
2071 {
2072 SvBorder aBorder;
2073 CalcAndSetBorderPixel( aBorder, TRUE );
2074 Rectangle aRect( rOfst, rSize );
2075 aRect += aBorder;
2076 ViewResizePixel( aViewWin, aRect.TopLeft(), aRect.GetSize(),
2077 aViewWin.GetOutputSizePixel(),
2078 TRUE,
2079 *pVScrollbar, *pHScrollbar, pPageUpBtn, pPageDownBtn, 0,
2080 *pScrollFill );
2081
2082 //EditWin niemals einstellen!
2083 //VisArea niemals einstellen!
2084 }
2085
2086 /*--------------------------------------------------------------------
2087 Beschreibung:
2088 --------------------------------------------------------------------*/
2089
2090
2091 void SwPagePreView::OuterResizePixel( const Point &rOfst, const Size &rSize )
2092 {
2093 SvBorder aBorder;
2094 CalcAndSetBorderPixel( aBorder, FALSE );
2095 ViewResizePixel( aViewWin, rOfst, rSize, aViewWin.GetOutputSizePixel(),
2096 FALSE, *pVScrollbar,
2097 *pHScrollbar, pPageUpBtn, pPageDownBtn, 0, *pScrollFill );
2098
2099 //EditWin niemals einstellen!
2100
2101 Size aTmpSize( aViewWin.GetOutputSizePixel() );
2102 Point aBottomRight( aViewWin.PixelToLogic( Point( aTmpSize.Width(), aTmpSize.Height() ) ) );
2103 SetVisArea( Rectangle( Point(), aBottomRight ) );
2104
2105 //Aufruf der DocSzChgd-Methode der Scrollbars ist noetig, da vom maximalen
2106 //Scrollrange immer die halbe Hoehe der VisArea abgezogen wird.
2107 if ( pVScrollbar )
2108 ScrollDocSzChg();
2109 }
2110
2111 /*--------------------------------------------------------------------
2112 Beschreibung:
2113 --------------------------------------------------------------------*/
2114
2115
2116 void SwPagePreView::SetVisArea( const Rectangle &rRect, BOOL bUpdateScrollbar )
2117 {
2118 const Point aTopLeft(AlignToPixel(rRect.TopLeft()));
2119 const Point aBottomRight(AlignToPixel(rRect.BottomRight()));
2120 Rectangle aLR(aTopLeft,aBottomRight);
2121
2122 if(aLR == aVisArea)
2123 return;
2124 // keine negative Position, keine neg. Groesse
2125
2126 if(aLR.Top() < 0)
2127 {
2128 aLR.Bottom() += Abs(aLR.Top());
2129 aLR.Top() = 0;
2130 }
2131
2132 if(aLR.Left() < 0)
2133 {
2134 aLR.Right() += Abs(aLR.Left());
2135 aLR.Left() = 0;
2136 }
2137 if(aLR.Right() < 0) aLR.Right() = 0;
2138 if(aLR.Bottom() < 0) aLR.Bottom() = 0;
2139 if(aLR == aVisArea ||
2140 // JP 29.10.97: Bug 45173 - Leeres Rechteck nicht beachten
2141 ( 0 == aLR.Bottom() - aLR.Top() && 0 == aLR.Right() - aLR.Left() ) )
2142 return;
2143
2144 if( aLR.Left() > aLR.Right() || aLR.Top() > aLR.Bottom() )
2145 return;
2146
2147 //Bevor die Daten veraendert werden ggf. ein Update rufen. Dadurch wird
2148 //sichergestellt, da? anliegende Paints korrekt in Dokumentkoordinaten
2149 //umgerechnet werden.
2150 //Vorsichtshalber tun wir das nur wenn an der Shell eine Action laeuft,
2151 //denn dann wir nicht wirklich gepaintet sondern die Rechtecke werden
2152 //lediglich (in Dokumentkoordinaten) vorgemerkt.
2153 if( GetViewShell()->ActionPend() )
2154 aViewWin.Update();
2155
2156 // setze am View-Win die aktuelle Size
2157 aVisArea = aLR;
2158 aViewWin.SetWinSize( aLR.GetSize() );
2159 // OD 18.12.2002 #103492# - use new mode
2160 ChgPage( SwPagePreViewWin::MV_NEWWINSIZE, bUpdateScrollbar );
2161
2162 aViewWin.Invalidate();
2163 }
2164
2165 /*--------------------------------------------------------------------
2166 Beschreibung:
2167 --------------------------------------------------------------------*/
2168
2169
2170 IMPL_LINK( SwPagePreView, ScrollHdl, SwScrollbar *, pScrollbar )
2171 {
2172 if(!GetViewShell())
2173 return 0;
2174 if( !pScrollbar->IsHoriScroll() &&
2175 pScrollbar->GetType() == SCROLL_DRAG &&
2176 Help::IsQuickHelpEnabled() &&
2177 GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow())
2178 {
2179 // wieviele Seiten scrollen ??
2180 String sStateStr(sPageStr);
2181 USHORT nThmbPos = (USHORT)pScrollbar->GetThumbPos();
2182 if( 1 == aViewWin.GetCol() || !nThmbPos )
2183 ++nThmbPos;
2184 sStateStr += String::CreateFromInt32( nThmbPos );
2185 Point aPos = pScrollbar->GetParent()->OutputToScreenPixel(
2186 pScrollbar->GetPosPixel());
2187 aPos.Y() = pScrollbar->OutputToScreenPixel(pScrollbar->GetPointerPosPixel()).Y();
2188 Size aSize = pScrollbar->GetSizePixel();
2189 Rectangle aRect;
2190 aRect.Left() = aPos.X() -8;
2191 aRect.Right() = aRect.Left();
2192 aRect.Top() = aPos.Y();
2193 aRect.Bottom() = aRect.Top();
2194
2195 Help::ShowQuickHelp(pScrollbar, aRect, sStateStr,
2196 QUICKHELP_RIGHT|QUICKHELP_VCENTER);
2197
2198 }
2199 else
2200 EndScrollHdl( pScrollbar );
2201 return 0;
2202 }
2203
2204 /*--------------------------------------------------------------------
2205 Beschreibung:
2206 --------------------------------------------------------------------*/
2207
2208
2209 IMPL_LINK( SwPagePreView, EndScrollHdl, SwScrollbar *, pScrollbar )
2210 {
2211 if(!GetViewShell())
2212 return 0;
2213
2214 // OD 04.03.2003 #107369# - boolean to avoid unnecessary invalidation of the window.
2215 bool bInvalidateWin = true;
2216
2217 if( !pScrollbar->IsHoriScroll() ) // scroll vertically
2218 {
2219 if ( Help::IsQuickHelpEnabled() )
2220 Help::ShowQuickHelp(pScrollbar, Rectangle(), aEmptyStr, 0);
2221 if ( GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow() )
2222 {
2223 // wieviele Seiten scrollen ??
2224 USHORT nThmbPos = (USHORT)pScrollbar->GetThumbPos();
2225 // OD 05.12.2002 #103492# - adjust to new preview functionality
2226 if( nThmbPos != aViewWin.SelectedPage() )
2227 {
2228 // OD 17.01.2003 #103492# - consider case that page <nThmbPos>
2229 // is already visible
2230 SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
2231 if ( pPagePrevwLay->IsPageVisible( nThmbPos ) )
2232 {
2233 pPagePrevwLay->MarkNewSelectedPage( nThmbPos );
2234 // OD 04.03.2003 #107369# - invalidation of window is unnecessary
2235 bInvalidateWin = false;
2236 }
2237 else
2238 {
2239 // OD 17.01.2003 #103492# - consider whether layout columns
2240 // fit or not.
2241 if ( !pPagePrevwLay->DoesPreviewLayoutColsFitIntoWindow() )
2242 {
2243 aViewWin.SetSttPage( nThmbPos );
2244 aViewWin.SetSelectedPage( nThmbPos );
2245 ChgPage( SwPagePreViewWin::MV_SCROLL, FALSE );
2246 // OD 20.01.2003 #103492# - update scrollbars
2247 ScrollViewSzChg();
2248 }
2249 else
2250 {
2251 // OD 04.03.2003 #107369# - correct scroll amount
2252 const sal_Int16 nPageDiff = nThmbPos - aViewWin.SelectedPage();
2253 const sal_uInt16 nVisPages = aViewWin.GetRow() * aViewWin.GetCol();
2254 sal_Int16 nWinPagesToScroll = nPageDiff / nVisPages;
2255 if ( nPageDiff % nVisPages )
2256 {
2257 // decrease/increase number of preview pages to scroll
2258 nPageDiff < 0 ? --nWinPagesToScroll : ++nWinPagesToScroll;
2259 }
2260 aViewWin.SetSelectedPage( nThmbPos );
2261 aViewWin.Scroll( 0, pPagePrevwLay->GetWinPagesScrollAmount( nWinPagesToScroll ) );
2262 }
2263 }
2264 // OD 17.01.2003 #103492# - update accessibility
2265 GetViewShell()->ShowPreViewSelection( nThmbPos );
2266 }
2267 else
2268 {
2269 // OD 04.03.2003 #107369# - invalidation of window is unnecessary
2270 bInvalidateWin = false;
2271 }
2272 }
2273 else
2274 {
2275 long nThmbPos = pScrollbar->GetThumbPos();
2276 aViewWin.Scroll(0, nThmbPos - aViewWin.GetPaintedPreviewDocRect().Top());
2277 }
2278 }
2279 else
2280 {
2281 long nThmbPos = pScrollbar->GetThumbPos();
2282 aViewWin.Scroll(nThmbPos - aViewWin.GetPaintedPreviewDocRect().Left(), 0);
2283 }
2284 // OD 24.03.2003 #108282# - additional invalidate page status.
2285 static USHORT __READONLY_DATA aInval[] =
2286 {
2287 FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
2288 FN_STAT_PAGE, 0
2289 };
2290 SfxBindings& rBindings = GetViewFrame()->GetBindings();
2291 rBindings.Invalidate( aInval );
2292 // OD 04.03.2003 #107369# - control invalidation of window
2293 if ( bInvalidateWin )
2294 {
2295 aViewWin.Invalidate();
2296 }
2297 return 0;
2298 }
2299 /*--------------------------------------------------------------------
2300 Beschreibung:
2301 --------------------------------------------------------------------*/
2302
2303
2304 Point SwPagePreView::AlignToPixel(const Point &rPt) const
2305 {
2306 return aViewWin.PixelToLogic( aViewWin.LogicToPixel( rPt ) );
2307 }
2308
2309 /*--------------------------------------------------------------------
2310 Beschreibung:
2311 --------------------------------------------------------------------*/
2312
2313
2314 void SwPagePreView::DocSzChgd( const Size &rSz )
2315 {
2316 if( aDocSz == rSz )
2317 return;
2318
2319 aDocSz = rSz;
2320
2321 // die neue Anzahl von Seiten bestimmen
2322 USHORT nNewCnt = GetViewShell()->GetNumPages();
2323 if( nNewCnt == mnPageCount )
2324 return;
2325
2326 // dann eine neue Startseite berechnen
2327 mnPageCount = nNewCnt;
2328 if( aVisArea.GetWidth() )
2329 {
2330 ChgPage( SwPagePreViewWin::MV_CALC, TRUE );
2331 ScrollDocSzChg();
2332
2333 aViewWin.Invalidate();
2334 }
2335 }
2336
2337 /*--------------------------------------------------------------------
2338 Beschreibung:
2339 --------------------------------------------------------------------*/
2340
2341
2342 void SwPagePreView::ScrollViewSzChg()
2343 {
2344 if(!GetViewShell())
2345 return ;
2346 if(pVScrollbar)
2347 {
2348 if(GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow())
2349 {
2350 //vertical scrolling by row
2351 // OD 04.12.2002 #103492# - adjust to new preview functionality
2352 USHORT nVisPages = aViewWin.GetRow() * aViewWin.GetCol();
2353 pVScrollbar->SetVisibleSize( nVisPages );
2354 // OD 19.02.2003 #107369# - set selected page as scroll bar position,
2355 // if it is visible.
2356 SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
2357 if ( pPagePrevwLay->IsPageVisible( aViewWin.SelectedPage() ) )
2358 {
2359 pVScrollbar->SetThumbPos( aViewWin.SelectedPage() );
2360 }
2361 else
2362 {
2363 pVScrollbar->SetThumbPos( aViewWin.GetSttPage() );
2364 }
2365 pVScrollbar->SetLineSize( aViewWin.GetCol() );
2366 pVScrollbar->SetPageSize( nVisPages );
2367 // calculate and set scrollbar range
2368 Range aScrollbarRange( 1, mnPageCount );
2369 // increase range by one, because left-top-corner is left blank.
2370 ++aScrollbarRange.Max();
2371 // OD 17.01.2003 #103492# - increase range in order to access all pages
2372 aScrollbarRange.Max() += ( nVisPages - 1 );
2373 pVScrollbar->SetRange( aScrollbarRange );
2374 }
2375 else //vertical scrolling by pixel
2376 {
2377 const Rectangle& rDocRect = aViewWin.GetPaintedPreviewDocRect();
2378 const Size& rPreviewSize =
2379 GetViewShell()->PagePreviewLayout()->GetPrevwDocSize();
2380 pVScrollbar->SetRangeMax(rPreviewSize.Height()) ;
2381 long nVisHeight = rDocRect.GetHeight();
2382 pVScrollbar->SetVisibleSize( nVisHeight );
2383 pVScrollbar->SetThumbPos( rDocRect.Top() );
2384 pVScrollbar->SetLineSize( nVisHeight / 10 );
2385 pVScrollbar->SetPageSize( nVisHeight / 2 );
2386 }
2387 }
2388 if(pHScrollbar)
2389 {
2390 const Rectangle& rDocRect = aViewWin.GetPaintedPreviewDocRect();
2391 const Size& rPreviewSize =
2392 GetViewShell()->PagePreviewLayout()->GetPrevwDocSize();
2393 long nVisWidth = 0;
2394 long nThumb = 0;
2395 Range aRange(0,0);
2396
2397 if(rDocRect.GetWidth() < rPreviewSize.Width())
2398 {
2399 nVisWidth = rDocRect.GetWidth();
2400 nThumb = rDocRect.Left();
2401 aRange = Range(0, rPreviewSize.Width());
2402 }
2403 pHScrollbar->SetRange( aRange );
2404 pHScrollbar->SetVisibleSize( nVisWidth );
2405 pHScrollbar->SetThumbPos( nThumb );
2406 pHScrollbar->SetLineSize( nVisWidth / 10 );
2407 pHScrollbar->SetPageSize( nVisWidth / 2 );
2408 }
2409 }
2410
2411 /*--------------------------------------------------------------------
2412 Beschreibung:
2413 --------------------------------------------------------------------*/
2414
2415
2416 void SwPagePreView::ScrollDocSzChg()
2417 {
2418 ScrollViewSzChg();
2419 }
2420
2421
2422 /* \f */
2423 /*--------------------------------------------------------------------
2424 Beschreibung:
2425 --------------------------------------------------------------------*/
2426
2427
2428 // alles zum Thema Drucken
2429
2430 USHORT SwPagePreView::Print( SfxProgress &rProgress, BOOL bIsAPI, PrintDialog *pDlg )
2431 {
2432 ViewShell* pSh = aViewWin.GetViewShell();
2433 SfxPrinter* pPrinter = GetPrinter();
2434 if( !pPrinter || !pPrinter->InitJob( &aViewWin,
2435 pSh->HasDrawView() && !bIsAPI && pSh->GetDrawView()->GetModel()->HasTransparentObjects() ))
2436 return ERRCODE_IO_ABORT;
2437
2438 SwWait aWait( *GetDocShell(), TRUE );
2439
2440 USHORT nRowCol = ( aViewWin.GetRow() << 8 ) +
2441 aViewWin.GetCol(); // Zeilen / DoppelSeiten
2442
2443 {
2444 // die Felder aktualisieren
2445 // ACHTUNG: hochcasten auf die EditShell, um die SS zu nutzen.
2446 // In den Methoden wird auf die akt. Shell abgefragt!
2447 SwEditShell* pESh = (SwEditShell*)pSh;
2448 SwDocStat aDocStat;
2449 BOOL bIsModified = pESh->IsModified();
2450
2451 pESh->StartAllAction();
2452 pESh->UpdateDocStat( aDocStat );
2453 pSh->UpdateFlds();
2454 pESh->EndAllAction();
2455
2456 if( !bIsModified )
2457 pESh->ResetModified();
2458 }
2459
2460 // Druckauftrag starten
2461 SfxObjectShell *pObjShell = GetViewFrame()->GetObjectShell();
2462 SwPrtOptions aOpts( pObjShell->GetTitle(0) );
2463
2464 BOOL bPrtPros;
2465 BOOL bPrtPros_RTL;
2466 SwView::MakeOptions( pDlg, aOpts, &bPrtPros, &bPrtPros_RTL, FALSE, GetPrinter(), GetDocShell()->GetDoc()->getPrintData() );
2467
2468 if( bNormalPrint )
2469 {
2470 if( bPrtPros )
2471 pSh->PrintProspect( aOpts, rProgress, bPrtPros_RTL );
2472 else
2473 pSh->Prt( aOpts, &rProgress );
2474 }
2475 else
2476 {
2477 const SwPagePreViewPrtData* pPPVPD = pSh->GetDoc()->GetPreViewPrtData();
2478 if( pPPVPD && pPPVPD->GetCol() && pPPVPD->GetRow() )
2479 {
2480 // Zeilen / Seiten
2481 nRowCol = ( pPPVPD->GetRow() << 8 ) + pPPVPD->GetCol();
2482 }
2483 else
2484 pPPVPD = 0;
2485 pSh->PrintPreViewPage( aOpts, nRowCol, rProgress, pPPVPD );
2486 }
2487
2488 return 0; // OK
2489 }
2490
2491 /*--------------------------------------------------------------------
2492 Beschreibung:
2493 --------------------------------------------------------------------*/
2494
2495
2496 SfxPrinter* SwPagePreView::GetPrinter( BOOL bCreate )
2497 {
2498 return aViewWin.GetViewShell()->getIDocumentDeviceAccess()->getPrinter( bCreate );
2499 }
2500
2501 /*--------------------------------------------------------------------
2502 Beschreibung:
2503 --------------------------------------------------------------------*/
2504
2505
2506 USHORT SwPagePreView::SetPrinter( SfxPrinter *pNew, USHORT nDiffFlags, bool )
2507 {
2508 ViewShell &rSh = *GetViewShell();
2509 SwEditShell &rESh = (SwEditShell&)rSh; //Buh...
2510 if( ( SFX_PRINTER_PRINTER | SFX_PRINTER_JOBSETUP ) & nDiffFlags )
2511 {
2512 rSh.getIDocumentDeviceAccess()->setPrinter( pNew, true, true );
2513 if( nDiffFlags & SFX_PRINTER_PRINTER )
2514 rESh.SetModified();
2515 }
2516 if ( ( nDiffFlags & SFX_PRINTER_OPTIONS ) == SFX_PRINTER_OPTIONS )
2517 ::SetPrinter( rSh.getIDocumentDeviceAccess(), pNew, FALSE );
2518
2519 const BOOL bChgOri = nDiffFlags & SFX_PRINTER_CHG_ORIENTATION ? TRUE : FALSE;
2520 const BOOL bChgSize= nDiffFlags & SFX_PRINTER_CHG_SIZE ? TRUE : FALSE;
2521 if ( bChgOri || bChgSize )
2522 {
2523 rESh.StartAllAction();
2524 if ( bChgOri )
2525 rSh.ChgAllPageOrientation( USHORT(pNew->GetOrientation()) );
2526 if ( bChgSize )
2527 {
2528 Size aSz( SvxPaperInfo::GetPaperSize( pNew ) );
2529 rSh.ChgAllPageSize( aSz );
2530 }
2531 if( !bNormalPrint )
2532 aViewWin.CalcWish( aViewWin.GetRow(), aViewWin.GetCol() );
2533 rESh.SetModified();
2534 rESh.EndAllAction();
2535
2536 static USHORT __READONLY_DATA aInval[] =
2537 {
2538 SID_ATTR_LONG_ULSPACE, SID_ATTR_LONG_LRSPACE,
2539 SID_RULER_BORDERS, SID_RULER_PAGE_POS, 0
2540 };
2541 #ifndef PRODUCT
2542 {
2543 const USHORT* pPtr = aInval + 1;
2544 do {
2545 ASSERT( *(pPtr - 1) < *pPtr, "falsche Sortierung!" );
2546 } while( *++pPtr );
2547 }
2548 #endif
2549
2550 GetViewFrame()->GetBindings().Invalidate(aInval);
2551 }
2552
2553 return 0;
2554 }
2555
2556 /*--------------------------------------------------------------------
2557 Beschreibung:
2558 --------------------------------------------------------------------*/
2559
2560
2561 SfxTabPage* SwPagePreView::CreatePrintOptionsPage( Window *pParent,
2562 const SfxItemSet &rOptions )
2563 {
2564 return ::CreatePrintOptionsPage( pParent, rOptions, !bNormalPrint );
2565 }
2566
2567 /*--------------------------------------------------------------------
2568 Beschreibung:
2569 --------------------------------------------------------------------*/
2570
2571
2572 PrintDialog* SwPagePreView::CreatePrintDialog( Window *pParent )
2573 {
2574 PrintDialog *pDlg = ::CreatePrintDialog( pParent, 1, 0 );
2575 pDlg->DisableRange( PRINTDIALOG_SELECTION );
2576 return pDlg;
2577 }
2578
2579 /*--------------------------------------------------------------------
2580 Beschreibung:
2581 --------------------------------------------------------------------*/
2582
2583
2584 // OD 18.12.2002 #103492# - no longer needed ??
2585 Size SwPagePreView::GetOptimalSizePixel() const
2586 {
2587 ASSERT( false, "overloaded virtual method <SwPagePreView::GetOptimalSizePixel()> needed ??" )
2588 return Size( -1, -1 );
2589 /*
2590 //JP 09.06.99: was wird hier errechnet ?????
2591 // ALT:
2592 // SfxApplicationWindow* pWin = SFX_APPWINDOW ;
2593 // Rectangle aRect = pWin->GetClientAreaPixel();
2594
2595 Window& rWin = GetViewFrame()->GetWindow();
2596 Rectangle aRect( Point(0, 0), rWin.GetOutputSizePixel() );
2597 Size aMaxSize( aRect.GetWidth(), aRect.GetHeight() );
2598 Size aInSize = rWin.GetOutputSizePixel();
2599 Size aOutSize = rWin.GetSizePixel();
2600 USHORT nXBorder = USHORT(aOutSize.Width() - aInSize.Width());
2601 USHORT nYBorder = USHORT(aOutSize.Height() - aInSize.Height());
2602 aMaxSize.Width() -= nXBorder;
2603 //'auf Verdacht' etwas vom Border abziehen (Menue)
2604 nYBorder -= (nYBorder - nXBorder) / 2;
2605 aMaxSize.Height() -= nYBorder;
2606 //mit der max. moeglichen Outputsize guenstigstes Verhaeltnis ausrechnen
2607 aViewWin.GetOptimalSize(aMaxSize);
2608 // Border wieder dazuzaehlen
2609 aMaxSize.Height() += nYBorder;
2610 aMaxSize.Width() += nXBorder;
2611 return aMaxSize;
2612 */
2613 }
2614
2615 /*--------------------------------------------------------------------
2616 Beschreibung:
2617 --------------------------------------------------------------------*/
2618
2619 // OD 12.12.2002 #103492#
2620 void SwPagePreViewWin::SetViewShell( ViewShell* pShell )
2621 {
2622 mpViewShell = pShell;
2623 if ( mpViewShell && mpViewShell->IsPreView() )
2624 {
2625 mpPgPrevwLayout = mpViewShell->PagePreviewLayout();
2626 }
2627 }
2628
2629 void SwPagePreViewWin::RepaintCoreRect( const SwRect& rRect )
2630 {
2631 // OD 2004-03-04 #i24183#
2632 if ( mpPgPrevwLayout->PreviewLayoutValid() )
2633 {
2634 mpPgPrevwLayout->Repaint( Rectangle( rRect.Pos(), rRect.SSize() ) );
2635 }
2636 }
2637
2638 /** method to adjust preview to a new zoom factor
2639
2640 OD 02.12.2002 #103492#
2641 OD 24.09.2003 #i19975# - also consider zoom type - adding parameter <_eZoomType>
2642 */
2643 void SwPagePreViewWin::AdjustPreviewToNewZoom( const sal_uInt16 _nZoomFactor,
2644 const SvxZoomType _eZoomType )
2645 {
2646 // OD 24.09.2003 #i19975# - consider zoom type
2647 if ( _eZoomType == SVX_ZOOM_WHOLEPAGE )
2648 {
2649 mnRow = 1;
2650 mnCol = 1;
2651 mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true );
2652 mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
2653 mnSttPage, maPaintedPreviewDocRect );
2654 SetSelectedPage( mnSttPage );
2655 SetPagePreview(mnRow, mnCol);
2656 maScale = GetMapMode().GetScaleX();
2657 }
2658 else if ( _nZoomFactor != 0 )
2659 {
2660 // calculate new scaling and set mapping mode appropriately.
2661 Fraction aNewScale( _nZoomFactor, 100 );
2662 MapMode aNewMapMode = GetMapMode();
2663 aNewMapMode.SetScaleX( aNewScale );
2664 aNewMapMode.SetScaleY( aNewScale );
2665 SetMapMode( aNewMapMode );
2666
2667 // calculate new start position for preview paint
2668 Size aNewWinSize = PixelToLogic( maPxWinSize );
2669 Point aNewPaintStartPos =
2670 mpPgPrevwLayout->GetPreviewStartPosForNewScale( aNewScale, maScale, aNewWinSize );
2671
2672 // remember new scaling and prepare preview paint
2673 // Note: paint of preview will be performed by a corresponding invalidate
2674 // due to property changes.
2675 maScale = aNewScale;
2676 mpPgPrevwLayout->Prepare( 0, aNewPaintStartPos, maPxWinSize,
2677 mnSttPage, maPaintedPreviewDocRect );
2678 }
2679
2680 }
2681 /* -----------------04.12.2002 10:46-----------------
2682 * pixel scrolling - horizontally always or vertically
2683 * when less than the desired number of rows fits into
2684 * the view
2685 * --------------------------------------------------*/
2686 void SwPagePreViewWin::Scroll(long nXMove, long nYMove, USHORT /*nFlags*/)
2687 {
2688 maPaintedPreviewDocRect.Move(nXMove, nYMove);
2689 mpPgPrevwLayout->Prepare( 0, maPaintedPreviewDocRect.TopLeft(),
2690 maPxWinSize, mnSttPage,
2691 maPaintedPreviewDocRect );
2692
2693 }
2694
2695 BOOL SwPagePreView::HandleWheelCommands( const CommandEvent& rCEvt )
2696 {
2697 BOOL bOk = FALSE;
2698 const CommandWheelData* pWData = rCEvt.GetWheelData();
2699 if( pWData && COMMAND_WHEEL_ZOOM == pWData->GetMode() )
2700 {
2701 if(!Application::GetSettings().GetMiscSettings().GetEnableATToolSupport())
2702 {
2703 USHORT nFactor = GetViewShell()->GetViewOptions()->GetZoom();
2704 const USHORT nOffset = 10;
2705 if( 0L > pWData->GetDelta() )
2706 {
2707 nFactor -= nOffset;
2708 if(nFactor < MIN_PREVIEW_ZOOM)
2709 nFactor = MIN_PREVIEW_ZOOM;
2710 }
2711 else
2712 {
2713 nFactor += nOffset;
2714 if(nFactor > MAX_PREVIEW_ZOOM)
2715 nFactor = MAX_PREVIEW_ZOOM;
2716 }
2717 SetZoom(SVX_ZOOM_PERCENT, nFactor);
2718 }
2719 bOk = TRUE;
2720 }
2721 else
2722 bOk = aViewWin.HandleScrollCommand( rCEvt, pHScrollbar, pVScrollbar );
2723 return bOk;
2724 }
2725
2726
2727 uno::Reference< ::com::sun::star::accessibility::XAccessible >
2728 SwPagePreViewWin::CreateAccessible()
2729 {
2730 vos::OGuard aGuard(Application::GetSolarMutex()); // this should have
2731 // happend already!!!
2732
2733 DBG_ASSERT( GetViewShell() != NULL, "We need a view shell" );
2734 return GetViewShell()->CreateAccessiblePreview();
2735 }
2736
2737 /* -----------------------------06.05.2002 13:18------------------------------
2738
2739 ---------------------------------------------------------------------------*/
2740 void SwPagePreView::ApplyAccessiblityOptions(SvtAccessibilityOptions& rAccessibilityOptions)
2741 {
2742 GetViewShell()->ApplyAccessiblityOptions(rAccessibilityOptions);
2743 }
2744 /* -----------------------------2002/06/26 14:30------------------------------
2745
2746 ---------------------------------------------------------------------------*/
2747 void SwPagePreView::ShowHScrollbar(sal_Bool bShow)
2748 {
2749 pHScrollbar->Show(bShow);
2750 InvalidateBorder();
2751 }
2752
2753 /* -----------------------------2002/06/26 14:30------------------------------
2754
2755 ---------------------------------------------------------------------------*/
2756 void SwPagePreView::ShowVScrollbar(sal_Bool bShow)
2757 {
2758 pVScrollbar->Show(bShow);
2759 InvalidateBorder();
2760 }
2761
2762 /* -----------------25.11.2002 16:36-----------------
2763 *
2764 * --------------------------------------------------*/
2765 void SwPagePreView::SetZoom(SvxZoomType eType, USHORT nFactor)
2766 {
2767 ViewShell& rSh = *GetViewShell();
2768 SwViewOption aOpt(*rSh.GetViewOptions());
2769 // OD 16.12.2002 #103492# - perform action only on changes of zoom or zoom type.
2770 if ( aOpt.GetZoom() != nFactor ||
2771 aOpt.GetZoomType() != eType )
2772 {
2773 aOpt.SetZoom(nFactor);
2774 aOpt.SetZoomType(eType);
2775 rSh.ApplyViewOptions( aOpt );
2776 lcl_InvalidateZoomSlots(GetViewFrame()->GetBindings());
2777 // OD 02.12.2002 #103492#
2778 // OD 24.09.2003 #i19975# - also consider zoom type
2779 aViewWin.AdjustPreviewToNewZoom( nFactor, eType );
2780 ScrollViewSzChg();
2781 }
2782 }
2783
2784 /** adjust position of vertical scrollbar
2785
2786 OD 19.02.2003 #107369
2787
2788 @author OD
2789 */
2790 void SwPagePreView::SetVScrollbarThumbPos( const sal_uInt16 _nNewThumbPos )
2791 {
2792 if ( pVScrollbar )
2793 {
2794 pVScrollbar->SetThumbPos( _nNewThumbPos );
2795 }
2796 }
vba interoperability for OOo