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