Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <sfx2/objface.hxx>
22 : #include <vcl/timer.hxx>
23 : #include <vcl/field.hxx>
24 : #include <vcl/fixed.hxx>
25 : #include <vcl/help.hxx>
26 : #include <vcl/cmdevt.hxx>
27 : #include <vcl/button.hxx>
28 : #include <svl/whiter.hxx>
29 : #include <svl/stritem.hxx>
30 : #include <svl/eitem.hxx>
31 : #include <sfx2/printer.hxx>
32 : #include <sfx2/progress.hxx>
33 : #include <sfx2/app.hxx>
34 : #include <sfx2/bindings.hxx>
35 : #include <sfx2/request.hxx>
36 : #include <sfx2/dispatch.hxx>
37 : #include <vcl/msgbox.hxx>
38 : #include <svx/stddlg.hxx>
39 : #include <editeng/paperinf.hxx>
40 : #include <svl/srchitem.hxx>
41 : #include <svx/svdview.hxx>
42 : #include <svx/dlgutil.hxx>
43 : #include <svx/zoomslideritem.hxx>
44 : #include <svx/svxids.hrc>
45 :
46 : #include <swwait.hxx>
47 : #include <globdoc.hxx>
48 : #include <wdocsh.hxx>
49 : #include <pvprtdat.hxx>
50 : #include <swmodule.hxx>
51 : #include <modcfg.hxx>
52 : #include <wrtsh.hxx>
53 : #include <docsh.hxx>
54 : #include <viewopt.hxx>
55 : #include <doc.hxx>
56 : #include <pview.hxx>
57 : #include <view.hxx>
58 : #include <textsh.hxx>
59 : #include <scroll.hxx>
60 : #include <prtopt.hxx>
61 : #include <docstat.hxx>
62 : #include <usrpref.hxx>
63 : #include <viewfunc.hxx>
64 :
65 : #include <helpid.h>
66 : #include <cmdid.h>
67 : #include <globals.hrc>
68 : #include <popup.hrc>
69 : #include <pview.hrc>
70 :
71 : #define SwPagePreView
72 : #include <sfx2/msg.hxx>
73 : #include <swslots.hxx>
74 : #include <pagepreviewlayout.hxx>
75 :
76 : #include <svx/svxdlg.hxx>
77 : #include <svx/dialogs.hrc>
78 : #include <osl/mutex.hxx>
79 :
80 :
81 : using namespace ::com::sun::star;
82 16 : SFX_IMPL_NAMED_VIEWFACTORY(SwPagePreView, "PrintPreview")
83 : {
84 8 : SFX_VIEW_REGISTRATION(SwDocShell);
85 8 : SFX_VIEW_REGISTRATION(SwWebDocShell);
86 8 : SFX_VIEW_REGISTRATION(SwGlobalDocShell);
87 8 : }
88 :
89 50 : SFX_IMPL_INTERFACE(SwPagePreView, SfxViewShell, SW_RES(RID_PVIEW_TOOLBOX))
90 : {
91 10 : SFX_POPUPMENU_REGISTRATION(SW_RES(MN_PPREVIEW_POPUPMENU));
92 20 : SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OBJECT|SFX_VISIBILITY_STANDARD|
93 : SFX_VISIBILITY_CLIENT|SFX_VISIBILITY_FULLSCREEN|
94 : SFX_VISIBILITY_READONLYDOC,
95 10 : SW_RES(RID_PVIEW_TOOLBOX));
96 10 : }
97 :
98 0 : TYPEINIT1(SwPagePreView,SfxViewShell)
99 :
100 : #define SWVIEWFLAGS ( SFX_VIEW_CAN_PRINT|SFX_VIEW_HAS_PRINTOPTIONS )
101 :
102 : #define MIN_PREVIEW_ZOOM 25
103 : #define MAX_PREVIEW_ZOOM 600
104 :
105 0 : static sal_uInt16 lcl_GetNextZoomStep(sal_uInt16 nCurrentZoom, sal_Bool bZoomIn)
106 : {
107 : static sal_uInt16 aZoomArr[] =
108 : {
109 : 25, 50, 75, 100, 150, 200, 400, 600
110 : };
111 0 : const sal_uInt16 nZoomArrSize = sizeof(aZoomArr)/sizeof(sal_uInt16);
112 0 : if(bZoomIn)
113 0 : for(int i = nZoomArrSize - 1; i >= 0; --i)
114 : {
115 0 : if(nCurrentZoom > aZoomArr[i] || !i)
116 0 : return aZoomArr[i];
117 : }
118 : else
119 0 : for(int i = 0; i < nZoomArrSize; ++i)
120 : {
121 0 : if(nCurrentZoom < aZoomArr[i])
122 0 : return aZoomArr[i];
123 : }
124 0 : return bZoomIn ? MAX_PREVIEW_ZOOM : MIN_PREVIEW_ZOOM;
125 : };
126 :
127 0 : static void lcl_InvalidateZoomSlots(SfxBindings& rBindings)
128 : {
129 : static sal_uInt16 const aInval[] =
130 : {
131 : SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN, SID_ATTR_ZOOMSLIDER, FN_PREVIEW_ZOOM, FN_STAT_ZOOM,
132 : 0
133 : };
134 0 : rBindings.Invalidate( aInval );
135 0 : }
136 :
137 : // erstmal der Zoom-Dialog
138 : class SwPreViewZoomDlg : public SvxStandardDialog
139 : {
140 : FixedText aRowLbl;
141 : NumericField aRowEdit;
142 : FixedText aColLbl;
143 : NumericField aColEdit;
144 :
145 : OKButton aOkBtn;
146 : CancelButton aCancelBtn;
147 : HelpButton aHelpBtn;
148 :
149 : virtual void Apply();
150 :
151 : public:
152 : SwPreViewZoomDlg( SwPagePreViewWin& rParent );
153 : ~SwPreViewZoomDlg();
154 : };
155 :
156 0 : SwPreViewZoomDlg::SwPreViewZoomDlg( SwPagePreViewWin& rParent ) :
157 : SvxStandardDialog( &rParent, SW_RES(DLG_PAGEPREVIEW_ZOOM) ),
158 : aRowLbl(this,SW_RES(FT_ROW)),
159 : aRowEdit(this,SW_RES(ED_ROW)),
160 : aColLbl(this,SW_RES(FT_COL)),
161 : aColEdit(this,SW_RES(ED_COL)),
162 : aOkBtn(this,SW_RES(BT_OK)),
163 : aCancelBtn(this,SW_RES(BT_CANCEL)),
164 0 : aHelpBtn(this,SW_RES(BT_HELP))
165 : {
166 0 : FreeResource();
167 :
168 0 : aRowEdit.SetValue( rParent.GetRow() );
169 0 : aColEdit.SetValue( rParent.GetCol() );
170 0 : }
171 :
172 0 : SwPreViewZoomDlg::~SwPreViewZoomDlg() {}
173 0 : void SwPreViewZoomDlg::Apply()
174 : {
175 0 : ((SwPagePreViewWin*)GetParent())->CalcWish(
176 0 : sal_uInt8(aRowEdit.GetValue()),
177 0 : sal_uInt8(aColEdit.GetValue()) );
178 0 : }
179 :
180 : // alles fuers SwPagePreViewWin
181 0 : SwPagePreViewWin::SwPagePreViewWin( Window *pParent, SwPagePreView& rPView )
182 : : Window( pParent, WinBits( WB_CLIPCHILDREN) ),
183 : mpViewShell( 0 ),
184 : mrView( rPView ),
185 : mbCalcScaleForPreviewLayout( true ),
186 0 : maPaintedPreviewDocRect( Rectangle(0,0,0,0) )
187 : {
188 0 : SetOutDevViewType( OUTDEV_VIEWTYPE_PRINTPREVIEW );
189 0 : SetHelpId(HID_PAGEPREVIEW);
190 0 : SetFillColor( GetBackground().GetColor() );
191 0 : SetLineColor( GetBackground().GetColor());
192 0 : SetMapMode( MapMode(MAP_TWIP) );
193 :
194 0 : const SwMasterUsrPref *pUsrPref = SW_MOD()->GetUsrPref(sal_False);
195 0 : mnRow = pUsrPref->GetPagePrevRow(); // 1 Zeile
196 0 : mnCol = pUsrPref->GetPagePrevCol(); // 1 Spalte
197 0 : mnSttPage = USHRT_MAX;
198 0 : }
199 :
200 0 : SwPagePreViewWin::~SwPagePreViewWin()
201 : {
202 0 : delete mpViewShell;
203 0 : }
204 :
205 0 : void SwPagePreViewWin::Paint( const Rectangle& rRect )
206 : {
207 0 : if( !mpViewShell || !mpViewShell->GetLayout() )
208 0 : return;
209 :
210 0 : if( USHRT_MAX == mnSttPage ) // wurde noch nie berechnet ? (Init-Phase!)
211 : {
212 : // das ist die Size, auf die ich mich immer beziehe
213 0 : if( !maPxWinSize.Height() || !maPxWinSize.Width() )
214 0 : maPxWinSize = GetOutputSizePixel();
215 :
216 0 : Rectangle aRect( LogicToPixel( rRect ));
217 : mpPgPrevwLayout->Prepare( 1, Point(0,0), maPxWinSize,
218 0 : mnSttPage, maPaintedPreviewDocRect );
219 0 : SetSelectedPage( 1 );
220 0 : mpPgPrevwLayout->Paint( PixelToLogic( aRect ) );
221 0 : SetPagePreview(mnRow, mnCol);
222 : }
223 : else
224 : {
225 0 : MapMode aMM( GetMapMode() );
226 0 : aMM.SetScaleX( maScale );
227 0 : aMM.SetScaleY( maScale );
228 0 : SetMapMode( aMM );
229 0 : mpPgPrevwLayout->Paint( rRect );
230 : }
231 : }
232 :
233 0 : void SwPagePreViewWin::CalcWish( sal_uInt8 nNewRow, sal_uInt8 nNewCol )
234 : {
235 0 : if( !mpViewShell || !mpViewShell->GetLayout() )
236 0 : return;
237 :
238 0 : sal_uInt16 nOldCol = mnCol;
239 0 : mnRow = nNewRow;
240 0 : mnCol = nNewCol;
241 0 : sal_uInt16 nPages = mnRow * mnCol,
242 0 : nLastSttPg = mrView.GetPageCount()+1 > nPages
243 0 : ? mrView.GetPageCount()+1 - nPages : 0;
244 0 : if( mnSttPage > nLastSttPg )
245 0 : mnSttPage = nLastSttPg;
246 :
247 0 : mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true );
248 : mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
249 0 : mnSttPage, maPaintedPreviewDocRect );
250 0 : SetSelectedPage( mnSttPage );
251 0 : SetPagePreview(mnRow, mnCol);
252 0 : maScale = GetMapMode().GetScaleX();
253 :
254 : // falls an der Spaltigkeit gedreht wurde, so muss der Sonderfall
255 : // Einspaltig beachtet und ggfs. der Scrollbar korrigiert werden
256 0 : if( (1 == nOldCol) ^ (1 == mnCol) )
257 0 : mrView.ScrollDocSzChg();
258 :
259 : // Sortierung muss eingehalten werden!!
260 : // additional invalidate page status.
261 : static sal_uInt16 aInval[] =
262 : {
263 : SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN,
264 : FN_PREVIEW_ZOOM,
265 : FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
266 : FN_STAT_PAGE, FN_STAT_ZOOM,
267 : FN_SHOW_TWO_PAGES, FN_SHOW_MULTIPLE_PAGES,
268 : 0
269 : };
270 0 : SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings();
271 0 : rBindings.Invalidate( aInval );
272 0 : rBindings.Update( FN_SHOW_TWO_PAGES );
273 0 : rBindings.Update( FN_SHOW_MULTIPLE_PAGES );
274 : // adjust scrollbars
275 0 : mrView.ScrollViewSzChg();
276 : }
277 :
278 : /*--------------------------------------------------------------------
279 : Beschreibung:, mnSttPage is Absolute
280 : --------------------------------------------------------------------*/
281 0 : int SwPagePreViewWin::MovePage( int eMoveMode )
282 : {
283 : // soviele Seiten hoch
284 0 : sal_uInt16 nPages = mnRow * mnCol;
285 0 : sal_uInt16 nNewSttPage = mnSttPage;
286 0 : sal_uInt16 nPageCount = mrView.GetPageCount();
287 0 : sal_uInt16 nDefSttPg = GetDefSttPage();
288 0 : bool bPaintPageAtFirstCol = true;
289 :
290 0 : switch( eMoveMode )
291 : {
292 : case MV_PAGE_UP:
293 : {
294 0 : const sal_uInt16 nRelSttPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( mnSttPage );
295 : const sal_uInt16 nNewAbsSttPage = nRelSttPage - nPages > 0 ?
296 0 : mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage - nPages ) :
297 0 : nDefSttPg;
298 0 : nNewSttPage = nNewAbsSttPage;
299 :
300 0 : const sal_uInt16 nRelSelPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() );
301 : const sal_uInt16 nNewRelSelPage = nRelSelPage - nPages > 0 ?
302 : nRelSelPage - nPages :
303 0 : 1;
304 0 : SetSelectedPage( mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nNewRelSelPage ) );
305 :
306 0 : break;
307 : }
308 : case MV_PAGE_DOWN:
309 : {
310 0 : const sal_uInt16 nRelSttPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( mnSttPage );
311 0 : const sal_uInt16 nNewAbsSttPage = mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage + nPages );
312 0 : nNewSttPage = nNewAbsSttPage < nPageCount ? nNewAbsSttPage : nPageCount;
313 :
314 0 : const sal_uInt16 nRelSelPage = mpPgPrevwLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() );
315 0 : const sal_uInt16 nNewAbsSelPage = mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nRelSelPage + nPages );
316 0 : SetSelectedPage( nNewAbsSelPage < nPageCount ? nNewAbsSelPage : nPageCount );
317 :
318 0 : break;
319 : }
320 : case MV_DOC_STT:
321 0 : nNewSttPage = nDefSttPg;
322 0 : SetSelectedPage( mpPgPrevwLayout->ConvertRelativeToAbsolutePageNum( nNewSttPage ? nNewSttPage : 1 ) );
323 0 : break;
324 : case MV_DOC_END:
325 : // correct calculation of new start page.
326 0 : nNewSttPage = nPageCount;
327 0 : SetSelectedPage( nPageCount );
328 0 : break;
329 : case MV_SELPAGE:
330 : // <nNewSttPage> and <SelectedPage()> are already set.
331 : // not start at first column, only if the
332 : // complete preview layout columns doesn't fit into window.
333 0 : if ( !mpPgPrevwLayout->DoesPreviewLayoutColsFitIntoWindow() )
334 0 : bPaintPageAtFirstCol = false;
335 0 : break;
336 : case MV_SCROLL:
337 : // check, if paint page at first column
338 : // has to be avoided
339 0 : if ( !mpPgPrevwLayout->DoesPreviewLayoutRowsFitIntoWindow() ||
340 0 : !mpPgPrevwLayout->DoesPreviewLayoutColsFitIntoWindow() )
341 0 : bPaintPageAtFirstCol = false;
342 0 : break;
343 : case MV_NEWWINSIZE:
344 : // nothing special to do.
345 0 : break;
346 : case MV_CALC:
347 : // re-init page preview layout.
348 0 : mpPgPrevwLayout->ReInit();
349 :
350 : // correct calculation of new start page.
351 0 : if( nNewSttPage > nPageCount )
352 0 : nNewSttPage = nPageCount;
353 :
354 : // correct selected page number
355 0 : if( SelectedPage() > nPageCount )
356 0 : SetSelectedPage( nNewSttPage ? nNewSttPage : 1 );
357 : }
358 :
359 : mpPgPrevwLayout->Prepare( nNewSttPage, Point(0,0), maPxWinSize,
360 : nNewSttPage,
361 0 : maPaintedPreviewDocRect, bPaintPageAtFirstCol );
362 0 : if( nNewSttPage == mnSttPage &&
363 : eMoveMode != MV_SELPAGE )
364 0 : return sal_False;
365 :
366 0 : SetPagePreview(mnRow, mnCol);
367 0 : mnSttPage = nNewSttPage;
368 :
369 : // additional invalidate page status.
370 : static sal_uInt16 aInval[] =
371 : {
372 : FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
373 : FN_STAT_PAGE, 0
374 : };
375 :
376 0 : SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings();
377 0 : rBindings.Invalidate( aInval );
378 :
379 0 : return sal_True;
380 : }
381 :
382 0 : void SwPagePreViewWin::SetWinSize( const Size& rNewSize )
383 : {
384 : // die Size wollen wir aber immer in Pixel-Einheiten haben
385 0 : maPxWinSize = LogicToPixel( rNewSize );
386 :
387 0 : if( USHRT_MAX == mnSttPage )
388 : {
389 0 : mnSttPage = GetDefSttPage();
390 0 : SetSelectedPage( GetDefSttPage() );
391 : }
392 :
393 0 : if ( mbCalcScaleForPreviewLayout )
394 : {
395 0 : mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true );
396 0 : maScale = GetMapMode().GetScaleX();
397 : }
398 : mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
399 0 : mnSttPage, maPaintedPreviewDocRect );
400 0 : if ( mbCalcScaleForPreviewLayout )
401 : {
402 0 : SetSelectedPage( mnSttPage );
403 0 : mbCalcScaleForPreviewLayout = false;
404 : }
405 0 : SetPagePreview(mnRow, mnCol);
406 0 : maScale = GetMapMode().GetScaleX();
407 0 : }
408 :
409 0 : OUString SwPagePreViewWin::GetStatusStr( sal_uInt16 nPageCnt ) const
410 : {
411 : // show physical and virtual page number of
412 : // selected page, if it's visible.
413 : sal_uInt16 nPageNum;
414 0 : if ( mpPgPrevwLayout->IsPageVisible( mpPgPrevwLayout->SelectedPage() ) )
415 : {
416 0 : nPageNum = mpPgPrevwLayout->SelectedPage();
417 : }
418 : else
419 : {
420 0 : nPageNum = mnSttPage > 1 ? mnSttPage : 1;
421 : }
422 0 : OUStringBuffer aStatusStr;
423 0 : sal_uInt16 nVirtPageNum = mpPgPrevwLayout->GetVirtPageNumByPageNum( nPageNum );
424 0 : if( nVirtPageNum && nVirtPageNum != nPageNum )
425 : {
426 0 : aStatusStr.append( static_cast<sal_Int32>(nVirtPageNum) ).append( ' ' );
427 : }
428 0 : aStatusStr.append( static_cast<sal_Int32>(nPageNum) );
429 0 : aStatusStr.append( " / " );
430 0 : aStatusStr.append( static_cast<sal_Int32>(nPageCnt) );
431 0 : return aStatusStr.makeStringAndClear();
432 : }
433 :
434 0 : void SwPagePreViewWin::KeyInput( const KeyEvent &rKEvt )
435 : {
436 0 : const KeyCode& rKeyCode = rKEvt.GetKeyCode();
437 0 : sal_uInt16 nKey = rKeyCode.GetCode();
438 0 : sal_Bool bHandled = sal_False;
439 0 : if(!rKeyCode.GetModifier())
440 : {
441 0 : sal_uInt16 nSlot = 0;
442 0 : switch(nKey)
443 : {
444 0 : case KEY_ADD : nSlot = SID_ZOOM_OUT; break;
445 0 : case KEY_ESCAPE: nSlot = FN_CLOSE_PAGEPREVIEW; break;
446 0 : case KEY_SUBTRACT : nSlot = SID_ZOOM_IN; break;
447 : }
448 0 : if(nSlot)
449 : {
450 0 : bHandled = sal_True;
451 : mrView.GetViewFrame()->GetDispatcher()->Execute(
452 0 : nSlot, SFX_CALLMODE_ASYNCHRON );
453 : }
454 : }
455 0 : if( !bHandled && !mrView.KeyInput( rKEvt ) )
456 0 : Window::KeyInput( rKEvt );
457 0 : }
458 :
459 0 : void SwPagePreViewWin::Command( const CommandEvent& rCEvt )
460 : {
461 0 : sal_Bool bCallBase = sal_True;
462 0 : switch( rCEvt.GetCommand() )
463 : {
464 : case COMMAND_CONTEXTMENU:
465 0 : mrView.GetViewFrame()->GetDispatcher()->ExecutePopup();
466 0 : bCallBase = sal_False;
467 0 : break;
468 :
469 : case COMMAND_WHEEL:
470 : case COMMAND_STARTAUTOSCROLL:
471 : case COMMAND_AUTOSCROLL:
472 : {
473 0 : const CommandWheelData* pData = rCEvt.GetWheelData();
474 0 : if( pData )
475 : {
476 : const CommandWheelData aDataNew(pData->GetDelta(),pData->GetNotchDelta(),COMMAND_WHEEL_PAGESCROLL,
477 0 : pData->GetMode(),pData->GetModifier(),pData->IsHorz(), pData->IsDeltaPixel());
478 0 : const CommandEvent aEvent( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),rCEvt.IsMouseEvent(),&aDataNew);
479 0 : bCallBase = !mrView.HandleWheelCommands( aEvent );
480 : }
481 : else
482 0 : bCallBase = !mrView.HandleWheelCommands( rCEvt );
483 : }
484 0 : break;
485 : default:
486 : ;
487 : }
488 :
489 0 : if( bCallBase )
490 0 : Window::Command( rCEvt );
491 0 : }
492 :
493 0 : void SwPagePreViewWin::MouseButtonDown( const MouseEvent& rMEvt )
494 : {
495 : // consider single-click to set selected page
496 0 : if( MOUSE_LEFT == ( rMEvt.GetModifier() + rMEvt.GetButtons() ) )
497 : {
498 0 : Point aPrevwPos( PixelToLogic( rMEvt.GetPosPixel() ) );
499 0 : Point aDocPos;
500 : bool bPosInEmptyPage;
501 : sal_uInt16 nNewSelectedPage;
502 : bool bIsDocPos =
503 : mpPgPrevwLayout->IsPrevwPosInDocPrevwPage( aPrevwPos,
504 0 : aDocPos, bPosInEmptyPage, nNewSelectedPage );
505 0 : if ( bIsDocPos && rMEvt.GetClicks() == 2 )
506 : {
507 : // close page preview, set new cursor position and switch to
508 : // normal view.
509 0 : String sNewCrsrPos( String::CreateFromInt32( aDocPos.X() ));
510 0 : ((( sNewCrsrPos += ';' )
511 0 : += String::CreateFromInt32( aDocPos.Y() )) )
512 0 : += ';';
513 0 : mrView.SetNewCrsrPos( sNewCrsrPos );
514 :
515 0 : SfxViewFrame *pTmpFrm = mrView.GetViewFrame();
516 0 : pTmpFrm->GetBindings().Execute( SID_VIEWSHELL0, NULL, 0,
517 0 : SFX_CALLMODE_ASYNCHRON );
518 : }
519 0 : else if ( bIsDocPos || bPosInEmptyPage )
520 : {
521 : // show clicked page as the selected one
522 0 : mpPgPrevwLayout->MarkNewSelectedPage( nNewSelectedPage );
523 0 : GetViewShell()->ShowPreViewSelection( nNewSelectedPage );
524 : // adjust position at vertical scrollbar.
525 0 : if ( mpPgPrevwLayout->DoesPreviewLayoutRowsFitIntoWindow() )
526 : {
527 0 : mrView.SetVScrollbarThumbPos( nNewSelectedPage );
528 : }
529 : // invalidate page status.
530 : static sal_uInt16 aInval[] =
531 : {
532 : FN_STAT_PAGE, 0
533 : };
534 0 : SfxBindings& rBindings = mrView.GetViewFrame()->GetBindings();
535 0 : rBindings.Invalidate( aInval );
536 : }
537 : }
538 0 : }
539 :
540 : /******************************************************************************
541 : * Beschreibung: Userprefs bzw Viewoptions setzen
542 : ******************************************************************************/
543 0 : void SwPagePreViewWin::SetPagePreview( sal_uInt8 nRow, sal_uInt8 nCol )
544 : {
545 0 : SwMasterUsrPref *pOpt = (SwMasterUsrPref *)SW_MOD()->GetUsrPref(sal_False);
546 :
547 0 : if (nRow != pOpt->GetPagePrevRow() || nCol != pOpt->GetPagePrevCol())
548 : {
549 0 : pOpt->SetPagePrevRow( nRow );
550 0 : pOpt->SetPagePrevCol( nCol );
551 0 : pOpt->SetModified();
552 :
553 : //Scrollbar updaten!
554 0 : mrView.ScrollViewSzChg();
555 : }
556 0 : }
557 :
558 : /** get selected page in document preview
559 :
560 : @author OD
561 : */
562 0 : sal_uInt16 SwPagePreViewWin::SelectedPage() const
563 : {
564 0 : return mpPgPrevwLayout->SelectedPage();
565 : }
566 :
567 : /** set selected page number in document preview
568 :
569 : @author OD
570 : */
571 0 : void SwPagePreViewWin::SetSelectedPage( sal_uInt16 _nSelectedPageNum )
572 : {
573 0 : mpPgPrevwLayout->SetSelectedPage( _nSelectedPageNum );
574 0 : }
575 :
576 : /** method to enable/disable book preview
577 :
578 : @author OD
579 : */
580 0 : bool SwPagePreViewWin::SetBookPreviewMode( const bool _bBookPreview )
581 : {
582 : return mpPgPrevwLayout->SetBookPreviewMode( _bBookPreview,
583 : mnSttPage,
584 0 : maPaintedPreviewDocRect );
585 : }
586 :
587 0 : void SwPagePreViewWin::DataChanged( const DataChangedEvent& rDCEvt )
588 : {
589 0 : Window::DataChanged( rDCEvt );
590 :
591 0 : switch( rDCEvt.GetType() )
592 : {
593 : case DATACHANGED_SETTINGS:
594 : // ScrollBars neu anordnen bzw. Resize ausloesen, da sich
595 : // ScrollBar-Groesse geaendert haben kann. Dazu muss dann im
596 : // Resize-Handler aber auch die Groesse der ScrollBars aus
597 : // den Settings abgefragt werden.
598 0 : if( rDCEvt.GetFlags() & SETTINGS_STYLE )
599 0 : mrView.InvalidateBorder(); //Scrollbarbreiten
600 : // zoom has to be disabled if Accessibility support is switched on
601 0 : lcl_InvalidateZoomSlots(mrView.GetViewFrame()->GetBindings());
602 0 : break;
603 :
604 : case DATACHANGED_PRINTER:
605 : case DATACHANGED_DISPLAY:
606 : case DATACHANGED_FONTS:
607 : case DATACHANGED_FONTSUBSTITUTION:
608 0 : mrView.GetDocShell()->UpdateFontList(); //Fontwechsel
609 0 : if ( mpViewShell->GetWin() )
610 0 : mpViewShell->GetWin()->Invalidate();
611 0 : break;
612 : }
613 0 : }
614 :
615 : /** help method to execute SfxRequest FN_PAGEUP and FN_PAGEDOWN
616 :
617 : @author OD
618 : */
619 0 : void SwPagePreView::_ExecPgUpAndPgDown( const bool _bPgUp,
620 : SfxRequest* _pReq )
621 : {
622 0 : SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
623 : // check, if top/bottom of preview is *not* already visible.
624 0 : if( pPagePrevwLay->GetWinPagesScrollAmount( _bPgUp ? -1 : 1 ) != 0 )
625 : {
626 0 : if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() &&
627 0 : pPagePrevwLay->DoesPreviewLayoutColsFitIntoWindow() )
628 : {
629 : const int eMvMode = _bPgUp ?
630 : SwPagePreViewWin::MV_PAGE_UP :
631 0 : SwPagePreViewWin::MV_PAGE_DOWN;
632 0 : if ( ChgPage( eMvMode, sal_True ) )
633 0 : aViewWin.Invalidate();
634 : }
635 : else
636 : {
637 : SwTwips nScrollAmount;
638 0 : sal_uInt16 nNewSelectedPageNum = 0;
639 0 : const sal_uInt16 nVisPages = aViewWin.GetRow() * aViewWin.GetCol();
640 0 : if( _bPgUp )
641 : {
642 0 : if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() )
643 : {
644 0 : nScrollAmount = pPagePrevwLay->GetWinPagesScrollAmount( -1 );
645 0 : if ( (aViewWin.SelectedPage() - nVisPages) > 0 )
646 0 : nNewSelectedPageNum = aViewWin.SelectedPage() - nVisPages;
647 : else
648 0 : nNewSelectedPageNum = 1;
649 : }
650 : else
651 0 : nScrollAmount = - Min( aViewWin.GetOutputSize().Height(),
652 0 : aViewWin.GetPaintedPreviewDocRect().Top() );
653 : }
654 : else
655 : {
656 0 : if ( pPagePrevwLay->DoesPreviewLayoutRowsFitIntoWindow() )
657 : {
658 0 : nScrollAmount = pPagePrevwLay->GetWinPagesScrollAmount( 1 );
659 0 : if ( (aViewWin.SelectedPage() + nVisPages) <= mnPageCount )
660 0 : nNewSelectedPageNum = aViewWin.SelectedPage() + nVisPages;
661 : else
662 0 : nNewSelectedPageNum = mnPageCount;
663 : }
664 : else
665 0 : nScrollAmount = Min( aViewWin.GetOutputSize().Height(),
666 0 : ( pPagePrevwLay->GetPrevwDocSize().Height() -
667 0 : aViewWin.GetPaintedPreviewDocRect().Bottom() ) );
668 : }
669 0 : aViewWin.Scroll( 0, nScrollAmount );
670 0 : if ( nNewSelectedPageNum != 0 )
671 : {
672 0 : aViewWin.SetSelectedPage( nNewSelectedPageNum );
673 : }
674 0 : ScrollViewSzChg();
675 : // additional invalidate page status.
676 : static sal_uInt16 aInval[] =
677 : {
678 : FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
679 : FN_STAT_PAGE, 0
680 : };
681 0 : SfxBindings& rBindings = GetViewFrame()->GetBindings();
682 0 : rBindings.Invalidate( aInval );
683 0 : aViewWin.Invalidate();
684 : }
685 : }
686 :
687 0 : if ( _pReq )
688 0 : _pReq->Done();
689 0 : }
690 :
691 : // dann mal alles fuer die SwPagePreView
692 0 : void SwPagePreView::Execute( SfxRequest &rReq )
693 : {
694 : int eMvMode;
695 0 : sal_uInt8 nRow = 1;
696 0 : sal_Bool bRetVal = sal_False;
697 0 : bool bRefresh = true;
698 :
699 0 : switch(rReq.GetSlot())
700 : {
701 : case FN_REFRESH_VIEW:
702 : case FN_STAT_PAGE:
703 : case FN_STAT_ZOOM:
704 0 : break;
705 :
706 : case FN_SHOW_MULTIPLE_PAGES:
707 : {
708 0 : const SfxItemSet *pArgs = rReq.GetArgs();
709 0 : if( pArgs && pArgs->Count() >= 2 )
710 : {
711 : sal_uInt8 nCols = (sal_uInt8)((SfxUInt16Item &)pArgs->Get(
712 0 : SID_ATTR_TABLE_COLUMN)).GetValue();
713 : sal_uInt8 nRows = (sal_uInt8)((SfxUInt16Item &)pArgs->Get(
714 0 : SID_ATTR_TABLE_ROW)).GetValue();
715 0 : aViewWin.CalcWish( nRows, nCols );
716 :
717 : }
718 : else
719 0 : SwPreViewZoomDlg( aViewWin ).Execute();
720 :
721 : }
722 0 : break;
723 : case FN_SHOW_BOOKVIEW:
724 : {
725 0 : const SfxItemSet* pArgs = rReq.GetArgs();
726 : const SfxPoolItem* pItem;
727 0 : bool bBookPreview = GetViewShell()->GetViewOptions()->IsPagePrevBookview();
728 0 : if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( FN_SHOW_BOOKVIEW, sal_False, &pItem ) )
729 : {
730 0 : bBookPreview = static_cast< const SfxBoolItem* >( pItem )->GetValue();
731 0 : ( ( SwViewOption* ) GetViewShell()->GetViewOptions() )->SetPagePrevBookview( bBookPreview );
732 : // cast is not gentleman like, but it's common use in writer and in this case
733 : }
734 0 : if ( aViewWin.SetBookPreviewMode( bBookPreview ) )
735 : {
736 : // book preview mode changed. Thus, adjust scrollbars and
737 : // invalidate corresponding states.
738 0 : ScrollViewSzChg();
739 : static sal_uInt16 aInval[] =
740 : {
741 : FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
742 : FN_STAT_PAGE, FN_SHOW_BOOKVIEW, 0
743 : };
744 0 : SfxBindings& rBindings = GetViewFrame()->GetBindings();
745 0 : rBindings.Invalidate( aInval );
746 0 : aViewWin.Invalidate();
747 : }
748 :
749 : }
750 0 : break;
751 : case FN_SHOW_TWO_PAGES:
752 0 : aViewWin.CalcWish( nRow, 2 );
753 0 : break;
754 :
755 : case FN_PREVIEW_ZOOM:
756 : case SID_ATTR_ZOOM:
757 : {
758 0 : const SfxItemSet *pArgs = rReq.GetArgs();
759 : const SfxPoolItem* pItem;
760 0 : AbstractSvxZoomDialog *pDlg = 0;
761 0 : if(!pArgs)
762 : {
763 0 : SfxItemSet aCoreSet(GetPool(), SID_ATTR_ZOOM, SID_ATTR_ZOOM);
764 0 : const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
765 : SvxZoomItem aZoom( (SvxZoomType)pVOpt->GetZoomType(),
766 0 : pVOpt->GetZoom() );
767 : aZoom.SetValueSet(
768 : SVX_ZOOM_ENABLE_50|
769 : SVX_ZOOM_ENABLE_75|
770 : SVX_ZOOM_ENABLE_100|
771 : SVX_ZOOM_ENABLE_150|
772 : SVX_ZOOM_ENABLE_200|
773 0 : SVX_ZOOM_ENABLE_WHOLEPAGE);
774 0 : aCoreSet.Put( aZoom );
775 :
776 0 : SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
777 0 : if(pFact)
778 : {
779 0 : pDlg = pFact->CreateSvxZoomDialog(&GetViewFrame()->GetWindow(), aCoreSet);
780 : OSL_ENSURE(pDlg, "Dialogdiet fail!");
781 : }
782 :
783 0 : pDlg->SetLimits( MINZOOM, MAXZOOM );
784 :
785 0 : if( pDlg->Execute() != RET_CANCEL )
786 0 : pArgs = pDlg->GetOutputItemSet();
787 : }
788 0 : if( pArgs )
789 : {
790 0 : enum SvxZoomType eType = SVX_ZOOM_PERCENT;
791 0 : sal_uInt16 nZoomFactor = USHRT_MAX;
792 0 : if(SFX_ITEM_SET == pArgs->GetItemState(SID_ATTR_ZOOM, sal_True, &pItem))
793 : {
794 0 : eType = ((const SvxZoomItem *)pItem)->GetType();
795 0 : nZoomFactor = ((const SvxZoomItem *)pItem)->GetValue();
796 : }
797 0 : else if(SFX_ITEM_SET == pArgs->GetItemState(FN_PREVIEW_ZOOM, sal_True, &pItem))
798 0 : nZoomFactor = ((const SfxUInt16Item *)pItem)->GetValue();
799 0 : if(USHRT_MAX != nZoomFactor)
800 0 : SetZoom(eType, nZoomFactor);
801 : }
802 0 : delete pDlg;
803 : }
804 0 : break;
805 : case SID_ATTR_ZOOMSLIDER :
806 : {
807 0 : const SfxItemSet *pArgs = rReq.GetArgs();
808 : const SfxPoolItem* pItem;
809 :
810 0 : if ( pArgs && SFX_ITEM_SET == pArgs->GetItemState(SID_ATTR_ZOOMSLIDER, sal_True, &pItem ) )
811 : {
812 0 : const sal_uInt16 nCurrentZoom = ((const SvxZoomSliderItem *)pItem)->GetValue();
813 0 : SetZoom( SVX_ZOOM_PERCENT, nCurrentZoom );
814 : }
815 : }
816 0 : break;
817 : case SID_ZOOM_IN:
818 : case SID_ZOOM_OUT:
819 : {
820 0 : enum SvxZoomType eType = SVX_ZOOM_PERCENT;
821 0 : const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
822 : SetZoom(eType,
823 0 : lcl_GetNextZoomStep(pVOpt->GetZoom(), SID_ZOOM_IN == rReq.GetSlot()));
824 : }
825 0 : break;
826 : case FN_CHAR_LEFT:
827 : case FN_CHAR_RIGHT:
828 : case FN_LINE_UP:
829 : case FN_LINE_DOWN:
830 : {
831 0 : SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
832 : sal_uInt16 nNewSelectedPage;
833 : sal_uInt16 nNewStartPage;
834 0 : Point aNewStartPos;
835 0 : sal_Int16 nHoriMove = 0;
836 0 : sal_Int16 nVertMove = 0;
837 0 : switch(rReq.GetSlot())
838 : {
839 0 : case FN_CHAR_LEFT: nHoriMove = -1; break;
840 0 : case FN_CHAR_RIGHT: nHoriMove = 1; break;
841 0 : case FN_LINE_UP: nVertMove = -1; break;
842 0 : case FN_LINE_DOWN: nVertMove = 1; break;
843 : }
844 : pPagePrevwLay->CalcStartValuesForSelectedPageMove( nHoriMove, nVertMove,
845 0 : nNewSelectedPage, nNewStartPage, aNewStartPos );
846 0 : if ( aViewWin.SelectedPage() != nNewSelectedPage )
847 : {
848 0 : if ( pPagePrevwLay->IsPageVisible( nNewSelectedPage ) )
849 : {
850 0 : pPagePrevwLay->MarkNewSelectedPage( nNewSelectedPage );
851 : // adjust position at vertical scrollbar.
852 0 : SetVScrollbarThumbPos( nNewSelectedPage );
853 0 : bRefresh = false;
854 : }
855 : else
856 : {
857 0 : aViewWin.SetSelectedPage( nNewSelectedPage );
858 0 : aViewWin.SetSttPage( nNewStartPage );
859 0 : int nRet = ChgPage( SwPagePreViewWin::MV_SELPAGE, sal_True );
860 0 : bRefresh = 0 != nRet;
861 : }
862 0 : GetViewShell()->ShowPreViewSelection( nNewSelectedPage );
863 : // invalidate page status.
864 : static sal_uInt16 aInval[] =
865 : {
866 : FN_STAT_PAGE, 0
867 : };
868 0 : SfxBindings& rBindings = GetViewFrame()->GetBindings();
869 0 : rBindings.Invalidate( aInval );
870 0 : rReq.Done();
871 : }
872 : else
873 : {
874 0 : bRefresh = false;
875 : }
876 : break;
877 : }
878 : case FN_PAGEUP:
879 : case FN_PAGEDOWN:
880 : {
881 0 : _ExecPgUpAndPgDown( rReq.GetSlot() == FN_PAGEUP, &rReq );
882 0 : break;
883 : }
884 : case FN_START_OF_LINE:
885 : case FN_START_OF_DOCUMENT:
886 0 : aViewWin.SetSelectedPage( 1 );
887 0 : eMvMode = SwPagePreViewWin::MV_DOC_STT; bRetVal = sal_True; goto MOVEPAGE;
888 : case FN_END_OF_LINE:
889 : case FN_END_OF_DOCUMENT:
890 0 : aViewWin.SetSelectedPage( mnPageCount );
891 0 : eMvMode = SwPagePreViewWin::MV_DOC_END; bRetVal = sal_True; goto MOVEPAGE;
892 : MOVEPAGE:
893 : {
894 0 : int nRet = ChgPage( eMvMode, sal_True );
895 : // return value fuer Basic
896 0 : if(bRetVal)
897 0 : rReq.SetReturnValue(SfxBoolItem(rReq.GetSlot(), nRet == 0));
898 :
899 0 : bRefresh = 0 != nRet;
900 0 : rReq.Done();
901 : }
902 0 : break;
903 :
904 : case FN_PRINT_PAGEPREVIEW:
905 : {
906 0 : const SwPagePreViewPrtData* pPPVPD = aViewWin.GetViewShell()->GetDoc()->GetPreViewPrtData();
907 : // die Sache mit der Orientation
908 0 : if(pPPVPD)
909 : {
910 0 : SfxPrinter* pPrinter = GetPrinter( sal_True );
911 0 : if((pPrinter->GetOrientation() == ORIENTATION_LANDSCAPE)
912 0 : != pPPVPD->GetLandscape())
913 0 : pPrinter->SetOrientation(pPPVPD->GetLandscape() ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT);
914 : }
915 0 : ::SetAppPrintOptions( aViewWin.GetViewShell(), sal_False );
916 0 : bNormalPrint = sal_False;
917 0 : sal_uInt16 nPrtSlot = SID_PRINTDOC;
918 0 : rReq.SetSlot( nPrtSlot );
919 0 : SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() );
920 0 : rReq.SetSlot( FN_PRINT_PAGEPREVIEW );
921 0 : return;
922 : }
923 : case SID_PRINTDOCDIRECT:
924 : case SID_PRINTDOC:
925 0 : ::SetAppPrintOptions( aViewWin.GetViewShell(), sal_False );
926 0 : bNormalPrint = sal_True;
927 0 : SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() );
928 0 : return;
929 : case FN_CLOSE_PAGEPREVIEW:
930 : case SID_PRINTPREVIEW:
931 : // print preview is now always in the same frame as the tab view
932 : // -> always switch this frame back to normal view
933 : // (ScTabViewShell ctor reads stored view data)
934 0 : GetViewFrame()->GetDispatcher()->Execute( SID_VIEWSHELL0, 0, 0, SFX_CALLMODE_ASYNCHRON );
935 0 : break;
936 : case FN_INSERT_BREAK:
937 : {
938 0 : sal_uInt16 nSelPage = aViewWin.SelectedPage();
939 : //if a dummy page is selected (e.g. a non-existing right/left page)
940 : //the direct neighbor is used
941 0 : if(GetViewShell()->IsDummyPage( nSelPage ) && GetViewShell()->IsDummyPage( --nSelPage ))
942 0 : nSelPage +=2;
943 0 : SetNewPage( nSelPage );
944 0 : SfxViewFrame *pTmpFrm = GetViewFrame();
945 0 : pTmpFrm->GetBindings().Execute( SID_VIEWSHELL0, NULL, 0,
946 0 : SFX_CALLMODE_ASYNCHRON );
947 : }
948 0 : break;
949 : default:
950 : OSL_ENSURE(!this, "wrong dispatcher");
951 0 : return;
952 : }
953 :
954 0 : if( bRefresh )
955 0 : aViewWin.Invalidate();
956 : }
957 :
958 0 : void SwPagePreView::GetState( SfxItemSet& rSet )
959 : {
960 0 : SfxWhichIter aIter(rSet);
961 0 : sal_uInt8 nRow = 1;
962 0 : sal_uInt16 nWhich = aIter.FirstWhich();
963 : OSL_ENSURE(nWhich, "empty set");
964 0 : SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
965 : // zoom has to be disabled if Accessibility support is switched on
966 0 : sal_Bool bZoomEnabled = sal_True; // !Application::GetSettings().GetMiscSettings().GetEnableATToolSupport();
967 :
968 0 : while(nWhich)
969 : {
970 0 : switch(nWhich)
971 : {
972 : case SID_BROWSER_MODE:
973 : case FN_PRINT_LAYOUT:
974 0 : rSet.DisableItem(nWhich);
975 0 : break;
976 : case FN_START_OF_DOCUMENT:
977 : {
978 0 : if ( pPagePrevwLay->IsPageVisible( 1 ) )
979 0 : rSet.DisableItem(nWhich);
980 0 : break;
981 : }
982 : case FN_END_OF_DOCUMENT:
983 : {
984 0 : if ( pPagePrevwLay->IsPageVisible( mnPageCount ) )
985 0 : rSet.DisableItem(nWhich);
986 0 : break;
987 : }
988 : case FN_PAGEUP:
989 : {
990 0 : if( pPagePrevwLay->GetWinPagesScrollAmount( -1 ) == 0 )
991 0 : rSet.DisableItem(nWhich);
992 0 : break;
993 : }
994 : case FN_PAGEDOWN:
995 : {
996 0 : if( pPagePrevwLay->GetWinPagesScrollAmount( 1 ) == 0 )
997 0 : rSet.DisableItem(nWhich);
998 0 : break;
999 : }
1000 :
1001 : case FN_STAT_PAGE:
1002 : {
1003 0 : OUString aStr = sPageStr + aViewWin.GetStatusStr( mnPageCount );
1004 0 : rSet.Put( SfxStringItem( nWhich, aStr) );
1005 : }
1006 0 : break;
1007 :
1008 : case SID_ATTR_ZOOM:
1009 : case FN_STAT_ZOOM:
1010 : {
1011 0 : if(bZoomEnabled)
1012 : {
1013 0 : const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1014 : SvxZoomItem aZoom((SvxZoomType)pVOpt->GetZoomType(),
1015 0 : pVOpt->GetZoom());
1016 : aZoom.SetValueSet(
1017 : SVX_ZOOM_ENABLE_50|
1018 : SVX_ZOOM_ENABLE_75|
1019 : SVX_ZOOM_ENABLE_100|
1020 : SVX_ZOOM_ENABLE_150|
1021 0 : SVX_ZOOM_ENABLE_200);
1022 0 : rSet.Put( aZoom );
1023 : }
1024 : else
1025 0 : rSet.DisableItem(nWhich);
1026 : }
1027 0 : break;
1028 : case SID_ATTR_ZOOMSLIDER :
1029 : {
1030 0 : if(bZoomEnabled)
1031 : {
1032 0 : const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1033 0 : const sal_uInt16 nCurrentZoom = pVOpt->GetZoom();
1034 0 : SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM, MAXZOOM );
1035 0 : aZoomSliderItem.AddSnappingPoint( 100 );
1036 0 : rSet.Put( aZoomSliderItem );
1037 : }
1038 : else
1039 0 : rSet.DisableItem(nWhich);
1040 : }
1041 0 : break;
1042 : case FN_PREVIEW_ZOOM:
1043 : {
1044 0 : if(bZoomEnabled)
1045 : {
1046 0 : const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1047 0 : rSet.Put(SfxUInt16Item(nWhich, pVOpt->GetZoom()));
1048 : }
1049 : else
1050 0 : rSet.DisableItem(nWhich);
1051 : }
1052 0 : break;
1053 : case SID_ZOOM_IN:
1054 : case SID_ZOOM_OUT:
1055 : {
1056 0 : const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
1057 0 : if(!bZoomEnabled || (SID_ZOOM_OUT == nWhich && pVOpt->GetZoom() >= MAX_PREVIEW_ZOOM)||
1058 0 : (SID_ZOOM_IN == nWhich && pVOpt->GetZoom() <= MIN_PREVIEW_ZOOM))
1059 : {
1060 0 : rSet.DisableItem(nWhich);
1061 : }
1062 : }
1063 0 : break;
1064 : case FN_SHOW_MULTIPLE_PAGES:
1065 : //should never be disabled
1066 0 : break;
1067 : case FN_SHOW_BOOKVIEW:
1068 : {
1069 0 : sal_Bool b = GetViewShell()->GetViewOptions()->IsPagePrevBookview();
1070 0 : rSet.Put(SfxBoolItem(nWhich, b));
1071 : }
1072 0 : break;
1073 :
1074 : case FN_SHOW_TWO_PAGES:
1075 0 : if( 2 == aViewWin.GetCol() && nRow == aViewWin.GetRow() )
1076 0 : rSet.DisableItem( nWhich );
1077 0 : break;
1078 :
1079 : case FN_PRINT_PAGEPREVIEW:
1080 : // hat den gleichen Status wie das normale Drucken
1081 : {
1082 : const SfxPoolItem* pItem;
1083 0 : SfxItemSet aSet( *rSet.GetPool(), SID_PRINTDOC, SID_PRINTDOC );
1084 0 : GetSlotState( SID_PRINTDOC, SfxViewShell::GetInterface(), &aSet );
1085 0 : if( SFX_ITEM_DISABLED == aSet.GetItemState( SID_PRINTDOC,
1086 0 : sal_False, &pItem ))
1087 0 : rSet.DisableItem( nWhich );
1088 0 : else if( SFX_ITEM_SET == aSet.GetItemState( SID_PRINTDOC,
1089 0 : sal_False, &pItem ))
1090 : {
1091 0 : ((SfxPoolItem*)pItem)->SetWhich( FN_PRINT_PAGEPREVIEW );
1092 0 : rSet.Put( *pItem );
1093 0 : }
1094 : }
1095 0 : break;
1096 :
1097 : case SID_PRINTPREVIEW:
1098 0 : rSet.Put( SfxBoolItem( nWhich, sal_True ) );
1099 0 : break;
1100 :
1101 : case SID_PRINTDOC:
1102 : case SID_PRINTDOCDIRECT:
1103 0 : GetSlotState( nWhich, SfxViewShell::GetInterface(), &rSet );
1104 0 : break;
1105 : }
1106 0 : nWhich = aIter.NextWhich();
1107 0 : }
1108 0 : }
1109 :
1110 0 : void SwPagePreView::StateUndo(SfxItemSet& rSet)
1111 : {
1112 0 : SfxWhichIter aIter(rSet);
1113 0 : sal_uInt16 nWhich = aIter.FirstWhich();
1114 :
1115 0 : while (nWhich)
1116 : {
1117 0 : rSet.DisableItem(nWhich);
1118 0 : nWhich = aIter.NextWhich();
1119 0 : }
1120 0 : }
1121 :
1122 0 : void SwPagePreView::Init(const SwViewOption * pPrefs)
1123 : {
1124 0 : if ( GetViewShell()->HasDrawView() )
1125 0 : GetViewShell()->GetDrawView()->SetAnimationEnabled( sal_False );
1126 :
1127 0 : bNormalPrint = sal_True;
1128 :
1129 : // Die DocSize erfragen und verarbeiten. Ueber die Handler konnte
1130 : // die Shell nicht gefunden werden, weil die Shell innerhalb CTOR-Phase
1131 : // nicht in der SFX-Verwaltung bekannt ist.
1132 :
1133 0 : if( !pPrefs )
1134 0 : pPrefs = SW_MOD()->GetUsrPref(sal_False);
1135 :
1136 0 : mbHScrollbarEnabled = pPrefs->IsViewHScrollBar();
1137 0 : mbVScrollbarEnabled = pPrefs->IsViewVScrollBar();
1138 :
1139 : // die Felder aktualisieren
1140 : // ACHTUNG: hochcasten auf die EditShell, um die SS zu nutzen.
1141 : // In den Methoden wird auf die akt. Shell abgefragt!
1142 0 : SwEditShell* pESh = (SwEditShell*)GetViewShell();
1143 0 : sal_Bool bIsModified = pESh->IsModified();
1144 :
1145 :
1146 0 : SwViewOption aOpt( *pPrefs );
1147 0 : aOpt.SetPagePreview(sal_True);
1148 0 : aOpt.SetTab( sal_False );
1149 0 : aOpt.SetBlank( sal_False );
1150 0 : aOpt.SetHardBlank( sal_False );
1151 0 : aOpt.SetParagraph( sal_False );
1152 0 : aOpt.SetLineBreak( sal_False );
1153 0 : aOpt.SetPageBreak( sal_False );
1154 0 : aOpt.SetColumnBreak( sal_False );
1155 0 : aOpt.SetSoftHyph( sal_False );
1156 0 : aOpt.SetFldName( sal_False );
1157 0 : aOpt.SetPostIts( sal_False );
1158 0 : aOpt.SetShowHiddenChar( sal_False );
1159 0 : aOpt.SetShowHiddenField( sal_False );
1160 0 : aOpt.SetShowHiddenPara( sal_False );
1161 0 : aOpt.SetViewHRuler( sal_False );
1162 0 : aOpt.SetViewVRuler( sal_False );
1163 0 : aOpt.SetGraphic( sal_True );
1164 0 : aOpt.SetTable( sal_True );
1165 0 : aOpt.SetSnap( sal_False );
1166 0 : aOpt.SetGridVisible( sal_False );
1167 :
1168 0 : GetViewShell()->ApplyViewOptions( aOpt );
1169 0 : GetViewShell()->ApplyAccessiblityOptions(SW_MOD()->GetAccessibilityOptions());
1170 :
1171 : // adjust view shell option to the same as for print
1172 0 : SwPrintData const aPrintOptions = *SW_MOD()->GetPrtOptions(false);
1173 0 : GetViewShell()->AdjustOptionsForPagePreview( aPrintOptions );
1174 :
1175 0 : GetViewShell()->CalcLayout();
1176 0 : DocSzChgd( GetViewShell()->GetDocSize() );
1177 :
1178 0 : if( !bIsModified )
1179 0 : pESh->ResetModified();
1180 0 : }
1181 :
1182 0 : SwPagePreView::SwPagePreView(SfxViewFrame *pViewFrame, SfxViewShell* pOldSh):
1183 : SfxViewShell( pViewFrame, SWVIEWFLAGS ),
1184 0 : aViewWin( &pViewFrame->GetWindow(), *this ),
1185 : nNewPage(USHRT_MAX),
1186 : sPageStr(SW_RES(STR_PAGE)),
1187 : pHScrollbar(0),
1188 : pVScrollbar(0),
1189 : pPageUpBtn(0),
1190 : pPageDownBtn(0),
1191 : pScrollFill(new ScrollBarBox( &pViewFrame->GetWindow(),
1192 0 : pViewFrame->GetFrame().GetParentFrame() ? 0 : WB_SIZEABLE )),
1193 : mnPageCount( 0 ),
1194 : mbResetFormDesignMode( false ),
1195 0 : mbFormDesignModeToReset( false )
1196 : {
1197 0 : SetName(rtl::OUString("PageView" ));
1198 0 : SetWindow( &aViewWin );
1199 0 : SetHelpId(SW_PAGEPREVIEW);
1200 0 : _CreateScrollbar( sal_True );
1201 0 : _CreateScrollbar( sal_False );
1202 :
1203 0 : SfxObjectShell* pObjShell = pViewFrame->GetObjectShell();
1204 0 : if ( !pOldSh )
1205 : {
1206 : //Gibt es schon eine Sicht auf das Dokument?
1207 0 : SfxViewFrame *pF = SfxViewFrame::GetFirst( pObjShell );
1208 0 : if ( pF == pViewFrame )
1209 0 : pF = SfxViewFrame::GetNext( *pF, pObjShell );
1210 0 : if ( pF )
1211 0 : pOldSh = pF->GetViewShell();
1212 : }
1213 :
1214 : ViewShell *pVS, *pNew;
1215 :
1216 0 : if( pOldSh && pOldSh->IsA( TYPE( SwPagePreView ) ) )
1217 0 : pVS = ((SwPagePreView*)pOldSh)->GetViewShell();
1218 : else
1219 : {
1220 0 : if( pOldSh && pOldSh->IsA( TYPE( SwView ) ) )
1221 : {
1222 0 : pVS = ((SwView*)pOldSh)->GetWrtShellPtr();
1223 : // save the current ViewData of the previous SwView
1224 0 : pOldSh->WriteUserData( sSwViewData, sal_False );
1225 : }
1226 : else
1227 0 : pVS = GetDocShell()->GetWrtShell();
1228 0 : if( pVS )
1229 : {
1230 : // setze die akt. Seite als die erste
1231 : sal_uInt16 nPhysPg, nVirtPg;
1232 0 : ((SwCrsrShell*)pVS)->GetPageNum( nPhysPg, nVirtPg, sal_True, sal_False );
1233 0 : if( 1 != aViewWin.GetCol() && 1 == nPhysPg )
1234 0 : --nPhysPg;
1235 0 : aViewWin.SetSttPage( nPhysPg );
1236 : }
1237 : }
1238 :
1239 : // for form shell remember design mode of draw view
1240 : // of previous view shell
1241 0 : if ( pVS && pVS->HasDrawView() )
1242 : {
1243 0 : mbResetFormDesignMode = true;
1244 0 : mbFormDesignModeToReset = pVS->GetDrawView()->IsDesignMode();
1245 : }
1246 :
1247 0 : if( pVS )
1248 0 : pNew = new ViewShell( *pVS, &aViewWin, 0, VSHELLFLAG_ISPREVIEW );
1249 : else
1250 : pNew = new ViewShell(
1251 0 : *((SwDocShell*)pViewFrame->GetObjectShell())->GetDoc(),
1252 0 : &aViewWin, 0, 0, VSHELLFLAG_ISPREVIEW );
1253 :
1254 0 : aViewWin.SetViewShell( pNew );
1255 0 : pNew->SetSfxViewShell( this );
1256 0 : Init();
1257 0 : }
1258 :
1259 0 : SwPagePreView::~SwPagePreView()
1260 : {
1261 0 : SetWindow( 0 );
1262 :
1263 0 : delete pScrollFill;
1264 0 : delete pHScrollbar;
1265 0 : delete pVScrollbar;
1266 0 : delete pPageUpBtn;
1267 0 : delete pPageDownBtn;
1268 :
1269 0 : }
1270 :
1271 0 : SwDocShell* SwPagePreView::GetDocShell()
1272 : {
1273 0 : return PTR_CAST(SwDocShell, GetViewFrame()->GetObjectShell());
1274 : }
1275 :
1276 0 : int SwPagePreView::_CreateScrollbar( sal_Bool bHori )
1277 : {
1278 0 : Window *pMDI = &GetViewFrame()->GetWindow();
1279 0 : SwScrollbar** ppScrollbar = bHori ? &pHScrollbar : &pVScrollbar;
1280 :
1281 : OSL_ENSURE( !*ppScrollbar, "vorher abpruefen!" );
1282 :
1283 0 : if( !bHori )
1284 : {
1285 :
1286 0 : pPageUpBtn = new ImageButton(pMDI, SW_RES( BTN_PAGEUP ) );
1287 0 : pPageUpBtn->SetHelpId(GetStaticInterface()->GetSlot(FN_PAGEUP)->GetCommand());
1288 0 : pPageDownBtn = new ImageButton(pMDI, SW_RES( BTN_PAGEDOWN ) );
1289 0 : pPageDownBtn->SetHelpId(GetStaticInterface()->GetSlot(FN_PAGEDOWN)->GetCommand());
1290 0 : Link aLk( LINK( this, SwPagePreView, BtnPage ) );
1291 0 : pPageUpBtn->SetClickHdl( aLk );
1292 0 : pPageDownBtn->SetClickHdl( aLk );
1293 0 : pPageUpBtn->Show();
1294 0 : pPageDownBtn->Show();
1295 : }
1296 :
1297 0 : *ppScrollbar = new SwScrollbar( pMDI, bHori );
1298 :
1299 0 : ScrollDocSzChg();
1300 0 : (*ppScrollbar)->EnableDrag( sal_True );
1301 0 : (*ppScrollbar)->SetEndScrollHdl( LINK( this, SwPagePreView, EndScrollHdl ));
1302 :
1303 :
1304 0 : (*ppScrollbar)->SetScrollHdl( LINK( this, SwPagePreView, ScrollHdl ));
1305 :
1306 0 : InvalidateBorder();
1307 0 : (*ppScrollbar)->ExtendedShow();
1308 0 : return 1;
1309 : }
1310 :
1311 : /*
1312 : * Button-Handler
1313 : */
1314 0 : IMPL_LINK_INLINE_START( SwPagePreView, BtnPage, Button *, pButton )
1315 : {
1316 : // use new helper method to perform page up
1317 : // respectively page down.
1318 0 : _ExecPgUpAndPgDown( pButton == pPageUpBtn );
1319 0 : return 0;
1320 : }
1321 0 : IMPL_LINK_INLINE_END( SwPagePreView, BtnPage, Button *, pButton )
1322 :
1323 0 : int SwPagePreView::ChgPage( int eMvMode, int bUpdateScrollbar )
1324 : {
1325 0 : Rectangle aPixVisArea( aViewWin.LogicToPixel( aVisArea ) );
1326 0 : int bChg = aViewWin.MovePage( eMvMode ) ||
1327 : eMvMode == SwPagePreViewWin::MV_CALC ||
1328 0 : eMvMode == SwPagePreViewWin::MV_NEWWINSIZE;
1329 0 : aVisArea = aViewWin.PixelToLogic( aPixVisArea );
1330 :
1331 0 : if( bChg )
1332 : {
1333 : // Statusleiste updaten
1334 0 : OUString aStr = sPageStr + aViewWin.GetStatusStr( mnPageCount );
1335 0 : SfxBindings& rBindings = GetViewFrame()->GetBindings();
1336 :
1337 0 : if( bUpdateScrollbar )
1338 : {
1339 0 : ScrollViewSzChg();
1340 :
1341 : static sal_uInt16 aInval[] =
1342 : {
1343 : FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT,
1344 : FN_PAGEUP, FN_PAGEDOWN, 0
1345 : };
1346 0 : rBindings.Invalidate( aInval );
1347 : }
1348 0 : rBindings.SetState( SfxStringItem( FN_STAT_PAGE, aStr ) );
1349 : }
1350 0 : return bChg;
1351 : }
1352 :
1353 : // ab hier alles aus der SwView uebernommen
1354 0 : void SwPagePreView::CalcAndSetBorderPixel( SvBorder &rToFill, sal_Bool /*bInner*/ )
1355 : {
1356 0 : const StyleSettings &rSet = aViewWin.GetSettings().GetStyleSettings();
1357 0 : const long nTmp = rSet.GetScrollBarSize();
1358 0 : if ( pVScrollbar->IsVisible( true ) )
1359 0 : rToFill.Right() = nTmp;
1360 0 : if ( pHScrollbar->IsVisible( true ) )
1361 0 : rToFill.Bottom() = nTmp;
1362 0 : SetBorderPixel( rToFill );
1363 0 : }
1364 :
1365 0 : void SwPagePreView::InnerResizePixel( const Point &rOfst, const Size &rSize )
1366 : {
1367 0 : SvBorder aBorder;
1368 0 : CalcAndSetBorderPixel( aBorder, sal_True );
1369 0 : Rectangle aRect( rOfst, rSize );
1370 0 : aRect += aBorder;
1371 : ViewResizePixel( aViewWin, aRect.TopLeft(), aRect.GetSize(),
1372 0 : aViewWin.GetOutputSizePixel(),
1373 : sal_True,
1374 : *pVScrollbar, *pHScrollbar, pPageUpBtn, pPageDownBtn, 0,
1375 0 : *pScrollFill );
1376 :
1377 : //EditWin niemals einstellen!
1378 : //VisArea niemals einstellen!
1379 0 : }
1380 :
1381 0 : void SwPagePreView::OuterResizePixel( const Point &rOfst, const Size &rSize )
1382 : {
1383 0 : SvBorder aBorder;
1384 0 : CalcAndSetBorderPixel( aBorder, sal_False );
1385 :
1386 : //EditWin niemals einstellen!
1387 :
1388 0 : Size aTmpSize( aViewWin.GetOutputSizePixel() );
1389 0 : Point aBottomRight( aViewWin.PixelToLogic( Point( aTmpSize.Width(), aTmpSize.Height() ) ) );
1390 0 : SetVisArea( Rectangle( Point(), aBottomRight ) );
1391 :
1392 : //Aufruf der DocSzChgd-Methode der Scrollbars ist noetig, da vom maximalen
1393 : //Scrollrange immer die halbe Hoehe der VisArea abgezogen wird.
1394 0 : if ( pVScrollbar && aTmpSize.Width() > 0 && aTmpSize.Height() > 0 )
1395 : {
1396 0 : ScrollDocSzChg();
1397 : }
1398 :
1399 0 : SvBorder aBorderNew;
1400 0 : CalcAndSetBorderPixel( aBorderNew, sal_False );
1401 0 : ViewResizePixel( aViewWin, rOfst, rSize, aViewWin.GetOutputSizePixel(),
1402 : sal_False, *pVScrollbar,
1403 0 : *pHScrollbar, pPageUpBtn, pPageDownBtn, 0, *pScrollFill );
1404 0 : }
1405 :
1406 0 : void SwPagePreView::SetVisArea( const Rectangle &rRect, sal_Bool bUpdateScrollbar )
1407 : {
1408 0 : const Point aTopLeft(AlignToPixel(rRect.TopLeft()));
1409 0 : const Point aBottomRight(AlignToPixel(rRect.BottomRight()));
1410 0 : Rectangle aLR(aTopLeft,aBottomRight);
1411 :
1412 0 : if(aLR == aVisArea)
1413 : return;
1414 : // keine negative Position, keine neg. Groesse
1415 :
1416 0 : if(aLR.Top() < 0)
1417 : {
1418 0 : aLR.Bottom() += Abs(aLR.Top());
1419 0 : aLR.Top() = 0;
1420 : }
1421 :
1422 0 : if(aLR.Left() < 0)
1423 : {
1424 0 : aLR.Right() += Abs(aLR.Left());
1425 0 : aLR.Left() = 0;
1426 : }
1427 0 : if(aLR.Right() < 0) aLR.Right() = 0;
1428 0 : if(aLR.Bottom() < 0) aLR.Bottom() = 0;
1429 0 : if(aLR == aVisArea ||
1430 : // Leeres Rechteck nicht beachten
1431 0 : ( 0 == aLR.Bottom() - aLR.Top() && 0 == aLR.Right() - aLR.Left() ) )
1432 : return;
1433 :
1434 0 : if( aLR.Left() > aLR.Right() || aLR.Top() > aLR.Bottom() )
1435 : return;
1436 :
1437 : //Bevor die Daten veraendert werden ggf. ein Update rufen. Dadurch wird
1438 : //sichergestellt, da? anliegende Paints korrekt in Dokumentkoordinaten
1439 : //umgerechnet werden.
1440 : //Vorsichtshalber tun wir das nur wenn an der Shell eine Action laeuft,
1441 : //denn dann wir nicht wirklich gepaintet sondern die Rechtecke werden
1442 : //lediglich (in Dokumentkoordinaten) vorgemerkt.
1443 0 : if( GetViewShell()->ActionPend() )
1444 0 : aViewWin.Update();
1445 :
1446 : // setze am View-Win die aktuelle Size
1447 0 : aVisArea = aLR;
1448 0 : aViewWin.SetWinSize( aLR.GetSize() );
1449 0 : ChgPage( SwPagePreViewWin::MV_NEWWINSIZE, bUpdateScrollbar );
1450 :
1451 0 : aViewWin.Invalidate();
1452 : }
1453 :
1454 0 : IMPL_LINK( SwPagePreView, ScrollHdl, SwScrollbar *, pScrollbar )
1455 : {
1456 0 : if(!GetViewShell())
1457 0 : return 0;
1458 0 : if( !pScrollbar->IsHoriScroll() &&
1459 0 : pScrollbar->GetType() == SCROLL_DRAG &&
1460 0 : Help::IsQuickHelpEnabled() &&
1461 0 : GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow())
1462 : {
1463 : // wieviele Seiten scrollen ??
1464 0 : String sStateStr(sPageStr);
1465 0 : sal_uInt16 nThmbPos = (sal_uInt16)pScrollbar->GetThumbPos();
1466 0 : if( 1 == aViewWin.GetCol() || !nThmbPos )
1467 0 : ++nThmbPos;
1468 0 : sStateStr += String::CreateFromInt32( nThmbPos );
1469 : Point aPos = pScrollbar->GetParent()->OutputToScreenPixel(
1470 0 : pScrollbar->GetPosPixel());
1471 0 : aPos.Y() = pScrollbar->OutputToScreenPixel(pScrollbar->GetPointerPosPixel()).Y();
1472 0 : Rectangle aRect;
1473 0 : aRect.Left() = aPos.X() -8;
1474 0 : aRect.Right() = aRect.Left();
1475 0 : aRect.Top() = aPos.Y();
1476 0 : aRect.Bottom() = aRect.Top();
1477 :
1478 : Help::ShowQuickHelp(pScrollbar, aRect, sStateStr,
1479 0 : QUICKHELP_RIGHT|QUICKHELP_VCENTER);
1480 :
1481 : }
1482 : else
1483 0 : EndScrollHdl( pScrollbar );
1484 0 : return 0;
1485 : }
1486 :
1487 0 : IMPL_LINK( SwPagePreView, EndScrollHdl, SwScrollbar *, pScrollbar )
1488 : {
1489 0 : if(!GetViewShell())
1490 0 : return 0;
1491 :
1492 : // boolean to avoid unnecessary invalidation of the window.
1493 0 : bool bInvalidateWin = true;
1494 :
1495 0 : if( !pScrollbar->IsHoriScroll() ) // scroll vertically
1496 : {
1497 0 : if ( Help::IsQuickHelpEnabled() )
1498 0 : Help::ShowQuickHelp(pScrollbar, Rectangle(), aEmptyStr, 0);
1499 0 : if ( GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow() )
1500 : {
1501 : // wieviele Seiten scrollen ??
1502 0 : sal_uInt16 nThmbPos = (sal_uInt16)pScrollbar->GetThumbPos();
1503 : // adjust to new preview functionality
1504 0 : if( nThmbPos != aViewWin.SelectedPage() )
1505 : {
1506 : // consider case that page <nThmbPos>
1507 : // is already visible
1508 0 : SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
1509 0 : if ( pPagePrevwLay->IsPageVisible( nThmbPos ) )
1510 : {
1511 0 : pPagePrevwLay->MarkNewSelectedPage( nThmbPos );
1512 : // invalidation of window is unnecessary
1513 0 : bInvalidateWin = false;
1514 : }
1515 : else
1516 : {
1517 : // consider whether layout columns
1518 : // fit or not.
1519 0 : if ( !pPagePrevwLay->DoesPreviewLayoutColsFitIntoWindow() )
1520 : {
1521 0 : aViewWin.SetSttPage( nThmbPos );
1522 0 : aViewWin.SetSelectedPage( nThmbPos );
1523 0 : ChgPage( SwPagePreViewWin::MV_SCROLL, sal_False );
1524 : // update scrollbars
1525 0 : ScrollViewSzChg();
1526 : }
1527 : else
1528 : {
1529 : // correct scroll amount
1530 0 : const sal_Int16 nPageDiff = nThmbPos - aViewWin.SelectedPage();
1531 0 : const sal_uInt16 nVisPages = aViewWin.GetRow() * aViewWin.GetCol();
1532 0 : sal_Int16 nWinPagesToScroll = nPageDiff / nVisPages;
1533 0 : if ( nPageDiff % nVisPages )
1534 : {
1535 : // decrease/increase number of preview pages to scroll
1536 0 : nPageDiff < 0 ? --nWinPagesToScroll : ++nWinPagesToScroll;
1537 : }
1538 0 : aViewWin.SetSelectedPage( nThmbPos );
1539 0 : aViewWin.Scroll( 0, pPagePrevwLay->GetWinPagesScrollAmount( nWinPagesToScroll ) );
1540 : }
1541 : }
1542 : // update accessibility
1543 0 : GetViewShell()->ShowPreViewSelection( nThmbPos );
1544 : }
1545 : else
1546 : {
1547 : // invalidation of window is unnecessary
1548 0 : bInvalidateWin = false;
1549 : }
1550 : }
1551 : else
1552 : {
1553 0 : long nThmbPos = pScrollbar->GetThumbPos();
1554 0 : aViewWin.Scroll(0, nThmbPos - aViewWin.GetPaintedPreviewDocRect().Top());
1555 : }
1556 : }
1557 : else
1558 : {
1559 0 : long nThmbPos = pScrollbar->GetThumbPos();
1560 0 : aViewWin.Scroll(nThmbPos - aViewWin.GetPaintedPreviewDocRect().Left(), 0);
1561 : }
1562 : // additional invalidate page status.
1563 : static sal_uInt16 aInval[] =
1564 : {
1565 : FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
1566 : FN_STAT_PAGE, 0
1567 : };
1568 0 : SfxBindings& rBindings = GetViewFrame()->GetBindings();
1569 0 : rBindings.Invalidate( aInval );
1570 : // control invalidation of window
1571 0 : if ( bInvalidateWin )
1572 : {
1573 0 : aViewWin.Invalidate();
1574 : }
1575 0 : return 0;
1576 : }
1577 :
1578 0 : Point SwPagePreView::AlignToPixel(const Point &rPt) const
1579 : {
1580 0 : return aViewWin.PixelToLogic( aViewWin.LogicToPixel( rPt ) );
1581 : }
1582 :
1583 0 : void SwPagePreView::DocSzChgd( const Size &rSz )
1584 : {
1585 0 : if( aDocSz == rSz )
1586 0 : return;
1587 :
1588 0 : aDocSz = rSz;
1589 :
1590 : // #i96726#
1591 : // Due to the multiple page layout it is needed to trigger recalculation
1592 : // of the page preview layout, even if the count of pages is not changing.
1593 0 : mnPageCount = GetViewShell()->GetNumPages();
1594 :
1595 0 : if( aVisArea.GetWidth() )
1596 : {
1597 0 : ChgPage( SwPagePreViewWin::MV_CALC, sal_True );
1598 0 : ScrollDocSzChg();
1599 :
1600 0 : aViewWin.Invalidate();
1601 : }
1602 : }
1603 :
1604 0 : void SwPagePreView::ScrollViewSzChg()
1605 : {
1606 0 : if(!GetViewShell())
1607 0 : return ;
1608 :
1609 0 : bool bShowVScrollbar = false, bShowHScrollbar = false;
1610 :
1611 0 : if(pVScrollbar)
1612 : {
1613 0 : if(GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow())
1614 : {
1615 : //vertical scrolling by row
1616 : // adjust to new preview functionality
1617 0 : sal_uInt16 nVisPages = aViewWin.GetRow() * aViewWin.GetCol();
1618 :
1619 0 : pVScrollbar->SetVisibleSize( nVisPages );
1620 : // set selected page as scroll bar position,
1621 : // if it is visible.
1622 0 : SwPagePreviewLayout* pPagePrevwLay = GetViewShell()->PagePreviewLayout();
1623 0 : if ( pPagePrevwLay->IsPageVisible( aViewWin.SelectedPage() ) )
1624 : {
1625 0 : pVScrollbar->SetThumbPos( aViewWin.SelectedPage() );
1626 : }
1627 : else
1628 : {
1629 0 : pVScrollbar->SetThumbPos( aViewWin.GetSttPage() );
1630 : }
1631 0 : pVScrollbar->SetLineSize( aViewWin.GetCol() );
1632 0 : pVScrollbar->SetPageSize( nVisPages );
1633 : // calculate and set scrollbar range
1634 0 : Range aScrollbarRange( 1, mnPageCount );
1635 : // increase range by one, because left-top-corner is left blank.
1636 0 : ++aScrollbarRange.Max();
1637 : // increase range in order to access all pages
1638 0 : aScrollbarRange.Max() += ( nVisPages - 1 );
1639 0 : pVScrollbar->SetRange( aScrollbarRange );
1640 :
1641 0 : bShowVScrollbar = nVisPages < mnPageCount;
1642 : }
1643 : else //vertical scrolling by pixel
1644 : {
1645 0 : const Rectangle& rDocRect = aViewWin.GetPaintedPreviewDocRect();
1646 : const Size& rPreviewSize =
1647 0 : GetViewShell()->PagePreviewLayout()->GetPrevwDocSize();
1648 0 : pVScrollbar->SetRangeMax(rPreviewSize.Height()) ;
1649 0 : long nVisHeight = rDocRect.GetHeight();
1650 0 : pVScrollbar->SetVisibleSize( nVisHeight );
1651 0 : pVScrollbar->SetThumbPos( rDocRect.Top() );
1652 0 : pVScrollbar->SetLineSize( nVisHeight / 10 );
1653 0 : pVScrollbar->SetPageSize( nVisHeight / 2 );
1654 :
1655 0 : bShowVScrollbar = true;
1656 : }
1657 :
1658 0 : if (!mbVScrollbarEnabled)
1659 0 : bShowVScrollbar = false;
1660 :
1661 0 : ShowVScrollbar(bShowVScrollbar);
1662 0 : pPageUpBtn->Show(bShowVScrollbar);
1663 0 : pPageDownBtn->Show(bShowVScrollbar);
1664 : }
1665 0 : if(pHScrollbar)
1666 : {
1667 0 : const Rectangle& rDocRect = aViewWin.GetPaintedPreviewDocRect();
1668 : const Size& rPreviewSize =
1669 0 : GetViewShell()->PagePreviewLayout()->GetPrevwDocSize();
1670 0 : long nVisWidth = 0;
1671 0 : long nThumb = 0;
1672 0 : Range aRange(0,0);
1673 :
1674 0 : if(rDocRect.GetWidth() < rPreviewSize.Width())
1675 : {
1676 0 : bShowHScrollbar = true;
1677 :
1678 0 : nVisWidth = rDocRect.GetWidth();
1679 0 : nThumb = rDocRect.Left();
1680 0 : aRange = Range(0, rPreviewSize.Width());
1681 :
1682 0 : pHScrollbar->SetRange( aRange );
1683 0 : pHScrollbar->SetVisibleSize( nVisWidth );
1684 0 : pHScrollbar->SetThumbPos( nThumb );
1685 0 : pHScrollbar->SetLineSize( nVisWidth / 10 );
1686 0 : pHScrollbar->SetPageSize( nVisWidth / 2 );
1687 : }
1688 :
1689 0 : if (!mbHScrollbarEnabled)
1690 0 : bShowHScrollbar = false;
1691 :
1692 0 : ShowHScrollbar(bShowHScrollbar);
1693 : }
1694 0 : pScrollFill->Show(bShowVScrollbar && bShowHScrollbar);
1695 : }
1696 :
1697 0 : void SwPagePreView::ScrollDocSzChg()
1698 : {
1699 0 : ScrollViewSzChg();
1700 0 : }
1701 :
1702 : // alles zum Thema Drucken
1703 0 : SfxPrinter* SwPagePreView::GetPrinter( sal_Bool bCreate )
1704 : {
1705 0 : return aViewWin.GetViewShell()->getIDocumentDeviceAccess()->getPrinter( bCreate );
1706 : }
1707 :
1708 0 : sal_uInt16 SwPagePreView::SetPrinter( SfxPrinter *pNew, sal_uInt16 nDiffFlags, bool )
1709 : {
1710 0 : ViewShell &rSh = *GetViewShell();
1711 0 : SfxPrinter* pOld = rSh.getIDocumentDeviceAccess()->getPrinter( false );
1712 0 : if ( pOld && pOld->IsPrinting() )
1713 0 : return SFX_PRINTERROR_BUSY;
1714 :
1715 0 : SwEditShell &rESh = (SwEditShell&)rSh; //Buh...
1716 0 : if( ( SFX_PRINTER_PRINTER | SFX_PRINTER_JOBSETUP ) & nDiffFlags )
1717 : {
1718 0 : rSh.getIDocumentDeviceAccess()->setPrinter( pNew, true, true );
1719 0 : if( nDiffFlags & SFX_PRINTER_PRINTER )
1720 0 : rESh.SetModified();
1721 : }
1722 0 : if ( ( nDiffFlags & SFX_PRINTER_OPTIONS ) == SFX_PRINTER_OPTIONS )
1723 0 : ::SetPrinter( rSh.getIDocumentDeviceAccess(), pNew, sal_False );
1724 :
1725 0 : const sal_Bool bChgOri = nDiffFlags & SFX_PRINTER_CHG_ORIENTATION ? sal_True : sal_False;
1726 0 : const sal_Bool bChgSize= nDiffFlags & SFX_PRINTER_CHG_SIZE ? sal_True : sal_False;
1727 0 : if ( bChgOri || bChgSize )
1728 : {
1729 0 : rESh.StartAllAction();
1730 0 : if ( bChgOri )
1731 0 : rSh.ChgAllPageOrientation( sal_uInt16(pNew->GetOrientation()) );
1732 0 : if ( bChgSize )
1733 : {
1734 0 : Size aSz( SvxPaperInfo::GetPaperSize( pNew ) );
1735 0 : rSh.ChgAllPageSize( aSz );
1736 : }
1737 0 : if( !bNormalPrint )
1738 0 : aViewWin.CalcWish( aViewWin.GetRow(), aViewWin.GetCol() );
1739 0 : rESh.SetModified();
1740 0 : rESh.EndAllAction();
1741 :
1742 : static sal_uInt16 aInval[] =
1743 : {
1744 : SID_ATTR_LONG_ULSPACE, SID_ATTR_LONG_LRSPACE,
1745 : SID_RULER_BORDERS, SID_RULER_PAGE_POS, 0
1746 : };
1747 : #if OSL_DEBUG_LEVEL > 0
1748 : {
1749 : const sal_uInt16* pPtr = aInval + 1;
1750 : do {
1751 : OSL_ENSURE( *(pPtr - 1) < *pPtr, "wrong sorting!" );
1752 : } while( *++pPtr );
1753 : }
1754 : #endif
1755 :
1756 0 : GetViewFrame()->GetBindings().Invalidate(aInval);
1757 : }
1758 :
1759 0 : return 0;
1760 : }
1761 :
1762 0 : bool SwPagePreView::HasPrintOptionsPage() const
1763 : {
1764 0 : return true;
1765 : }
1766 :
1767 0 : SfxTabPage* SwPagePreView::CreatePrintOptionsPage( Window *pParent,
1768 : const SfxItemSet &rOptions )
1769 : {
1770 0 : return ::CreatePrintOptionsPage( pParent, rOptions, !bNormalPrint );
1771 : }
1772 :
1773 0 : Size SwPagePreView::GetOptimalSizePixel() const
1774 : {
1775 : OSL_FAIL( "overloaded virtual method <SwPagePreView::GetOptimalSizePixel()> needed ??" );
1776 0 : return Size( -1, -1 );
1777 : }
1778 :
1779 0 : void SwPagePreViewWin::SetViewShell( ViewShell* pShell )
1780 : {
1781 0 : mpViewShell = pShell;
1782 0 : if ( mpViewShell && mpViewShell->IsPreView() )
1783 : {
1784 0 : mpPgPrevwLayout = mpViewShell->PagePreviewLayout();
1785 : }
1786 0 : }
1787 :
1788 0 : void SwPagePreViewWin::RepaintCoreRect( const SwRect& rRect )
1789 : {
1790 : // #i24183#
1791 0 : if ( mpPgPrevwLayout->PreviewLayoutValid() )
1792 : {
1793 0 : mpPgPrevwLayout->Repaint( Rectangle( rRect.Pos(), rRect.SSize() ) );
1794 : }
1795 0 : }
1796 :
1797 : /** method to adjust preview to a new zoom factor
1798 :
1799 : #i19975# also consider zoom type - adding parameter <_eZoomType>
1800 : */
1801 0 : void SwPagePreViewWin::AdjustPreviewToNewZoom( const sal_uInt16 _nZoomFactor,
1802 : const SvxZoomType _eZoomType )
1803 : {
1804 : // #i19975# consider zoom type
1805 0 : if ( _eZoomType == SVX_ZOOM_WHOLEPAGE )
1806 : {
1807 0 : mnRow = 1;
1808 0 : mnCol = 1;
1809 0 : mpPgPrevwLayout->Init( mnCol, mnRow, maPxWinSize, true );
1810 : mpPgPrevwLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
1811 0 : mnSttPage, maPaintedPreviewDocRect );
1812 0 : SetSelectedPage( mnSttPage );
1813 0 : SetPagePreview(mnRow, mnCol);
1814 0 : maScale = GetMapMode().GetScaleX();
1815 : }
1816 0 : else if ( _nZoomFactor != 0 )
1817 : {
1818 : // calculate new scaling and set mapping mode appropriately.
1819 0 : Fraction aNewScale( _nZoomFactor, 100 );
1820 0 : MapMode aNewMapMode = GetMapMode();
1821 0 : aNewMapMode.SetScaleX( aNewScale );
1822 0 : aNewMapMode.SetScaleY( aNewScale );
1823 0 : SetMapMode( aNewMapMode );
1824 :
1825 : // calculate new start position for preview paint
1826 0 : Size aNewWinSize = PixelToLogic( maPxWinSize );
1827 : Point aNewPaintStartPos =
1828 0 : mpPgPrevwLayout->GetPreviewStartPosForNewScale( aNewScale, maScale, aNewWinSize );
1829 :
1830 : // remember new scaling and prepare preview paint
1831 : // Note: paint of preview will be performed by a corresponding invalidate
1832 : // due to property changes.
1833 0 : maScale = aNewScale;
1834 : mpPgPrevwLayout->Prepare( 0, aNewPaintStartPos, maPxWinSize,
1835 0 : mnSttPage, maPaintedPreviewDocRect );
1836 : }
1837 :
1838 0 : }
1839 :
1840 : /**
1841 : * pixel scrolling - horizontally always or vertically
1842 : * when less than the desired number of rows fits into
1843 : * the view
1844 : */
1845 0 : void SwPagePreViewWin::Scroll(long nXMove, long nYMove, sal_uInt16 /*nFlags*/)
1846 : {
1847 0 : maPaintedPreviewDocRect.Move(nXMove, nYMove);
1848 : mpPgPrevwLayout->Prepare( 0, maPaintedPreviewDocRect.TopLeft(),
1849 : maPxWinSize, mnSttPage,
1850 0 : maPaintedPreviewDocRect );
1851 :
1852 0 : }
1853 :
1854 0 : sal_Bool SwPagePreView::HandleWheelCommands( const CommandEvent& rCEvt )
1855 : {
1856 0 : sal_Bool bOk = sal_False;
1857 0 : const CommandWheelData* pWData = rCEvt.GetWheelData();
1858 0 : if( pWData && COMMAND_WHEEL_ZOOM == pWData->GetMode() )
1859 : {
1860 0 : if(!Application::GetSettings().GetMiscSettings().GetEnableATToolSupport())
1861 : {
1862 0 : sal_uInt16 nFactor = GetViewShell()->GetViewOptions()->GetZoom();
1863 0 : const sal_uInt16 nOffset = 10;
1864 0 : if( 0L > pWData->GetDelta() )
1865 : {
1866 0 : nFactor -= nOffset;
1867 0 : if(nFactor < MIN_PREVIEW_ZOOM)
1868 0 : nFactor = MIN_PREVIEW_ZOOM;
1869 : }
1870 : else
1871 : {
1872 0 : nFactor += nOffset;
1873 0 : if(nFactor > MAX_PREVIEW_ZOOM)
1874 0 : nFactor = MAX_PREVIEW_ZOOM;
1875 : }
1876 0 : SetZoom(SVX_ZOOM_PERCENT, nFactor);
1877 : }
1878 0 : bOk = sal_True;
1879 : }
1880 : else
1881 0 : bOk = aViewWin.HandleScrollCommand( rCEvt, pHScrollbar, pVScrollbar );
1882 0 : return bOk;
1883 : }
1884 :
1885 : uno::Reference< ::com::sun::star::accessibility::XAccessible >
1886 0 : SwPagePreViewWin::CreateAccessible()
1887 : {
1888 0 : SolarMutexGuard aGuard; // this should have happend already!!!
1889 :
1890 : OSL_ENSURE( GetViewShell() != NULL, "We need a view shell" );
1891 0 : return GetViewShell()->CreateAccessiblePreview();
1892 : }
1893 :
1894 0 : void SwPagePreView::ApplyAccessiblityOptions(SvtAccessibilityOptions& rAccessibilityOptions)
1895 : {
1896 0 : GetViewShell()->ApplyAccessiblityOptions(rAccessibilityOptions);
1897 0 : }
1898 :
1899 0 : void SwPagePreView::ShowHScrollbar(sal_Bool bShow)
1900 : {
1901 0 : pHScrollbar->Show(bShow);
1902 0 : InvalidateBorder();
1903 0 : }
1904 :
1905 0 : void SwPagePreView::ShowVScrollbar(sal_Bool bShow)
1906 : {
1907 0 : pVScrollbar->Show(bShow);
1908 0 : InvalidateBorder();
1909 0 : }
1910 :
1911 0 : void SwPagePreView::EnableHScrollbar(bool bEnable)
1912 : {
1913 0 : if (mbHScrollbarEnabled != bEnable)
1914 : {
1915 0 : mbHScrollbarEnabled = bEnable;
1916 0 : ScrollViewSzChg();
1917 : }
1918 0 : }
1919 :
1920 0 : void SwPagePreView::EnableVScrollbar(bool bEnable)
1921 : {
1922 0 : if (mbVScrollbarEnabled != bEnable)
1923 : {
1924 0 : mbVScrollbarEnabled = bEnable;
1925 0 : ScrollViewSzChg();
1926 : }
1927 0 : }
1928 :
1929 0 : void SwPagePreView::SetZoom(SvxZoomType eType, sal_uInt16 nFactor)
1930 : {
1931 0 : ViewShell& rSh = *GetViewShell();
1932 0 : SwViewOption aOpt(*rSh.GetViewOptions());
1933 : // perform action only on changes of zoom or zoom type.
1934 0 : if ( aOpt.GetZoom() != nFactor ||
1935 0 : aOpt.GetZoomType() != eType )
1936 : {
1937 0 : aOpt.SetZoom(nFactor);
1938 0 : aOpt.SetZoomType(eType);
1939 0 : rSh.ApplyViewOptions( aOpt );
1940 0 : lcl_InvalidateZoomSlots(GetViewFrame()->GetBindings());
1941 : // #i19975# also consider zoom type
1942 0 : aViewWin.AdjustPreviewToNewZoom( nFactor, eType );
1943 0 : ScrollViewSzChg();
1944 0 : }
1945 0 : }
1946 :
1947 : /** adjust position of vertical scrollbar
1948 :
1949 : @author OD
1950 : */
1951 0 : void SwPagePreView::SetVScrollbarThumbPos( const sal_uInt16 _nNewThumbPos )
1952 : {
1953 0 : if ( pVScrollbar )
1954 : {
1955 0 : pVScrollbar->SetThumbPos( _nNewThumbPos );
1956 : }
1957 30 : }
1958 :
1959 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
