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