sw/source/ui/uiview/viewport.cxx

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