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