1efeef26fSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3efeef26fSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4efeef26fSAndrew Rist * or more contributor license agreements. See the NOTICE file
5efeef26fSAndrew Rist * distributed with this work for additional information
6efeef26fSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7efeef26fSAndrew Rist * to you under the Apache License, Version 2.0 (the
8efeef26fSAndrew Rist * "License"); you may not use this file except in compliance
9efeef26fSAndrew Rist * with the License. You may obtain a copy of the License at
10efeef26fSAndrew Rist *
11efeef26fSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12efeef26fSAndrew Rist *
13efeef26fSAndrew Rist * Unless required by applicable law or agreed to in writing,
14efeef26fSAndrew Rist * software distributed under the License is distributed on an
15efeef26fSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16efeef26fSAndrew Rist * KIND, either express or implied. See the License for the
17efeef26fSAndrew Rist * specific language governing permissions and limitations
18efeef26fSAndrew Rist * under the License.
19efeef26fSAndrew Rist *
20efeef26fSAndrew Rist *************************************************************/
21efeef26fSAndrew Rist
22efeef26fSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sw.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir
28cdf0e10cSrcweir #include "hintids.hxx"
29cdf0e10cSrcweir #include <vcl/help.hxx>
30cdf0e10cSrcweir #include <svx/ruler.hxx>
31cdf0e10cSrcweir #include <editeng/paperinf.hxx>
32cdf0e10cSrcweir #include <editeng/lrspitem.hxx>
33cdf0e10cSrcweir #include <sfx2/bindings.hxx>
34cdf0e10cSrcweir #ifndef _VIEW_HXX
35cdf0e10cSrcweir #include <view.hxx>
36cdf0e10cSrcweir #endif
37cdf0e10cSrcweir #include <wrtsh.hxx>
38cdf0e10cSrcweir #include <swmodule.hxx>
39cdf0e10cSrcweir #include <viewopt.hxx>
40cdf0e10cSrcweir #include <frmatr.hxx>
41cdf0e10cSrcweir #ifndef _DOCSH_HXX
42cdf0e10cSrcweir #include <docsh.hxx>
43cdf0e10cSrcweir #endif
44cdf0e10cSrcweir #ifndef _CMDID_H
45cdf0e10cSrcweir #include <cmdid.h>
46cdf0e10cSrcweir #endif
47cdf0e10cSrcweir #include <edtwin.hxx>
48cdf0e10cSrcweir #include <scroll.hxx>
49cdf0e10cSrcweir #ifndef _WVIEW_HXX
50cdf0e10cSrcweir #include <wview.hxx>
51cdf0e10cSrcweir #endif
52cdf0e10cSrcweir #include <usrpref.hxx>
53cdf0e10cSrcweir #include <pagedesc.hxx>
54cdf0e10cSrcweir #include <workctrl.hxx>
55cdf0e10cSrcweir #include <crsskip.hxx>
56cdf0e10cSrcweir
57cdf0e10cSrcweir #include <PostItMgr.hxx>
58cdf0e10cSrcweir
59cdf0e10cSrcweir #include <IDocumentSettingAccess.hxx>
60cdf0e10cSrcweir
61cdf0e10cSrcweir //Das SetVisArea der DocShell darf nicht vom InnerResizePixel gerufen werden.
62cdf0e10cSrcweir //Unsere Einstellungen muessen aber stattfinden.
63cdf0e10cSrcweir #ifndef WB_RIGHT_ALIGNED
64cdf0e10cSrcweir #define WB_RIGHT_ALIGNED ((WinBits)0x00008000)
65cdf0e10cSrcweir #endif
66cdf0e10cSrcweir
67cdf0e10cSrcweir static sal_Bool bProtectDocShellVisArea = sal_False;
68cdf0e10cSrcweir
69cdf0e10cSrcweir static sal_uInt16 nPgNum = 0;
70cdf0e10cSrcweir
IsDocumentBorder()71cdf0e10cSrcweir sal_Bool SwView::IsDocumentBorder()
72cdf0e10cSrcweir {
73cdf0e10cSrcweir return GetDocShell()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ||
74cdf0e10cSrcweir pWrtShell->GetViewOptions()->getBrowseMode() ||
75cdf0e10cSrcweir SVX_ZOOM_PAGEWIDTH_NOBORDER == (SvxZoomType)pWrtShell->GetViewOptions()->GetZoomType();
76cdf0e10cSrcweir }
77cdf0e10cSrcweir
GetLeftMargin(SwView & rView)78cdf0e10cSrcweir inline long GetLeftMargin( SwView &rView )
79cdf0e10cSrcweir {
80cdf0e10cSrcweir SvxZoomType eType = (SvxZoomType)rView.GetWrtShell().GetViewOptions()->GetZoomType();
81cdf0e10cSrcweir long lRet = rView.GetWrtShell().GetAnyCurRect(RECT_PAGE_PRT).Left();
82cdf0e10cSrcweir return eType == SVX_ZOOM_PERCENT ? lRet + DOCUMENTBORDER :
83cdf0e10cSrcweir eType == SVX_ZOOM_PAGEWIDTH || eType == SVX_ZOOM_PAGEWIDTH_NOBORDER ? 0 :
84cdf0e10cSrcweir lRet + DOCUMENTBORDER + nLeftOfst;
85cdf0e10cSrcweir }
86cdf0e10cSrcweir
87cdf0e10cSrcweir //-------------------------------------------------------------------------
88cdf0e10cSrcweir
lcl_GetPos(SwView * pView,Point & rPos,SwScrollbar * pScrollbar,sal_Bool bBorder)89cdf0e10cSrcweir void lcl_GetPos(SwView* pView,
90cdf0e10cSrcweir Point& rPos,
91cdf0e10cSrcweir SwScrollbar* pScrollbar,
92cdf0e10cSrcweir sal_Bool bBorder)
93cdf0e10cSrcweir {
94cdf0e10cSrcweir SwWrtShell &rSh = pView->GetWrtShell();
95cdf0e10cSrcweir const Size aDocSz( rSh.GetDocSize() );
96cdf0e10cSrcweir
97cdf0e10cSrcweir const long lBorder = bBorder ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
98cdf0e10cSrcweir sal_Bool bHori = pScrollbar->IsHoriScroll();
99cdf0e10cSrcweir
100cdf0e10cSrcweir const long lPos = pScrollbar->GetThumbPos() + (bBorder ? DOCUMENTBORDER : 0);
101cdf0e10cSrcweir long Point:: *pPt = bHori ? &Point::nA : &Point::nB;
102cdf0e10cSrcweir long Size:: *pSz = bHori ? &Size::nA : &Size::nB;
103cdf0e10cSrcweir
104cdf0e10cSrcweir long lDelta = lPos - rSh.VisArea().Pos().*pPt;
105cdf0e10cSrcweir const long lSize = aDocSz.*pSz + lBorder;
106cdf0e10cSrcweir // Bug 11693: sollte rechts oder unten zuviel Wiese sein, dann muss
107cdf0e10cSrcweir // diese von der VisArea herausgerechnet werden!
108cdf0e10cSrcweir long nTmp = pView->GetVisArea().Right()+lDelta;
109cdf0e10cSrcweir if ( bHori && nTmp > lSize )
110cdf0e10cSrcweir lDelta -= nTmp - lSize;
111cdf0e10cSrcweir nTmp = pView->GetVisArea().Bottom()+lDelta;
112cdf0e10cSrcweir if ( !bHori && nTmp > lSize )
113cdf0e10cSrcweir lDelta -= nTmp - lSize;
114cdf0e10cSrcweir
115cdf0e10cSrcweir rPos.*pPt += lDelta;
116cdf0e10cSrcweir if ( bBorder && rPos.*pPt < DOCUMENTBORDER )
117cdf0e10cSrcweir rPos.*pPt = DOCUMENTBORDER;
118cdf0e10cSrcweir }
119cdf0e10cSrcweir
120cdf0e10cSrcweir /*--------------------------------------------------------------------
121cdf0e10cSrcweir Beschreibung: Nullpunkt Lineal setzen
122cdf0e10cSrcweir --------------------------------------------------------------------*/
123cdf0e10cSrcweir
InvalidateRulerPos()124cdf0e10cSrcweir void SwView::InvalidateRulerPos()
125cdf0e10cSrcweir {
126cdf0e10cSrcweir static sal_uInt16 __READONLY_DATA aInval[] =
127cdf0e10cSrcweir {
128cdf0e10cSrcweir SID_ATTR_PARA_LRSPACE, SID_RULER_BORDERS, SID_RULER_PAGE_POS,
129cdf0e10cSrcweir SID_RULER_LR_MIN_MAX, SID_ATTR_LONG_ULSPACE, SID_ATTR_LONG_LRSPACE,
130cdf0e10cSrcweir SID_RULER_BORDER_DISTANCE,
131cdf0e10cSrcweir SID_ATTR_PARA_LRSPACE_VERTICAL, SID_RULER_BORDERS_VERTICAL,
132cdf0e10cSrcweir SID_RULER_TEXT_RIGHT_TO_LEFT,
133cdf0e10cSrcweir SID_RULER_ROWS, SID_RULER_ROWS_VERTICAL, FN_STAT_PAGE,
134cdf0e10cSrcweir 0
135cdf0e10cSrcweir };
136cdf0e10cSrcweir
137cdf0e10cSrcweir GetViewFrame()->GetBindings().Invalidate(aInval);
138cdf0e10cSrcweir
139cdf0e10cSrcweir DBG_ASSERT(pHRuler, "warum ist das Lineal nicht da?");
140cdf0e10cSrcweir pHRuler->ForceUpdate();
141cdf0e10cSrcweir pVRuler->ForceUpdate();
142cdf0e10cSrcweir }
143cdf0e10cSrcweir
144cdf0e10cSrcweir /*--------------------------------------------------------------------
145cdf0e10cSrcweir Beschreibung: begrenzt das Scrollen soweit, dass jeweils nur einen
146cdf0e10cSrcweir viertel Bildschirm bis vor das Ende des Dokumentes
147cdf0e10cSrcweir gescrollt werden kann.
148cdf0e10cSrcweir --------------------------------------------------------------------*/
149cdf0e10cSrcweir
SetHScrollMax(long lMax)150cdf0e10cSrcweir long SwView::SetHScrollMax( long lMax )
151cdf0e10cSrcweir {
152cdf0e10cSrcweir const long lBorder = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
153cdf0e10cSrcweir const long lSize = GetDocSz().Width() + lBorder - aVisArea.GetWidth();
154cdf0e10cSrcweir
155cdf0e10cSrcweir // bei negativen Werten ist das Dokument vollstaendig sichtbar;
156cdf0e10cSrcweir // in diesem Fall kein Scrollen
157cdf0e10cSrcweir return Max( Min( lMax, lSize ), 0L );
158cdf0e10cSrcweir }
159cdf0e10cSrcweir
160cdf0e10cSrcweir
SetVScrollMax(long lMax)161cdf0e10cSrcweir long SwView::SetVScrollMax( long lMax )
162cdf0e10cSrcweir {
163cdf0e10cSrcweir const long lBorder = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
164cdf0e10cSrcweir long lSize = GetDocSz().Height() + lBorder - aVisArea.GetHeight();
165cdf0e10cSrcweir return Max( Min( lMax, lSize), 0L ); // siehe horz.
166cdf0e10cSrcweir }
167cdf0e10cSrcweir
168cdf0e10cSrcweir
AlignToPixel(const Point & rPt) const169cdf0e10cSrcweir Point SwView::AlignToPixel(const Point &rPt) const
170cdf0e10cSrcweir {
171cdf0e10cSrcweir return GetEditWin().PixelToLogic( GetEditWin().LogicToPixel( rPt ) );
172cdf0e10cSrcweir }
173cdf0e10cSrcweir
174cdf0e10cSrcweir /*--------------------------------------------------------------------
175cdf0e10cSrcweir Beschreibung: Dokumentgroesse hat sich geaendert
176cdf0e10cSrcweir --------------------------------------------------------------------*/
177cdf0e10cSrcweir
DocSzChgd(const Size & rSz)178cdf0e10cSrcweir void SwView::DocSzChgd(const Size &rSz)
179cdf0e10cSrcweir {
180cdf0e10cSrcweir
181cdf0e10cSrcweir extern int bDocSzUpdated;
182cdf0e10cSrcweir
183cdf0e10cSrcweir
184cdf0e10cSrcweir aDocSz = rSz;
185cdf0e10cSrcweir
186cdf0e10cSrcweir if( !pWrtShell || aVisArea.IsEmpty() ) // keine Shell -> keine Aenderung
187cdf0e10cSrcweir {
188cdf0e10cSrcweir bDocSzUpdated = sal_False;
189cdf0e10cSrcweir return;
190cdf0e10cSrcweir }
191cdf0e10cSrcweir
192cdf0e10cSrcweir //Wenn Text geloescht worden ist, kann es sein, dass die VisArea hinter
193cdf0e10cSrcweir //den sichtbaren Bereich verweist
194cdf0e10cSrcweir Rectangle aNewVisArea( aVisArea );
195cdf0e10cSrcweir bool bModified = false;
196cdf0e10cSrcweir SwTwips lGreenOffset = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
197cdf0e10cSrcweir SwTwips lTmp = aDocSz.Width() + lGreenOffset;
198cdf0e10cSrcweir
199cdf0e10cSrcweir if ( aNewVisArea.Right() >= lTmp )
200cdf0e10cSrcweir {
201cdf0e10cSrcweir lTmp = aNewVisArea.Right() - lTmp;
202cdf0e10cSrcweir aNewVisArea.Right() -= lTmp;
203cdf0e10cSrcweir aNewVisArea.Left() -= lTmp;
204cdf0e10cSrcweir bModified = true;
205cdf0e10cSrcweir }
206cdf0e10cSrcweir
207cdf0e10cSrcweir lTmp = aDocSz.Height() + lGreenOffset;
208cdf0e10cSrcweir if ( aNewVisArea.Bottom() >= lTmp )
209cdf0e10cSrcweir {
210cdf0e10cSrcweir lTmp = aNewVisArea.Bottom() - lTmp;
211cdf0e10cSrcweir aNewVisArea.Bottom() -= lTmp;
212cdf0e10cSrcweir aNewVisArea.Top() -= lTmp;
213cdf0e10cSrcweir bModified = true;
214cdf0e10cSrcweir }
215cdf0e10cSrcweir
216cdf0e10cSrcweir if ( bModified )
217cdf0e10cSrcweir SetVisArea( aNewVisArea, sal_False );
218cdf0e10cSrcweir
219cdf0e10cSrcweir if ( UpdateScrollbars() && !bInOuterResizePixel && !bInInnerResizePixel &&
220cdf0e10cSrcweir !GetViewFrame()->GetFrame().IsInPlace())
221cdf0e10cSrcweir OuterResizePixel( Point(),
222cdf0e10cSrcweir GetViewFrame()->GetWindow().GetOutputSizePixel() );
223cdf0e10cSrcweir }
224cdf0e10cSrcweir
225cdf0e10cSrcweir /*--------------------------------------------------------------------
226cdf0e10cSrcweir Beschreibung: Visarea neu setzen
227cdf0e10cSrcweir --------------------------------------------------------------------*/
228cdf0e10cSrcweir
SetVisArea(const Rectangle & rRect,sal_Bool bUpdateScrollbar)229cdf0e10cSrcweir void SwView::SetVisArea( const Rectangle &rRect, sal_Bool bUpdateScrollbar )
230cdf0e10cSrcweir {
231cdf0e10cSrcweir const Size aOldSz( aVisArea.GetSize() );
232cdf0e10cSrcweir
233cdf0e10cSrcweir const Point aTopLeft( AlignToPixel( rRect.TopLeft() ));
234cdf0e10cSrcweir const Point aBottomRight( AlignToPixel( rRect.BottomRight() ));
235cdf0e10cSrcweir Rectangle aLR( aTopLeft, aBottomRight );
236cdf0e10cSrcweir
237cdf0e10cSrcweir if( aLR == aVisArea )
238cdf0e10cSrcweir return;
239cdf0e10cSrcweir
240cdf0e10cSrcweir const SwTwips lMin = IsDocumentBorder() ? DOCUMENTBORDER : 0;
241cdf0e10cSrcweir
242cdf0e10cSrcweir // keine negative Position, keine neg. Groesse
243cdf0e10cSrcweir if( aLR.Top() < lMin )
244cdf0e10cSrcweir {
245cdf0e10cSrcweir aLR.Bottom() += lMin - aLR.Top();
246cdf0e10cSrcweir aLR.Top() = lMin;
247cdf0e10cSrcweir }
248cdf0e10cSrcweir if( aLR.Left() < lMin )
249cdf0e10cSrcweir {
250cdf0e10cSrcweir aLR.Right() += lMin - aLR.Left();
251cdf0e10cSrcweir aLR.Left() = lMin;
252cdf0e10cSrcweir }
253cdf0e10cSrcweir if( aLR.Right() < 0 )
254cdf0e10cSrcweir aLR.Right() = 0;
255cdf0e10cSrcweir if( aLR.Bottom() < 0 )
256cdf0e10cSrcweir aLR.Bottom() = 0;
257cdf0e10cSrcweir
258cdf0e10cSrcweir if( aLR == aVisArea )
259cdf0e10cSrcweir return;
260cdf0e10cSrcweir
261cdf0e10cSrcweir const Size aSize( aLR.GetSize() );
262cdf0e10cSrcweir if( aSize.Width() < 0 || aSize.Height() < 0 )
263cdf0e10cSrcweir return;
264cdf0e10cSrcweir
265cdf0e10cSrcweir //Bevor die Daten veraendert werden ggf. ein Update rufen. Dadurch wird
266cdf0e10cSrcweir //sichergestellt, da? anliegende Paints korrekt in Dokumentkoordinaten
267cdf0e10cSrcweir //umgerechnet werden.
268cdf0e10cSrcweir //Vorsichtshalber tun wir das nur wenn an der Shell eine Action laeuft,
269cdf0e10cSrcweir //denn dann wir nicht wirklich gepaintet sondern die Rechtecke werden
270cdf0e10cSrcweir //lediglich (in Dokumentkoordinaten) vorgemerkt.
271cdf0e10cSrcweir if ( pWrtShell && pWrtShell->ActionPend() )
272cdf0e10cSrcweir pWrtShell->GetWin()->Update();
273cdf0e10cSrcweir
274cdf0e10cSrcweir aVisArea = aLR;
275cdf0e10cSrcweir
276cdf0e10cSrcweir const sal_Bool bOuterResize = bUpdateScrollbar && UpdateScrollbars();
277cdf0e10cSrcweir
278cdf0e10cSrcweir if ( pWrtShell )
279cdf0e10cSrcweir {
280cdf0e10cSrcweir pWrtShell->VisPortChgd( aVisArea );
281cdf0e10cSrcweir if ( aOldSz != pWrtShell->VisArea().SSize() &&
282cdf0e10cSrcweir ( Abs(aOldSz.Width() - pWrtShell->VisArea().Width()) > 2 ||
283cdf0e10cSrcweir Abs(aOldSz.Height() - pWrtShell->VisArea().Height()) > 2 ) )
284cdf0e10cSrcweir pWrtShell->CheckBrowseView( sal_False );
285cdf0e10cSrcweir }
286cdf0e10cSrcweir
287cdf0e10cSrcweir if ( !bProtectDocShellVisArea )
288cdf0e10cSrcweir {
289cdf0e10cSrcweir //Wenn die Groesse der VisArea unveraendert ist, reichen wir die
290cdf0e10cSrcweir //Groesse der VisArea vom InternalObject weiter. Damit soll der
291cdf0e10cSrcweir //Transport von Fehlern vermieden werden.
292cdf0e10cSrcweir Rectangle aVis( aVisArea );
293cdf0e10cSrcweir if ( aVis.GetSize() == aOldSz )
294cdf0e10cSrcweir aVis.SetSize( GetDocShell()->SfxObjectShell::GetVisArea(ASPECT_CONTENT).GetSize() );
295cdf0e10cSrcweir // TODO/LATER: why casting?!
296cdf0e10cSrcweir //GetDocShell()->SfxInPlaceObject::GetVisArea().GetSize() );
297cdf0e10cSrcweir
298cdf0e10cSrcweir //Bei embedded immer mit Modify...
299cdf0e10cSrcweir // TODO/LATER: why casting?!
300cdf0e10cSrcweir GetDocShell()->SfxObjectShell::SetVisArea( aVis );
301cdf0e10cSrcweir /*
302cdf0e10cSrcweir if ( GetDocShell()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
303cdf0e10cSrcweir GetDocShell()->SfxInPlaceObject::SetVisArea( aVis );
304cdf0e10cSrcweir else
305cdf0e10cSrcweir GetDocShell()->SvEmbeddedObject::SetVisArea( aVis );*/
306cdf0e10cSrcweir }
307cdf0e10cSrcweir
308cdf0e10cSrcweir SfxViewShell::VisAreaChanged( aVisArea );
309cdf0e10cSrcweir
310cdf0e10cSrcweir InvalidateRulerPos();
311cdf0e10cSrcweir
312cdf0e10cSrcweir SwEditWin::ClearTip();
313cdf0e10cSrcweir
314cdf0e10cSrcweir if ( bOuterResize && !bInOuterResizePixel && !bInInnerResizePixel)
315cdf0e10cSrcweir OuterResizePixel( Point(),
316cdf0e10cSrcweir GetViewFrame()->GetWindow().GetOutputSizePixel() );
317cdf0e10cSrcweir }
318cdf0e10cSrcweir
319cdf0e10cSrcweir /*--------------------------------------------------------------------
320cdf0e10cSrcweir Beschreibung: Pos VisArea setzen
321cdf0e10cSrcweir --------------------------------------------------------------------*/
322cdf0e10cSrcweir
SetVisArea(const Point & rPt,sal_Bool bUpdateScrollbar)323cdf0e10cSrcweir void SwView::SetVisArea( const Point &rPt, sal_Bool bUpdateScrollbar )
324cdf0e10cSrcweir {
325cdf0e10cSrcweir //einmal alignen, damit Brushes korrekt angesetzt werden.
326cdf0e10cSrcweir //MA 31. May. 96: Das geht in der BrowseView schief, weil evlt.
327cdf0e10cSrcweir //nicht das ganze Dokument sichtbar wird. Da der Inhalt in Frames
328cdf0e10cSrcweir //passgenau ist, kann nicht aligned werden (bessere Idee?!?!)
329cdf0e10cSrcweir //MA 29. Oct. 96 (fix: Bild.de, 200%) ganz ohne Alignment geht es nicht
330cdf0e10cSrcweir //mal sehen wie weit wir mit der halben BrushSize kommen.
331cdf0e10cSrcweir //TODO: why BRUSH_SIZE?
332cdf0e10cSrcweir Point aPt( rPt );
333cdf0e10cSrcweir // const long nTmp = GetWrtShell().IsFrameView() ? BRUSH_SIZE/2 : BRUSH_SIZE;
334cdf0e10cSrcweir const long nTmp = GetWrtShell().IsFrameView() ? 4 : 8;
335cdf0e10cSrcweir aPt = GetEditWin().LogicToPixel( aPt );
336cdf0e10cSrcweir aPt.X() -= aPt.X() % nTmp;
337cdf0e10cSrcweir aPt.Y() -= aPt.Y() % nTmp;
338cdf0e10cSrcweir aPt = GetEditWin().PixelToLogic( aPt );
339cdf0e10cSrcweir
340cdf0e10cSrcweir if ( aPt == aVisArea.TopLeft() )
341cdf0e10cSrcweir return;
342cdf0e10cSrcweir
343cdf0e10cSrcweir const long lXDiff = aVisArea.Left() - aPt.X();
344cdf0e10cSrcweir const long lYDiff = aVisArea.Top() - aPt.Y();
345cdf0e10cSrcweir SetVisArea( Rectangle( aPt,
346cdf0e10cSrcweir Point( aVisArea.Right() - lXDiff, aVisArea.Bottom() - lYDiff ) ),
347cdf0e10cSrcweir bUpdateScrollbar);
348cdf0e10cSrcweir }
349cdf0e10cSrcweir
350cdf0e10cSrcweir
CheckVisArea()351cdf0e10cSrcweir void SwView::CheckVisArea()
352cdf0e10cSrcweir {
353cdf0e10cSrcweir pHScrollbar->SetAuto( pWrtShell->GetViewOptions()->getBrowseMode() &&
354cdf0e10cSrcweir !GetViewFrame()->GetFrame().IsInPlace() );
355cdf0e10cSrcweir if ( IsDocumentBorder() )
356cdf0e10cSrcweir {
357cdf0e10cSrcweir if ( aVisArea.Left() != DOCUMENTBORDER ||
358cdf0e10cSrcweir aVisArea.Top() != DOCUMENTBORDER )
359cdf0e10cSrcweir {
360cdf0e10cSrcweir Rectangle aNewVisArea( aVisArea );
361cdf0e10cSrcweir aNewVisArea.Move( DOCUMENTBORDER - aVisArea.Left(),
362cdf0e10cSrcweir DOCUMENTBORDER - aVisArea.Top() );
363cdf0e10cSrcweir SetVisArea( aNewVisArea, sal_True );
364cdf0e10cSrcweir }
365cdf0e10cSrcweir }
366cdf0e10cSrcweir }
367cdf0e10cSrcweir
368cdf0e10cSrcweir /*--------------------------------------------------------------------
369cdf0e10cSrcweir Beschreibung: Sichtbaren Bereich berechnen
370cdf0e10cSrcweir
371cdf0e10cSrcweir OUT Point *pPt: neue Position des sichtbaren
372cdf0e10cSrcweir Bereiches
373cdf0e10cSrcweir IN Rectangle &rRect: Rechteck, das sich innerhalb des neuen
374cdf0e10cSrcweir sichtbaren Bereiches befinden soll
375cdf0e10cSrcweir sal_uInt16 nRange optional exakte Angabe des Bereiches,
376cdf0e10cSrcweir um den ggfs. gescrollt werden soll
377cdf0e10cSrcweir --------------------------------------------------------------------*/
378cdf0e10cSrcweir
CalcPt(Point * pPt,const Rectangle & rRect,sal_uInt16 nRangeX,sal_uInt16 nRangeY)379cdf0e10cSrcweir void SwView::CalcPt( Point *pPt, const Rectangle &rRect,
380cdf0e10cSrcweir sal_uInt16 nRangeX, sal_uInt16 nRangeY)
381cdf0e10cSrcweir {
382cdf0e10cSrcweir
383cdf0e10cSrcweir const SwTwips lMin = IsDocumentBorder() ? DOCUMENTBORDER : 0;
384cdf0e10cSrcweir
385cdf0e10cSrcweir long nYScroll = GetYScroll();
386cdf0e10cSrcweir long nDesHeight = rRect.GetHeight();
387cdf0e10cSrcweir long nCurHeight = aVisArea.GetHeight();
388cdf0e10cSrcweir nYScroll = Min(nYScroll, nCurHeight - nDesHeight); // wird es knapp, dann nicht zuviel scrollen
389cdf0e10cSrcweir if(nDesHeight > nCurHeight) // die Hoehe reicht nicht aus, dann interessiert nYScroll nicht mehr
390cdf0e10cSrcweir {
391cdf0e10cSrcweir pPt->Y() = rRect.Top();
392cdf0e10cSrcweir pPt->Y() = Max( lMin, pPt->Y() );
393cdf0e10cSrcweir }
394cdf0e10cSrcweir else if ( rRect.Top() < aVisArea.Top() ) //Verschiebung nach oben
395cdf0e10cSrcweir {
396cdf0e10cSrcweir pPt->Y() = rRect.Top() - (nRangeY != USHRT_MAX ? nRangeY : nYScroll);
397cdf0e10cSrcweir pPt->Y() = Max( lMin, pPt->Y() );
398cdf0e10cSrcweir }
399cdf0e10cSrcweir else if( rRect.Bottom() > aVisArea.Bottom() ) //Verschiebung nach unten
400cdf0e10cSrcweir {
401cdf0e10cSrcweir pPt->Y() = rRect.Bottom() -
402cdf0e10cSrcweir (aVisArea.GetHeight()) + ( nRangeY != USHRT_MAX ?
403cdf0e10cSrcweir nRangeY : nYScroll );
404cdf0e10cSrcweir pPt->Y() = SetVScrollMax( pPt->Y() );
405cdf0e10cSrcweir }
406cdf0e10cSrcweir long nXScroll = GetXScroll();
407cdf0e10cSrcweir if ( rRect.Right() > aVisArea.Right() ) //Verschiebung nach rechts
408cdf0e10cSrcweir {
409cdf0e10cSrcweir pPt->X() = rRect.Right() -
410cdf0e10cSrcweir (aVisArea.GetWidth()) +
411cdf0e10cSrcweir (nRangeX != USHRT_MAX ? nRangeX : nXScroll);
412cdf0e10cSrcweir pPt->X() = SetHScrollMax( pPt->X() );
413cdf0e10cSrcweir }
414cdf0e10cSrcweir else if ( rRect.Left() < aVisArea.Left() ) //Verschiebung nach links
415cdf0e10cSrcweir {
416cdf0e10cSrcweir pPt->X() = rRect.Left() - (nRangeX != USHRT_MAX ? nRangeX : nXScroll);
417cdf0e10cSrcweir pPt->X() = Max( ::GetLeftMargin( *this ) + nLeftOfst, pPt->X() );
418cdf0e10cSrcweir pPt->X() = Min( rRect.Left() - nScrollX, pPt->X() );
419cdf0e10cSrcweir pPt->X() = Max( 0L, pPt->X() );
420cdf0e10cSrcweir }
421cdf0e10cSrcweir }
422cdf0e10cSrcweir
423cdf0e10cSrcweir /*--------------------------------------------------------------------
424cdf0e10cSrcweir Beschreibung: Scrolling
425cdf0e10cSrcweir --------------------------------------------------------------------*/
426cdf0e10cSrcweir
IsScroll(const Rectangle & rRect) const427cdf0e10cSrcweir sal_Bool SwView::IsScroll( const Rectangle &rRect ) const
428cdf0e10cSrcweir {
429cdf0e10cSrcweir return bCenterCrsr || bTopCrsr || !aVisArea.IsInside(rRect);
430cdf0e10cSrcweir }
431cdf0e10cSrcweir
432cdf0e10cSrcweir
Scroll(const Rectangle & rRect,sal_uInt16 nRangeX,sal_uInt16 nRangeY)433cdf0e10cSrcweir void SwView::Scroll( const Rectangle &rRect, sal_uInt16 nRangeX, sal_uInt16 nRangeY )
434cdf0e10cSrcweir {
435cdf0e10cSrcweir if ( aVisArea.IsEmpty() )
436cdf0e10cSrcweir return;
437cdf0e10cSrcweir
438cdf0e10cSrcweir Rectangle aOldVisArea( aVisArea );
439cdf0e10cSrcweir long nDiffY = 0;
440cdf0e10cSrcweir
441cdf0e10cSrcweir Window* pCareWn = ViewShell::GetCareWin(GetWrtShell());
442cdf0e10cSrcweir if ( pCareWn )
443cdf0e10cSrcweir {
444cdf0e10cSrcweir Rectangle aDlgRect( GetEditWin().PixelToLogic(
445cdf0e10cSrcweir pCareWn->GetWindowExtentsRelative( &GetEditWin() ) ) );
446cdf0e10cSrcweir // Nur, wenn der Dialog nicht rechts oder links der VisArea liegt:
447cdf0e10cSrcweir if ( aDlgRect.Left() < aVisArea.Right() &&
448cdf0e10cSrcweir aDlgRect.Right() > aVisArea.Left() )
449cdf0e10cSrcweir {
450cdf0e10cSrcweir // Falls wir nicht zentriert werden sollen, in der VisArea liegen
451cdf0e10cSrcweir // und nicht vom Dialog ueberdeckt werden ...
452cdf0e10cSrcweir if ( !bCenterCrsr && aOldVisArea.IsInside( rRect )
453cdf0e10cSrcweir && ( rRect.Left() > aDlgRect.Right()
454cdf0e10cSrcweir || rRect.Right() < aDlgRect.Left()
455cdf0e10cSrcweir || rRect.Top() > aDlgRect.Bottom()
456cdf0e10cSrcweir || rRect.Bottom() < aDlgRect.Top() ) )
457cdf0e10cSrcweir return;
458cdf0e10cSrcweir
459cdf0e10cSrcweir // Ist oberhalb oder unterhalb der Dialogs mehr Platz?
460cdf0e10cSrcweir long nTopDiff = aDlgRect.Top() - aVisArea.Top();
461cdf0e10cSrcweir long nBottomDiff = aVisArea.Bottom() - aDlgRect.Bottom();
462cdf0e10cSrcweir if ( nTopDiff < nBottomDiff )
463cdf0e10cSrcweir {
464cdf0e10cSrcweir if ( nBottomDiff > 0 ) // Ist unterhalb ueberhaupt Platz?
465cdf0e10cSrcweir { // dann verschieben wir die Oberkante und merken uns dies
466cdf0e10cSrcweir nDiffY = aDlgRect.Bottom() - aVisArea.Top();
467cdf0e10cSrcweir aVisArea.Top() += nDiffY;
468cdf0e10cSrcweir }
469cdf0e10cSrcweir }
470cdf0e10cSrcweir else
471cdf0e10cSrcweir {
472cdf0e10cSrcweir if ( nTopDiff > 0 ) // Ist oberhalb ueberhaupt Platz?
473cdf0e10cSrcweir aVisArea.Bottom() = aDlgRect.Top(); // Unterkante aendern
474cdf0e10cSrcweir }
475cdf0e10cSrcweir }
476cdf0e10cSrcweir }
477cdf0e10cSrcweir
478cdf0e10cSrcweir //s.o. !IsScroll()
479cdf0e10cSrcweir if( !(bCenterCrsr || bTopCrsr) && aVisArea.IsInside( rRect ) )
480cdf0e10cSrcweir {
481cdf0e10cSrcweir aVisArea = aOldVisArea;
482cdf0e10cSrcweir return;
483cdf0e10cSrcweir }
484cdf0e10cSrcweir //falls das Rechteck groesser als der sichtbare Bereich -->
485cdf0e10cSrcweir //obere linke Ecke
486cdf0e10cSrcweir Size aSize( rRect.GetSize() );
487cdf0e10cSrcweir const Size aVisSize( aVisArea.GetSize() );
488cdf0e10cSrcweir if( !aVisArea.IsEmpty() && (
489cdf0e10cSrcweir aSize.Width() + GetXScroll() > aVisSize.Width() ||
490cdf0e10cSrcweir aSize.Height()+ GetYScroll() > aVisSize.Height() ))
491cdf0e10cSrcweir {
492cdf0e10cSrcweir Point aPt( aVisArea.TopLeft() );
493cdf0e10cSrcweir aSize.Width() = Min( aSize.Width(), aVisSize.Width() );
494cdf0e10cSrcweir aSize.Height()= Min( aSize.Height(),aVisSize.Height());
495cdf0e10cSrcweir
496cdf0e10cSrcweir CalcPt( &aPt, Rectangle( rRect.TopLeft(), aSize ),
497cdf0e10cSrcweir static_cast< sal_uInt16 >((aVisSize.Width() - aSize.Width()) / 2),
498cdf0e10cSrcweir static_cast< sal_uInt16 >((aVisSize.Height()- aSize.Height())/ 2) );
499cdf0e10cSrcweir
500cdf0e10cSrcweir if( bTopCrsr )
501cdf0e10cSrcweir {
502cdf0e10cSrcweir const long nBorder = IsDocumentBorder() ? DOCUMENTBORDER : 0;
503cdf0e10cSrcweir aPt.Y() = Min( Max( nBorder, rRect.Top() ),
504cdf0e10cSrcweir aDocSz.Height() + nBorder -
505cdf0e10cSrcweir aVisArea.GetHeight() );
506cdf0e10cSrcweir }
507cdf0e10cSrcweir aPt.Y() -= nDiffY;
508cdf0e10cSrcweir aVisArea = aOldVisArea;
509cdf0e10cSrcweir SetVisArea( aPt );
510cdf0e10cSrcweir return;
511cdf0e10cSrcweir }
512cdf0e10cSrcweir if( !bCenterCrsr )
513cdf0e10cSrcweir {
514cdf0e10cSrcweir Point aPt( aVisArea.TopLeft() );
515cdf0e10cSrcweir CalcPt( &aPt, rRect, nRangeX, nRangeY );
516cdf0e10cSrcweir
517cdf0e10cSrcweir if( bTopCrsr )
518cdf0e10cSrcweir {
519cdf0e10cSrcweir const long nBorder = IsDocumentBorder() ? DOCUMENTBORDER : 0;
520cdf0e10cSrcweir aPt.Y() = Min( Max( nBorder, rRect.Top() ),
521cdf0e10cSrcweir aDocSz.Height() + nBorder -
522cdf0e10cSrcweir aVisArea.GetHeight() );
523cdf0e10cSrcweir }
524cdf0e10cSrcweir
525cdf0e10cSrcweir aPt.Y() -= nDiffY;
526cdf0e10cSrcweir aVisArea = aOldVisArea;
527cdf0e10cSrcweir SetVisArea( aPt );
528cdf0e10cSrcweir return;
529cdf0e10cSrcweir }
530cdf0e10cSrcweir
531cdf0e10cSrcweir //Cursor zentrieren
532cdf0e10cSrcweir Point aPnt( aVisArea.TopLeft() );
533cdf0e10cSrcweir // ... in Y-Richtung auf jeden Fall
534cdf0e10cSrcweir aPnt.Y() += ( rRect.Top() + rRect.Bottom()
535cdf0e10cSrcweir - aVisArea.Top() - aVisArea.Bottom() ) / 2 - nDiffY;
536cdf0e10cSrcweir // ... in X-Richtung nur, wenn das Rechteck rechts oder links aus der
537cdf0e10cSrcweir // VisArea hinausragt.
538cdf0e10cSrcweir if ( rRect.Right() > aVisArea.Right() || rRect.Left() < aVisArea.Left() )
539cdf0e10cSrcweir {
540cdf0e10cSrcweir aPnt.X() += ( rRect.Left() + rRect.Right()
541cdf0e10cSrcweir - aVisArea.Left() - aVisArea.Right() ) / 2;
542cdf0e10cSrcweir aPnt.X() = SetHScrollMax( aPnt.X() );
543cdf0e10cSrcweir const SwTwips lMin = IsDocumentBorder() ? DOCUMENTBORDER : 0;
544cdf0e10cSrcweir aPnt.X() = Max( (GetLeftMargin( *this ) - lMin) + nLeftOfst, aPnt.X() );
545cdf0e10cSrcweir }
546cdf0e10cSrcweir aVisArea = aOldVisArea;
547cdf0e10cSrcweir if( pCareWn )
548cdf0e10cSrcweir { // Wenn wir nur einem Dialog ausweichen wollen, wollen wir nicht ueber
549cdf0e10cSrcweir // das Ende des Dokument hinausgehen.
550cdf0e10cSrcweir aPnt.Y() = SetVScrollMax( aPnt.Y() );
551cdf0e10cSrcweir }
552cdf0e10cSrcweir SetVisArea( aPnt );
553cdf0e10cSrcweir }
554cdf0e10cSrcweir
555cdf0e10cSrcweir /*--------------------------------------------------------------------
556cdf0e10cSrcweir Beschreibung: Seitenweises Scrollen
557cdf0e10cSrcweir Liefern den Wert, um den bei PageUp / -Down gescrollt werden soll
558cdf0e10cSrcweir --------------------------------------------------------------------*/
559cdf0e10cSrcweir
GetPageScrollUpOffset(SwTwips & rOff) const560cdf0e10cSrcweir sal_Bool SwView::GetPageScrollUpOffset( SwTwips &rOff ) const
561cdf0e10cSrcweir {
562cdf0e10cSrcweir if ( !aVisArea.Top() || !aVisArea.GetHeight() )
563cdf0e10cSrcweir return sal_False;
564cdf0e10cSrcweir long nYScrl = GetYScroll() / 2;
565cdf0e10cSrcweir rOff = -(aVisArea.GetHeight() - nYScrl);
566cdf0e10cSrcweir //nicht vor den Dokumentanfang scrollen
567cdf0e10cSrcweir if( aVisArea.Top() - rOff < 0 )
568cdf0e10cSrcweir rOff = rOff - aVisArea.Top();
569cdf0e10cSrcweir else if( GetWrtShell().GetCharRect().Top() < (aVisArea.Top() + nYScrl))
570cdf0e10cSrcweir rOff += nYScrl;
571cdf0e10cSrcweir return sal_True;
572cdf0e10cSrcweir }
573cdf0e10cSrcweir
574cdf0e10cSrcweir
GetPageScrollDownOffset(SwTwips & rOff) const575cdf0e10cSrcweir sal_Bool SwView::GetPageScrollDownOffset( SwTwips &rOff ) const
576cdf0e10cSrcweir {
577cdf0e10cSrcweir if ( !aVisArea.GetHeight() ||
578cdf0e10cSrcweir (aVisArea.GetHeight() > aDocSz.Height()) )
579cdf0e10cSrcweir return sal_False;
580cdf0e10cSrcweir long nYScrl = GetYScroll() / 2;
581cdf0e10cSrcweir rOff = aVisArea.GetHeight() - nYScrl;
582cdf0e10cSrcweir //nicht hinter das Dokumentende scrollen
583cdf0e10cSrcweir if ( aVisArea.Top() + rOff > aDocSz.Height() )
584cdf0e10cSrcweir rOff = aDocSz.Height() - aVisArea.Bottom();
585cdf0e10cSrcweir else if( GetWrtShell().GetCharRect().Bottom() >
586cdf0e10cSrcweir ( aVisArea.Bottom() - nYScrl ))
587cdf0e10cSrcweir rOff -= nYScrl;
588cdf0e10cSrcweir return rOff > 0;
589cdf0e10cSrcweir }
590cdf0e10cSrcweir
591cdf0e10cSrcweir // Seitenweises Blaettern
592cdf0e10cSrcweir
PageUp()593cdf0e10cSrcweir long SwView::PageUp()
594cdf0e10cSrcweir {
595cdf0e10cSrcweir if (!aVisArea.GetHeight())
596cdf0e10cSrcweir return 0;
597cdf0e10cSrcweir
598cdf0e10cSrcweir Point aPos(aVisArea.TopLeft());
599cdf0e10cSrcweir aPos.Y() -= aVisArea.GetHeight() - (GetYScroll() / 2);
600cdf0e10cSrcweir aPos.Y() = Max(0L, aPos.Y());
601cdf0e10cSrcweir SetVisArea( aPos );
602cdf0e10cSrcweir return 1;
603cdf0e10cSrcweir }
604cdf0e10cSrcweir
605cdf0e10cSrcweir
PageDown()606cdf0e10cSrcweir long SwView::PageDown()
607cdf0e10cSrcweir {
608cdf0e10cSrcweir if ( !aVisArea.GetHeight() )
609cdf0e10cSrcweir return 0;
610cdf0e10cSrcweir Point aPos( aVisArea.TopLeft() );
611cdf0e10cSrcweir aPos.Y() += aVisArea.GetHeight() - (GetYScroll() / 2);
612cdf0e10cSrcweir aPos.Y() = SetVScrollMax( aPos.Y() );
613cdf0e10cSrcweir SetVisArea( aPos );
614cdf0e10cSrcweir return 1;
615cdf0e10cSrcweir }
616cdf0e10cSrcweir
617cdf0e10cSrcweir
PhyPageUp()618cdf0e10cSrcweir long SwView::PhyPageUp()
619cdf0e10cSrcweir {
620cdf0e10cSrcweir //aktuell sichtbare Seite erfragen, nicht formatieren
621cdf0e10cSrcweir sal_uInt16 nActPage = pWrtShell->GetNextPrevPageNum( sal_False );
622cdf0e10cSrcweir
623cdf0e10cSrcweir if( USHRT_MAX != nActPage )
624cdf0e10cSrcweir {
625cdf0e10cSrcweir const Point aPt( aVisArea.Left(),
626cdf0e10cSrcweir pWrtShell->GetPagePos( nActPage ).Y() );
627cdf0e10cSrcweir Point aAlPt( AlignToPixel( aPt ) );
628cdf0e10cSrcweir // falls ein Unterschied besteht, wurde abgeschnitten --> dann
629cdf0e10cSrcweir // einen Pixel addieren, damit kein Rest der Vorgaengerseite
630cdf0e10cSrcweir // sichtbar ist
631cdf0e10cSrcweir if( aPt.Y() != aAlPt.Y() )
632cdf0e10cSrcweir aAlPt.Y() += 3 * GetEditWin().PixelToLogic( Size( 0, 1 ) ).Height();
633cdf0e10cSrcweir SetVisArea( aAlPt );
634cdf0e10cSrcweir }
635cdf0e10cSrcweir return 1;
636cdf0e10cSrcweir }
637cdf0e10cSrcweir
638cdf0e10cSrcweir
PhyPageDown()639cdf0e10cSrcweir long SwView::PhyPageDown()
640cdf0e10cSrcweir {
641cdf0e10cSrcweir //aktuell sichtbare Seite erfragen, nicht formatieren
642cdf0e10cSrcweir sal_uInt16 nActPage = pWrtShell->GetNextPrevPageNum( sal_True );
643cdf0e10cSrcweir // falls die letzte Dokumentseite sichtbar ist, nichts tun
644cdf0e10cSrcweir if( USHRT_MAX != nActPage )
645cdf0e10cSrcweir {
646cdf0e10cSrcweir const Point aPt( aVisArea.Left(),
647cdf0e10cSrcweir pWrtShell->GetPagePos( nActPage ).Y() );
648cdf0e10cSrcweir Point aAlPt( AlignToPixel( aPt ) );
649cdf0e10cSrcweir // falls ein Unterschied besteht, wurde abgeschnitten --> dann
650cdf0e10cSrcweir // einen Pixel addieren, damit kein Rest der Vorgaengerseite sichtbar ist
651cdf0e10cSrcweir if( aPt.Y() != aAlPt.Y() )
652cdf0e10cSrcweir aAlPt.Y() += 3 * GetEditWin().PixelToLogic( Size( 0, 1 ) ).Height();
653cdf0e10cSrcweir SetVisArea( aAlPt );
654cdf0e10cSrcweir }
655cdf0e10cSrcweir return 1;
656cdf0e10cSrcweir }
657cdf0e10cSrcweir
658cdf0e10cSrcweir
PageUpCrsr(sal_Bool bSelect)659cdf0e10cSrcweir long SwView::PageUpCrsr( sal_Bool bSelect )
660cdf0e10cSrcweir {
661cdf0e10cSrcweir if ( !bSelect )
662cdf0e10cSrcweir {
663cdf0e10cSrcweir const sal_uInt16 eType = pWrtShell->GetFrmType(0,sal_True);
664cdf0e10cSrcweir if ( eType & FRMTYPE_FOOTNOTE )
665cdf0e10cSrcweir {
666cdf0e10cSrcweir pWrtShell->MoveCrsr();
667cdf0e10cSrcweir pWrtShell->GotoFtnAnchor();
668cdf0e10cSrcweir pWrtShell->Right(CRSR_SKIP_CHARS, sal_False, 1, sal_False );
669cdf0e10cSrcweir return 1;
670cdf0e10cSrcweir }
671cdf0e10cSrcweir }
672cdf0e10cSrcweir
673cdf0e10cSrcweir SwTwips lOff = 0;
674cdf0e10cSrcweir if ( GetPageScrollUpOffset( lOff ) &&
675cdf0e10cSrcweir (pWrtShell->IsCrsrReadonly() ||
676cdf0e10cSrcweir !pWrtShell->PageCrsr( lOff, bSelect )) &&
677cdf0e10cSrcweir PageUp() )
678cdf0e10cSrcweir {
679cdf0e10cSrcweir pWrtShell->ResetCursorStack();
680cdf0e10cSrcweir return sal_True;
681cdf0e10cSrcweir }
682cdf0e10cSrcweir return sal_False;
683cdf0e10cSrcweir }
684cdf0e10cSrcweir
685cdf0e10cSrcweir
PageDownCrsr(sal_Bool bSelect)686cdf0e10cSrcweir long SwView::PageDownCrsr(sal_Bool bSelect)
687cdf0e10cSrcweir {
688cdf0e10cSrcweir SwTwips lOff = 0;
689cdf0e10cSrcweir if ( GetPageScrollDownOffset( lOff ) &&
690cdf0e10cSrcweir (pWrtShell->IsCrsrReadonly() ||
691cdf0e10cSrcweir !pWrtShell->PageCrsr( lOff, bSelect )) &&
692cdf0e10cSrcweir PageDown() )
693cdf0e10cSrcweir {
694cdf0e10cSrcweir pWrtShell->ResetCursorStack();
695cdf0e10cSrcweir return sal_True;
696cdf0e10cSrcweir }
697cdf0e10cSrcweir return sal_False;
698cdf0e10cSrcweir }
699cdf0e10cSrcweir
700cdf0e10cSrcweir /*------------------------------------------------------------------------
701cdf0e10cSrcweir Beschreibung: Handler der Scrollbars
702cdf0e10cSrcweir ------------------------------------------------------------------------*/
703cdf0e10cSrcweir
IMPL_LINK(SwView,ScrollHdl,SwScrollbar *,pScrollbar)704cdf0e10cSrcweir IMPL_LINK( SwView, ScrollHdl, SwScrollbar *, pScrollbar )
705cdf0e10cSrcweir {
706cdf0e10cSrcweir if ( GetWrtShell().ActionPend() )
707cdf0e10cSrcweir return 0;
708cdf0e10cSrcweir
709cdf0e10cSrcweir if ( pScrollbar->GetType() == SCROLL_DRAG )
710cdf0e10cSrcweir pWrtShell->EnableSmooth( sal_False );
711cdf0e10cSrcweir
712cdf0e10cSrcweir if(!pWrtShell->GetViewOptions()->getBrowseMode() &&
713cdf0e10cSrcweir pScrollbar->GetType() == SCROLL_DRAG)
714cdf0e10cSrcweir {
715cdf0e10cSrcweir //Hier wieder auskommentieren wenn das mitscrollen nicht gewuenscht ist.
716cdf0e10cSrcweir // JP 21.07.00: the end scrollhandler invalidate the FN_STAT_PAGE,
717cdf0e10cSrcweir // so we dont must do it agin.
718cdf0e10cSrcweir EndScrollHdl(pScrollbar);
719cdf0e10cSrcweir
720*a41e6500SAriel Constenla-Haile if ( Help::IsQuickHelpEnabled() &&
721*a41e6500SAriel Constenla-Haile pWrtShell->GetViewOptions()->IsShowScrollBarTips())
722*a41e6500SAriel Constenla-Haile {
723*a41e6500SAriel Constenla-Haile Point aPos( aVisArea.TopLeft() );
724*a41e6500SAriel Constenla-Haile lcl_GetPos(this, aPos, pScrollbar, IsDocumentBorder());
725*a41e6500SAriel Constenla-Haile
726*a41e6500SAriel Constenla-Haile sal_uInt16 nPhNum = 1;
727*a41e6500SAriel Constenla-Haile sal_uInt16 nVirtNum = 1;
728*a41e6500SAriel Constenla-Haile
729*a41e6500SAriel Constenla-Haile String sDisplay;
730*a41e6500SAriel Constenla-Haile if(pWrtShell->GetPageNumber( aPos.Y(), sal_False, nPhNum, nVirtNum, sDisplay ))
731*a41e6500SAriel Constenla-Haile {
732*a41e6500SAriel Constenla-Haile // JP 21.07.00: the end scrollhandler invalidate the FN_STAT_PAGE,
733*a41e6500SAriel Constenla-Haile // so we dont must do it agin.
734*a41e6500SAriel Constenla-Haile // if(!GetViewFrame()->GetFrame().IsInPlace())
735*a41e6500SAriel Constenla-Haile // S F X_BINDINGS().Update(FN_STAT_PAGE);
736*a41e6500SAriel Constenla-Haile
737*a41e6500SAriel Constenla-Haile //QuickHelp:
738*a41e6500SAriel Constenla-Haile if( pWrtShell->GetPageCnt() > 1 )
739*a41e6500SAriel Constenla-Haile {
740*a41e6500SAriel Constenla-Haile if( !nPgNum || nPgNum != nPhNum )
741*a41e6500SAriel Constenla-Haile {
742*a41e6500SAriel Constenla-Haile Rectangle aRect;
743*a41e6500SAriel Constenla-Haile aRect.Left() = pScrollbar->GetParent()->OutputToScreenPixel(
744*a41e6500SAriel Constenla-Haile pScrollbar->GetPosPixel() ).X() -8;
745*a41e6500SAriel Constenla-Haile aRect.Top() = pScrollbar->OutputToScreenPixel(
746*a41e6500SAriel Constenla-Haile pScrollbar->GetPointerPosPixel() ).Y();
747*a41e6500SAriel Constenla-Haile aRect.Right() = aRect.Left();
748*a41e6500SAriel Constenla-Haile aRect.Bottom() = aRect.Top();
749*a41e6500SAriel Constenla-Haile
750*a41e6500SAriel Constenla-Haile String sPageStr( GetPageStr( nPhNum, nVirtNum, sDisplay ));
751*a41e6500SAriel Constenla-Haile SwContentAtPos aCnt( SwContentAtPos::SW_OUTLINE );
752*a41e6500SAriel Constenla-Haile pWrtShell->GetContentAtPos( aPos, aCnt );
753*a41e6500SAriel Constenla-Haile if( aCnt.sStr.Len() )
754*a41e6500SAriel Constenla-Haile {
755*a41e6500SAriel Constenla-Haile sPageStr += String::CreateFromAscii(
756*a41e6500SAriel Constenla-Haile RTL_CONSTASCII_STRINGPARAM( " - " ));
757*a41e6500SAriel Constenla-Haile sPageStr.Insert( aCnt.sStr, 0, 80 );
758*a41e6500SAriel Constenla-Haile sPageStr.SearchAndReplaceAll( '\t', ' ' );
759*a41e6500SAriel Constenla-Haile sPageStr.SearchAndReplaceAll( 0x0a, ' ' );
760*a41e6500SAriel Constenla-Haile }
761*a41e6500SAriel Constenla-Haile
762*a41e6500SAriel Constenla-Haile Help::ShowQuickHelp( pScrollbar, aRect, sPageStr,
763*a41e6500SAriel Constenla-Haile QUICKHELP_RIGHT|QUICKHELP_VCENTER);
764cdf0e10cSrcweir }
765*a41e6500SAriel Constenla-Haile nPgNum = nPhNum;
766*a41e6500SAriel Constenla-Haile }
767*a41e6500SAriel Constenla-Haile }
768*a41e6500SAriel Constenla-Haile }
769cdf0e10cSrcweir }
770cdf0e10cSrcweir else
771cdf0e10cSrcweir EndScrollHdl(pScrollbar);
772cdf0e10cSrcweir
773cdf0e10cSrcweir if ( pScrollbar->GetType() == SCROLL_DRAG )
774cdf0e10cSrcweir pWrtShell->EnableSmooth( sal_True );
775cdf0e10cSrcweir
776cdf0e10cSrcweir return 0;
777cdf0e10cSrcweir }
778cdf0e10cSrcweir /*------------------------------------------------------------------------
779cdf0e10cSrcweir Beschreibung: Handler der Scrollbars
780cdf0e10cSrcweir ------------------------------------------------------------------------*/
781cdf0e10cSrcweir
IMPL_LINK(SwView,EndScrollHdl,SwScrollbar *,pScrollbar)782cdf0e10cSrcweir IMPL_LINK( SwView, EndScrollHdl, SwScrollbar *, pScrollbar )
783cdf0e10cSrcweir {
784cdf0e10cSrcweir if ( !GetWrtShell().ActionPend() )
785cdf0e10cSrcweir {
786cdf0e10cSrcweir if(nPgNum)
787cdf0e10cSrcweir {
788cdf0e10cSrcweir nPgNum = 0;
789cdf0e10cSrcweir Help::ShowQuickHelp(pScrollbar, Rectangle(), aEmptyStr, 0);
790cdf0e10cSrcweir }
791cdf0e10cSrcweir Point aPos( aVisArea.TopLeft() );
792cdf0e10cSrcweir sal_Bool bBorder = IsDocumentBorder();
793cdf0e10cSrcweir lcl_GetPos(this, aPos, pScrollbar, bBorder);
794cdf0e10cSrcweir if ( bBorder && aPos == aVisArea.TopLeft() )
795cdf0e10cSrcweir UpdateScrollbars();
796cdf0e10cSrcweir else
797cdf0e10cSrcweir SetVisArea( aPos, sal_False );
798cdf0e10cSrcweir
799cdf0e10cSrcweir GetViewFrame()->GetBindings().Update(FN_STAT_PAGE);
800cdf0e10cSrcweir }
801cdf0e10cSrcweir return 0;
802cdf0e10cSrcweir }
803cdf0e10cSrcweir
804cdf0e10cSrcweir /*--------------------------------------------------------------------
805cdf0e10cSrcweir Beschreibung:
806cdf0e10cSrcweir
807cdf0e10cSrcweir berechnet die Groesse von aVisArea abhaengig von der Groesse
808cdf0e10cSrcweir des EditWin auf dem Schirm.
809cdf0e10cSrcweir
810cdf0e10cSrcweir --------------------------------------------------------------------*/
811cdf0e10cSrcweir
CalcVisArea(const Size & rOutPixel)812cdf0e10cSrcweir void SwView::CalcVisArea( const Size &rOutPixel )
813cdf0e10cSrcweir {
814cdf0e10cSrcweir Point aTopLeft;
815cdf0e10cSrcweir Rectangle aRect( aTopLeft, rOutPixel );
816cdf0e10cSrcweir aTopLeft = GetEditWin().PixelToLogic( aTopLeft );
817cdf0e10cSrcweir Point aBottomRight( GetEditWin().PixelToLogic( aRect.BottomRight() ) );
818cdf0e10cSrcweir
819cdf0e10cSrcweir aRect.Left() = aTopLeft.X();
820cdf0e10cSrcweir aRect.Top() = aTopLeft.Y();
821cdf0e10cSrcweir aRect.Right() = aBottomRight.X();
822cdf0e10cSrcweir aRect.Bottom() = aBottomRight.Y();
823cdf0e10cSrcweir
824cdf0e10cSrcweir //Die Verschiebungen nach rechts und/oder unten koennen jetzt falsch
825cdf0e10cSrcweir //sein (z.B. Zoom aendern, Viewgroesse aendern.
826cdf0e10cSrcweir const long lBorder = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER*2;
827cdf0e10cSrcweir if ( aRect.Left() )
828cdf0e10cSrcweir {
829cdf0e10cSrcweir const long lWidth = GetWrtShell().GetDocSize().Width() + lBorder;
830cdf0e10cSrcweir if ( aRect.Right() > lWidth )
831cdf0e10cSrcweir {
832cdf0e10cSrcweir long lDelta = aRect.Right() - lWidth;
833cdf0e10cSrcweir aRect.Left() -= lDelta;
834cdf0e10cSrcweir aRect.Right() -= lDelta;
835cdf0e10cSrcweir }
836cdf0e10cSrcweir }
837cdf0e10cSrcweir if ( aRect.Top() )
838cdf0e10cSrcweir {
839cdf0e10cSrcweir const long lHeight = GetWrtShell().GetDocSize().Height() + lBorder;
840cdf0e10cSrcweir if ( aRect.Bottom() > lHeight )
841cdf0e10cSrcweir {
842cdf0e10cSrcweir long lDelta = aRect.Bottom() - lHeight;
843cdf0e10cSrcweir aRect.Top() -= lDelta;
844cdf0e10cSrcweir aRect.Bottom() -= lDelta;
845cdf0e10cSrcweir }
846cdf0e10cSrcweir }
847cdf0e10cSrcweir SetVisArea( aRect );
848cdf0e10cSrcweir GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
849cdf0e10cSrcweir GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); // for snapping points
850cdf0e10cSrcweir }
851cdf0e10cSrcweir
852cdf0e10cSrcweir /*--------------------------------------------------------------------
853cdf0e10cSrcweir Beschreibung: Bedienelemente neu anordnen
854cdf0e10cSrcweir --------------------------------------------------------------------*/
855cdf0e10cSrcweir
856cdf0e10cSrcweir
CalcAndSetBorderPixel(SvBorder & rToFill,sal_Bool)857cdf0e10cSrcweir void SwView::CalcAndSetBorderPixel( SvBorder &rToFill, sal_Bool /*bInner*/ )
858cdf0e10cSrcweir {
859cdf0e10cSrcweir sal_Bool bRightVRuler = pWrtShell->GetViewOptions()->IsVRulerRight();
860cdf0e10cSrcweir if ( pVRuler->IsVisible() )
861cdf0e10cSrcweir {
862cdf0e10cSrcweir long nWidth = pVRuler->GetSizePixel().Width();
863cdf0e10cSrcweir if(bRightVRuler)
864cdf0e10cSrcweir rToFill.Right() = nWidth;
865cdf0e10cSrcweir else
866cdf0e10cSrcweir rToFill.Left() = nWidth;
867cdf0e10cSrcweir }
868cdf0e10cSrcweir
869cdf0e10cSrcweir DBG_ASSERT(pHRuler, "warum ist das Lineal nicht da?");
870cdf0e10cSrcweir if ( pHRuler->IsVisible() )
871cdf0e10cSrcweir rToFill.Top() = pHRuler->GetSizePixel().Height();
872cdf0e10cSrcweir
873cdf0e10cSrcweir const StyleSettings &rSet = GetEditWin().GetSettings().GetStyleSettings();
874cdf0e10cSrcweir const long nTmp = rSet.GetScrollBarSize();
875cdf0e10cSrcweir if( pVScrollbar->IsVisible(sal_False) )
876cdf0e10cSrcweir {
877cdf0e10cSrcweir if(bRightVRuler)
878cdf0e10cSrcweir rToFill.Left() = nTmp;
879cdf0e10cSrcweir else
880cdf0e10cSrcweir rToFill.Right() = nTmp;
881cdf0e10cSrcweir }
882cdf0e10cSrcweir //#i32913# in browse mode the visibility of the horizontal scrollbar
883cdf0e10cSrcweir // depends on the content (fixed width tables may require a scrollbar)
884cdf0e10cSrcweir if ( pHScrollbar->IsVisible(pWrtShell->GetViewOptions()->getBrowseMode()) )
885cdf0e10cSrcweir rToFill.Bottom() = nTmp;
886cdf0e10cSrcweir
887cdf0e10cSrcweir SetBorderPixel( rToFill );
888cdf0e10cSrcweir }
889cdf0e10cSrcweir
890cdf0e10cSrcweir
ViewResizePixel(const Window & rRef,const Point & rOfst,const Size & rSize,const Size & rEditSz,const sal_Bool,SwScrollbar & rVScrollbar,SwScrollbar & rHScrollbar,ImageButton * pPageUpBtn,ImageButton * pPageDownBtn,ImageButton * pNaviBtn,Window & rScrollBarBox,SvxRuler * pVLineal,SvxRuler * pHLineal,sal_Bool bWebView,sal_Bool bVRulerRight)891cdf0e10cSrcweir void ViewResizePixel( const Window &rRef,
892cdf0e10cSrcweir const Point &rOfst,
893cdf0e10cSrcweir const Size &rSize,
894cdf0e10cSrcweir const Size &rEditSz,
895cdf0e10cSrcweir const sal_Bool /*bInner*/,
896cdf0e10cSrcweir SwScrollbar& rVScrollbar,
897cdf0e10cSrcweir SwScrollbar& rHScrollbar,
898cdf0e10cSrcweir ImageButton* pPageUpBtn,
899cdf0e10cSrcweir ImageButton* pPageDownBtn,
900cdf0e10cSrcweir ImageButton* pNaviBtn,
901cdf0e10cSrcweir Window& rScrollBarBox,
902cdf0e10cSrcweir SvxRuler* pVLineal,
903cdf0e10cSrcweir SvxRuler* pHLineal,
904cdf0e10cSrcweir sal_Bool bWebView,
905cdf0e10cSrcweir sal_Bool bVRulerRight )
906cdf0e10cSrcweir {
907cdf0e10cSrcweir // ViewResizePixel wird auch von der PreView benutzt!!!
908cdf0e10cSrcweir
909cdf0e10cSrcweir const sal_Bool bHLineal = pHLineal && pHLineal->IsVisible();
910cdf0e10cSrcweir const long nHLinSzHeight = bHLineal ?
911cdf0e10cSrcweir pHLineal->GetSizePixel().Height() : 0;
912cdf0e10cSrcweir const sal_Bool bVLineal = pVLineal && pVLineal->IsVisible();
913cdf0e10cSrcweir const long nVLinSzWidth = bVLineal ?
914cdf0e10cSrcweir pVLineal->GetSizePixel().Width() : 0;
915cdf0e10cSrcweir long nHBSzHeight2= rHScrollbar.IsVisible( sal_False ) || !rHScrollbar.IsAuto() ?
916cdf0e10cSrcweir rRef.GetSettings().GetStyleSettings().GetScrollBarSize() : 0;
917cdf0e10cSrcweir long nHBSzHeight =
918cdf0e10cSrcweir rHScrollbar.IsVisible(sal_True) || (rHScrollbar.IsVisible( sal_False ) && !rHScrollbar.IsAuto()) ?
919cdf0e10cSrcweir nHBSzHeight2:0;
920cdf0e10cSrcweir long nVBSzWidth = rVScrollbar.IsVisible(sal_True) || (rVScrollbar.IsVisible( sal_False ) && !rVScrollbar.IsAuto()) ?
921cdf0e10cSrcweir rRef.GetSettings().GetStyleSettings().GetScrollBarSize() : 0;
922cdf0e10cSrcweir
923cdf0e10cSrcweir if(pVLineal)
924cdf0e10cSrcweir {
925cdf0e10cSrcweir WinBits nStyle = pVLineal->GetStyle()&~WB_RIGHT_ALIGNED;
926cdf0e10cSrcweir Point aPos( rOfst.X(), rOfst.Y()+nHLinSzHeight );
927cdf0e10cSrcweir if(bVRulerRight)
928cdf0e10cSrcweir {
929cdf0e10cSrcweir aPos.X() += rSize.Width() - nVLinSzWidth;
930cdf0e10cSrcweir nStyle |= WB_RIGHT_ALIGNED;
931cdf0e10cSrcweir }
932cdf0e10cSrcweir Size aSize( nVLinSzWidth, rEditSz.Height() );
933cdf0e10cSrcweir if(!aSize.Width())
934cdf0e10cSrcweir aSize.Width() = pVLineal->GetSizePixel().Width();
935cdf0e10cSrcweir pVLineal->SetStyle(nStyle);
936cdf0e10cSrcweir pVLineal->SetPosSizePixel( aPos, aSize );
937cdf0e10cSrcweir if(!pVLineal->IsVisible())
938cdf0e10cSrcweir pVLineal->Resize();
939cdf0e10cSrcweir }
940cdf0e10cSrcweir // Lineal braucht ein Resize, sonst funktioniert es nicht im unischtbaren Zustand
941cdf0e10cSrcweir if(pHLineal)
942cdf0e10cSrcweir {
943cdf0e10cSrcweir Size aSize( rSize.Width(), nHLinSzHeight );
944cdf0e10cSrcweir if ( nVBSzWidth && !bVRulerRight)
945cdf0e10cSrcweir aSize.Width() -= nVBSzWidth;
946cdf0e10cSrcweir if(!aSize.Height())
947cdf0e10cSrcweir aSize.Height() = pHLineal->GetSizePixel().Height();
948cdf0e10cSrcweir pHLineal->SetPosSizePixel( rOfst, aSize );
949cdf0e10cSrcweir // #46802 VCL ruft an unsichtbaren Fenstern kein Resize
950cdf0e10cSrcweir // fuer das Lineal ist das aber keine gute Idee
951cdf0e10cSrcweir if(!pHLineal->IsVisible())
952cdf0e10cSrcweir pHLineal->Resize();
953cdf0e10cSrcweir }
954cdf0e10cSrcweir
955cdf0e10cSrcweir // Scrollbars und SizeBox anordnen
956cdf0e10cSrcweir Point aScrollFillPos;
957cdf0e10cSrcweir {
958cdf0e10cSrcweir Point aPos( rOfst.X(),
959cdf0e10cSrcweir rOfst.Y()+rSize.Height()-nHBSzHeight );
960cdf0e10cSrcweir if(bVRulerRight)
961cdf0e10cSrcweir {
962cdf0e10cSrcweir aPos.X() += nVBSzWidth;
963cdf0e10cSrcweir }
964cdf0e10cSrcweir
965cdf0e10cSrcweir Size aSize( rSize.Width(), nHBSzHeight2 );
966cdf0e10cSrcweir if ( nVBSzWidth )
967cdf0e10cSrcweir aSize.Width() -= nVBSzWidth;
968cdf0e10cSrcweir rHScrollbar.SetPosSizePixel( aPos, aSize );
969cdf0e10cSrcweir aScrollFillPos.Y() = aPos.Y();
970cdf0e10cSrcweir }
971cdf0e10cSrcweir {
972cdf0e10cSrcweir Point aPos( rOfst.X()+rSize.Width()-nVBSzWidth,
973cdf0e10cSrcweir rOfst.Y() );
974cdf0e10cSrcweir Size aSize( nVBSzWidth, rSize.Height() );
975cdf0e10cSrcweir if(bVRulerRight)
976cdf0e10cSrcweir {
977cdf0e10cSrcweir aPos.X() = rOfst.X();
978cdf0e10cSrcweir if(bHLineal)
979cdf0e10cSrcweir {
980cdf0e10cSrcweir aPos.Y() += nHLinSzHeight;
981cdf0e10cSrcweir aSize.Height() -= nHLinSzHeight;
982cdf0e10cSrcweir }
983cdf0e10cSrcweir }
984cdf0e10cSrcweir
985cdf0e10cSrcweir Size aImgSz( nVBSzWidth, nVBSzWidth );
986cdf0e10cSrcweir
987cdf0e10cSrcweir //#55949# wenn der Platz fuer Scrollbar und Page-Buttons zu klein wird, dann
988cdf0e10cSrcweir // werden die Buttons versteckt
989cdf0e10cSrcweir sal_uInt16 nCnt = pNaviBtn ? 3 : 2;
990cdf0e10cSrcweir long nSubSize = (aImgSz.Width() * nCnt );
991cdf0e10cSrcweir //
992cdf0e10cSrcweir sal_Bool bHidePageButtons = aSize.Height() < ((bWebView ? 3 : 2) * nSubSize);
993cdf0e10cSrcweir if(!bHidePageButtons)
994cdf0e10cSrcweir aSize.Height() -= nSubSize;
995cdf0e10cSrcweir else
996cdf0e10cSrcweir aImgSz.Width() = 0; // kein Hide, weil das im Update Scrollbar missverstanden wird
997cdf0e10cSrcweir
998cdf0e10cSrcweir if ( nHBSzHeight )
999cdf0e10cSrcweir aSize.Height() -= nHBSzHeight;
1000cdf0e10cSrcweir rVScrollbar.SetPosSizePixel( aPos, aSize );
1001cdf0e10cSrcweir
1002cdf0e10cSrcweir aPos.Y() += aSize.Height();
1003cdf0e10cSrcweir pPageUpBtn->SetPosSizePixel( aPos, aImgSz );
1004cdf0e10cSrcweir if(pNaviBtn)
1005cdf0e10cSrcweir {
1006cdf0e10cSrcweir aPos.Y() += aImgSz.Height();
1007cdf0e10cSrcweir pNaviBtn->SetPosSizePixel(aPos, aImgSz);
1008cdf0e10cSrcweir }
1009cdf0e10cSrcweir
1010cdf0e10cSrcweir aPos.Y() += aImgSz.Height();
1011cdf0e10cSrcweir pPageDownBtn->SetPosSizePixel( aPos, aImgSz );
1012cdf0e10cSrcweir
1013cdf0e10cSrcweir
1014cdf0e10cSrcweir if( rHScrollbar.IsVisible( sal_False ) )
1015cdf0e10cSrcweir {
1016cdf0e10cSrcweir aScrollFillPos.X() = aPos.X();
1017cdf0e10cSrcweir
1018cdf0e10cSrcweir rScrollBarBox.SetPosSizePixel( aScrollFillPos,
1019cdf0e10cSrcweir Size( nHBSzHeight, nVBSzWidth) );
1020cdf0e10cSrcweir }
1021cdf0e10cSrcweir }
1022cdf0e10cSrcweir }
1023cdf0e10cSrcweir
1024cdf0e10cSrcweir
ShowAtResize()1025cdf0e10cSrcweir void SwView::ShowAtResize()
1026cdf0e10cSrcweir {
1027cdf0e10cSrcweir bShowAtResize = sal_False;
1028cdf0e10cSrcweir if ( pWrtShell->GetViewOptions()->IsViewHRuler() )
1029cdf0e10cSrcweir pHRuler->Show();
1030cdf0e10cSrcweir }
1031cdf0e10cSrcweir
1032cdf0e10cSrcweir
InnerResizePixel(const Point & rOfst,const Size & rSize)1033cdf0e10cSrcweir void SwView::InnerResizePixel( const Point &rOfst, const Size &rSize )
1034cdf0e10cSrcweir {
1035cdf0e10cSrcweir Size aObjSize = GetObjectShell()->GetVisArea().GetSize();
1036cdf0e10cSrcweir if ( aObjSize.Width() > 0 && aObjSize.Height() > 0 )
1037cdf0e10cSrcweir {
1038cdf0e10cSrcweir SvBorder aBorder( GetBorderPixel() );
1039cdf0e10cSrcweir Size aSize( rSize );
1040cdf0e10cSrcweir aSize.Width() -= (aBorder.Left() + aBorder.Right());
1041cdf0e10cSrcweir aSize.Height() -= (aBorder.Top() + aBorder.Bottom());
1042cdf0e10cSrcweir Size aObjSizePixel = GetWindow()->LogicToPixel( aObjSize, MAP_TWIP );
1043cdf0e10cSrcweir SfxViewShell::SetZoomFactor( Fraction( aSize.Width(), aObjSizePixel.Width() ),
1044cdf0e10cSrcweir Fraction( aSize.Height(), aObjSizePixel.Height() ) );
1045cdf0e10cSrcweir }
1046cdf0e10cSrcweir
1047cdf0e10cSrcweir bInInnerResizePixel = sal_True;
1048cdf0e10cSrcweir const sal_Bool bHScrollVisible = pHScrollbar->IsVisible(sal_True);
1049cdf0e10cSrcweir const sal_Bool bVScrollVisible = pVScrollbar->IsVisible(sal_True);
1050cdf0e10cSrcweir sal_Bool bRepeat = sal_False;
1051cdf0e10cSrcweir do
1052cdf0e10cSrcweir {
1053cdf0e10cSrcweir Size aSz( rSize );
1054cdf0e10cSrcweir SvBorder aBorder;
1055cdf0e10cSrcweir CalcAndSetBorderPixel( aBorder, sal_True );
1056cdf0e10cSrcweir if ( GetViewFrame()->GetFrame().IsInPlace() )
1057cdf0e10cSrcweir {
1058cdf0e10cSrcweir Size aViewSize( aSz );
1059cdf0e10cSrcweir Point aViewPos( rOfst );
1060cdf0e10cSrcweir aViewSize.Height() -= (aBorder.Top() + aBorder.Bottom());
1061cdf0e10cSrcweir aViewSize.Width() -= (aBorder.Left() + aBorder.Right());
1062cdf0e10cSrcweir aViewPos.X() += aBorder.Left();
1063cdf0e10cSrcweir aViewPos.Y() += aBorder.Top();
1064cdf0e10cSrcweir GetEditWin().SetPosSizePixel( aViewPos, aViewSize );
1065cdf0e10cSrcweir }
1066cdf0e10cSrcweir else
1067cdf0e10cSrcweir {
1068cdf0e10cSrcweir aSz.Height() += aBorder.Top() + aBorder.Bottom();
1069cdf0e10cSrcweir aSz.Width() += aBorder.Left() + aBorder.Right();
1070cdf0e10cSrcweir }
1071cdf0e10cSrcweir
1072cdf0e10cSrcweir Size aEditSz( GetEditWin().GetOutputSizePixel() );
1073cdf0e10cSrcweir ViewResizePixel( GetEditWin(), rOfst, aSz, aEditSz, sal_True, *pVScrollbar,
1074cdf0e10cSrcweir *pHScrollbar, pPageUpBtn, pPageDownBtn,
1075cdf0e10cSrcweir pNaviBtn,
1076cdf0e10cSrcweir *pScrollFill, pVRuler, pHRuler,
1077cdf0e10cSrcweir 0 != PTR_CAST(SwWebView, this),
1078cdf0e10cSrcweir pWrtShell->GetViewOptions()->IsVRulerRight());
1079cdf0e10cSrcweir if ( bShowAtResize )
1080cdf0e10cSrcweir ShowAtResize();
1081cdf0e10cSrcweir
1082cdf0e10cSrcweir if( pHRuler->IsVisible() || pVRuler->IsVisible() )
1083cdf0e10cSrcweir {
1084cdf0e10cSrcweir const Fraction& rFrac = GetEditWin().GetMapMode().GetScaleX();
1085cdf0e10cSrcweir sal_uInt16 nZoom = 100;
1086cdf0e10cSrcweir if (0 != rFrac.GetDenominator())
1087cdf0e10cSrcweir nZoom = sal_uInt16(rFrac.GetNumerator() * 100L / rFrac.GetDenominator());
1088cdf0e10cSrcweir
1089cdf0e10cSrcweir const Fraction aFrac( nZoom, 100 );
1090cdf0e10cSrcweir pVRuler->SetZoom( aFrac );
1091cdf0e10cSrcweir pHRuler->SetZoom( aFrac );
1092cdf0e10cSrcweir InvalidateRulerPos(); //Inhalt invalidieren.
1093cdf0e10cSrcweir }
1094cdf0e10cSrcweir //CursorStack zuruecksetzen, da die Cursorpositionen fuer PageUp/-Down
1095cdf0e10cSrcweir //nicht mehr zum aktuell sichtbaren Bereich passen
1096cdf0e10cSrcweir pWrtShell->ResetCursorStack();
1097cdf0e10cSrcweir
1098cdf0e10cSrcweir //EditWin niemals einstellen!
1099cdf0e10cSrcweir
1100cdf0e10cSrcweir //VisArea einstellen, aber dort nicht das SetVisArea der DocShell rufen!
1101cdf0e10cSrcweir bProtectDocShellVisArea = sal_True;
1102cdf0e10cSrcweir CalcVisArea( aEditSz );
1103cdf0e10cSrcweir //visibility changes of the automatic horizontal scrollbar
1104cdf0e10cSrcweir //require to repeat the ViewResizePixel() call - but only once!
1105cdf0e10cSrcweir if(bRepeat)
1106cdf0e10cSrcweir bRepeat = sal_False;
1107cdf0e10cSrcweir else if(bHScrollVisible != pHScrollbar->IsVisible(sal_True) ||
1108cdf0e10cSrcweir bVScrollVisible != pVScrollbar->IsVisible(sal_True))
1109cdf0e10cSrcweir bRepeat = sal_True;
1110cdf0e10cSrcweir }while( bRepeat );
1111cdf0e10cSrcweir bProtectDocShellVisArea = sal_False;
1112cdf0e10cSrcweir bInInnerResizePixel = sal_False;
1113cdf0e10cSrcweir }
1114cdf0e10cSrcweir
1115cdf0e10cSrcweir
OuterResizePixel(const Point & rOfst,const Size & rSize)1116cdf0e10cSrcweir void SwView::OuterResizePixel( const Point &rOfst, const Size &rSize )
1117cdf0e10cSrcweir {
1118cdf0e10cSrcweir // FME 22.08.2003 #i16909# - return, if no size (caused by minimize window).
1119cdf0e10cSrcweir if ( bInOuterResizePixel || ( !rSize.Width() && !rSize.Height() ) )
1120cdf0e10cSrcweir return;
1121cdf0e10cSrcweir bInOuterResizePixel = sal_True;
1122cdf0e10cSrcweir
1123cdf0e10cSrcweir // feststellen, ob Scrollbars angezeigt werden duerfen
1124cdf0e10cSrcweir sal_Bool bBrowse = pWrtShell->GetViewOptions()->getBrowseMode();
1125cdf0e10cSrcweir sal_Bool bShowH = sal_False,
1126cdf0e10cSrcweir bShowV = sal_False,
1127cdf0e10cSrcweir bAuto = sal_False,
1128cdf0e10cSrcweir bHAuto = bBrowse;
1129cdf0e10cSrcweir switch( GetScrollingMode() )
1130cdf0e10cSrcweir {
1131cdf0e10cSrcweir case SCROLLING_DEFAULT:
1132cdf0e10cSrcweir {
1133cdf0e10cSrcweir const SwViewOption *pVOpt = pWrtShell->GetViewOptions();
1134cdf0e10cSrcweir if ( !pVOpt->IsReadonly() || pVOpt->IsStarOneSetting() )
1135cdf0e10cSrcweir {
1136cdf0e10cSrcweir bShowH = pVOpt->IsViewHScrollBar();
1137cdf0e10cSrcweir bShowV = pVOpt->IsViewVScrollBar();
1138cdf0e10cSrcweir break;
1139cdf0e10cSrcweir }
1140cdf0e10cSrcweir }
1141cdf0e10cSrcweir /* kein break hier */
1142cdf0e10cSrcweir case SCROLLING_AUTO:
1143cdf0e10cSrcweir bAuto = bHAuto = sal_True;
1144cdf0e10cSrcweir bShowH = bShowV = sal_True;
1145cdf0e10cSrcweir break;
1146cdf0e10cSrcweir case SCROLLING_YES:
1147cdf0e10cSrcweir bShowH = bShowV = sal_True;
1148cdf0e10cSrcweir break;
1149cdf0e10cSrcweir case SCROLLING_NO:
1150cdf0e10cSrcweir bShowH = bShowV = bHAuto = sal_False;
1151cdf0e10cSrcweir break;
1152cdf0e10cSrcweir }
1153cdf0e10cSrcweir SwDocShell* pDocSh = GetDocShell();
1154cdf0e10cSrcweir sal_Bool bIsPreview = pDocSh->IsPreview();
1155cdf0e10cSrcweir if( bIsPreview )
1156cdf0e10cSrcweir {
1157cdf0e10cSrcweir bShowH = bShowV = bHAuto = bAuto = sal_False;
1158cdf0e10cSrcweir }
1159cdf0e10cSrcweir if(pHScrollbar->IsVisible(sal_False) != bShowH)
1160cdf0e10cSrcweir ShowHScrollbar(bShowH);
1161cdf0e10cSrcweir pHScrollbar->SetAuto( bHAuto );
1162cdf0e10cSrcweir if(pVScrollbar->IsVisible(sal_False) != bShowV)
1163cdf0e10cSrcweir ShowVScrollbar(bShowV);
1164cdf0e10cSrcweir pVScrollbar->SetAuto(bAuto);
1165cdf0e10cSrcweir
1166cdf0e10cSrcweir SET_CURR_SHELL( pWrtShell );
1167cdf0e10cSrcweir sal_Bool bRepeat = sal_False;
1168cdf0e10cSrcweir long nCnt = 0;
1169cdf0e10cSrcweir
1170cdf0e10cSrcweir sal_Bool bUnLockView = !pWrtShell->IsViewLocked();
1171cdf0e10cSrcweir pWrtShell->LockView( sal_True );
1172cdf0e10cSrcweir pWrtShell->LockPaint();
1173cdf0e10cSrcweir
1174cdf0e10cSrcweir do {
1175cdf0e10cSrcweir ++nCnt;
1176cdf0e10cSrcweir const sal_Bool bScroll1 = pVScrollbar->IsVisible(sal_True);
1177cdf0e10cSrcweir const sal_Bool bScroll2 = pHScrollbar->IsVisible(sal_True);
1178cdf0e10cSrcweir SvBorder aBorder;
1179cdf0e10cSrcweir CalcAndSetBorderPixel( aBorder, sal_False );
1180cdf0e10cSrcweir const Size aEditSz( GetEditWin().GetOutputSizePixel() );
1181cdf0e10cSrcweir ViewResizePixel( GetEditWin(), rOfst, rSize, aEditSz, sal_False, *pVScrollbar,
1182cdf0e10cSrcweir *pHScrollbar, pPageUpBtn, pPageDownBtn,
1183cdf0e10cSrcweir pNaviBtn,
1184cdf0e10cSrcweir *pScrollFill, pVRuler, pHRuler,
1185cdf0e10cSrcweir 0 != PTR_CAST(SwWebView, this),
1186cdf0e10cSrcweir pWrtShell->GetViewOptions()->IsVRulerRight() );
1187cdf0e10cSrcweir if ( bShowAtResize )
1188cdf0e10cSrcweir ShowAtResize();
1189cdf0e10cSrcweir
1190cdf0e10cSrcweir if( pHRuler->IsVisible() || pVRuler->IsVisible() )
1191cdf0e10cSrcweir InvalidateRulerPos(); //Inhalt invalidieren.
1192cdf0e10cSrcweir
1193cdf0e10cSrcweir //CursorStack zuruecksetzen, da die Cursorpositionen fuer PageUp/-Down
1194cdf0e10cSrcweir //nicht mehr zum aktuell sichtbaren Bereich passen
1195cdf0e10cSrcweir pWrtShell->ResetCursorStack();
1196cdf0e10cSrcweir
1197cdf0e10cSrcweir ASSERT( !GetEditWin().IsVisible() ||
1198cdf0e10cSrcweir (( aEditSz.Width() > 0 && aEditSz.Height() > 0 )
1199cdf0e10cSrcweir || !aVisArea.IsEmpty()), "Small world, isn't it?" );
1200cdf0e10cSrcweir
1201cdf0e10cSrcweir //EditWin niemals einstellen!
1202cdf0e10cSrcweir
1203cdf0e10cSrcweir //Die VisArea muss aber natuerlich eingestellt werden.
1204cdf0e10cSrcweir //jetzt ist auch der richtige Zeitpunkt den Zoom neu zu berechnen wenn
1205cdf0e10cSrcweir //es kein einfacher Faktor ist.
1206cdf0e10cSrcweir pWrtShell->StartAction();
1207cdf0e10cSrcweir CalcVisArea( aEditSz );
1208cdf0e10cSrcweir
1209cdf0e10cSrcweir //Damit auch beim outplace editing die Seitenbreite sofort
1210cdf0e10cSrcweir //angepasst wird.
1211cdf0e10cSrcweir //TODO/LATER: is that still necessary?!
1212cdf0e10cSrcweir /*
1213cdf0e10cSrcweir if ( pDocSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
1214cdf0e10cSrcweir pDocSh->SetVisArea(
1215cdf0e10cSrcweir pDocSh->SfxInPlaceObject::GetVisArea() );*/
1216cdf0e10cSrcweir if ( pWrtShell->GetViewOptions()->GetZoomType() != SVX_ZOOM_PERCENT &&
1217cdf0e10cSrcweir !pWrtShell->GetViewOptions()->getBrowseMode() )
1218cdf0e10cSrcweir _SetZoom( aEditSz, (SvxZoomType)pWrtShell->GetViewOptions()->GetZoomType(), 100, sal_True );
1219cdf0e10cSrcweir pWrtShell->EndAction();
1220cdf0e10cSrcweir
1221cdf0e10cSrcweir bRepeat = bScroll1 != pVScrollbar->IsVisible(sal_True);
1222cdf0e10cSrcweir if ( !bRepeat )
1223cdf0e10cSrcweir bRepeat = bScroll2 != pHScrollbar->IsVisible(sal_True);
1224cdf0e10cSrcweir
1225cdf0e10cSrcweir //Nicht endlosschleifen. Moeglichst dann stoppen wenn die
1226cdf0e10cSrcweir //(Auto-)Scrollbars sichtbar sind.
1227cdf0e10cSrcweir if ( bRepeat &&
1228cdf0e10cSrcweir ( nCnt > 10 || ( nCnt > 3 && bHAuto && bAuto ) )
1229cdf0e10cSrcweir )
1230cdf0e10cSrcweir {
1231cdf0e10cSrcweir bRepeat = sal_False;
1232cdf0e10cSrcweir }
1233cdf0e10cSrcweir
1234cdf0e10cSrcweir }while ( bRepeat );
1235cdf0e10cSrcweir
1236cdf0e10cSrcweir if( pVScrollbar->IsVisible(sal_False) || pVScrollbar->IsAuto())
1237cdf0e10cSrcweir {
1238cdf0e10cSrcweir sal_Bool bShowButtons = pVScrollbar->IsVisible(sal_True);
1239cdf0e10cSrcweir if(pPageUpBtn && pPageUpBtn->IsVisible() != bShowButtons)
1240cdf0e10cSrcweir {
1241cdf0e10cSrcweir pPageUpBtn->Show(bShowButtons);
1242cdf0e10cSrcweir if(pPageDownBtn)
1243cdf0e10cSrcweir pPageDownBtn->Show(bShowButtons);
1244cdf0e10cSrcweir if(pNaviBtn)
1245cdf0e10cSrcweir pNaviBtn->Show(bShowButtons);
1246cdf0e10cSrcweir }
1247cdf0e10cSrcweir }
1248cdf0e10cSrcweir
1249cdf0e10cSrcweir pWrtShell->UnlockPaint();
1250cdf0e10cSrcweir if( bUnLockView )
1251cdf0e10cSrcweir pWrtShell->LockView( sal_False );
1252cdf0e10cSrcweir
1253cdf0e10cSrcweir bInOuterResizePixel = sal_False;
1254cdf0e10cSrcweir
1255cdf0e10cSrcweir if ( mpPostItMgr )
1256cdf0e10cSrcweir {
1257cdf0e10cSrcweir mpPostItMgr->CalcRects();
1258cdf0e10cSrcweir mpPostItMgr->LayoutPostIts();
1259cdf0e10cSrcweir }
1260cdf0e10cSrcweir }
1261cdf0e10cSrcweir
1262cdf0e10cSrcweir
SetZoomFactor(const Fraction & rX,const Fraction & rY)1263cdf0e10cSrcweir void SwView::SetZoomFactor( const Fraction &rX, const Fraction &rY )
1264cdf0e10cSrcweir {
1265cdf0e10cSrcweir const Fraction &rFrac = rX < rY ? rX : rY;
1266cdf0e10cSrcweir SetZoom( SVX_ZOOM_PERCENT, (short) long(rFrac * Fraction( 100, 1 )) );
1267cdf0e10cSrcweir
1268cdf0e10cSrcweir //Um Rundungsfehler zu minimieren lassen wir von der Basisklasse ggf.
1269cdf0e10cSrcweir //auch die krummen Werte einstellen
1270cdf0e10cSrcweir SfxViewShell::SetZoomFactor( rX, rY );
1271cdf0e10cSrcweir }
1272cdf0e10cSrcweir
1273cdf0e10cSrcweir
GetOptimalSizePixel() const1274cdf0e10cSrcweir Size SwView::GetOptimalSizePixel() const
1275cdf0e10cSrcweir {
1276cdf0e10cSrcweir Size aPgSize;
1277cdf0e10cSrcweir if ( pWrtShell->GetViewOptions()->getBrowseMode() )
1278cdf0e10cSrcweir aPgSize = SvxPaperInfo::GetPaperSize(PAPER_A4);
1279cdf0e10cSrcweir else
1280cdf0e10cSrcweir {
1281cdf0e10cSrcweir aPgSize = GetWrtShell().GetAnyCurRect(RECT_PAGE).SSize();
1282cdf0e10cSrcweir aPgSize.Width() += DOCUMENTBORDER * 2;
1283cdf0e10cSrcweir
1284cdf0e10cSrcweir const SwPageDesc &rDesc = pWrtShell->GetPageDesc( pWrtShell->GetCurPageDesc() );
1285cdf0e10cSrcweir if( nsUseOnPage::PD_MIRROR == rDesc.GetUseOn() )
1286cdf0e10cSrcweir {
1287cdf0e10cSrcweir const SvxLRSpaceItem &rLRSpace = rDesc.GetMaster().GetLRSpace();
1288cdf0e10cSrcweir const SvxLRSpaceItem &rLeftLRSpace = rDesc.GetLeft().GetLRSpace();
1289cdf0e10cSrcweir aPgSize.Width() += Abs( long(rLeftLRSpace.GetLeft()) - long(rLRSpace.GetLeft()) );
1290cdf0e10cSrcweir }
1291cdf0e10cSrcweir }
1292cdf0e10cSrcweir return GetEditWin().LogicToPixel( aPgSize );
1293cdf0e10cSrcweir }
1294cdf0e10cSrcweir
1295cdf0e10cSrcweir
UpdateScrollbars()1296cdf0e10cSrcweir sal_Bool SwView::UpdateScrollbars()
1297cdf0e10cSrcweir {
1298cdf0e10cSrcweir sal_Bool bRet = sal_False;
1299cdf0e10cSrcweir if ( !aVisArea.IsEmpty() )
1300cdf0e10cSrcweir {
1301cdf0e10cSrcweir const sal_Bool bBorder = IsDocumentBorder();
1302cdf0e10cSrcweir Rectangle aTmpRect( aVisArea );
1303cdf0e10cSrcweir if ( bBorder )
1304cdf0e10cSrcweir {
1305cdf0e10cSrcweir Point aPt( DOCUMENTBORDER, DOCUMENTBORDER );
1306cdf0e10cSrcweir aPt = AlignToPixel( aPt );
1307cdf0e10cSrcweir aTmpRect.Move( -aPt.X(), -aPt.Y() );
1308cdf0e10cSrcweir }
1309cdf0e10cSrcweir
1310cdf0e10cSrcweir Size aTmpSz( aDocSz );
1311cdf0e10cSrcweir const long lOfst = bBorder ? 0 : DOCUMENTBORDER * 2L;
1312cdf0e10cSrcweir aTmpSz.Width() += lOfst; aTmpSz.Height() += lOfst;
1313cdf0e10cSrcweir
1314cdf0e10cSrcweir {
1315cdf0e10cSrcweir const sal_Bool bVScrollVisible = pVScrollbar->IsVisible(sal_True);
1316cdf0e10cSrcweir pVScrollbar->DocSzChgd( aTmpSz );
1317cdf0e10cSrcweir pVScrollbar->ViewPortChgd( aTmpRect );
1318cdf0e10cSrcweir
1319cdf0e10cSrcweir sal_Bool bShowButtons = pVScrollbar->IsVisible(sal_True);
1320cdf0e10cSrcweir if(pPageUpBtn && pPageUpBtn->IsVisible() != bShowButtons)
1321cdf0e10cSrcweir {
1322cdf0e10cSrcweir pPageUpBtn->Show(bShowButtons);
1323cdf0e10cSrcweir if(pPageDownBtn)
1324cdf0e10cSrcweir pPageDownBtn->Show(bShowButtons);
1325cdf0e10cSrcweir if(pNaviBtn)
1326cdf0e10cSrcweir pNaviBtn->Show(bShowButtons);
1327cdf0e10cSrcweir }
1328cdf0e10cSrcweir
1329cdf0e10cSrcweir if ( bVScrollVisible != pVScrollbar->IsVisible(sal_True) )
1330cdf0e10cSrcweir bRet = sal_True;
1331cdf0e10cSrcweir }
1332cdf0e10cSrcweir {
1333cdf0e10cSrcweir const sal_Bool bHScrollVisible = pHScrollbar->IsVisible(sal_True);
1334cdf0e10cSrcweir pHScrollbar->DocSzChgd( aTmpSz );
1335cdf0e10cSrcweir pHScrollbar->ViewPortChgd( aTmpRect );
1336cdf0e10cSrcweir if ( bHScrollVisible != pHScrollbar->IsVisible(sal_True) )
1337cdf0e10cSrcweir bRet = sal_True;
1338cdf0e10cSrcweir pScrollFill->Show(pHScrollbar->IsVisible(sal_True) && pVScrollbar->IsVisible(sal_True) );
1339cdf0e10cSrcweir }
1340cdf0e10cSrcweir }
1341cdf0e10cSrcweir return bRet;
1342cdf0e10cSrcweir }
1343cdf0e10cSrcweir
1344cdf0e10cSrcweir
Move()1345cdf0e10cSrcweir void SwView::Move()
1346cdf0e10cSrcweir {
1347cdf0e10cSrcweir if ( GetWrtShell().IsInSelect() )
1348cdf0e10cSrcweir GetWrtShell().EndSelect(); //#32427#
1349cdf0e10cSrcweir SfxViewShell::Move();
1350cdf0e10cSrcweir }
1351cdf0e10cSrcweir
HandleWheelCommands(const CommandEvent & rCEvt)1352cdf0e10cSrcweir sal_Bool SwView::HandleWheelCommands( const CommandEvent& rCEvt )
1353cdf0e10cSrcweir {
1354cdf0e10cSrcweir sal_Bool bOk = sal_False;
1355cdf0e10cSrcweir const CommandWheelData* pWData = rCEvt.GetWheelData();
1356cdf0e10cSrcweir if( pWData && COMMAND_WHEEL_ZOOM == pWData->GetMode() )
1357cdf0e10cSrcweir {
1358cdf0e10cSrcweir sal_uInt16 nFact = pWrtShell->GetViewOptions()->GetZoom();
1359cdf0e10cSrcweir if( 0L > pWData->GetDelta() )
1360cdf0e10cSrcweir nFact = static_cast< sal_uInt16 >(Max( 20, nFact - 10 ));
1361cdf0e10cSrcweir else
1362cdf0e10cSrcweir nFact = static_cast< sal_uInt16 >(Min( 600, nFact + 10 ));
1363cdf0e10cSrcweir
1364cdf0e10cSrcweir SetZoom( SVX_ZOOM_PERCENT, nFact );
1365cdf0e10cSrcweir bOk = sal_True;
1366cdf0e10cSrcweir }
1367cdf0e10cSrcweir else
1368cdf0e10cSrcweir {
1369cdf0e10cSrcweir if (pWData && (COMMAND_WHEEL_SCROLL==pWData->GetMode()) && (((sal_uLong)0xFFFFFFFF) == pWData->GetScrollLines()))
1370cdf0e10cSrcweir {
1371cdf0e10cSrcweir if (pWData->GetDelta()<0)
1372cdf0e10cSrcweir PhyPageDown();
1373cdf0e10cSrcweir else
1374cdf0e10cSrcweir PhyPageUp();
1375cdf0e10cSrcweir bOk = sal_True;
1376cdf0e10cSrcweir }
1377cdf0e10cSrcweir else
1378cdf0e10cSrcweir bOk = pEditWin->HandleScrollCommand( rCEvt,
1379cdf0e10cSrcweir pHScrollbar, pVScrollbar);
1380cdf0e10cSrcweir }
1381cdf0e10cSrcweir return bOk;
1382cdf0e10cSrcweir }
1383cdf0e10cSrcweir
1384cdf0e10cSrcweir
1385