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