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 : #include <sal/config.h>
21 :
22 : #include <cstdlib>
23 :
24 : #include "scitems.hxx"
25 : #include <comphelper/string.hxx>
26 : #include <editeng/eeitem.hxx>
27 :
28 : #include <sfx2/app.hxx>
29 : #include <editeng/sizeitem.hxx>
30 : #include <svl/srchitem.hxx>
31 : #include <svx/zoomslideritem.hxx>
32 : #include <svx/svdview.hxx>
33 : #include <sfx2/dispatch.hxx>
34 : #include <sfx2/objface.hxx>
35 : #include <sfx2/request.hxx>
36 : #include <svl/stritem.hxx>
37 : #include <svl/whiter.hxx>
38 : #include <vcl/msgbox.hxx>
39 : #include <vcl/help.hxx>
40 : #include <vcl/settings.hxx>
41 : #include <tools/urlobj.hxx>
42 : #include <sfx2/docfile.hxx>
43 : #include <sfx2/printer.hxx>
44 :
45 : #include "prevwsh.hxx"
46 : #include "preview.hxx"
47 : #include "printfun.hxx"
48 : #include "attrib.hxx"
49 : #include "scmod.hxx"
50 : #include "inputhdl.hxx"
51 : #include "docsh.hxx"
52 : #include "tabvwsh.hxx"
53 : #include "stlpool.hxx"
54 : #include "editutil.hxx"
55 : #include "scresid.hxx"
56 : #include "globstr.hrc"
57 : #include "sc.hrc"
58 : #include "ViewSettingsSequenceDefines.hxx"
59 : #include "tpprint.hxx"
60 : #include "printopt.hxx"
61 : #include "viewuno.hxx"
62 : #include <sax/tools/converter.hxx>
63 : #include <rtl/ustrbuf.hxx>
64 :
65 : #include <svx/svxdlg.hxx>
66 : #include <svx/dialogs.hrc>
67 :
68 : #include <basegfx/tools/zoomtools.hxx>
69 : #include <svx/zoom_def.hxx>
70 : #include <com/sun/star/document/XDocumentProperties.hpp>
71 :
72 : #include "scabstdlg.hxx"
73 : // for mouse wheel
74 : #define MINZOOM_SLIDER 10
75 : #define MAXZOOM_SLIDER 400
76 :
77 : #define SC_USERDATA_SEP ';'
78 :
79 : using namespace com::sun::star;
80 :
81 : #define ScPreviewShell
82 : #include "scslots.hxx"
83 :
84 : #include <boost/scoped_ptr.hpp>
85 :
86 780 : TYPEINIT1( ScPreviewShell, SfxViewShell );
87 :
88 5272 : SFX_IMPL_INTERFACE(ScPreviewShell, SfxViewShell, ScResId(SCSTR_PREVIEWSHELL))
89 :
90 76 : void ScPreviewShell::InitInterface_Impl()
91 : {
92 : GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT|SFX_VISIBILITY_STANDARD|SFX_VISIBILITY_SERVER|SFX_VISIBILITY_READONLYDOC,
93 76 : ScResId(RID_OBJECTBAR_PREVIEW));
94 :
95 76 : GetStaticInterface()->RegisterPopupMenu(ScResId(RID_POPUP_PREVIEW));
96 76 : }
97 :
98 168 : SFX_IMPL_NAMED_VIEWFACTORY( ScPreviewShell, "PrintPreview" )
99 : {
100 76 : SFX_VIEW_REGISTRATION(ScDocShell);
101 76 : }
102 :
103 16 : void ScPreviewShell::Construct( vcl::Window* pParent )
104 : {
105 : // Find the top-most window, and set the close window handler to intercept
106 : // the window close event.
107 16 : vcl::Window* pWin = pParent;
108 64 : while (!pWin->IsSystemWindow())
109 : {
110 32 : if (pWin->GetParent())
111 32 : pWin = pWin->GetParent();
112 : else
113 0 : break;
114 : }
115 :
116 16 : mpFrameWindow = dynamic_cast<SystemWindow*>(pWin);
117 16 : if (mpFrameWindow)
118 16 : mpFrameWindow->SetCloseHdl(LINK(this, ScPreviewShell, CloseHdl));
119 :
120 16 : eZoom = SVX_ZOOM_WHOLEPAGE;
121 :
122 16 : pCorner = new ScrollBarBox( pParent, WB_SIZEABLE );
123 :
124 16 : pHorScroll = new ScrollBar(pParent, WB_HSCROLL );
125 16 : pVerScroll = new ScrollBar(pParent, WB_VSCROLL);
126 :
127 : // SSA: --- RTL --- no mirroring for horizontal scrollbars
128 16 : pHorScroll->EnableRTL( false );
129 :
130 16 : pHorScroll->SetEndScrollHdl( LINK( this, ScPreviewShell, ScrollHandler ) );
131 16 : pVerScroll->SetEndScrollHdl( LINK( this, ScPreviewShell, ScrollHandler ) );
132 :
133 16 : pPreview = new ScPreview( pParent, pDocShell, this );
134 :
135 16 : SetPool( &SC_MOD()->GetPool() );
136 16 : SetWindow( pPreview );
137 16 : StartListening(*pDocShell,true);
138 16 : StartListening(*SfxGetpApp(),true); // #i62045# #i62046# application is needed for Calc's own hints
139 16 : SfxBroadcaster* pDrawBC = pDocShell->GetDocument().GetDrawBroadcaster();
140 16 : if (pDrawBC)
141 16 : StartListening(*pDrawBC);
142 :
143 16 : pHorScroll->Show( false );
144 16 : pVerScroll->Show( false );
145 16 : pCorner->Show();
146 16 : SetHelpId( HID_SCSHELL_PREVWSH );
147 16 : SetName(OUString("Preview"));
148 16 : }
149 :
150 16 : ScPreviewShell::ScPreviewShell( SfxViewFrame* pViewFrame,
151 : SfxViewShell* pOldSh ) :
152 : SfxViewShell( pViewFrame, SFX_VIEW_CAN_PRINT | SFX_VIEW_HAS_PRINTOPTIONS ),
153 16 : pDocShell( static_cast<ScDocShell*>(pViewFrame->GetObjectShell()) ),
154 : mpFrameWindow(NULL),
155 : nSourceDesignMode( SC_FORCEMODE_NONE ),
156 : nMaxVertPos(0),
157 32 : pAccessibilityBroadcaster( NULL )
158 : {
159 16 : Construct( &pViewFrame->GetWindow() );
160 :
161 16 : if ( pOldSh && pOldSh->ISA( ScTabViewShell ) )
162 : {
163 : // store view settings, show table from TabView
164 : //! store live ScViewData instead, and update on ScTablesHint?
165 : //! or completely forget aSourceData on ScTablesHint?
166 :
167 16 : ScTabViewShell* pTabViewShell = static_cast<ScTabViewShell*>(pOldSh);
168 16 : const ScViewData& rData = pTabViewShell->GetViewData();
169 16 : rData.WriteUserDataSequence( aSourceData );
170 16 : pPreview->SetSelectedTabs(rData.GetMarkData());
171 16 : InitStartTable( rData.GetTabNo() );
172 :
173 : // also have to store the TabView's DesignMode state
174 : // (only if draw view exists)
175 16 : SdrView* pDrawView = pTabViewShell->GetSdrView();
176 16 : if ( pDrawView )
177 16 : nSourceDesignMode = pDrawView->IsDesignMode();
178 : }
179 :
180 16 : new ScPreviewObj(this);
181 16 : }
182 :
183 48 : ScPreviewShell::~ScPreviewShell()
184 : {
185 16 : if (mpFrameWindow)
186 16 : mpFrameWindow->SetCloseHdl(Link()); // Remove close handler.
187 :
188 : // #108333#; notify Accessibility that Shell is dying and before destroy all
189 16 : BroadcastAccessibility( SfxSimpleHint( SFX_HINT_DYING ) );
190 16 : DELETEZ(pAccessibilityBroadcaster);
191 :
192 16 : SfxBroadcaster* pDrawBC = pDocShell->GetDocument().GetDrawBroadcaster();
193 16 : if (pDrawBC)
194 16 : EndListening(*pDrawBC);
195 16 : EndListening(*SfxGetpApp());
196 16 : EndListening(*pDocShell);
197 :
198 16 : SetWindow(0);
199 16 : delete pPreview;
200 16 : delete pHorScroll;
201 16 : delete pVerScroll;
202 16 : delete pCorner;
203 :
204 : // normal mode of operation is switching back to default view in the same frame,
205 : // so there's no need to activate any other window here anymore
206 32 : }
207 :
208 16 : void ScPreviewShell::InitStartTable(SCTAB nTab)
209 : {
210 16 : pPreview->SetPageNo( pPreview->GetFirstPage(nTab) );
211 16 : }
212 :
213 0 : OUString ScPreviewShell::GetDescription() const
214 : {
215 0 : return OUString(" ** Test ** ");
216 : }
217 :
218 16 : void ScPreviewShell::AdjustPosSizePixel( const Point &rPos, const Size &rSize )
219 : {
220 16 : Size aOutSize( rSize );
221 16 : pPreview->SetPosSizePixel( rPos, aOutSize );
222 :
223 16 : if ( SVX_ZOOM_WHOLEPAGE == eZoom )
224 16 : pPreview->SetZoom( pPreview->GetOptimalZoom(false) );
225 0 : else if ( SVX_ZOOM_PAGEWIDTH == eZoom )
226 0 : pPreview->SetZoom( pPreview->GetOptimalZoom(true) );
227 :
228 16 : UpdateNeededScrollBars();
229 16 : }
230 :
231 0 : void ScPreviewShell::InnerResizePixel( const Point &rOfs, const Size &rSize )
232 : {
233 0 : AdjustPosSizePixel( rOfs,rSize );
234 0 : }
235 :
236 16 : void ScPreviewShell::OuterResizePixel( const Point &rOfs, const Size &rSize )
237 : {
238 16 : AdjustPosSizePixel( rOfs,rSize );
239 16 : }
240 :
241 138 : bool ScPreviewShell::GetPageSize( Size& aPageSize )
242 : {
243 138 : ScDocument& rDoc = pDocShell->GetDocument();
244 138 : SCTAB nTab = pPreview->GetTab();
245 :
246 138 : ScStyleSheetPool* pStylePool = rDoc.GetStyleSheetPool();
247 : SfxStyleSheetBase* pStyleSheet = pStylePool->Find( rDoc.GetPageStyle( nTab ),
248 138 : SFX_STYLE_FAMILY_PAGE );
249 : OSL_ENSURE(pStyleSheet,"No style sheet");
250 138 : if (!pStyleSheet) return false;
251 138 : const SfxItemSet* pParamSet = &pStyleSheet->GetItemSet();
252 :
253 138 : aPageSize = static_cast<const SvxSizeItem&>( pParamSet->Get(ATTR_PAGE_SIZE)).GetSize();
254 138 : aPageSize.Width() = (long) (aPageSize.Width() * HMM_PER_TWIPS );
255 138 : aPageSize.Height() = (long) (aPageSize.Height() * HMM_PER_TWIPS );
256 138 : return true;
257 : }
258 :
259 36 : void ScPreviewShell::UpdateNeededScrollBars( bool bFromZoom )
260 : {
261 36 : Size aPageSize;
262 36 : OutputDevice* pDevice = Application::GetDefaultDevice();
263 :
264 36 : long nBarW = GetViewFrame()->GetWindow().GetSettings().GetStyleSettings().GetScrollBarSize();
265 36 : long nBarH = nBarW;
266 :
267 36 : long aHeightOffSet = pDevice ? pDevice->PixelToLogic( Size( nBarW, nBarH ), pPreview->GetMapMode() ).Height() : 0;
268 36 : long aWidthOffSet = aHeightOffSet;
269 :
270 36 : if (!GetPageSize( aPageSize ))
271 36 : return;
272 :
273 : // for centering, page size without the shadow is used
274 36 : bool bVert = pVerScroll->IsVisible();
275 36 : bool bHori = pHorScroll->IsVisible();
276 36 : Size aWindowSize = pPreview->GetOutputSize();
277 36 : Point aPos = pPreview->GetPosPixel();
278 36 : Size aWindowPixelSize = pPreview->GetOutputSizePixel();
279 :
280 : // if we are called from Zoom then we need to compensate for whatever
281 : // scrollbars were displayed before the zoom was called
282 36 : if ( bFromZoom )
283 : {
284 20 : if ( bVert )
285 : {
286 2 : aWindowPixelSize.Width() += nBarH;
287 2 : aWindowSize.Width() += aHeightOffSet;
288 : }
289 20 : if ( bHori )
290 : {
291 0 : aWindowPixelSize.Height() += nBarW;
292 0 : aWindowSize.Height() += aWidthOffSet;
293 : }
294 : }
295 : // recalculate any needed scrollbars
296 36 : bHori = false;
297 36 : bVert = false;
298 :
299 36 : long nMaxWidthPos = aPageSize.Width() - aWindowSize.Width();
300 36 : if ( nMaxWidthPos<0 )
301 36 : bHori = false;
302 : else
303 0 : bHori = true;
304 :
305 36 : long nMaxHeightPos = aPageSize.Height() - aWindowSize.Height();
306 :
307 36 : if ( nMaxHeightPos < 0 )
308 32 : bVert = false;
309 : else
310 4 : bVert = true;
311 :
312 : // see if having a scroll bar requires the other
313 36 : if ( bVert != bHori && ( bVert || bHori ) )
314 : {
315 4 : if ( bVert && ( (nMaxWidthPos + aWidthOffSet ) > 0 ) )
316 0 : bHori = true;
317 4 : else if ( (nMaxHeightPos + aHeightOffSet ) > 0 )
318 4 : bVert = true;
319 : }
320 36 : pHorScroll->Show( bHori );
321 36 : pVerScroll->Show( bVert );
322 :
323 : // make room for needed scrollbars ( and reduce the size
324 : // of the preview appropriately )
325 36 : if ( bHori )
326 0 : aWindowPixelSize.Height() -= nBarW;
327 36 : if ( bVert )
328 4 : aWindowPixelSize.Width() -= nBarH;
329 :
330 36 : pPreview->SetSizePixel( aWindowPixelSize );
331 108 : pHorScroll->SetPosSizePixel( Point( aPos.X(), aPos.Y() + aWindowPixelSize.Height() ),
332 144 : Size( aWindowPixelSize.Width(), nBarH ) );
333 108 : pVerScroll->SetPosSizePixel( Point( aPos.X() + aWindowPixelSize.Width(), aPos.Y() ),
334 144 : Size( nBarW, aWindowPixelSize.Height() ) );
335 144 : pCorner->SetPosSizePixel( Point( aPos.X() + aWindowPixelSize.Width(), aPos.Y() + aWindowPixelSize.Height() ),
336 180 : Size( nBarW, nBarH ) );
337 36 : UpdateScrollBars();
338 : }
339 :
340 102 : void ScPreviewShell::UpdateScrollBars()
341 : {
342 102 : Size aPageSize;
343 102 : if ( !GetPageSize( aPageSize ) )
344 102 : return;
345 :
346 : // for centering, page size without the shadow is used
347 :
348 102 : Size aWindowSize = pPreview->GetOutputSize();
349 :
350 102 : Point aOfs = pPreview->GetOffset();
351 :
352 102 : if( pHorScroll )
353 : {
354 102 : pHorScroll->SetRange( Range( 0, aPageSize.Width() ) );
355 102 : pHorScroll->SetLineSize( aWindowSize.Width() / 16 );
356 102 : pHorScroll->SetPageSize( aWindowSize.Width() );
357 102 : pHorScroll->SetVisibleSize( aWindowSize.Width() );
358 102 : long nMaxPos = aPageSize.Width() - aWindowSize.Width();
359 102 : if ( nMaxPos<0 )
360 : {
361 : // page smaller than window -> center (but put scrollbar to 0)
362 102 : aOfs.X() = 0;
363 102 : pPreview->SetXOffset( nMaxPos / 2 );
364 : }
365 0 : else if (aOfs.X() < 0)
366 : {
367 : // page larger than window -> never use negative offset
368 0 : aOfs.X() = 0;
369 0 : pPreview->SetXOffset( 0 );
370 : }
371 0 : else if (aOfs.X() > nMaxPos)
372 : {
373 : // limit offset to align with right edge of window
374 0 : aOfs.X() = nMaxPos;
375 0 : pPreview->SetXOffset(nMaxPos);
376 : }
377 102 : pHorScroll->SetThumbPos( aOfs.X() );
378 : }
379 :
380 102 : if( pVerScroll )
381 : {
382 102 : long nPageNo = pPreview->GetPageNo();
383 102 : long nTotalPages = pPreview->GetTotalPages();
384 :
385 102 : nMaxVertPos = aPageSize.Height() - aWindowSize.Height();
386 102 : pVerScroll->SetLineSize( aWindowSize.Height() / 16 );
387 102 : pVerScroll->SetPageSize( aWindowSize.Height() );
388 102 : pVerScroll->SetVisibleSize( aWindowSize.Height() );
389 102 : if ( nMaxVertPos < 0 )
390 : {
391 : // page smaller than window -> center (but put scrollbar to 0)
392 88 : aOfs.Y() = 0;
393 88 : pPreview->SetYOffset( nMaxVertPos / 2 );
394 88 : pVerScroll->SetThumbPos( nPageNo * aWindowSize.Height() );
395 88 : pVerScroll->SetRange( Range( 0, aWindowSize.Height() * nTotalPages ));
396 : }
397 14 : else if (aOfs.Y() < 0)
398 : {
399 : // page larger than window -> never use negative offset
400 4 : pVerScroll->SetRange( Range( 0, aPageSize.Height() ) );
401 4 : aOfs.Y() = 0;
402 4 : pPreview->SetYOffset( 0 );
403 4 : pVerScroll->SetThumbPos( aOfs.Y() );
404 : }
405 10 : else if (aOfs.Y() > nMaxVertPos )
406 : {
407 : // limit offset to align with window bottom
408 0 : pVerScroll->SetRange( Range( 0, aPageSize.Height() ) );
409 0 : aOfs.Y() = nMaxVertPos;
410 0 : pPreview->SetYOffset( nMaxVertPos );
411 0 : pVerScroll->SetThumbPos( aOfs.Y() );
412 : }
413 : }
414 : }
415 :
416 0 : IMPL_LINK (ScPreviewShell,ScrollHandler, ScrollBar* ,pScroll )
417 : {
418 0 : long nPos = pScroll->GetThumbPos();
419 0 : long nDelta = pScroll->GetDelta();
420 0 : long nMaxRange = pScroll->GetRangeMax();
421 0 : long nTotalPages = pPreview->GetTotalPages();
422 0 : long nPageNo = 0;
423 0 : long nPerPageLength = 0;
424 0 : bool bIsDivide = true;
425 :
426 0 : if( nTotalPages )
427 0 : nPerPageLength = nMaxRange / nTotalPages;
428 :
429 0 : if( nPerPageLength )
430 : {
431 0 : nPageNo = nPos / nPerPageLength;
432 0 : if( nPos % nPerPageLength )
433 : {
434 0 : bIsDivide = false;
435 0 : nPageNo ++;
436 : }
437 : }
438 :
439 0 : bool bHoriz = ( pScroll == pHorScroll );
440 :
441 0 : if( bHoriz )
442 0 : pPreview->SetXOffset( nPos );
443 : else
444 : {
445 0 : if( nMaxVertPos > 0 )
446 0 : pPreview->SetYOffset( nPos );
447 : else
448 : {
449 0 : Point aMousePos = pScroll->OutputToNormalizedScreenPixel( pScroll->GetPointerPosPixel() );
450 0 : Point aPos = pScroll->GetParent()->OutputToNormalizedScreenPixel( pScroll->GetPosPixel() );
451 0 : OUString aHelpStr;
452 0 : Rectangle aRect;
453 : sal_uInt16 nAlign;
454 :
455 0 : if( nDelta < 0 )
456 : {
457 0 : if ( nTotalPages && nPageNo > 0 && !bIsDivide )
458 0 : pPreview->SetPageNo( nPageNo-1 );
459 0 : if( bIsDivide )
460 0 : pPreview->SetPageNo( nPageNo );
461 :
462 0 : aHelpStr = ScGlobal::GetRscString( STR_PAGE ) +
463 0 : " " + OUString::number( nPageNo ) +
464 0 : " / " + OUString::number( nTotalPages );
465 : }
466 0 : else if( nDelta > 0 )
467 : {
468 0 : bool bAllTested = pPreview->AllTested();
469 0 : if ( nTotalPages && ( nPageNo < nTotalPages || !bAllTested ) )
470 0 : pPreview->SetPageNo( nPageNo );
471 :
472 0 : aHelpStr = ScGlobal::GetRscString( STR_PAGE ) +
473 0 : " " + OUString::number( nPageNo+1 ) +
474 0 : " / " + OUString::number( nTotalPages );
475 : }
476 :
477 0 : aRect.Left() = aPos.X() - 8;
478 0 : aRect.Top() = aMousePos.Y();
479 0 : aRect.Right() = aRect.Left();
480 0 : aRect.Bottom() = aRect.Top();
481 0 : nAlign = QUICKHELP_BOTTOM|QUICKHELP_CENTER;
482 0 : Help::ShowQuickHelp( pScroll->GetParent(), aRect, aHelpStr, nAlign );
483 : }
484 : }
485 :
486 0 : return 0;
487 : }
488 :
489 0 : IMPL_LINK (ScPreviewShell, CloseHdl, SystemWindow*, EMPTYARG)
490 : {
491 0 : ExitPreview();
492 0 : return 0;
493 : }
494 :
495 0 : bool ScPreviewShell::ScrollCommand( const CommandEvent& rCEvt )
496 : {
497 0 : bool bDone = false;
498 0 : const CommandWheelData* pData = rCEvt.GetWheelData();
499 0 : if ( pData && pData->GetMode() == CommandWheelMode::ZOOM )
500 : {
501 0 : long nOld = pPreview->GetZoom();
502 0 : long nNew = nOld;
503 0 : if ( pData->GetDelta() < 0 )
504 0 : nNew = std::max( (long) MINZOOM, basegfx::zoomtools::zoomOut( nOld ));
505 : else
506 0 : nNew = std::min( (long) MAXZOOM, basegfx::zoomtools::zoomIn( nOld ));
507 :
508 0 : if ( nNew != nOld )
509 : {
510 0 : eZoom = SVX_ZOOM_PERCENT;
511 0 : pPreview->SetZoom( (sal_uInt16)nNew );
512 : }
513 :
514 0 : bDone = true;
515 : }
516 : else
517 : {
518 0 : bDone = pPreview->HandleScrollCommand( rCEvt, pHorScroll, pVerScroll );
519 : }
520 :
521 0 : return bDone;
522 : }
523 :
524 84 : SfxPrinter* ScPreviewShell::GetPrinter( bool bCreate )
525 : {
526 84 : return pDocShell->GetPrinter(bCreate);
527 : }
528 :
529 0 : sal_uInt16 ScPreviewShell::SetPrinter( SfxPrinter *pNewPrinter, sal_uInt16 nDiffFlags, bool )
530 : {
531 0 : return pDocShell->SetPrinter( pNewPrinter, nDiffFlags );
532 : }
533 :
534 0 : bool ScPreviewShell::HasPrintOptionsPage() const
535 : {
536 0 : return true;
537 : }
538 :
539 0 : SfxTabPage* ScPreviewShell::CreatePrintOptionsPage( vcl::Window *pParent, const SfxItemSet &rOptions )
540 : {
541 0 : ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
542 : OSL_ENSURE(pFact, "ScAbstractFactory create fail!");
543 0 : ::CreateTabPage ScTpPrintOptionsCreate = pFact->GetTabPageCreatorFunc( RID_SCPAGE_PRINT );
544 0 : if ( ScTpPrintOptionsCreate )
545 0 : return (*ScTpPrintOptionsCreate)( pParent, &rOptions);
546 0 : return 0;
547 : }
548 :
549 16 : void ScPreviewShell::Activate(bool bMDI)
550 : {
551 16 : SfxViewShell::Activate(bMDI);
552 :
553 : //! Basic etc. -> auslagern in eigene Datei (s. tabvwsh4)
554 :
555 16 : if (bMDI)
556 : {
557 : // InputHdl ist jetzt meistens Null, keine Assertion mehr!
558 16 : ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl();
559 16 : if ( pInputHdl )
560 0 : pInputHdl->NotifyChange( NULL );
561 : }
562 16 : }
563 :
564 16 : void ScPreviewShell::Deactivate(bool bMDI)
565 : {
566 16 : SfxViewShell::Deactivate(bMDI);
567 :
568 : if (bMDI)
569 : {
570 : }
571 16 : }
572 :
573 4 : void ScPreviewShell::Execute( SfxRequest& rReq )
574 : {
575 4 : sal_uInt16 nSlot = rReq.GetSlot();
576 4 : const SfxItemSet* pReqArgs = rReq.GetArgs();
577 :
578 4 : switch ( nSlot )
579 : {
580 : case SID_FORMATPAGE:
581 : case SID_STATUS_PAGESTYLE:
582 : case SID_HFEDIT:
583 0 : pDocShell->ExecutePageStyle( *this, rReq, pPreview->GetTab() );
584 0 : break;
585 : case SID_REPAINT:
586 0 : pPreview->Invalidate();
587 0 : rReq.Done();
588 0 : break;
589 : case SID_PREV_TABLE: // Accelerator
590 : case SID_PREVIEW_PREVIOUS:
591 : {
592 0 : long nPage = pPreview->GetPageNo();
593 0 : long nTotal = pPreview->GetTotalPages();
594 0 : if (nTotal && nPage > 0)
595 0 : pPreview->SetPageNo( nPage-1 );
596 : }
597 0 : break;
598 : case SID_NEXT_TABLE: // Accelerator
599 : case SID_PREVIEW_NEXT:
600 : {
601 0 : bool bAllTested = pPreview->AllTested();
602 0 : long nPage = pPreview->GetPageNo();
603 0 : long nTotal = pPreview->GetTotalPages();
604 0 : if (nTotal && (nPage+1 < nTotal || !bAllTested))
605 0 : pPreview->SetPageNo( nPage+1 );
606 : }
607 0 : break;
608 : case SID_CURSORTOPOFFILE: // Accelerator
609 : case SID_PREVIEW_FIRST:
610 : {
611 0 : long nPage = pPreview->GetPageNo();
612 0 : long nTotal = pPreview->GetTotalPages();
613 0 : if (nTotal && nPage != 0)
614 0 : pPreview->SetPageNo( 0 );
615 : }
616 0 : break;
617 : case SID_CURSORENDOFFILE: // Accelerator
618 : case SID_PREVIEW_LAST:
619 : {
620 0 : if (!pPreview->AllTested())
621 0 : pPreview->CalcAll();
622 :
623 0 : long nPage = pPreview->GetPageNo();
624 0 : long nTotal = pPreview->GetTotalPages();
625 0 : if (nTotal && nPage+1 != nTotal)
626 0 : pPreview->SetPageNo( nTotal-1 );
627 : }
628 0 : break;
629 : case SID_ATTR_ZOOM:
630 : case FID_SCALE:
631 : {
632 0 : sal_uInt16 nZoom = 100;
633 0 : bool bCancel = false;
634 :
635 0 : eZoom = SVX_ZOOM_PERCENT;
636 :
637 0 : if ( pReqArgs )
638 : {
639 :
640 : const SvxZoomItem& rZoomItem = static_cast<const SvxZoomItem&>(
641 0 : pReqArgs->Get(SID_ATTR_ZOOM));
642 :
643 0 : eZoom = rZoomItem.GetType();
644 0 : nZoom = rZoomItem.GetValue();
645 : }
646 : else
647 : {
648 0 : SfxItemSet aSet ( GetPool(), SID_ATTR_ZOOM, SID_ATTR_ZOOM );
649 0 : SvxZoomItem aZoomItem( SVX_ZOOM_PERCENT, pPreview->GetZoom(), SID_ATTR_ZOOM );
650 :
651 0 : aSet.Put( aZoomItem );
652 0 : SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
653 0 : if(pFact)
654 : {
655 0 : boost::scoped_ptr<AbstractSvxZoomDialog> pDlg(pFact->CreateSvxZoomDialog(NULL, aSet));
656 : OSL_ENSURE(pDlg, "Dialog creation failed!");
657 0 : pDlg->SetLimits( 20, 400 );
658 0 : pDlg->HideButton( ZOOMBTN_OPTIMAL );
659 0 : bCancel = ( RET_CANCEL == pDlg->Execute() );
660 :
661 0 : if ( !bCancel )
662 : {
663 : const SvxZoomItem& rZoomItem = static_cast<const SvxZoomItem&>(
664 0 : pDlg->GetOutputItemSet()->
665 0 : Get( SID_ATTR_ZOOM ));
666 :
667 0 : eZoom = rZoomItem.GetType();
668 0 : nZoom = rZoomItem.GetValue();
669 0 : }
670 0 : }
671 : }
672 :
673 0 : if ( !bCancel )
674 : {
675 0 : switch ( eZoom )
676 : {
677 : case SVX_ZOOM_OPTIMAL:
678 : case SVX_ZOOM_WHOLEPAGE:
679 0 : nZoom = pPreview->GetOptimalZoom(false);
680 0 : break;
681 : case SVX_ZOOM_PAGEWIDTH:
682 0 : nZoom = pPreview->GetOptimalZoom(true);
683 0 : break;
684 : default:
685 : {
686 : // added to avoid warnings
687 : }
688 : }
689 :
690 0 : pPreview->SetZoom( nZoom );
691 0 : rReq.Done();
692 : }
693 : }
694 0 : break;
695 : case SID_PREVIEW_ZOOMIN:
696 : {
697 4 : sal_uInt16 nNew = pPreview->GetZoom() + 20 ;
698 4 : nNew -= nNew % 20;
699 4 : pPreview->SetZoom( nNew );
700 4 : eZoom = SVX_ZOOM_PERCENT;
701 4 : rReq.Done();
702 : }
703 4 : break;
704 : case SID_PREVIEW_ZOOMOUT:
705 : {
706 0 : sal_uInt16 nNew = pPreview->GetZoom() - 1;
707 0 : nNew -= nNew % 20;
708 0 : pPreview->SetZoom( nNew );
709 0 : eZoom = SVX_ZOOM_PERCENT;
710 0 : rReq.Done();
711 : }
712 0 : break;
713 : case SID_PREVIEW_MARGIN:
714 : {
715 0 : bool bMargin = pPreview->GetPageMargins();
716 0 : pPreview->SetPageMargins( !bMargin );
717 0 : pPreview->Invalidate();
718 0 : rReq.Done();
719 : }
720 0 : break;
721 : case SID_ATTR_ZOOMSLIDER:
722 : {
723 : const SfxPoolItem* pItem;
724 0 : eZoom = SVX_ZOOM_PERCENT;
725 0 : if( pReqArgs && SfxItemState::SET == pReqArgs->GetItemState( SID_ATTR_ZOOMSLIDER, true, &pItem ) )
726 : {
727 0 : const sal_uInt16 nCurrentZoom = static_cast<const SvxZoomSliderItem*>(pItem)->GetValue();
728 0 : if( nCurrentZoom )
729 : {
730 0 : pPreview->SetZoom( nCurrentZoom );
731 0 : rReq.Done();
732 : }
733 : }
734 : }
735 0 : break;
736 : case SID_PREVIEW_SCALINGFACTOR:
737 : {
738 : const SfxPoolItem* pItem;
739 0 : SCTAB nTab = pPreview->GetTab();
740 0 : OUString aOldName = pDocShell->GetDocument().GetPageStyle( pPreview->GetTab() );
741 0 : ScStyleSheetPool* pStylePool = pDocShell->GetDocument().GetStyleSheetPool();
742 0 : SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aOldName, SFX_STYLE_FAMILY_PAGE );
743 : OSL_ENSURE( pStyleSheet, "PageStyle not found! :-/" );
744 :
745 0 : if ( pReqArgs && pStyleSheet && SfxItemState::SET == pReqArgs->GetItemState( SID_PREVIEW_SCALINGFACTOR, true, &pItem ) )
746 : {
747 0 : const sal_uInt16 nCurrentZoom = static_cast<const SvxZoomSliderItem *>(pItem)->GetValue();
748 0 : SfxItemSet& rSet = pStyleSheet->GetItemSet();
749 0 : rSet.Put( SfxUInt16Item( ATTR_PAGE_SCALE, nCurrentZoom ) );
750 0 : ScPrintFunc aPrintFunc( pDocShell, pDocShell->GetPrinter(), nTab );
751 0 : aPrintFunc.UpdatePages();
752 0 : rReq.Done();
753 : }
754 0 : GetViewFrame()->GetBindings().Invalidate( nSlot );
755 : }
756 0 : break;
757 : case SID_PRINTPREVIEW:
758 : case SID_PREVIEW_CLOSE:
759 : // print preview is now always in the same frame as the tab view
760 : // -> always switch this frame back to normal view
761 : // (ScTabViewShell ctor reads stored view data)
762 :
763 0 : ExitPreview();
764 0 : break;
765 : case SID_CURSORPAGEUP:
766 : case SID_CURSORPAGEDOWN:
767 : case SID_CURSORHOME:
768 : case SID_CURSOREND:
769 : case SID_CURSORUP:
770 : case SID_CURSORDOWN:
771 : case SID_CURSORLEFT:
772 : case SID_CURSORRIGHT:
773 0 : DoScroll( nSlot );
774 0 : break;
775 : case SID_CANCEL:
776 0 : if( ScViewUtil::IsFullScreen( *this ) )
777 0 : ScViewUtil::SetFullScreen( *this, false );
778 0 : break;
779 :
780 : default:
781 0 : break;
782 : }
783 4 : }
784 :
785 390 : void ScPreviewShell::GetState( SfxItemSet& rSet )
786 : {
787 390 : pPreview->SetInGetState(true);
788 :
789 390 : SCTAB nTab = pPreview->GetTab();
790 390 : long nPage = pPreview->GetPageNo();
791 390 : long nTotal = pPreview->GetTotalPages();
792 390 : sal_uInt16 nZoom = pPreview->GetZoom();
793 390 : bool bAllTested = pPreview->AllTested();
794 :
795 390 : SfxWhichIter aIter(rSet);
796 390 : sal_uInt16 nWhich = aIter.FirstWhich();
797 1460 : while ( nWhich )
798 : {
799 680 : switch (nWhich)
800 : {
801 : case SID_STATUS_PAGESTYLE:
802 : case SID_HFEDIT:
803 60 : pDocShell->GetStatePageStyle( *this, rSet, nTab );
804 60 : break;
805 : case SID_UNDO:
806 : case SID_REDO:
807 : case SID_REPEAT:
808 : case SID_SAVEDOC:
809 : case SID_SAVEASDOC:
810 : case SID_MAIL_SENDDOC:
811 : case SID_VIEW_DATA_SOURCE_BROWSER:
812 : case SID_QUITAPP:
813 156 : rSet.DisableItem(nWhich);
814 156 : break;
815 : case SID_PREVIEW_PREVIOUS:
816 : case SID_PREVIEW_FIRST:
817 68 : if (!nTotal || nPage==0)
818 68 : rSet.DisableItem(nWhich);
819 68 : break;
820 : case SID_PREVIEW_NEXT:
821 : case SID_PREVIEW_LAST:
822 68 : if (bAllTested)
823 68 : if (!nTotal || nPage==nTotal-1)
824 68 : rSet.DisableItem(nWhich);
825 68 : break;
826 : case SID_PREVIEW_ZOOMIN:
827 38 : if (nZoom >= 400)
828 0 : rSet.DisableItem(nWhich);
829 38 : break;
830 : case SID_PREVIEW_ZOOMOUT:
831 34 : if (nZoom <= 20)
832 0 : rSet.DisableItem(nWhich);
833 34 : break;
834 : case SID_ATTR_ZOOM:
835 : {
836 50 : SvxZoomItem aZoom( eZoom, nZoom, nWhich );
837 50 : aZoom.SetValueSet( SVX_ZOOM_ENABLE_ALL & ~SVX_ZOOM_ENABLE_OPTIMAL );
838 50 : rSet.Put( aZoom );
839 : }
840 50 : break;
841 : case SID_ATTR_ZOOMSLIDER:
842 : {
843 34 : SvxZoomSliderItem aZoomSliderItem( nZoom, MINZOOM, MAXZOOM, SID_ATTR_ZOOMSLIDER );
844 34 : aZoomSliderItem.AddSnappingPoint( 100 );
845 34 : rSet.Put( aZoomSliderItem );
846 : }
847 34 : break;
848 : case SID_PREVIEW_SCALINGFACTOR:
849 : {
850 34 : if( pDocShell->IsReadOnly() )
851 0 : rSet.DisableItem( nWhich );
852 : else
853 : {
854 34 : OUString aOldName = pDocShell->GetDocument().GetPageStyle( pPreview->GetTab() );
855 34 : ScStyleSheetPool* pStylePool = pDocShell->GetDocument().GetStyleSheetPool();
856 34 : SfxStyleSheetBase* pStyleSheet = pStylePool->Find( aOldName, SFX_STYLE_FAMILY_PAGE );
857 : OSL_ENSURE( pStyleSheet, "PageStyle not found! :-/" );
858 :
859 34 : if ( pStyleSheet )
860 : {
861 34 : SfxItemSet& rStyleSet = pStyleSheet->GetItemSet();
862 34 : sal_uInt16 nCurrentZoom = static_cast<const SfxUInt16Item&>(rStyleSet.Get(ATTR_PAGE_SCALE)).GetValue();
863 34 : if( nCurrentZoom )
864 : {
865 34 : SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM_SLIDER, MAXZOOM_SLIDER, SID_PREVIEW_SCALINGFACTOR );
866 34 : aZoomSliderItem.AddSnappingPoint( 100 );
867 34 : rSet.Put( aZoomSliderItem );
868 : }
869 : else
870 0 : rSet.DisableItem( nWhich );
871 34 : }
872 : }
873 : }
874 34 : break;
875 : case SID_STATUS_DOCPOS:
876 34 : rSet.Put( SfxStringItem( nWhich, pPreview->GetPosString() ) );
877 34 : break;
878 : case SID_PRINTPREVIEW:
879 26 : rSet.Put( SfxBoolItem( nWhich, true ) );
880 26 : break;
881 : case SID_FORMATPAGE:
882 : case SID_PREVIEW_MARGIN:
883 52 : if( pDocShell->IsReadOnly() )
884 0 : rSet.DisableItem( nWhich );
885 52 : break;
886 : }
887 :
888 680 : nWhich = aIter.NextWhich();
889 : }
890 :
891 390 : pPreview->SetInGetState(false);
892 390 : }
893 :
894 20 : void ScPreviewShell::FillFieldData( ScHeaderFieldData& rData )
895 : {
896 20 : ScDocument& rDoc = pDocShell->GetDocument();
897 20 : SCTAB nTab = pPreview->GetTab();
898 20 : OUString aTmp;
899 20 : rDoc.GetName(nTab, aTmp);
900 20 : rData.aTabName = aTmp;
901 :
902 20 : if( pDocShell->getDocProperties()->getTitle().getLength() != 0 )
903 0 : rData.aTitle = pDocShell->getDocProperties()->getTitle();
904 : else
905 20 : rData.aTitle = pDocShell->GetTitle();
906 :
907 20 : const INetURLObject& rURLObj = pDocShell->GetMedium()->GetURLObject();
908 20 : rData.aLongDocName = rURLObj.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
909 20 : if ( !rData.aLongDocName.isEmpty() )
910 0 : rData.aShortDocName = rURLObj.GetName( INetURLObject::DECODE_UNAMBIGUOUS );
911 : else
912 20 : rData.aShortDocName = rData.aLongDocName = rData.aTitle;
913 20 : rData.nPageNo = pPreview->GetPageNo() + 1;
914 :
915 20 : bool bAllTested = pPreview->AllTested();
916 20 : if (bAllTested)
917 20 : rData.nTotalPages = pPreview->GetTotalPages();
918 : else
919 0 : rData.nTotalPages = 99;
920 :
921 : // the dialog knows eNumType
922 20 : }
923 :
924 0 : void ScPreviewShell::WriteUserData(OUString& rData, bool /* bBrowse */)
925 : {
926 : // nZoom
927 : // nPageNo
928 :
929 0 : rData = OUString::number(pPreview->GetZoom());
930 0 : rData += OUString(SC_USERDATA_SEP);
931 0 : rData += OUString::number(pPreview->GetPageNo());
932 0 : }
933 :
934 0 : void ScPreviewShell::ReadUserData(const OUString& rData, bool /* bBrowse */)
935 : {
936 0 : if (!rData.isEmpty())
937 : {
938 0 : sal_Int32 nIndex = 0;
939 0 : pPreview->SetZoom((sal_uInt16)rData.getToken(0, SC_USERDATA_SEP, nIndex).toInt32());
940 0 : pPreview->SetPageNo(rData.getToken(0, SC_USERDATA_SEP, nIndex).toInt32());
941 0 : eZoom = SVX_ZOOM_PERCENT;
942 : }
943 0 : }
944 :
945 0 : void ScPreviewShell::WriteUserDataSequence(uno::Sequence < beans::PropertyValue >& rSeq, bool /* bBrowse */)
946 : {
947 0 : rSeq.realloc(3);
948 0 : beans::PropertyValue* pSeq = rSeq.getArray();
949 0 : if(pSeq)
950 : {
951 0 : sal_uInt16 nViewID(GetViewFrame()->GetCurViewId());
952 0 : pSeq[0].Name = OUString(SC_VIEWID);
953 0 : OUStringBuffer sBuffer(SC_VIEW);
954 : ::sax::Converter::convertNumber(sBuffer,
955 0 : static_cast<sal_Int32>(nViewID));
956 0 : pSeq[0].Value <<= sBuffer.makeStringAndClear();
957 0 : pSeq[1].Name = OUString(SC_ZOOMVALUE);
958 0 : pSeq[1].Value <<= sal_Int32 (pPreview->GetZoom());
959 0 : pSeq[2].Name = "PageNumber";
960 0 : pSeq[2].Value <<= pPreview->GetPageNo();
961 : }
962 0 : }
963 :
964 16 : void ScPreviewShell::ReadUserDataSequence(const uno::Sequence < beans::PropertyValue >& rSeq, bool /* bBrowse */)
965 : {
966 16 : sal_Int32 nCount(rSeq.getLength());
967 16 : if (nCount)
968 : {
969 16 : const beans::PropertyValue* pSeq = rSeq.getConstArray();
970 16 : if(pSeq)
971 : {
972 384 : for(sal_Int32 i = 0; i < nCount; i++, pSeq++)
973 : {
974 368 : OUString sName(pSeq->Name);
975 368 : if(sName.equalsAscii(SC_ZOOMVALUE))
976 : {
977 16 : sal_Int32 nTemp = 0;
978 16 : if (pSeq->Value >>= nTemp)
979 16 : pPreview->SetZoom(sal_uInt16(nTemp));
980 : }
981 352 : else if (sName.equalsAscii("PageNumber"))
982 : {
983 0 : sal_Int32 nTemp = 0;
984 0 : if (pSeq->Value >>= nTemp)
985 0 : pPreview->SetPageNo(nTemp);
986 : }
987 368 : }
988 : }
989 : }
990 16 : }
991 :
992 0 : void ScPreviewShell::DoScroll( sal_uInt16 nMode )
993 : {
994 0 : Point aCurPos, aPrevPos;
995 :
996 0 : long nHRange = pHorScroll->GetRange().Max();
997 0 : long nHLine = pHorScroll->GetLineSize();
998 0 : long nHPage = pHorScroll->GetPageSize();
999 0 : long nVRange = pVerScroll->GetRange().Max();
1000 0 : long nVLine = pVerScroll->GetLineSize();
1001 0 : long nVPage = pVerScroll->GetPageSize();
1002 :
1003 0 : aCurPos.X() = pHorScroll->GetThumbPos();
1004 0 : aCurPos.Y() = pVerScroll->GetThumbPos();
1005 0 : aPrevPos = aCurPos;
1006 :
1007 0 : long nThumbPos = pVerScroll->GetThumbPos();
1008 0 : long nRangeMax = pVerScroll->GetRangeMax();
1009 :
1010 0 : switch( nMode )
1011 : {
1012 : case SID_CURSORUP:
1013 0 : if( nMaxVertPos<0 )
1014 : {
1015 0 : long nPage = pPreview->GetPageNo();
1016 :
1017 0 : if( nPage>0 )
1018 : {
1019 0 : SfxViewFrame* pSfxViewFrame = GetViewFrame();
1020 0 : SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_PREVIOUS );
1021 0 : Execute( aSfxRequest );
1022 : }
1023 : }
1024 : else
1025 0 : aCurPos.Y() -= nVLine;
1026 0 : break;
1027 : case SID_CURSORDOWN:
1028 0 : if( nMaxVertPos<0 )
1029 : {
1030 0 : long nPage = pPreview->GetPageNo();
1031 0 : long nTotal = pPreview->GetTotalPages();
1032 :
1033 : // before testing for last page, make sure all page counts are calculated
1034 0 : if ( nPage+1 == nTotal && !pPreview->AllTested() )
1035 : {
1036 0 : pPreview->CalcAll();
1037 0 : nTotal = pPreview->GetTotalPages();
1038 : }
1039 :
1040 0 : if( nPage<nTotal-1 )
1041 : {
1042 0 : SfxViewFrame* pSfxViewFrame = GetViewFrame();
1043 0 : SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_NEXT );
1044 0 : Execute( aSfxRequest );
1045 : }
1046 : }
1047 : else
1048 0 : aCurPos.Y() += nVLine;
1049 0 : break;
1050 : case SID_CURSORLEFT:
1051 0 : aCurPos.X() -= nHLine;
1052 0 : break;
1053 : case SID_CURSORRIGHT:
1054 0 : aCurPos.X() += nHLine;
1055 0 : break;
1056 : case SID_CURSORPAGEUP:
1057 0 : if( nThumbPos==0 || nMaxVertPos<0 )
1058 : {
1059 0 : long nPage = pPreview->GetPageNo();
1060 :
1061 0 : if( nPage>0 )
1062 : {
1063 0 : SfxViewFrame* pSfxViewFrame = GetViewFrame();
1064 0 : SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_PREVIOUS );
1065 0 : Execute( aSfxRequest );
1066 0 : aCurPos.Y() = nVRange;
1067 0 : }
1068 : }
1069 : else
1070 0 : aCurPos.Y() -= nVPage;
1071 0 : break;
1072 : case SID_CURSORPAGEDOWN:
1073 0 : if( (std::abs(nVPage+nThumbPos-nRangeMax)<10) || nMaxVertPos<0 )
1074 : {
1075 0 : long nPage = pPreview->GetPageNo();
1076 0 : long nTotal = pPreview->GetTotalPages();
1077 :
1078 : // before testing for last page, make sure all page counts are calculated
1079 0 : if ( nPage+1 == nTotal && !pPreview->AllTested() )
1080 : {
1081 0 : pPreview->CalcAll();
1082 0 : nTotal = pPreview->GetTotalPages();
1083 : }
1084 0 : if( nPage<nTotal-1 )
1085 : {
1086 0 : SfxViewFrame* pSfxViewFrame = GetViewFrame();
1087 0 : SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_NEXT );
1088 0 : Execute( aSfxRequest );
1089 0 : aCurPos.Y() = 0;
1090 : }
1091 : }
1092 : else
1093 0 : aCurPos.Y() += nVPage;
1094 0 : break;
1095 : case SID_CURSORHOME:
1096 0 : if( nMaxVertPos<0 )
1097 : {
1098 0 : long nPage = pPreview->GetPageNo();
1099 0 : long nTotal = pPreview->GetTotalPages();
1100 0 : if( nTotal && nPage != 0 )
1101 : {
1102 0 : SfxViewFrame* pSfxViewFrame = GetViewFrame();
1103 0 : SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_FIRST );
1104 0 : Execute( aSfxRequest );
1105 : }
1106 : }
1107 : else
1108 : {
1109 0 : aCurPos.Y() = 0;
1110 0 : aCurPos.X() = 0;
1111 : }
1112 0 : break;
1113 : case SID_CURSOREND:
1114 0 : if( nMaxVertPos<0 )
1115 : {
1116 0 : if( !pPreview->AllTested() )
1117 0 : pPreview->CalcAll();
1118 0 : long nPage = pPreview->GetPageNo();
1119 0 : long nTotal = pPreview->GetTotalPages();
1120 0 : if( nTotal && nPage+1 != nTotal )
1121 : {
1122 0 : SfxViewFrame* pSfxViewFrame = GetViewFrame();
1123 0 : SfxRequest aSfxRequest( pSfxViewFrame, SID_PREVIEW_LAST );
1124 0 : Execute( aSfxRequest );
1125 : }
1126 : }
1127 : else
1128 : {
1129 0 : aCurPos.Y() = nVRange;
1130 0 : aCurPos.X() = nHRange;
1131 : }
1132 0 : break;
1133 : }
1134 :
1135 : // nHRange-nHPage might be negative, that's why we check for < 0 afterwards
1136 :
1137 0 : if( aCurPos.Y() > (nVRange-nVPage) )
1138 0 : aCurPos.Y() = (nVRange-nVPage);
1139 0 : if( aCurPos.Y() < 0 )
1140 0 : aCurPos.Y() = 0;
1141 0 : if( aCurPos.X() > (nHRange-nHPage) )
1142 0 : aCurPos.X() = (nHRange-nHPage);
1143 0 : if( aCurPos.X() < 0 )
1144 0 : aCurPos.X() = 0;
1145 :
1146 0 : if( nMaxVertPos>=0 )
1147 : {
1148 0 : if( aCurPos.Y() != aPrevPos.Y() )
1149 : {
1150 0 : pVerScroll->SetThumbPos( aCurPos.Y() );
1151 0 : pPreview->SetYOffset( aCurPos.Y() );
1152 : }
1153 : }
1154 :
1155 0 : if( aCurPos.X() != aPrevPos.X() )
1156 : {
1157 0 : pHorScroll->SetThumbPos( aCurPos.X() );
1158 0 : pPreview->SetXOffset( aCurPos.X() );
1159 : }
1160 :
1161 0 : }
1162 :
1163 0 : void ScPreviewShell::ExitPreview()
1164 : {
1165 0 : GetViewFrame()->GetDispatcher()->Execute(SID_VIEWSHELL0, SfxCallMode::ASYNCHRON);
1166 0 : }
1167 :
1168 134 : void ScPreviewShell::AddAccessibilityObject( SfxListener& rObject )
1169 : {
1170 134 : if (!pAccessibilityBroadcaster)
1171 16 : pAccessibilityBroadcaster = new SfxBroadcaster;
1172 :
1173 134 : rObject.StartListening( *pAccessibilityBroadcaster );
1174 134 : }
1175 :
1176 134 : void ScPreviewShell::RemoveAccessibilityObject( SfxListener& rObject )
1177 : {
1178 134 : if (pAccessibilityBroadcaster)
1179 134 : rObject.EndListening( *pAccessibilityBroadcaster );
1180 : else
1181 : {
1182 : OSL_FAIL("kein Accessibility-Broadcaster?");
1183 : }
1184 134 : }
1185 :
1186 58 : void ScPreviewShell::BroadcastAccessibility( const SfxHint &rHint )
1187 : {
1188 58 : if (pAccessibilityBroadcaster)
1189 58 : pAccessibilityBroadcaster->Broadcast( rHint );
1190 58 : }
1191 :
1192 122 : bool ScPreviewShell::HasAccessibilityObjects()
1193 : {
1194 122 : return pAccessibilityBroadcaster && pAccessibilityBroadcaster->HasListeners();
1195 : }
1196 :
1197 1876 : const ScPreviewLocationData& ScPreviewShell::GetLocationData()
1198 : {
1199 1876 : return pPreview->GetLocationData();
1200 : }
1201 :
1202 342 : ScDocument& ScPreviewShell::GetDocument()
1203 : {
1204 342 : return pDocShell->GetDocument();
1205 228 : }
1206 :
1207 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
