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