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