1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 // MARKER(update_precomp.py): autogen include statement, do not remove 23 #include "precompiled_sw.hxx" 24 25 #define _SVX_PARAITEM_HXX 26 #define _SVX_TEXTITEM_HXX 27 28 #include <com/sun/star/accessibility/XAccessible.hpp> 29 #include <sfx2/viewfrm.hxx> 30 #include <sfx2/progress.hxx> 31 #include <svx/srchdlg.hxx> 32 #include <svx/svdobj.hxx> 33 #include <sfx2/viewsh.hxx> 34 #include <swwait.hxx> 35 #include <swmodule.hxx> 36 #include <fesh.hxx> 37 #include <doc.hxx> 38 #include <rootfrm.hxx> 39 #include <pagefrm.hxx> 40 #include <cntfrm.hxx> 41 #include <viewimp.hxx> 42 #include <frmtool.hxx> 43 #include <viewopt.hxx> 44 #include <dview.hxx> 45 #include <swregion.hxx> 46 #include <hints.hxx> 47 #include <fmtfsize.hxx> 48 #include <docufld.hxx> 49 #include <txtfrm.hxx> 50 #include <layact.hxx> 51 #include <mdiexp.hxx> 52 #include <fntcache.hxx> 53 #include <ptqueue.hxx> 54 #include <tabfrm.hxx> 55 #include <docsh.hxx> 56 #include <pagedesc.hxx> 57 #include <ndole.hxx> 58 #include <ndindex.hxx> 59 #include <accmap.hxx> 60 #include <svtools/colorcfg.hxx> 61 #include <svtools/accessibilityoptions.hxx> 62 #include <accessibilityoptions.hxx> 63 #include <statstr.hrc> 64 #include <comcore.hrc> 65 #include <pagepreviewlayout.hxx> 66 #include <sortedobjs.hxx> 67 #include <anchoredobject.hxx> 68 #include "../../ui/inc/view.hxx" 69 #include <PostItMgr.hxx> 70 #include <vcl/virdev.hxx> 71 #include <vcl/svapp.hxx> 72 #include <svx/sdrpaintwindow.hxx> 73 #include <vcl/dibtools.hxx> 74 75 sal_Bool ViewShell::bLstAct = sal_False; 76 ShellResource *ViewShell::pShellRes = 0; 77 Window *ViewShell::pCareWindow = 0; 78 BitmapEx* ViewShell::pErrorBmp = NULL; 79 BitmapEx* ViewShell::pReplaceBmp = NULL; 80 81 sal_Bool bInSizeNotify = sal_False; 82 83 DBG_NAME(LayoutIdle) 84 85 TYPEINIT0(ViewShell); 86 87 using namespace ::com::sun::star; 88 89 ////////////////////////////////////////////////////////////////////////////// 90 // #i72754# 2nd set of Pre/PostPaints 91 // This time it uses the lock counter mnPrePostPaintCount to allow only one activation 92 // and deactivation and mpPrePostOutDev to remember the OutDev from the BeginDrawLayers 93 // call. That way, all places where paint take place can be handled the same way, even 94 // when calling other paint methods. This is the case at the places where SW paints 95 // buffered into VDevs to avoid flicker. Tis is in general problematic and should be 96 // solved once using the BufferedOutput functionality of the DrawView. 97 98 void ViewShell::PrePaint() 99 { 100 // forward PrePaint event from VCL Window to DrawingLayer 101 if(HasDrawView()) 102 { 103 Imp()->GetDrawView()->PrePaint(); 104 } 105 } 106 107 void ViewShell::DLPrePaint2(const Region& rRegion) 108 { 109 if(0L == mnPrePostPaintCount) 110 { 111 // #i75172# ensure DrawView to use DrawingLayer bufferings 112 if ( !HasDrawView() ) 113 MakeDrawView(); 114 115 // Prefer window; if tot available, get pOut (e.g. printer) 116 mpPrePostOutDev = (GetWin() ? GetWin() : GetOut()); 117 118 // #i74769# use SdrPaintWindow now direct 119 mpTargetPaintWindow = Imp()->GetDrawView()->BeginDrawLayers(mpPrePostOutDev, rRegion); 120 OSL_ENSURE(mpTargetPaintWindow, "BeginDrawLayers: Got no SdrPaintWindow (!)"); 121 122 // #i74769# if prerender, save OutDev and redirect to PreRenderDevice 123 if(mpTargetPaintWindow->GetPreRenderDevice()) 124 { 125 mpBufferedOut = pOut; 126 pOut = &(mpTargetPaintWindow->GetTargetOutputDevice()); 127 } 128 129 // remember original paint MapMode for wrapped FlyFrame paints 130 maPrePostMapMode = pOut->GetMapMode(); 131 } 132 133 mnPrePostPaintCount++; 134 } 135 136 void ViewShell::DLPostPaint2(bool bPaintFormLayer) 137 { 138 OSL_ENSURE(mnPrePostPaintCount > 0L, "ViewShell::DLPostPaint2: Pre/PostPaint encapsulation broken (!)"); 139 mnPrePostPaintCount--; 140 141 if((0L == mnPrePostPaintCount) && (0 != mpTargetPaintWindow)) 142 { 143 // #i74769# restore buffered OutDev 144 if(mpTargetPaintWindow->GetPreRenderDevice()) 145 { 146 pOut = mpBufferedOut; 147 } 148 149 // #i74769# use SdrPaintWindow now direct 150 Imp()->GetDrawView()->EndDrawLayers(*mpTargetPaintWindow, bPaintFormLayer); 151 mpTargetPaintWindow = 0; 152 } 153 } 154 155 ////////////////////////////////////////////////////////////////////////////// 156 157 /****************************************************************************** 158 |* 159 |* ViewShell::ImplEndAction() 160 |* 161 |* Letzte Aenderung MA 04. Sep. 96 162 |* 163 ******************************************************************************/ 164 165 void ViewShell::ImplEndAction( const sal_Bool bIdleEnd ) 166 { 167 //Fuer den Drucker gibt es hier nichts zu tun. 168 if ( !GetWin() || IsPreView() ) 169 { 170 bPaintWorks = sal_True; 171 UISizeNotify(); 172 return; 173 } 174 175 bInEndAction = sal_True; 176 177 //Laeuft hiermit das EndAction der Letzten Shell im Ring? 178 ViewShell::bLstAct = sal_True; 179 ViewShell *pSh = (ViewShell*)this->GetNext(); 180 while ( pSh != this ) 181 { if ( pSh->ActionPend() ) 182 { ViewShell::bLstAct = sal_False; 183 pSh = this; 184 } 185 else 186 pSh = (ViewShell*)pSh->GetNext(); 187 } 188 189 const bool bIsShellForCheckViewLayout = ( this == GetLayout()->GetCurrShell() ); 190 191 SET_CURR_SHELL( this ); 192 if ( Imp()->HasDrawView() && !Imp()->GetDrawView()->areMarkHandlesHidden() ) 193 Imp()->StartAction(); 194 195 if ( Imp()->GetRegion() && Imp()->GetRegion()->GetOrigin() != VisArea() ) 196 Imp()->DelRegion(); 197 198 const sal_Bool bExtraData = ::IsExtraData( GetDoc() ); 199 200 if ( !bIdleEnd ) 201 { 202 SwLayAction aAction( GetLayout(), Imp() ); 203 aAction.SetComplete( sal_False ); 204 if ( nLockPaint ) 205 aAction.SetPaint( sal_False ); 206 aAction.SetInputType( INPUT_KEYBOARD ); 207 aAction.Action(); 208 } 209 210 if ( bIsShellForCheckViewLayout ) 211 GetLayout()->CheckViewLayout( GetViewOptions(), &aVisArea ); 212 213 //Wenn wir selbst keine Paints erzeugen, so warten wir auf das Paint 214 //vom System. Dann ist das Clipping korrekt gesetzt; Beispiel: verschieben 215 //eines DrawObjektes. 216 if ( Imp()->GetRegion() || 217 aInvalidRect.HasArea() || 218 bExtraData ) 219 { 220 if ( !nLockPaint ) 221 { 222 sal_Bool bPaintsFromSystem = aInvalidRect.HasArea(); 223 GetWin()->Update(); 224 if ( aInvalidRect.HasArea() ) 225 { 226 if ( bPaintsFromSystem ) 227 Imp()->AddPaintRect( aInvalidRect ); 228 229 ResetInvalidRect(); 230 bPaintsFromSystem = sal_True; 231 } 232 bPaintWorks = sal_True; 233 234 SwRegionRects *pRegion = Imp()->GetRegion(); 235 236 //JP 27.11.97: wer die Selection hided, muss sie aber auch 237 // wieder Showen. Sonst gibt es Paintfehler! 238 // z.B.: addional Mode, Seite vertikal hab zu sehen, in der 239 // Mitte eine Selektion und mit einem anderen Cursor an linken 240 // rechten Rand springen. Ohne ShowCrsr verschwindet die 241 // Selektion 242 sal_Bool bShowCrsr = pRegion && IsA( TYPE(SwCrsrShell) ); 243 if( bShowCrsr ) 244 ((SwCrsrShell*)this)->HideCrsrs(); 245 246 if ( pRegion ) 247 { 248 SwRootFrm* pCurrentLayout = GetLayout(); 249 250 Imp()->pRegion = NULL; 251 252 //Erst Invert dann Compress, niemals andersherum! 253 pRegion->Invert(); 254 255 pRegion->Compress(); 256 257 VirtualDevice *pVout = 0; 258 while ( pRegion->Count() ) 259 { 260 SwRect aRect( (*pRegion)[ pRegion->Count() - 1 ] ); 261 pRegion->Remove( pRegion->Count() - 1 ); 262 263 sal_Bool bPaint = sal_True; 264 if ( IsEndActionByVirDev() ) 265 { 266 //virtuelles device erzeugen und einstellen. 267 if ( !pVout ) 268 pVout = new VirtualDevice( *GetOut() ); 269 MapMode aMapMode( GetOut()->GetMapMode() ); 270 pVout->SetMapMode( aMapMode ); 271 272 sal_Bool bSizeOK = sal_True; 273 274 Rectangle aTmp1( aRect.SVRect() ); 275 aTmp1 = GetOut()->LogicToPixel( aTmp1 ); 276 Rectangle aTmp2( GetOut()->PixelToLogic( aTmp1 ) ); 277 if ( aTmp2.Left() > aRect.Left() ) 278 aTmp1.Left() = Max( 0L, aTmp1.Left() - 1L ); 279 if ( aTmp2.Top() > aRect.Top() ) 280 aTmp1.Top() = Max( 0L, aTmp1.Top() - 1L ); 281 aTmp1.Right() += 1; 282 aTmp1.Bottom() += 1; 283 aTmp1 = GetOut()->PixelToLogic( aTmp1 ); 284 aRect = SwRect( aTmp1 ); 285 286 const Size aTmp( pVout->GetOutputSize() ); 287 if ( aTmp.Height() < aRect.Height() || 288 aTmp.Width() < aRect.Width() ) 289 { 290 bSizeOK = pVout->SetOutputSize( aRect.SSize() ); 291 } 292 if ( bSizeOK ) 293 { 294 bPaint = sal_False; 295 296 // --> OD 2007-07-26 #i79947# 297 // #i72754# start Pre/PostPaint encapsulation before pOut is changed to the buffering VDev 298 const Region aRepaintRegion(aRect.SVRect()); 299 DLPrePaint2(aRepaintRegion); 300 // <-- 301 302 OutputDevice *pOld = GetOut(); 303 pVout->SetLineColor( pOld->GetLineColor() ); 304 pVout->SetFillColor( pOld->GetFillColor() ); 305 Point aOrigin( aRect.Pos() ); 306 aOrigin.X() = -aOrigin.X(); aOrigin.Y() = -aOrigin.Y(); 307 aMapMode.SetOrigin( aOrigin ); 308 pVout->SetMapMode( aMapMode ); 309 310 pOut = pVout; 311 if ( bPaintsFromSystem ) 312 PaintDesktop( aRect ); 313 pCurrentLayout->Paint( aRect ); 314 pOld->DrawOutDev( aRect.Pos(), aRect.SSize(), 315 aRect.Pos(), aRect.SSize(), *pVout ); 316 pOut = pOld; 317 318 // #i72754# end Pre/PostPaint encapsulation when pOut is back and content is painted 319 DLPostPaint2(true); 320 } 321 } 322 if ( bPaint ) 323 { 324 // #i75172# begin DrawingLayer paint 325 // need to do begin/end DrawingLayer preparation for each single rectangle of the 326 // repaint region. I already tried to prepare only once for the whole Region. This 327 // seems to work (and does technically) but fails with transparent objects. Since the 328 // region given to BeginDarwLayers() defines the clip region for DrawingLayer paint, 329 // transparent objects in the single rectangles will indeed be painted multiple times. 330 DLPrePaint2(Region(aRect.SVRect())); 331 332 if ( bPaintsFromSystem ) 333 PaintDesktop( aRect ); 334 pCurrentLayout->Paint( aRect ); 335 336 // #i75172# end DrawingLayer paint 337 DLPostPaint2(true); 338 } 339 340 // --> OD 2009-12-03 #i107365# 341 // Direct paint has been performed. Thus, take care of 342 // transparent child windows. 343 if ( GetWin() ) 344 { 345 Window& rWindow = *(GetWin()); 346 if(rWindow.IsChildTransparentModeEnabled() && rWindow.GetChildCount()) 347 { 348 const Rectangle aRectanglePixel(rWindow.LogicToPixel(aRect.SVRect())); 349 350 for ( sal_uInt16 a(0); a < rWindow.GetChildCount(); a++ ) 351 { 352 Window* pCandidate = rWindow.GetChild(a); 353 354 if ( pCandidate && pCandidate->IsPaintTransparent() ) 355 { 356 const Rectangle aCandidatePosSizePixel( 357 pCandidate->GetPosPixel(), 358 pCandidate->GetSizePixel()); 359 360 if ( aCandidatePosSizePixel.IsOver(aRectanglePixel) ) 361 { 362 pCandidate->Invalidate( INVALIDATE_NOTRANSPARENT|INVALIDATE_CHILDREN ); 363 pCandidate->Update(); 364 } 365 } 366 } 367 } 368 } 369 // <-- 370 } 371 372 delete pVout; 373 delete pRegion; 374 Imp()->DelRegion(); 375 } 376 if( bShowCrsr ) 377 ((SwCrsrShell*)this)->ShowCrsrs( sal_True ); 378 } 379 else 380 { 381 Imp()->DelRegion(); 382 bPaintWorks = sal_True; 383 } 384 } 385 else 386 bPaintWorks = sal_True; 387 388 bInEndAction = sal_False; 389 ViewShell::bLstAct = sal_False; 390 Imp()->EndAction(); 391 392 393 //Damit sich die automatischen Scrollbars auch richtig anordnen k?nnen 394 //muessen wir die Aktion hier kuenstlich beenden (EndAction loesst ein 395 //Notify aus, und das muss Start-/EndAction rufen um die Scrollbars 396 //klarzubekommen. 397 --nStartAction; 398 UISizeNotify(); 399 ++nStartAction; 400 401 if( Imp()->IsAccessible() ) 402 Imp()->FireAccessibleEvents(); 403 } 404 405 /****************************************************************************** 406 |* 407 |* ViewShell::ImplStartAction() 408 |* 409 |* Ersterstellung MA 25. Jul. 94 410 |* Letzte Aenderung MA 25. Jul. 94 411 |* 412 ******************************************************************************/ 413 414 void ViewShell::ImplStartAction() 415 { 416 bPaintWorks = sal_False; 417 Imp()->StartAction(); 418 } 419 420 421 /****************************************************************************** 422 |* 423 |* ViewShell::ImplLockPaint(), ImplUnlockPaint() 424 |* 425 |* Ersterstellung MA 11. Jun. 96 426 |* Letzte Aenderung MA 11. Jun. 96 427 |* 428 ******************************************************************************/ 429 430 void ViewShell::ImplLockPaint() 431 { 432 if ( GetWin() && GetWin()->IsVisible() ) 433 GetWin()->EnablePaint( sal_False ); //Auch die Controls abklemmen. 434 Imp()->LockPaint(); 435 } 436 437 438 void ViewShell::ImplUnlockPaint( sal_Bool bVirDev ) 439 { 440 SET_CURR_SHELL( this ); 441 if ( GetWin() && GetWin()->IsVisible() ) 442 { 443 if ( (bInSizeNotify || bVirDev ) && VisArea().HasArea() ) 444 { 445 //Refresh mit virtuellem Device um das Flackern zu verhindern. 446 VirtualDevice *pVout = new VirtualDevice( *pOut ); 447 pVout->SetMapMode( pOut->GetMapMode() ); 448 Size aSize( VisArea().SSize() ); 449 aSize.Width() += 20; 450 aSize.Height()+= 20; 451 if( pVout->SetOutputSize( aSize ) ) 452 { 453 GetWin()->EnablePaint( sal_True ); 454 GetWin()->Validate(); 455 456 Imp()->UnlockPaint(); 457 pVout->SetLineColor( pOut->GetLineColor() ); 458 pVout->SetFillColor( pOut->GetFillColor() ); 459 460 // #i72754# start Pre/PostPaint encapsulation before pOut is changed to the buffering VDev 461 const Region aRepaintRegion(VisArea().SVRect()); 462 DLPrePaint2(aRepaintRegion); 463 464 OutputDevice *pOld = pOut; 465 pOut = pVout; 466 Paint( VisArea().SVRect() ); 467 pOut = pOld; 468 pOut->DrawOutDev( VisArea().Pos(), aSize, 469 VisArea().Pos(), aSize, *pVout ); 470 471 // #i72754# end Pre/PostPaint encapsulation when pOut is back and content is painted 472 DLPostPaint2(true); 473 } 474 else 475 { 476 Imp()->UnlockPaint(); 477 GetWin()->EnablePaint( sal_True ); 478 GetWin()->Invalidate( INVALIDATE_CHILDREN ); 479 } 480 delete pVout; 481 } 482 else 483 { 484 Imp()->UnlockPaint(); 485 GetWin()->EnablePaint( sal_True ); 486 GetWin()->Invalidate( INVALIDATE_CHILDREN ); 487 } 488 } 489 else 490 Imp()->UnlockPaint(); 491 } 492 493 /****************************************************************************** 494 |* 495 |* ViewShell::AddPaintRect() 496 |* 497 |* Ersterstellung MA ?? 498 |* Letzte Aenderung MA 09. Feb. 97 499 |* 500 ******************************************************************************/ 501 502 sal_Bool ViewShell::AddPaintRect( const SwRect & rRect ) 503 { 504 sal_Bool bRet = sal_False; 505 ViewShell *pSh = this; 506 do 507 { 508 if( pSh->Imp() ) 509 { 510 if ( pSh->IsPreView() && pSh->GetWin() ) 511 ::RepaintPagePreview( pSh, rRect ); 512 else 513 bRet |= pSh->Imp()->AddPaintRect( rRect );//swmod 080111 514 } 515 pSh = (ViewShell*)pSh->GetNext(); 516 } while ( pSh != this ); 517 return bRet; 518 } 519 520 /****************************************************************************** 521 |* 522 |* ViewShell::InvalidateWindows() 523 |* 524 |* Ersterstellung MA ?? 525 |* Letzte Aenderung MA 09. Feb. 97 526 |* 527 ******************************************************************************/ 528 529 void ViewShell::InvalidateWindows( const SwRect &rRect ) 530 { 531 if ( !Imp()->IsCalcLayoutProgress() ) 532 { 533 ViewShell *pSh = this; 534 do 535 { 536 if ( pSh->GetWin() ) 537 { 538 if ( pSh->IsPreView() ) 539 ::RepaintPagePreview( pSh, rRect ); 540 else if ( pSh->VisArea().IsOver( rRect ) ) 541 pSh->GetWin()->Invalidate( rRect.SVRect() ); 542 } 543 pSh = (ViewShell*)pSh->GetNext(); 544 545 } while ( pSh != this ); 546 } 547 } 548 549 /****************************************************************************** 550 |* 551 |* ViewShell::MakeVisible() 552 |* 553 |* Ersterstellung MA ?? 554 |* Letzte Aenderung AMA 10. Okt. 95 555 |* 556 ******************************************************************************/ 557 558 void ViewShell::MakeVisible( const SwRect &rRect ) 559 { 560 if ( !VisArea().IsInside( rRect ) || IsScrollMDI( this, rRect ) || GetCareWin(*this) ) 561 { 562 if ( !IsViewLocked() ) 563 { 564 if( pWin ) 565 { 566 const SwFrm* pRoot = GetLayout(); 567 int nLoopCnt = 3; 568 long nOldH; 569 do{ 570 nOldH = pRoot->Frm().Height(); 571 StartAction(); 572 ScrollMDI( this, rRect, USHRT_MAX, USHRT_MAX ); 573 EndAction(); 574 } while( nOldH != pRoot->Frm().Height() && nLoopCnt-- ); //swmod 071108//swmod 071225 575 } 576 #ifdef DBG_UTIL 577 else 578 { 579 //MA: 04. Nov. 94, braucht doch keiner oder?? 580 ASSERT( !this, "MakeVisible fuer Drucker wird doch gebraucht?" ); 581 } 582 583 #endif 584 } 585 } 586 } 587 588 /****************************************************************************** 589 |* 590 |* ViewShell::CareChildWindow() 591 |* 592 |* Ersterstellung AMA 10. Okt. 95 593 |* Letzte Aenderung AMA 10. Okt. 95 594 |* 595 ******************************************************************************/ 596 597 Window* ViewShell::CareChildWin(ViewShell& rVSh) 598 { 599 if(rVSh.pSfxViewShell) 600 { 601 const sal_uInt16 nId = SvxSearchDialogWrapper::GetChildWindowId(); 602 SfxViewFrame* pVFrame = rVSh.pSfxViewShell->GetViewFrame(); 603 const SfxChildWindow* pChWin = pVFrame->GetChildWindow( nId ); 604 Window *pWin = pChWin ? pChWin->GetWindow() : NULL; 605 if ( pWin && pWin->IsVisible() ) 606 return pWin; 607 } 608 return NULL; 609 } 610 611 /****************************************************************************** 612 |* 613 |* ViewShell::GetPagePos() 614 |* 615 |* Ersterstellung MA ?? 616 |* Letzte Aenderung MA 04. Aug. 93 617 |* 618 ******************************************************************************/ 619 620 Point ViewShell::GetPagePos( sal_uInt16 nPageNum ) const 621 { 622 return GetLayout()->GetPagePos( nPageNum ); 623 } 624 625 /****************************************************************************** 626 |* 627 |* ViewShell::GetNumPages() 628 |* 629 |* Ersterstellung MA ?? 630 |* Letzte Aenderung MA 20. Apr. 94 631 |* 632 ******************************************************************************/ 633 634 sal_uInt16 ViewShell::GetNumPages() 635 { 636 //Es kann sein, das noch kein Layout existiert weil die Methode vom 637 //Root-Ctor gerufen wird. 638 return GetLayout() ? GetLayout()->GetPageNum() : 0; 639 } 640 641 sal_Bool ViewShell::IsDummyPage( sal_uInt16 nPageNum ) const 642 { 643 return GetLayout() ? GetLayout()->IsDummyPage( nPageNum ) : 0; 644 } 645 646 /************************************************************************* 647 |* 648 |* ViewShell::UpdateFlds() 649 |* 650 |* Ersterstellung BP 04.05.92 651 |* Beschreibung erzwingt ein Update fuer jedes Feld 652 |* 653 |* UpdateFlds benachrichtigt alle Felder mit pNewHt. 654 |* Wenn pNewHt == 0 ist (default), wird der Feldtyp verschickt. 655 |* 656 *************************************************************************/ 657 658 void ViewShell::UpdateFlds(sal_Bool bCloseDB) 659 { 660 SET_CURR_SHELL( this ); 661 662 sal_Bool bCrsr = ISA(SwCrsrShell); 663 if ( bCrsr ) 664 ((SwCrsrShell*)this)->StartAction(); 665 else 666 StartAction(); 667 668 GetDoc()->UpdateFlds(0, bCloseDB); 669 670 if ( bCrsr ) 671 ((SwCrsrShell*)this)->EndAction(); 672 else 673 EndAction(); 674 } 675 676 // update all charts, for that exists any table 677 void ViewShell::UpdateAllCharts() 678 { 679 SET_CURR_SHELL( this ); 680 // Start-/EndAction handled in the SwDoc-Method! 681 GetDoc()->UpdateAllCharts(); 682 } 683 684 sal_Bool ViewShell::HasCharts() const 685 { 686 sal_Bool bRet = sal_False; 687 const SwStartNode *pStNd; 688 SwNodeIndex aIdx( *GetDoc()->GetNodes().GetEndOfAutotext(). 689 StartOfSectionNode(), 1 ); 690 while ( 0 != (pStNd = aIdx.GetNode().GetStartNode()) ) 691 { 692 aIdx++; 693 const SwOLENode *pNd = aIdx.GetNode().GetOLENode(); 694 if( pNd && pNd->GetChartTblName().Len() ) 695 { 696 bRet = sal_True; 697 break; 698 } 699 } 700 return bRet; 701 } 702 703 /************************************************************************* 704 |* 705 |* ViewShell::LayoutIdle() 706 |* 707 |* Ersterstellung MA 26. May. 92 708 |* Letzte Aenderung OG 19. Mar. 96 709 |* 710 *************************************************************************/ 711 712 void ViewShell::LayoutIdle() 713 { 714 #ifdef TCOVER 715 //fuer TCV-Version: Ende der Startphase des Programmes 716 TCovCall::Idle(); 717 #endif 718 if( !pOpt->IsIdle() || !GetWin() || 719 ( Imp()->HasDrawView() && Imp()->GetDrawView()->IsDragObj() ) ) 720 return; 721 722 //Kein Idle wenn gerade gedruckt wird. 723 ViewShell *pSh = this; 724 do 725 { if ( !pSh->GetWin() ) 726 return; 727 pSh = (ViewShell*)pSh->GetNext(); 728 729 } while ( pSh != this ); 730 731 SET_CURR_SHELL( this ); 732 733 #ifdef DBG_UTIL 734 // Wenn Test5 gedrueckt ist, wird der IdleFormatierer abgeknipst. 735 if( pOpt->IsTest5() ) 736 return; 737 #endif 738 739 { 740 DBG_PROFSTART( LayoutIdle ); 741 742 //Cache vorbereiten und restaurieren, damit er nicht versaut wird. 743 SwSaveSetLRUOfst aSave( *SwTxtFrm::GetTxtCache(), 744 SwTxtFrm::GetTxtCache()->GetCurMax() - 50 ); 745 // #125243# there are lots of stacktraces indicating that Imp() returns NULL 746 // this ViewShell seems to be invalid - but it's not clear why 747 // this return is only a workaround! 748 DBG_ASSERT(Imp(), "ViewShell already deleted?"); 749 if(!Imp()) 750 return; 751 SwLayIdle aIdle( GetLayout(), Imp() ); 752 DBG_PROFSTOP( LayoutIdle ); 753 } 754 } 755 756 /************************************************************************* 757 |* 758 |* DOCUMENT COMPATIBILITY FLAGS 759 |* 760 *************************************************************************/ 761 762 void lcl_InvalidateAllCntnt( ViewShell& rSh, sal_uInt8 nInv ) 763 { 764 sal_Bool bCrsr = rSh.ISA(SwCrsrShell); 765 if ( bCrsr ) 766 ((SwCrsrShell&)rSh).StartAction(); 767 else 768 rSh.StartAction(); 769 rSh.GetLayout()->InvalidateAllCntnt( nInv ); 770 if ( bCrsr ) 771 ((SwCrsrShell&)rSh).EndAction(); 772 else 773 rSh.EndAction(); 774 775 rSh.GetDoc()->SetModified(); 776 } 777 778 /** local method to invalidate/re-calculate positions of floating screen 779 objects (Writer fly frame and drawing objects), which are anchored 780 to paragraph or to character. 781 782 OD 2004-03-16 #i11860# 783 784 @author OD 785 */ 786 void lcl_InvalidateAllObjPos( ViewShell &_rSh ) 787 { 788 const bool bIsCrsrShell = _rSh.ISA(SwCrsrShell); 789 if ( bIsCrsrShell ) 790 static_cast<SwCrsrShell&>(_rSh).StartAction(); 791 else 792 _rSh.StartAction(); 793 794 _rSh.GetLayout()->InvalidateAllObjPos(); 795 796 if ( bIsCrsrShell ) 797 static_cast<SwCrsrShell&>(_rSh).EndAction(); 798 else 799 _rSh.EndAction(); 800 801 _rSh.GetDoc()->SetModified(); 802 } 803 804 void ViewShell::SetParaSpaceMax( bool bNew ) 805 { 806 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 807 if( pIDSA->get(IDocumentSettingAccess::PARA_SPACE_MAX) != bNew ) 808 { 809 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 810 pIDSA->set(IDocumentSettingAccess::PARA_SPACE_MAX, bNew ); 811 const sal_uInt8 nInv = INV_PRTAREA | INV_TABLE | INV_SECTION; 812 lcl_InvalidateAllCntnt( *this, nInv ); 813 } 814 } 815 816 void ViewShell::SetParaSpaceMaxAtPages( bool bNew ) 817 { 818 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 819 if( pIDSA->get(IDocumentSettingAccess::PARA_SPACE_MAX_AT_PAGES) != bNew ) 820 { 821 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 822 pIDSA->set(IDocumentSettingAccess::PARA_SPACE_MAX_AT_PAGES, bNew ); 823 const sal_uInt8 nInv = INV_PRTAREA | INV_TABLE | INV_SECTION; 824 lcl_InvalidateAllCntnt( *this, nInv ); 825 } 826 } 827 828 void ViewShell::SetTabCompat( bool bNew ) 829 { 830 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 831 if( pIDSA->get(IDocumentSettingAccess::TAB_COMPAT) != bNew ) 832 { 833 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 834 pIDSA->set(IDocumentSettingAccess::TAB_COMPAT, bNew ); 835 const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION; 836 lcl_InvalidateAllCntnt( *this, nInv ); 837 } 838 } 839 840 void ViewShell::SetAddExtLeading( bool bNew ) 841 { 842 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 843 if ( pIDSA->get(IDocumentSettingAccess::ADD_EXT_LEADING) != bNew ) 844 { 845 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 846 pIDSA->set(IDocumentSettingAccess::ADD_EXT_LEADING, bNew ); 847 SdrModel* pTmpDrawModel = getIDocumentDrawModelAccess()->GetDrawModel(); 848 if ( pTmpDrawModel ) 849 pTmpDrawModel->SetAddExtLeading( bNew ); 850 const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION; 851 lcl_InvalidateAllCntnt( *this, nInv ); 852 } 853 } 854 855 void ViewShell::SetUseVirDev( bool bNewVirtual ) 856 { 857 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 858 if ( pIDSA->get(IDocumentSettingAccess::USE_VIRTUAL_DEVICE) != bNewVirtual ) 859 { 860 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 861 // this sets the flag at the document and calls PrtDataChanged 862 IDocumentDeviceAccess* pIDDA = getIDocumentDeviceAccess(); 863 pIDDA->setReferenceDeviceType( bNewVirtual, true ); 864 } 865 } 866 867 // OD 2004-02-16 #106629# - control, if paragraph and table spacing is added 868 // at bottom of table cells 869 void ViewShell::SetAddParaSpacingToTableCells( bool _bAddParaSpacingToTableCells ) 870 { 871 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 872 if ( pIDSA->get(IDocumentSettingAccess::ADD_PARA_SPACING_TO_TABLE_CELLS) != _bAddParaSpacingToTableCells ) 873 { 874 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 875 pIDSA->set(IDocumentSettingAccess::ADD_PARA_SPACING_TO_TABLE_CELLS, _bAddParaSpacingToTableCells ); 876 const sal_uInt8 nInv = INV_PRTAREA; 877 lcl_InvalidateAllCntnt( *this, nInv ); 878 } 879 } 880 881 // OD 06.01.2004 #i11859# - control, if former formatting of text lines with 882 // proportional line spacing is used or not. 883 void ViewShell::SetUseFormerLineSpacing( bool _bUseFormerLineSpacing ) 884 { 885 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 886 if ( pIDSA->get(IDocumentSettingAccess::OLD_LINE_SPACING) != _bUseFormerLineSpacing ) 887 { 888 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 889 pIDSA->set(IDocumentSettingAccess::OLD_LINE_SPACING, _bUseFormerLineSpacing ); 890 const sal_uInt8 nInv = INV_PRTAREA; 891 lcl_InvalidateAllCntnt( *this, nInv ); 892 } 893 } 894 895 // OD 2004-03-12 #i11860# - control, if former object positioning is used or not. 896 void ViewShell::SetUseFormerObjectPositioning( bool _bUseFormerObjPos ) 897 { 898 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 899 if ( pIDSA->get(IDocumentSettingAccess::USE_FORMER_OBJECT_POS) != _bUseFormerObjPos ) 900 { 901 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 902 pIDSA->set(IDocumentSettingAccess::USE_FORMER_OBJECT_POS, _bUseFormerObjPos ); 903 lcl_InvalidateAllObjPos( *this ); 904 } 905 } 906 907 // OD 2004-05-05 #i28701# 908 void ViewShell::SetConsiderWrapOnObjPos( bool _bConsiderWrapOnObjPos ) 909 { 910 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 911 if ( pIDSA->get(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION) != _bConsiderWrapOnObjPos ) 912 { 913 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 914 pIDSA->set(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION, _bConsiderWrapOnObjPos ); 915 lcl_InvalidateAllObjPos( *this ); 916 } 917 } 918 919 // --> FME #108724# 920 void ViewShell::SetUseFormerTextWrapping( bool _bUseFormerTextWrapping ) 921 { 922 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 923 if ( pIDSA->get(IDocumentSettingAccess::USE_FORMER_TEXT_WRAPPING) != _bUseFormerTextWrapping ) 924 { 925 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 926 pIDSA->set(IDocumentSettingAccess::USE_FORMER_TEXT_WRAPPING, _bUseFormerTextWrapping ); 927 const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION; 928 lcl_InvalidateAllCntnt( *this, nInv ); 929 } 930 } 931 // <-- 932 933 // -> PB 2007-06-11 #i45491# 934 void ViewShell::SetDoNotJustifyLinesWithManualBreak( bool _bDoNotJustifyLinesWithManualBreak ) 935 { 936 IDocumentSettingAccess* pIDSA = getIDocumentSettingAccess(); 937 if ( pIDSA->get(IDocumentSettingAccess::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK) != _bDoNotJustifyLinesWithManualBreak ) 938 { 939 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 940 pIDSA->set(IDocumentSettingAccess::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK, _bDoNotJustifyLinesWithManualBreak ); 941 const sal_uInt8 nInv = INV_PRTAREA | INV_SIZE | INV_TABLE | INV_SECTION; 942 lcl_InvalidateAllCntnt( *this, nInv ); 943 } 944 } 945 // <-- 946 947 /****************************************************************************** 948 |* 949 |* ViewShell::Reformat 950 |* 951 |* Ersterstellung BP ??? 952 |* Letzte Aenderung MA 13. Feb. 98 953 |* 954 ******************************************************************************/ 955 956 void ViewShell::Reformat() 957 { 958 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 959 960 // Wir gehen auf Nummer sicher: 961 // Wir muessen die alten Fontinformationen wegschmeissen, 962 // wenn die Druckeraufloesung oder der Zoomfaktor sich aendert. 963 // Init() und Reformat() sind die sichersten Stellen. 964 #ifdef FNTMET 965 aFntMetList.Flush(); 966 #else 967 pFntCache->Flush( ); 968 #endif 969 970 if( GetLayout()->IsCallbackActionEnabled() ) 971 { 972 973 StartAction(); 974 GetLayout()->InvalidateAllCntnt( INV_SIZE | INV_POS | INV_PRTAREA ); 975 EndAction(); 976 } 977 } 978 979 void ViewShell::ChgNumberDigits() 980 { 981 SdrModel* pTmpDrawModel = getIDocumentDrawModelAccess()->GetDrawModel(); 982 if ( pTmpDrawModel ) 983 pTmpDrawModel->ReformatAllTextObjects(); 984 Reformat(); 985 } 986 987 /****************************************************************************** 988 |* 989 |* ViewShell::CalcLayout() 990 |* Vollstaendige Formatierung von Layout und Inhalt. 991 |* 992 |* Ersterstellung MA 31. Jan. 94 993 |* Letzte Aenderung MA 08. Oct. 96 994 |* 995 ******************************************************************************/ 996 997 void ViewShell::CalcLayout() 998 { 999 SET_CURR_SHELL( this ); 1000 SwWait aWait( *GetDoc()->GetDocShell(), sal_True ); 1001 1002 //Cache vorbereiten und restaurieren, damit er nicht versaut wird. 1003 SwSaveSetLRUOfst aSaveLRU( *SwTxtFrm::GetTxtCache(), 1004 SwTxtFrm::GetTxtCache()->GetCurMax() - 50 ); 1005 1006 //Progress einschalten wenn noch keiner Lauft. 1007 const sal_Bool bEndProgress = SfxProgress::GetActiveProgress( GetDoc()->GetDocShell() ) == 0; 1008 if ( bEndProgress ) 1009 { 1010 sal_uInt16 nEndPage = GetLayout()->GetPageNum(); 1011 nEndPage += nEndPage * 10 / 100; 1012 ::StartProgress( STR_STATSTR_REFORMAT, 0, nEndPage, GetDoc()->GetDocShell() ); 1013 } 1014 1015 SwLayAction aAction( GetLayout(), Imp() ); 1016 aAction.SetPaint( sal_False ); 1017 aAction.SetStatBar( sal_True ); 1018 aAction.SetCalcLayout( sal_True ); 1019 aAction.SetReschedule( sal_True ); 1020 GetDoc()->LockExpFlds(); 1021 aAction.Action(); 1022 GetDoc()->UnlockExpFlds(); 1023 1024 //Das SetNewFldLst() am Doc wurde unterbunden und muss nachgeholt 1025 //werden (siehe flowfrm.cxx, txtfld.cxx) 1026 if ( aAction.IsExpFlds() ) 1027 { 1028 aAction.Reset(); 1029 aAction.SetPaint( sal_False ); 1030 aAction.SetStatBar( sal_True ); 1031 aAction.SetReschedule( sal_True ); 1032 1033 SwDocPosUpdate aMsgHnt( 0 ); 1034 GetDoc()->UpdatePageFlds( &aMsgHnt ); 1035 GetDoc()->UpdateExpFlds(NULL, true); 1036 1037 aAction.Action(); 1038 } 1039 1040 if ( VisArea().HasArea() ) 1041 InvalidateWindows( VisArea() ); 1042 if ( bEndProgress ) 1043 ::EndProgress( GetDoc()->GetDocShell() ); 1044 } 1045 1046 /****************************************************************************** 1047 |* 1048 |* ViewShell::SetFirstVisPageInvalid() 1049 |* 1050 |* Ersterstellung MA 19. May. 94 1051 |* Letzte Aenderung MA 19. May. 94 1052 |* 1053 ******************************************************************************/ 1054 1055 void ViewShell::SetFirstVisPageInvalid() 1056 { 1057 ViewShell *pSh = this; 1058 do 1059 { pSh->Imp()->SetFirstVisPageInvalid(); 1060 pSh = (ViewShell*)pSh->GetNext(); 1061 1062 } while ( pSh != this ); 1063 } 1064 1065 /****************************************************************************** 1066 |* 1067 |* ViewShell::SizeChgNotify() 1068 |* 1069 |* Ersterstellung MA ?? 1070 |* Letzte Aenderung MA 17. Sep. 96 1071 |* 1072 ******************************************************************************/ 1073 1074 void ViewShell::SizeChgNotify() 1075 { 1076 if ( !pWin ) 1077 bDocSizeChgd = sal_True; 1078 else if( ActionPend() || Imp()->IsCalcLayoutProgress() || bPaintInProgress ) 1079 { 1080 bDocSizeChgd = sal_True; 1081 1082 if ( !Imp()->IsCalcLayoutProgress() && ISA( SwCrsrShell ) ) 1083 { 1084 const SwFrm *pCnt = ((SwCrsrShell*)this)->GetCurrFrm( sal_False ); 1085 const SwPageFrm *pPage; 1086 if ( pCnt && 0 != (pPage = pCnt->FindPageFrm()) ) 1087 { 1088 sal_uInt16 nVirtNum = pPage->GetVirtPageNum(); 1089 const SvxNumberType& rNum = pPage->GetPageDesc()->GetNumType(); 1090 String sDisplay = rNum.GetNumStr( nVirtNum ); 1091 PageNumNotify( this, pCnt->GetPhyPageNum(), nVirtNum, sDisplay ); 1092 } 1093 } 1094 } 1095 else 1096 { 1097 bDocSizeChgd = sal_False; 1098 ::SizeNotify( this, GetDocSize() ); 1099 } 1100 } 1101 1102 /****************************************************************************** 1103 |* 1104 |* ViewShell::VisPortChgd() 1105 |* 1106 |* Ersterstellung MA ?? 1107 |* Letzte Aenderung MA 22. Jul. 96 1108 |* 1109 ******************************************************************************/ 1110 1111 void ViewShell::VisPortChgd( const SwRect &rRect) 1112 { 1113 ASSERT( GetWin(), "VisPortChgd ohne Window." ); 1114 1115 if ( rRect == VisArea() ) 1116 return; 1117 1118 #ifdef DBG_UTIL 1119 if ( bInEndAction ) 1120 { 1121 //Da Rescheduled doch schon wieder irgendwo einer? 1122 ASSERT( !this, "Scroll waehrend einer EndAction." ); 1123 } 1124 #endif 1125 1126 //Ersteinmal die alte sichtbare Seite holen, dann braucht nacher nicht 1127 //lange gesucht werden. 1128 const SwFrm *pOldPage = Imp()->GetFirstVisPage(); 1129 1130 const SwRect aPrevArea( VisArea() ); 1131 const sal_Bool bFull = aPrevArea.IsEmpty(); 1132 aVisArea = rRect; 1133 SetFirstVisPageInvalid(); 1134 1135 //Wenn noch eine PaintRegion herumsteht und sich die VisArea geaendert hat, 1136 //so ist die PaintRegion spaetestens jetzt obsolete. Die PaintRegion kann 1137 //vom RootFrm::Paint erzeugt worden sein. 1138 if ( !bInEndAction && 1139 Imp()->GetRegion() && Imp()->GetRegion()->GetOrigin() != VisArea() ) 1140 Imp()->DelRegion(); 1141 1142 SET_CURR_SHELL( this ); 1143 1144 bool bScrolled = false; 1145 1146 SwPostItMgr* pPostItMgr = GetPostItMgr(); 1147 1148 if ( bFull ) 1149 GetWin()->Invalidate(); 1150 else 1151 { 1152 // Betrag ausrechnen, um den gescrolled werden muss. 1153 const long nXDiff = aPrevArea.Left() - VisArea().Left(); 1154 const long nYDiff = aPrevArea.Top() - VisArea().Top(); 1155 1156 if( !nXDiff && !GetViewOptions()->getBrowseMode() && 1157 (!Imp()->HasDrawView() || !Imp()->GetDrawView()->IsGridVisible() ) ) 1158 { 1159 //Falls moeglich die Wiese nicht mit Scrollen. 1160 //Also linke und rechte Kante des Scrollbereiches auf die 1161 //Seiten begrenzen. 1162 const SwPageFrm *pPage = (SwPageFrm*)GetLayout()->Lower(); //swmod 071108//swmod 071225 1163 if ( pPage->Frm().Top() > pOldPage->Frm().Top() ) 1164 pPage = (SwPageFrm*)pOldPage; 1165 SwRect aBoth( VisArea() ); 1166 aBoth.Union( aPrevArea ); 1167 const SwTwips nBottom = aBoth.Bottom(); 1168 SwTwips nMinLeft = LONG_MAX; 1169 SwTwips nMaxRight= 0; 1170 1171 const SwTwips nSidebarWidth = pPostItMgr && pPostItMgr->ShowNotes() && pPostItMgr->HasNotes() ? 1172 pPostItMgr->GetSidebarWidth() + pPostItMgr->GetSidebarBorderWidth() : 1173 0; 1174 const bool bBookMode = GetViewOptions()->IsViewLayoutBookMode(); 1175 1176 while ( pPage && pPage->Frm().Top() <= nBottom ) 1177 { 1178 SwRect aPageRect( pPage->Frm() ); 1179 if ( bBookMode ) 1180 { 1181 const SwPageFrm& rFormatPage = static_cast<const SwPageFrm*>(pPage)->GetFormatPage(); 1182 aPageRect.SSize() = rFormatPage.Frm().SSize(); 1183 } 1184 1185 if ( aPageRect.IsOver( aBoth ) ) 1186 { 1187 // OD 12.02.2003 #i9719#, #105645# - consider new border 1188 // and shadow width 1189 const SwTwips nBorderWidth = 1190 GetOut()->PixelToLogic( Size( pPage->BorderPxWidth(), 0 ) ).Width(); 1191 const SwTwips nShadowWidth = 1192 GetOut()->PixelToLogic( Size( pPage->ShadowPxWidth(), 0 ) ).Width(); 1193 1194 SwTwips nPageLeft = 0; 1195 SwTwips nPageRight = 0; 1196 switch ( pPage->SidebarPosition() ) 1197 { 1198 case sw::sidebarwindows::SIDEBAR_LEFT: 1199 { 1200 nPageLeft = aPageRect.Left() - nBorderWidth - nSidebarWidth; 1201 nPageRight = aPageRect.Right() + nBorderWidth + nShadowWidth; 1202 } 1203 break; 1204 case sw::sidebarwindows::SIDEBAR_RIGHT: 1205 { 1206 nPageLeft = aPageRect.Left() - nBorderWidth; 1207 nPageRight = aPageRect.Right() + nBorderWidth + nShadowWidth + nSidebarWidth; 1208 } 1209 break; 1210 case sw::sidebarwindows::SIDEBAR_NONE: 1211 // nothing to do 1212 break; 1213 } 1214 if( nPageLeft < nMinLeft ) 1215 nMinLeft = nPageLeft; 1216 if( nPageRight > nMaxRight ) 1217 nMaxRight = nPageRight; 1218 //Zus. auf die Zeichenobjekte abgleichen. 1219 //Einen Ofst beruecksichtigen, weil die Objekte u.U. 1220 //selektiert sind und die Henkel dann hinausstehen. 1221 if ( pPage->GetSortedObjs() ) 1222 { 1223 const long nOfst = GetOut()->PixelToLogic( 1224 Size(Imp()->GetDrawView()->GetMarkHdlSizePixel()/2,0)).Width(); 1225 for ( sal_uInt16 i = 0; 1226 i < pPage->GetSortedObjs()->Count(); ++i ) 1227 { 1228 SwAnchoredObject* pObj = (*pPage->GetSortedObjs())[i]; 1229 const Rectangle &rBound = pObj->GetObjRect().SVRect(); 1230 // OD 03.03.2003 #107927# - use correct datatype 1231 const SwTwips nL = Max( 0L, rBound.Left() - nOfst ); 1232 if ( nL < nMinLeft ) 1233 nMinLeft = nL; 1234 if( rBound.Right() + nOfst > nMaxRight ) 1235 nMaxRight = rBound.Right() + nOfst; 1236 } 1237 } 1238 } 1239 pPage = (SwPageFrm*)pPage->GetNext(); 1240 } 1241 Rectangle aRect( aPrevArea.SVRect() ); 1242 aRect.Left() = nMinLeft; 1243 aRect.Right() = nMaxRight; 1244 if( VisArea().IsOver( aPrevArea ) && !nLockPaint ) 1245 { 1246 bScrolled = true; 1247 aVisArea.Pos() = aPrevArea.Pos(); 1248 if ( SmoothScroll( nXDiff, nYDiff, &aRect ) ) 1249 return; 1250 aVisArea.Pos() = rRect.Pos(); 1251 } 1252 else 1253 GetWin()->Invalidate( aRect ); 1254 } 1255 else if ( !nLockPaint ) //Wird im UnLock erledigt 1256 { 1257 if( VisArea().IsOver( aPrevArea ) ) 1258 { 1259 bScrolled = true; 1260 aVisArea.Pos() = aPrevArea.Pos(); 1261 if ( SmoothScroll( nXDiff, nYDiff, 0 ) ) 1262 return; 1263 aVisArea.Pos() = rRect.Pos(); 1264 } 1265 else 1266 GetWin()->Invalidate(); 1267 } 1268 } 1269 1270 Point aPt( VisArea().Pos() ); 1271 aPt.X() = -aPt.X(); aPt.Y() = -aPt.Y(); 1272 MapMode aMapMode( GetWin()->GetMapMode() ); 1273 aMapMode.SetOrigin( aPt ); 1274 GetWin()->SetMapMode( aMapMode ); 1275 if ( HasDrawView() ) 1276 { 1277 Imp()->GetDrawView()->VisAreaChanged( GetWin() ); 1278 Imp()->GetDrawView()->SetActualWin( GetWin() ); 1279 } 1280 GetWin()->Update(); 1281 1282 // --> OD 2010-02-11 #i88070# 1283 if ( pPostItMgr ) 1284 { 1285 pPostItMgr->Rescale(); 1286 pPostItMgr->CalcRects(); 1287 pPostItMgr->LayoutPostIts(); 1288 } 1289 // <-- 1290 1291 if ( !bScrolled && pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() ) 1292 pPostItMgr->CorrectPositions(); 1293 1294 if( Imp()->IsAccessible() ) 1295 Imp()->UpdateAccessible(); 1296 1297 } 1298 1299 /****************************************************************************** 1300 |* 1301 |* ViewShell::SmoothScroll() 1302 |* 1303 |* Ersterstellung MA 04. Jul. 96 1304 |* Letzte Aenderung MA 25. Mar. 97 1305 |* 1306 ******************************************************************************/ 1307 1308 sal_Bool ViewShell::SmoothScroll( long lXDiff, long lYDiff, const Rectangle *pRect ) 1309 { 1310 const sal_uLong nColCnt = pOut->GetColorCount(); 1311 long lMult = 1, lMax = LONG_MAX; 1312 if ( nColCnt == 65536 ) 1313 { 1314 lMax = 7000; 1315 lMult = 2; 1316 } 1317 if ( nColCnt == 16777216 ) 1318 { 1319 lMax = 5000; 1320 lMult = 6; 1321 } 1322 else if ( nColCnt == 1 ) 1323 { 1324 lMax = 3000; 1325 lMult = 12; 1326 } 1327 1328 // #i75172# isolated static conditions 1329 const bool bOnlyYScroll(!lXDiff && Abs(lYDiff) != 0 && Abs(lYDiff) < lMax); 1330 const bool bAllowedWithChildWindows(GetWin()->GetWindowClipRegionPixel(WINDOW_GETCLIPREGION_NOCHILDREN|WINDOW_GETCLIPREGION_NULL).IsNull()); 1331 // --> OD 2009-08-12 #i98766# - disable smooth scrolling for Mac port builds 1332 #ifdef QUARTZ 1333 const bool bSmoothScrollAllowed(false); 1334 (void) bOnlyYScroll; 1335 (void) bAllowedWithChildWindows; 1336 #else 1337 const bool bSmoothScrollAllowed(bOnlyYScroll && bEnableSmooth && GetViewOptions()->IsSmoothScroll() && bAllowedWithChildWindows); 1338 #endif 1339 // <- 1340 const bool bIAmCursorShell(ISA(SwCrsrShell)); 1341 (void) bIAmCursorShell; 1342 1343 // #i75172# with selection on overlay, smooth scroll should be allowed with it 1344 const bool bAllowedForSelection(true || (bIAmCursorShell && !((SwCrsrShell*)this)->HasSelection())); 1345 1346 // #i75172# with cursors on overlay, smooth scroll should be allowed with it 1347 const bool bAllowedForMultipleCursors(true || (bIAmCursorShell && ((SwCrsrShell*)this)->GetCrsrCnt() < 2)); 1348 1349 if(bSmoothScrollAllowed && bAllowedForSelection && bAllowedForMultipleCursors) 1350 { 1351 Imp()->bStopSmooth = sal_False; 1352 1353 const SwRect aOldVis( VisArea() ); 1354 1355 //Virtuelles Device erzeugen und einstellen. 1356 const Size aPixSz = GetWin()->PixelToLogic(Size(1,1)); 1357 VirtualDevice *pVout = new VirtualDevice( *GetWin() ); 1358 pVout->SetLineColor( GetWin()->GetLineColor() ); 1359 pVout->SetFillColor( GetWin()->GetFillColor() ); 1360 MapMode aMapMode( GetWin()->GetMapMode() ); 1361 pVout->SetMapMode( aMapMode ); 1362 Size aSize( aVisArea.Width()+2*aPixSz.Width(), Abs(lYDiff)+(2*aPixSz.Height()) ); 1363 if ( pRect ) 1364 aSize.Width() = Min(aSize.Width(), pRect->GetWidth()+2*aPixSz.Width()); 1365 if ( pVout->SetOutputSize( aSize ) ) 1366 { 1367 nLockPaint++; 1368 1369 //Ersteinmal alles neue in das VirDev Painten. 1370 SwRect aRect( VisArea() ); 1371 aRect.Height( aSize.Height() ); 1372 if ( pRect ) 1373 { 1374 aRect.Pos().X() = Max(aRect.Left(),pRect->Left()-aPixSz.Width()); 1375 aRect.Right( Min(aRect.Right()+2*aPixSz.Width(), pRect->Right()+aPixSz.Width())); 1376 } 1377 else 1378 aRect.SSize().Width() += 2*aPixSz.Width(); 1379 aRect.Pos().Y() = lYDiff < 0 ? aOldVis.Bottom() - aPixSz.Height() 1380 : aRect.Top() - aSize.Height() + aPixSz.Height(); 1381 aRect.Pos().X() = Max( 0L, aRect.Left()-aPixSz.Width() ); 1382 aRect.Pos() = GetWin()->PixelToLogic( GetWin()->LogicToPixel( aRect.Pos())); 1383 aRect.SSize()= GetWin()->PixelToLogic( GetWin()->LogicToPixel( aRect.SSize())); 1384 aVisArea = aRect; 1385 const Point aPt( -aRect.Left(), -aRect.Top() ); 1386 aMapMode.SetOrigin( aPt ); 1387 pVout->SetMapMode( aMapMode ); 1388 OutputDevice *pOld = pOut; 1389 pOut = pVout; 1390 1391 { 1392 // #i75172# To get a clean repaint, a new ObjectContact is needed here. Without, the 1393 // repaint would not be correct since it would use the wrong DrawPage visible region. 1394 // This repaint IS about painting something currently outside the visible part (!). 1395 // For that purpose, AddWindowToPaintView is used which creates a new SdrPageViewWindow 1396 // and all the necessary stuff. It's not cheap, but necessary here. Alone because repaint 1397 // target really is NOT the current window. 1398 // Also will automatically NOT use PreRendering and overlay (since target is VirtualDevice) 1399 if(!HasDrawView()) 1400 MakeDrawView(); 1401 SdrView* pDrawView = GetDrawView(); 1402 pDrawView->AddWindowToPaintView(pVout); 1403 1404 // clear pWin during DLPrePaint2 to get paint preparation for pOut, but set it again 1405 // immediately afterwards. There are many decisions in SW which imply that Printing 1406 // is used when pWin == 0 (wrong but widely used). 1407 Window* pOldWin = pWin; 1408 pWin = 0; 1409 DLPrePaint2(Region(aRect.SVRect())); 1410 pWin = pOldWin; 1411 1412 // SW paint stuff 1413 PaintDesktop( aRect ); 1414 ViewShell::bLstAct = sal_True; 1415 GetLayout()->Paint( aRect ); 1416 ViewShell::bLstAct = sal_False; 1417 1418 // end paint and destroy ObjectContact again 1419 DLPostPaint2(true); 1420 pDrawView->DeleteWindowFromPaintView(pVout); 1421 1422 // temporary debug paint checking... 1423 static bool bDoSaveForVisualControl(false); 1424 if(bDoSaveForVisualControl) 1425 { 1426 const bool bMapModeWasEnabledVDev(pVout->IsMapModeEnabled()); 1427 pVout->EnableMapMode(false); 1428 const Bitmap aBitmap(pVout->GetBitmap(Point(), pVout->GetOutputSizePixel())); 1429 const String aTmpString(ByteString( "c:\\test.bmp" ), RTL_TEXTENCODING_UTF8); 1430 SvFileStream aNew(aTmpString, STREAM_WRITE|STREAM_TRUNC); 1431 WriteDIB(aBitmap, aNew, false, true); 1432 pVout->EnableMapMode(bMapModeWasEnabledVDev); 1433 } 1434 } 1435 1436 pOut = pOld; 1437 aVisArea = aOldVis; 1438 1439 //Jetzt Stueckchenweise schieben und die neuen Pixel aus dem 1440 //VirDev kopieren. 1441 1442 // ?????????????????????? 1443 // or is it better to get the scrollfactor from the User 1444 // as option? 1445 // ?????????????????????? 1446 long lMaDelta = aPixSz.Height(); 1447 if ( Abs(lYDiff) > ( aVisArea.Height() / 3 ) ) 1448 lMaDelta *= 6; 1449 else 1450 lMaDelta *= 2; 1451 1452 lMaDelta *= lMult; 1453 1454 if ( lYDiff < 0 ) 1455 lMaDelta = -lMaDelta; 1456 1457 long lDiff = lYDiff; 1458 while ( lDiff ) 1459 { 1460 long lScroll; 1461 if ( Imp()->bStopSmooth || Abs(lDiff) <= Abs(lMaDelta) ) 1462 { 1463 lScroll = lDiff; 1464 lDiff = 0; 1465 } 1466 else 1467 { 1468 lScroll = lMaDelta; 1469 lDiff -= lMaDelta; 1470 } 1471 1472 const SwRect aTmpOldVis = VisArea(); 1473 aVisArea.Pos().Y() -= lScroll; 1474 aVisArea.Pos() = GetWin()->PixelToLogic( GetWin()->LogicToPixel( VisArea().Pos())); 1475 lScroll = aTmpOldVis.Top() - VisArea().Top(); 1476 if ( pRect ) 1477 { 1478 Rectangle aTmp( aTmpOldVis.SVRect() ); 1479 aTmp.Left() = pRect->Left(); 1480 aTmp.Right()= pRect->Right(); 1481 GetWin()->Scroll( 0, lScroll, aTmp, SCROLL_CHILDREN); 1482 } 1483 else 1484 GetWin()->Scroll( 0, lScroll, SCROLL_CHILDREN ); 1485 1486 const Point aTmpPt( -VisArea().Left(), -VisArea().Top() ); 1487 MapMode aTmpMapMode( GetWin()->GetMapMode() ); 1488 aTmpMapMode.SetOrigin( aTmpPt ); 1489 GetWin()->SetMapMode( aTmpMapMode ); 1490 1491 if ( Imp()->HasDrawView() ) 1492 Imp()->GetDrawView()->VisAreaChanged( GetWin() ); 1493 1494 SetFirstVisPageInvalid(); 1495 if ( !Imp()->bStopSmooth ) 1496 { 1497 const bool bScrollDirectionIsUp(lScroll > 0); 1498 Imp()->aSmoothRect = VisArea(); 1499 1500 if(bScrollDirectionIsUp) 1501 { 1502 Imp()->aSmoothRect.Bottom( VisArea().Top() + lScroll + aPixSz.Height()); 1503 } 1504 else 1505 { 1506 Imp()->aSmoothRect.Top( VisArea().Bottom() + lScroll - aPixSz.Height()); 1507 } 1508 1509 Imp()->bSmoothUpdate = sal_True; 1510 GetWin()->Update(); 1511 Imp()->bSmoothUpdate = sal_False; 1512 1513 if(!Imp()->bStopSmooth) 1514 { 1515 static bool bDoItOnPixels(true); 1516 if(bDoItOnPixels) 1517 { 1518 // start paint on logic base 1519 const Rectangle aTargetLogic(Imp()->aSmoothRect.SVRect()); 1520 DLPrePaint2(Region(aTargetLogic)); 1521 1522 // get target rectangle in discrete pixels 1523 OutputDevice& rTargetDevice = mpTargetPaintWindow->GetTargetOutputDevice(); 1524 const Rectangle aTargetPixel(rTargetDevice.LogicToPixel(aTargetLogic)); 1525 1526 // get source top-left in discrete pixels 1527 const Point aSourceTopLeft(pVout->LogicToPixel(aTargetLogic.TopLeft())); 1528 1529 // switch off MapModes 1530 const bool bMapModeWasEnabledDest(rTargetDevice.IsMapModeEnabled()); 1531 const bool bMapModeWasEnabledSource(pVout->IsMapModeEnabled()); 1532 rTargetDevice.EnableMapMode(false); 1533 pVout->EnableMapMode(false); 1534 1535 // copy content 1536 static bool bTestDirectToWindowPaint(false); 1537 if(bTestDirectToWindowPaint) 1538 { 1539 const bool bMapModeWasEnabledWin(GetWin()->IsMapModeEnabled()); 1540 GetWin()->EnableMapMode(false); 1541 1542 GetWin()->DrawOutDev( 1543 aTargetPixel.TopLeft(), aTargetPixel.GetSize(), // dest 1544 aSourceTopLeft, aTargetPixel.GetSize(), // source 1545 *pVout); 1546 1547 GetWin()->EnableMapMode(bMapModeWasEnabledWin); 1548 } 1549 1550 rTargetDevice.DrawOutDev( 1551 aTargetPixel.TopLeft(), aTargetPixel.GetSize(), // dest 1552 aSourceTopLeft, aTargetPixel.GetSize(), // source 1553 *pVout); 1554 1555 // restore MapModes 1556 rTargetDevice.EnableMapMode(bMapModeWasEnabledDest); 1557 pVout->EnableMapMode(bMapModeWasEnabledSource); 1558 1559 // end paint on logoc base 1560 DLPostPaint2(true); 1561 } 1562 else 1563 { 1564 Rectangle aRectangle(Imp()->aSmoothRect.SVRect()); 1565 aRectangle.Left() -= aPixSz.Width(); 1566 aRectangle.Right() += aPixSz.Width(); 1567 aRectangle.Top() -= aPixSz.Height(); 1568 aRectangle.Bottom() += aPixSz.Height(); 1569 const Point aUpdateTopLeft(aRectangle.TopLeft()); 1570 const Size aUpdateSize(aRectangle.GetSize()); 1571 1572 // #i75172# the part getting visible needs to be handled like a repaint. 1573 // For that, start with DLPrePaint2 and the correct Rectangle 1574 DLPrePaint2(Region(aRectangle)); 1575 1576 static bool bTestDirectToWindowPaint(false); 1577 if(bTestDirectToWindowPaint) 1578 { 1579 GetWin()->DrawOutDev(aUpdateTopLeft, aUpdateSize, aUpdateTopLeft, aUpdateSize, *pVout); 1580 } 1581 1582 mpTargetPaintWindow->GetTargetOutputDevice().DrawOutDev(aUpdateTopLeft, aUpdateSize, aUpdateTopLeft, aUpdateSize, *pVout); 1583 1584 // #i75172# Corret repaint end 1585 // Note: This also correcty creates the overlay, thus smooth scroll will 1586 // also be allowed now wth selection (see big IF above) 1587 DLPostPaint2(true); 1588 } 1589 } 1590 else 1591 --nLockPaint; 1592 } 1593 } 1594 delete pVout; 1595 GetWin()->Update(); 1596 if ( !Imp()->bStopSmooth ) 1597 --nLockPaint; 1598 SetFirstVisPageInvalid(); 1599 return sal_True; 1600 } 1601 delete pVout; 1602 } 1603 1604 aVisArea.Pos().X() -= lXDiff; 1605 aVisArea.Pos().Y() -= lYDiff; 1606 if ( pRect ) 1607 GetWin()->Scroll( lXDiff, lYDiff, *pRect, SCROLL_CHILDREN); 1608 else 1609 GetWin()->Scroll( lXDiff, lYDiff, SCROLL_CHILDREN); 1610 return sal_False; 1611 } 1612 1613 /****************************************************************************** 1614 |* 1615 |* ViewShell::PaintDesktop() 1616 |* 1617 |* Ersterstellung MA 16. Dec. 93 1618 |* Letzte Aenderung MA 30. Nov. 95 1619 |* 1620 ******************************************************************************/ 1621 1622 void ViewShell::PaintDesktop( const SwRect &rRect ) 1623 { 1624 if ( !GetWin() && !GetOut()->GetConnectMetaFile() ) 1625 return; //Fuer den Drucker tun wir hier nix 1626 1627 //Sonderfaelle abfangen, damit es nicht gar so ueberraschend aussieht. 1628 //Kann z.B. waehrend des Idle'ns zwischenzeitlich auftreten. 1629 //Die Rechtecke neben den Seiten muessen wir leider auf jedenfall Painten, 1630 //den diese werden spaeter beim VisPortChgd ausgespart. 1631 sal_Bool bBorderOnly = sal_False; 1632 const SwRootFrm *pRoot = GetLayout();//swmod 080305 1633 if ( rRect.Top() > pRoot->Frm().Bottom() ) 1634 { 1635 const SwFrm *pPg = pRoot->Lower(); 1636 while ( pPg && pPg->GetNext() ) 1637 pPg = pPg->GetNext(); 1638 if ( !pPg || !pPg->Frm().IsOver( VisArea() ) ) 1639 bBorderOnly = sal_True; 1640 } 1641 1642 const bool bBookMode = GetViewOptions()->IsViewLayoutBookMode(); 1643 1644 SwRegionRects aRegion( rRect ); 1645 1646 //mod #i6193: remove sidebar area to avoid flickering 1647 const SwPostItMgr* pPostItMgr = GetPostItMgr(); 1648 const SwTwips nSidebarWidth = pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() ? 1649 pPostItMgr->GetSidebarWidth() + pPostItMgr->GetSidebarBorderWidth() : 1650 0; 1651 1652 if ( bBorderOnly ) 1653 { 1654 const SwFrm *pPage =pRoot->Lower(); //swmod 071108//swmod 071225 1655 SwRect aLeft( rRect ), aRight( rRect ); 1656 while ( pPage ) 1657 { 1658 long nTmp = pPage->Frm().Left(); 1659 if ( nTmp < aLeft.Right() ) 1660 aLeft.Right( nTmp ); 1661 nTmp = pPage->Frm().Right(); 1662 if ( nTmp > aRight.Left() ) 1663 { 1664 aRight.Left( nTmp + nSidebarWidth ); 1665 } 1666 pPage = pPage->GetNext(); 1667 } 1668 aRegion.Remove( 0, aRegion.Count() ); 1669 if ( aLeft.HasArea() ) 1670 aRegion.Insert( aLeft, 0 ); 1671 if ( aRight.HasArea() ) 1672 aRegion.Insert( aRight, 1 ); 1673 } 1674 else 1675 { 1676 const SwFrm *pPage = Imp()->GetFirstVisPage(); 1677 const SwTwips nBottom = rRect.Bottom(); 1678 //const SwTwips nRight = rRect.Right(); 1679 while ( pPage && aRegion.Count() && 1680 (pPage->Frm().Top() <= nBottom) ) // PAGES01 && (pPage->Frm().Left() <= nRight)) 1681 { 1682 SwRect aPageRect( pPage->Frm() ); 1683 if ( bBookMode ) 1684 { 1685 const SwPageFrm& rFormatPage = static_cast<const SwPageFrm*>(pPage)->GetFormatPage(); 1686 aPageRect.SSize() = rFormatPage.Frm().SSize(); 1687 } 1688 1689 const bool bSidebarRight = 1690 static_cast<const SwPageFrm*>(pPage)->SidebarPosition() == sw::sidebarwindows::SIDEBAR_RIGHT; 1691 aPageRect.Pos().X() -= bSidebarRight ? 0 : nSidebarWidth; 1692 aPageRect.SSize().Width() += nSidebarWidth; 1693 1694 if ( aPageRect.IsOver( rRect ) ) 1695 aRegion -= aPageRect; 1696 1697 pPage = pPage->GetNext(); 1698 } 1699 } 1700 if ( aRegion.Count() ) 1701 _PaintDesktop( aRegion ); 1702 } 1703 1704 1705 // PaintDesktop gesplittet, dieser Teil wird auch von PreViewPage benutzt 1706 void ViewShell::_PaintDesktop( const SwRegionRects &rRegion ) 1707 { 1708 // OD 2004-04-23 #116347# 1709 GetOut()->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR ); 1710 GetOut()->SetLineColor(); 1711 1712 for ( sal_uInt16 i = 0; i < rRegion.Count(); ++i ) 1713 { 1714 const Rectangle aRectangle(rRegion[i].SVRect()); 1715 1716 // #i93170# 1717 // Here we have a real Problem. On the one hand we have the buffering for paint 1718 // and overlay which needs an embracing pair of DLPrePaint2/DLPostPaint2 calls, 1719 // on the other hand the MapMode is not set correctly when this code is executed. 1720 // This is done in the users of this method, for each SWpage before painting it. 1721 // Since the MapMode is not correct here, the call to DLPostPaint2 will paint 1722 // existing FormControls due to the current MapMode. 1723 // 1724 // There are basically three solutions for this: 1725 // 1726 // (1) Set the MapMode correct, move the background painting to the users of 1727 // this code 1728 // 1729 // (2) Do no DLPrePaint2/DLPostPaint2 here; no SdrObjects are allowed to lie in 1730 // the desktop region. Disadvantage: the desktop will not be part of the 1731 // buffers, e.g. overlay. Thus, as soon as overlay will be used over the 1732 // desktop, it will not work. 1733 // 1734 // (3) expand DLPostPaint2 with a flag to signal if FormControl paints shall 1735 // be done or not 1736 // 1737 // Currently, (3) will be the best possible solution. It will keep overlay and 1738 // buffering intact and work without MapMode for single pages. In the medium 1739 // to long run, (1) will need to be used and the bool bPaintFormLayer needs 1740 // to be removed again 1741 1742 // #i68597# inform Drawinglayer about display change 1743 DLPrePaint2(Region(aRectangle)); 1744 1745 // #i75172# needed to move line/Fill color setters into loop since DLPrePaint2 1746 // may exchange GetOut(), that's it's purpose. This happens e.g. at print preview. 1747 GetOut()->SetFillColor( SwViewOption::GetAppBackgroundColor()); 1748 GetOut()->SetLineColor(); 1749 GetOut()->DrawRect(aRectangle); 1750 1751 DLPostPaint2(false); 1752 } 1753 1754 GetOut()->Pop(); 1755 } 1756 1757 /****************************************************************************** 1758 |* 1759 |* ViewShell::CheckInvalidForPaint() 1760 |* 1761 |* Ersterstellung MA 19. May. 94 1762 |* Letzte Aenderung MA 09. Jun. 94 1763 |* 1764 ******************************************************************************/ 1765 1766 sal_Bool ViewShell::CheckInvalidForPaint( const SwRect &rRect ) 1767 { 1768 if ( !GetWin() ) 1769 return sal_False; 1770 1771 const SwPageFrm *pPage = Imp()->GetFirstVisPage(); 1772 const SwTwips nBottom = VisArea().Bottom(); 1773 const SwTwips nRight = VisArea().Right(); 1774 sal_Bool bRet = sal_False; 1775 while ( !bRet && pPage && !((pPage->Frm().Top() > nBottom) || 1776 (pPage->Frm().Left() > nRight))) 1777 { 1778 if ( pPage->IsInvalid() || pPage->IsInvalidFly() ) 1779 bRet = sal_True; 1780 pPage = (SwPageFrm*)pPage->GetNext(); 1781 } 1782 1783 if ( bRet ) 1784 { 1785 //Start/EndAction wuerden hier leider nix helfen, weil das Paint vom 1786 //GUI 'reinkam und somit ein Clipping gesetzt ist gegen das wir nicht 1787 //nicht ankommen. 1788 //Ergo: Alles selbst machen (siehe ImplEndAction()) 1789 if ( Imp()->GetRegion() && Imp()->GetRegion()->GetOrigin() != VisArea()) 1790 Imp()->DelRegion(); 1791 1792 SwLayAction aAction( GetLayout(), Imp() ); 1793 aAction.SetComplete( sal_False ); 1794 // We increment the action counter to avoid a recursive call of actions 1795 // e.g. from a SwFEShell::RequestObjectResize(..) in bug 95829. 1796 // A recursive call of actions is no good idea because the inner action 1797 // can't format frames which are locked by the outer action. This may 1798 // cause and endless loop. 1799 ++nStartAction; 1800 aAction.Action(); 1801 --nStartAction; 1802 1803 SwRegionRects *pRegion = Imp()->GetRegion(); 1804 if ( pRegion && aAction.IsBrowseActionStop() ) 1805 { 1806 //Nur dann interessant, wenn sich im sichtbaren Bereich etwas 1807 //veraendert hat. 1808 sal_Bool bStop = sal_True; 1809 for ( sal_uInt16 i = 0; i < pRegion->Count(); ++i ) 1810 { 1811 const SwRect &rTmp = (*pRegion)[i]; 1812 if ( sal_False == (bStop = rTmp.IsOver( VisArea() )) ) 1813 break; 1814 } 1815 if ( bStop ) 1816 { 1817 Imp()->DelRegion(); 1818 pRegion = 0; 1819 } 1820 } 1821 1822 if ( pRegion ) 1823 { 1824 //Erst Invert dann Compress, niemals andersherum! 1825 pRegion->Invert(); 1826 pRegion->Compress(); 1827 bRet = sal_False; 1828 if ( pRegion->Count() ) 1829 { 1830 SwRegionRects aRegion( rRect ); 1831 for ( sal_uInt16 i = 0; i < pRegion->Count(); ++i ) 1832 { const SwRect &rTmp = (*pRegion)[i]; 1833 if ( !rRect.IsInside( rTmp ) ) 1834 { 1835 InvalidateWindows( rTmp ); 1836 if ( rTmp.IsOver( VisArea() ) ) 1837 { aRegion -= rTmp; 1838 bRet = sal_True; 1839 } 1840 } 1841 } 1842 if ( bRet ) 1843 { 1844 for ( sal_uInt16 i = 0; i < aRegion.Count(); ++i ) 1845 GetWin()->Invalidate( aRegion[i].SVRect() ); 1846 1847 if ( rRect != VisArea() ) 1848 { 1849 //rRect == VisArea ist der spezialfall fuer neu bzw. 1850 //Shift-Ctrl-R, dafuer sollte es nicht notwendig sein 1851 //das Rechteck nocheinmal in Dokumentkoordinaten v 1852 //vorzuhalten. 1853 if ( aInvalidRect.IsEmpty() ) 1854 aInvalidRect = rRect; 1855 else 1856 aInvalidRect.Union( rRect ); 1857 } 1858 } 1859 } 1860 else 1861 bRet = sal_False; 1862 Imp()->DelRegion(); 1863 } 1864 else 1865 bRet = sal_False; 1866 } 1867 return bRet; 1868 } 1869 1870 /****************************************************************************** 1871 |* 1872 |* ViewShell::Paint() 1873 |* 1874 |* Ersterstellung MA ?? 1875 |* Letzte Aenderung MA 17. Sep. 96 1876 |* 1877 ******************************************************************************/ 1878 1879 void ViewShell::Paint(const Rectangle &rRect) 1880 { 1881 if ( nLockPaint ) 1882 { 1883 if ( Imp()->bSmoothUpdate ) 1884 { 1885 SwRect aTmp( rRect ); 1886 if ( !Imp()->aSmoothRect.IsInside( aTmp ) ) 1887 Imp()->bStopSmooth = sal_True; 1888 else 1889 { 1890 Imp()->aSmoothRect = aTmp; 1891 return; 1892 } 1893 } 1894 else 1895 return; 1896 } 1897 1898 if ( SwRootFrm::IsInPaint() ) 1899 { 1900 //Waehrend der Ausgabe einer Seite beim Druckvorgang wird das 1901 //Paint gepuffert. 1902 SwPaintQueue::Add( this, SwRect( rRect ) ); 1903 return; 1904 } 1905 1906 //MA 30. Jul. 95: fix(16787): mit !nStartAction versuche ich mal mich gegen 1907 //fehlerhaften Code an anderen Stellen zu wehren. Hoffentlich fuehrt das 1908 //nicht zu Problemen!? 1909 if ( bPaintWorks && !nStartAction ) 1910 { 1911 if( GetWin() && GetWin()->IsVisible() ) 1912 { 1913 SwRect aRect( rRect ); 1914 if ( bPaintInProgress ) //Schutz gegen doppelte Paints! 1915 { 1916 GetWin()->Invalidate( rRect ); 1917 return; 1918 } 1919 1920 bPaintInProgress = sal_True; 1921 SET_CURR_SHELL( this ); 1922 SwRootFrm::SetNoVirDev( sal_True ); 1923 1924 //Wir wollen nicht staendig hin und her Clippen, wir verlassen 1925 //uns darauf, das sich alle auf das Rechteck beschraeken und 1926 //brauchen das Clipping hier nur einmalig einkalkulieren. Das 1927 //ClipRect wird hier einmal entfernt und nicht Restauriert, denn 1928 //von aussen braucht es sowieso keiner mehr. 1929 //Nicht wenn wir ein MetaFile aufzeichnen. 1930 if( !GetOut()->GetConnectMetaFile() && GetOut()->IsClipRegion()) 1931 GetOut()->SetClipRegion(); 1932 1933 if ( IsPreView() ) 1934 { 1935 //Falls sinnvoll gleich das alte InvalidRect verarbeiten bzw. 1936 //vernichten. 1937 if ( aRect.IsInside( aInvalidRect ) ) 1938 ResetInvalidRect(); 1939 ViewShell::bLstAct = sal_True; 1940 GetLayout()->Paint( aRect ); 1941 ViewShell::bLstAct = sal_False; 1942 } 1943 else 1944 { 1945 //SwSaveHdl *pSaveHdl = 0; 1946 //if ( Imp()->HasDrawView() ) 1947 // pSaveHdl = new SwSaveHdl( Imp() ); 1948 1949 //Wenn eine der sichtbaren Seiten noch irgendetwas zum Repaint 1950 //angemeldet hat, so muessen Repaints ausgeloest werden. 1951 if ( !CheckInvalidForPaint( aRect ) ) 1952 { 1953 // --> OD 2009-08-12 #i101192# 1954 // start Pre/PostPaint encapsulation to avoid screen blinking 1955 const Region aRepaintRegion(aRect.SVRect()); 1956 DLPrePaint2(aRepaintRegion); 1957 // <-- 1958 PaintDesktop( aRect ); 1959 //Falls sinnvoll gleich das alte InvalidRect verarbeiten bzw. 1960 //vernichten. 1961 if ( aRect.IsInside( aInvalidRect ) ) 1962 ResetInvalidRect(); 1963 ViewShell::bLstAct = sal_True; 1964 GetLayout()->Paint( aRect ); 1965 ViewShell::bLstAct = sal_False; 1966 // --> OD 2009-08-12 #i101192# 1967 // end Pre/PostPaint encapsulation 1968 DLPostPaint2(true); 1969 // <-- 1970 } 1971 1972 //delete pSaveHdl; 1973 } 1974 SwRootFrm::SetNoVirDev( sal_False ); 1975 bPaintInProgress = sal_False; 1976 UISizeNotify(); 1977 } 1978 } 1979 else 1980 { 1981 if ( aInvalidRect.IsEmpty() ) 1982 aInvalidRect = SwRect( rRect ); 1983 else 1984 aInvalidRect.Union( SwRect( rRect ) ); 1985 1986 if ( bInEndAction && GetWin() ) 1987 { 1988 const Region aRegion(GetWin()->GetPaintRegion()); 1989 RectangleVector aRectangles; 1990 aRegion.GetRegionRectangles(aRectangles); 1991 1992 for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++) 1993 { 1994 Imp()->AddPaintRect(*aRectIter); 1995 } 1996 1997 //RegionHandle hHdl( aRegion.BeginEnumRects() ); 1998 //Rectangle aRect; 1999 //while ( aRegion.GetEnumRects( hHdl, aRect ) ) 2000 // Imp()->AddPaintRect( aRect ); 2001 //aRegion.EndEnumRects( hHdl ); 2002 } 2003 else if ( SfxProgress::GetActiveProgress( GetDoc()->GetDocShell() ) && 2004 GetOut() == GetWin() ) 2005 { 2006 // #i68597# 2007 const Region aDLRegion(rRect); 2008 DLPrePaint2(aDLRegion); 2009 2010 // OD 2004-04-23 #116347# 2011 pOut->Push( PUSH_FILLCOLOR|PUSH_LINECOLOR ); 2012 pOut->SetFillColor( Imp()->GetRetoucheColor() ); 2013 pOut->SetLineColor(); 2014 pOut->DrawRect( rRect ); 2015 pOut->Pop(); 2016 2017 // #i68597# 2018 DLPostPaint2(true); 2019 } 2020 } 2021 } 2022 2023 /****************************************************************************** 2024 |* 2025 |* ViewShell::SetBrowseBorder() 2026 |* 2027 |* Ersterstellung AMA 20. Aug. 96 2028 |* Letzte Aenderung AMA 20. Aug. 96 2029 |* 2030 ******************************************************************************/ 2031 2032 void ViewShell::SetBrowseBorder( const Size& rNew ) 2033 { 2034 if( rNew != aBrowseBorder ) 2035 { 2036 aBrowseBorder = rNew; 2037 if ( aVisArea.HasArea() ) 2038 CheckBrowseView( sal_False ); 2039 } 2040 } 2041 2042 const Size& ViewShell::GetBrowseBorder() const 2043 { 2044 return aBrowseBorder; 2045 } 2046 2047 sal_Int32 ViewShell::GetBrowseWidth() const 2048 { 2049 const SwPostItMgr* pPostItMgr = GetPostItMgr(); 2050 if ( pPostItMgr && pPostItMgr->HasNotes() && pPostItMgr->ShowNotes() ) 2051 { 2052 Size aBorder( aBrowseBorder ); 2053 aBorder.Width() += aBrowseBorder.Width(); 2054 aBorder.Width() += pPostItMgr->GetSidebarWidth(true) + pPostItMgr->GetSidebarBorderWidth(true); 2055 return aVisArea.Width() - GetOut()->PixelToLogic(aBorder).Width(); 2056 } 2057 else 2058 return aVisArea.Width() - 2 * GetOut()->PixelToLogic(aBrowseBorder).Width(); 2059 } 2060 2061 /****************************************************************************** 2062 |* 2063 |* ViewShell::CheckBrowseView() 2064 |* 2065 |* Ersterstellung MA 04. Mar. 96 2066 |* Letzte Aenderung MA 04. Jul. 96 2067 |* 2068 ******************************************************************************/ 2069 2070 void ViewShell::CheckBrowseView( sal_Bool bBrowseChgd ) 2071 { 2072 if ( !bBrowseChgd && !GetViewOptions()->getBrowseMode() ) 2073 return; 2074 2075 SET_CURR_SHELL( this ); 2076 2077 ASSERT( GetLayout(), "Layout not ready" ); 2078 2079 // Wenn das Layout noch nicht einmal eine Hoehe hat, 2080 // ist sowieso nichts formatiert. 2081 // Dann eruebrigt sich die Invalidierung 2082 // Falsch, z.B. beim Anlegen einer neuen View wird der Inhalt eingef?gt 2083 // und formatiert (trotz einer leeren VisArea). Hier muessen deshalb 2084 // die Seiten zur Formatierung angeregt werden. 2085 if( !GetLayout()->Frm().Height() ) 2086 { 2087 SwFrm* pPage = GetLayout()->Lower(); 2088 while( pPage ) 2089 { 2090 pPage->_InvalidateSize(); 2091 pPage = pPage->GetNext(); 2092 } 2093 return; 2094 } 2095 2096 LockPaint(); 2097 StartAction(); 2098 2099 SwPageFrm *pPg = (SwPageFrm*)GetLayout()->Lower(); 2100 do 2101 { pPg->InvalidateSize(); 2102 pPg->_InvalidatePrt(); 2103 pPg->InvaPercentLowers(); 2104 if ( bBrowseChgd ) 2105 { 2106 pPg->PrepareHeader(); 2107 pPg->PrepareFooter(); 2108 } 2109 pPg = (SwPageFrm*)pPg->GetNext(); 2110 } while ( pPg ); 2111 2112 // Wenn sich die Groessenverhaeltnise im BrowseModus aendern, 2113 // muss die Position und PrtArea der Cntnt- und Tab-Frames invalidiert werden. 2114 sal_uInt8 nInv = INV_PRTAREA | INV_TABLE | INV_POS; 2115 // Beim BrowseModus-Wechsel benoetigen die CntntFrms 2116 // wg. der Drucker/Bildschirmformatierung eine Size-Invalidierung 2117 if( bBrowseChgd ) 2118 nInv |= INV_SIZE | INV_DIRECTION; 2119 2120 GetLayout()->InvalidateAllCntnt( nInv ); 2121 2122 SwFrm::CheckPageDescs( (SwPageFrm*)GetLayout()->Lower() ); 2123 2124 EndAction(); 2125 UnlockPaint(); 2126 } 2127 2128 /************************************************************************* 2129 |* 2130 |* ViewShell::GetLayout() 2131 |* ViewShell::GetNodes() 2132 |* 2133 |* Ersterstellung OK 26. May. 92 2134 |* Letzte Aenderung MA 16. Sep. 93 2135 |* 2136 *************************************************************************/ 2137 2138 SwRootFrm *ViewShell::GetLayout() const 2139 { 2140 return pLayout.get(); //swmod 080116 2141 } 2142 /***********************************************************************/ 2143 2144 OutputDevice& ViewShell::GetRefDev() const 2145 { 2146 OutputDevice* pTmpOut = 0; 2147 if ( GetWin() && 2148 GetViewOptions()->getBrowseMode() && 2149 !GetViewOptions()->IsPrtFormat() ) 2150 pTmpOut = GetWin(); 2151 else if ( 0 != mpTmpRef ) 2152 pTmpOut = mpTmpRef; 2153 else 2154 pTmpOut = GetDoc()->getReferenceDevice( true ); 2155 2156 return *pTmpOut; 2157 } 2158 2159 const SwNodes& ViewShell::GetNodes() const 2160 { 2161 return pDoc->GetNodes(); 2162 } 2163 2164 2165 void ViewShell::DrawSelChanged() 2166 { 2167 } 2168 2169 2170 Size ViewShell::GetDocSize() const 2171 { 2172 Size aSz; 2173 const SwRootFrm* pRoot = GetLayout(); 2174 if( pRoot ) 2175 aSz = pRoot->Frm().SSize(); 2176 2177 return aSz; 2178 } 2179 2180 2181 SfxItemPool& ViewShell::GetAttrPool() 2182 { 2183 return GetDoc()->GetAttrPool(); 2184 } 2185 2186 /****************************************************************************** 2187 |* 2188 |* ViewShell::ApplyViewOptions(), ImplApplyViewOptions() 2189 |* 2190 |* Ersterstellung ?? 2191 |* Letzte Aenderung MA 03. Mar. 98 2192 |* 2193 ******************************************************************************/ 2194 2195 void ViewShell::ApplyViewOptions( const SwViewOption &rOpt ) 2196 { 2197 2198 ViewShell *pSh = this; 2199 do 2200 { pSh->StartAction(); 2201 pSh = (ViewShell*)pSh->GetNext(); 2202 } while ( pSh != this ); 2203 2204 ImplApplyViewOptions( rOpt ); 2205 2206 // swmod 080115 2207 // With one layout per view it is not longer necessary 2208 // to sync these "layout related" view options 2209 // But as long as we have to disable "multiple layout" 2210 pSh = (ViewShell*)this->GetNext(); 2211 while ( pSh != this ) 2212 { 2213 SwViewOption aOpt( *pSh->GetViewOptions() ); 2214 aOpt.SetFldName( rOpt.IsFldName() ); 2215 aOpt.SetShowHiddenField( rOpt.IsShowHiddenField() ); 2216 aOpt.SetShowHiddenPara( rOpt.IsShowHiddenPara() ); 2217 aOpt.SetShowHiddenChar( rOpt.IsShowHiddenChar() ); 2218 aOpt.SetViewLayoutBookMode( rOpt.IsViewLayoutBookMode() ); 2219 aOpt.SetViewLayoutColumns( rOpt.GetViewLayoutColumns() ); 2220 aOpt.SetPostIts(rOpt.IsPostIts()); 2221 if ( !(aOpt == *pSh->GetViewOptions()) ) 2222 pSh->ImplApplyViewOptions( aOpt ); 2223 pSh = (ViewShell*)pSh->GetNext(); 2224 } 2225 // End of disabled multiple window 2226 2227 pSh = this; 2228 do 2229 { pSh->EndAction(); 2230 pSh = (ViewShell*)pSh->GetNext(); 2231 } while ( pSh != this ); 2232 2233 } 2234 2235 void ViewShell::ImplApplyViewOptions( const SwViewOption &rOpt ) 2236 { 2237 if (*pOpt == rOpt) 2238 return; 2239 2240 Window *pMyWin = GetWin(); 2241 if( !pMyWin ) 2242 { 2243 ASSERT( pMyWin, "ViewShell::ApplyViewOptions: no window" ); 2244 return; 2245 } 2246 2247 SET_CURR_SHELL( this ); 2248 2249 sal_Bool bReformat = sal_False; 2250 2251 if( pOpt->IsShowHiddenField() != rOpt.IsShowHiddenField() ) 2252 { 2253 ((SwHiddenTxtFieldType*)pDoc->GetSysFldType( RES_HIDDENTXTFLD ))-> 2254 SetHiddenFlag( !rOpt.IsShowHiddenField() ); 2255 bReformat = sal_True; 2256 } 2257 if ( pOpt->IsShowHiddenPara() != rOpt.IsShowHiddenPara() ) 2258 { 2259 SwHiddenParaFieldType* pFldType = (SwHiddenParaFieldType*)GetDoc()-> 2260 GetSysFldType(RES_HIDDENPARAFLD); 2261 if( pFldType && pFldType->GetDepends() ) 2262 { 2263 SwMsgPoolItem aHnt( RES_HIDDENPARA_PRINT ); 2264 pFldType->ModifyNotification( &aHnt, 0); 2265 } 2266 bReformat = sal_True; 2267 } 2268 if ( !bReformat && pOpt->IsShowHiddenChar() != rOpt.IsShowHiddenChar() ) 2269 { 2270 bReformat = GetDoc()->ContainsHiddenChars(); 2271 } 2272 2273 // bReformat wird sal_True, wenn ... 2274 // - Feldnamen anzeigen oder nicht ... 2275 // ( - SwEndPortion muessen _nicht_ mehr generiert werden. ) 2276 // - Das Window ist natuerlich was ganz anderes als der Drucker... 2277 bReformat = bReformat || pOpt->IsFldName() != rOpt.IsFldName(); 2278 2279 // Der Mapmode wird veraendert, Minima/Maxima werden von der UI beachtet 2280 if( pOpt->GetZoom() != rOpt.GetZoom() && !IsPreView() ) 2281 { 2282 MapMode aMode( pMyWin->GetMapMode() ); 2283 Fraction aNewFactor( rOpt.GetZoom(), 100 ); 2284 aMode.SetScaleX( aNewFactor ); 2285 aMode.SetScaleY( aNewFactor ); 2286 pMyWin->SetMapMode( aMode ); 2287 // Wenn kein ReferenzDevice (Drucker) zum Formatieren benutzt wird, 2288 // sondern der Bildschirm, muss bei Zoomfaktoraenderung neu formatiert 2289 // werden. 2290 if( pOpt->getBrowseMode() ) 2291 bReformat = sal_True; 2292 } 2293 2294 bool bBrowseModeChanged = false; 2295 if( pOpt->getBrowseMode() != rOpt.getBrowseMode() ) 2296 { 2297 bBrowseModeChanged = true; 2298 bReformat = sal_True; 2299 } 2300 else if( pOpt->getBrowseMode() && pOpt->IsPrtFormat() != rOpt.IsPrtFormat() ) 2301 bReformat = sal_True; 2302 2303 if ( HasDrawView() || rOpt.IsGridVisible() ) 2304 { 2305 if ( !HasDrawView() ) 2306 MakeDrawView(); 2307 2308 SwDrawView *pDView = Imp()->GetDrawView(); 2309 if ( pDView->IsDragStripes() != rOpt.IsCrossHair() ) 2310 pDView->SetDragStripes( rOpt.IsCrossHair() ); 2311 2312 if ( pDView->IsGridSnap() != rOpt.IsSnap() ) 2313 pDView->SetGridSnap( rOpt.IsSnap() ); 2314 2315 if ( pDView->IsGridVisible() != rOpt.IsGridVisible() ) 2316 pDView->SetGridVisible( rOpt.IsGridVisible() ); 2317 2318 const Size &rSz = rOpt.GetSnapSize(); 2319 pDView->SetGridCoarse( rSz ); 2320 2321 const Size aFSize 2322 ( rSz.Width() ? rSz.Width() / (rOpt.GetDivisionX()+1) : 0, 2323 rSz.Height()? rSz.Height()/ (rOpt.GetDivisionY()+1) : 0); 2324 pDView->SetGridFine( aFSize ); 2325 Fraction aSnGrWdtX(rSz.Width(), rOpt.GetDivisionX() + 1); 2326 Fraction aSnGrWdtY(rSz.Height(), rOpt.GetDivisionY() + 1); 2327 pDView->SetSnapGridWidth( aSnGrWdtX, aSnGrWdtY ); 2328 2329 if ( pOpt->IsSolidMarkHdl() != rOpt.IsSolidMarkHdl() ) 2330 pDView->SetSolidMarkHdl( rOpt.IsSolidMarkHdl() ); 2331 2332 // it's a JOE interface ! 2333 if ( pOpt->IsBigMarkHdl() != rOpt.IsBigMarkHdl() ) 2334 pDView->SetMarkHdlSizePixel(rOpt.IsBigMarkHdl() ? 9 : 7); 2335 } 2336 2337 sal_Bool bOnlineSpellChgd = pOpt->IsOnlineSpell() != rOpt.IsOnlineSpell(); 2338 2339 *pOpt = rOpt; // Erst jetzt werden die Options uebernommen. 2340 pOpt->SetUIOptions(rOpt); 2341 2342 pDoc->set(IDocumentSettingAccess::HTML_MODE, 0 != ::GetHtmlMode(pDoc->GetDocShell())); 2343 2344 if( bBrowseModeChanged ) 2345 { 2346 // --> FME 2005-03-16 #i44963# Good occasion to check if page sizes in 2347 // page descriptions are still set to (LONG_MAX, LONG_MAX) (html import) 2348 pDoc->CheckDefaultPageFmt(); 2349 // <-- 2350 CheckBrowseView( sal_True ); 2351 } 2352 2353 pMyWin->Invalidate(); 2354 if ( bReformat ) 2355 { 2356 // Es hilft alles nichts, wir muessen an alle CntntFrms ein 2357 // Prepare verschicken, wir formatieren neu: 2358 StartAction(); 2359 Reformat(); 2360 EndAction(); 2361 } 2362 2363 if( bOnlineSpellChgd ) 2364 { 2365 ViewShell *pSh = (ViewShell*)this->GetNext(); 2366 sal_Bool bOnlineSpl = rOpt.IsOnlineSpell(); 2367 while( pSh != this ) 2368 { pSh->pOpt->SetOnlineSpell( bOnlineSpl ); 2369 Window *pTmpWin = pSh->GetWin(); 2370 if( pTmpWin ) 2371 pTmpWin->Invalidate(); 2372 pSh = (ViewShell*)pSh->GetNext(); 2373 } 2374 } 2375 2376 } 2377 2378 /****************************************************************************** 2379 |* 2380 |* ViewShell::SetUIOptions() 2381 |* 2382 |* Ersterstellung OS 29.07.96 2383 |* Letzte Aenderung OS 29.07.96 2384 |* 2385 ******************************************************************************/ 2386 2387 void ViewShell::SetUIOptions( const SwViewOption &rOpt ) 2388 { 2389 pOpt->SetUIOptions(rOpt); 2390 //the API-Flag of the view options is set but never reset 2391 //it is required to set scroll bars in readonly documents 2392 if(rOpt.IsStarOneSetting()) 2393 pOpt->SetStarOneSetting(sal_True); 2394 2395 pOpt->SetSymbolFont(rOpt.GetSymbolFont()); 2396 } 2397 2398 /****************************************************************************** 2399 |* 2400 |* ViewShell::SetReadonly() 2401 |* 2402 |* Ersterstellung OS 05.09.96 2403 |* Letzte Aenderung MA 12. Feb. 97 2404 |* 2405 ******************************************************************************/ 2406 2407 void ViewShell::SetReadonlyOption(sal_Bool bSet) 2408 { 2409 //JP 01.02.99: bei ReadOnly Flag richtig abfragen und ggfs. neu 2410 // formatieren; Bug 61335 2411 2412 // Schalten wir gerade von Readonly auf Bearbeiten um? 2413 if( bSet != pOpt->IsReadonly() ) 2414 { 2415 // damit die Flags richtig erfragt werden koennen. 2416 pOpt->SetReadonly( sal_False ); 2417 2418 sal_Bool bReformat = pOpt->IsFldName(); 2419 2420 pOpt->SetReadonly( bSet ); 2421 2422 if( bReformat ) 2423 { 2424 StartAction(); 2425 Reformat(); 2426 if ( GetWin() ) 2427 GetWin()->Invalidate(); 2428 EndAction(); 2429 } 2430 else if ( GetWin() ) 2431 GetWin()->Invalidate(); 2432 if( Imp()->IsAccessible() ) 2433 Imp()->InvalidateAccessibleEditableState( sal_False ); 2434 } 2435 } 2436 /* -----------------28.08.2003 15:45----------------- 2437 2438 --------------------------------------------------*/ 2439 void ViewShell::SetPDFExportOption(sal_Bool bSet) 2440 { 2441 if( bSet != pOpt->IsPDFExport() ) 2442 { 2443 if( bSet && pOpt->getBrowseMode() ) 2444 pOpt->SetPrtFormat( sal_True ); 2445 pOpt->SetPDFExport(bSet); 2446 } 2447 } 2448 /* -----------------------------2002/07/31 17:06------------------------------ 2449 2450 ---------------------------------------------------------------------------*/ 2451 void ViewShell::SetReadonlySelectionOption(sal_Bool bSet) 2452 { 2453 if( bSet != pOpt->IsSelectionInReadonly() ) 2454 { 2455 pOpt->SetSelectionInReadonly(bSet); 2456 } 2457 } 2458 /****************************************************************************** 2459 |* 2460 |* ViewShell::SetPrtFormatOption() 2461 |* 2462 |* Ersterstellung AMA 10. Sep. 97 2463 |* Letzte Aenderung AMA 10. Sep. 97 2464 |* 2465 ******************************************************************************/ 2466 2467 void ViewShell::SetPrtFormatOption( sal_Bool bSet ) 2468 { 2469 pOpt->SetPrtFormat( bSet ); 2470 } 2471 2472 /****************************************************************************** 2473 |* 2474 |* ViewShell::UISizeNotify() 2475 |* 2476 |* Ersterstellung MA 14. Jan. 97 2477 |* Letzte Aenderung MA 14. Jan. 97 2478 |* 2479 ******************************************************************************/ 2480 2481 2482 void ViewShell::UISizeNotify() 2483 { 2484 if ( bDocSizeChgd ) 2485 { 2486 bDocSizeChgd = sal_False; 2487 sal_Bool bOld = bInSizeNotify; 2488 bInSizeNotify = sal_True; 2489 ::SizeNotify( this, GetDocSize() ); 2490 bInSizeNotify = bOld; 2491 } 2492 } 2493 2494 2495 void ViewShell::SetRestoreActions(sal_uInt16 nSet) 2496 { 2497 DBG_ASSERT(!GetRestoreActions()||!nSet, "mehrfaches Restore der Actions ?"); 2498 Imp()->SetRestoreActions(nSet); 2499 } 2500 sal_uInt16 ViewShell::GetRestoreActions() const 2501 { 2502 return Imp()->GetRestoreActions(); 2503 } 2504 2505 sal_Bool ViewShell::IsNewLayout() const 2506 { 2507 return GetLayout()->IsNewLayout(); 2508 } 2509 2510 uno::Reference< ::com::sun::star::accessibility::XAccessible > ViewShell::CreateAccessible() 2511 { 2512 uno::Reference< ::com::sun::star::accessibility::XAccessible > xAcc; 2513 2514 // We require a layout and an XModel to be accessible. 2515 ASSERT( pLayout, "no layout, no access" ); 2516 ASSERT( GetWin(), "no window, no access" ); 2517 2518 if( pDoc->GetCurrentViewShell() && GetWin() ) //swmod 071108 2519 xAcc = Imp()->GetAccessibleMap().GetDocumentView(); 2520 2521 return xAcc; 2522 } 2523 2524 uno::Reference< ::com::sun::star::accessibility::XAccessible > 2525 ViewShell::CreateAccessiblePreview() 2526 { 2527 DBG_ASSERT( IsPreView(), 2528 "Can't create accessible preview for non-preview ViewShell" ); 2529 2530 // We require a layout and an XModel to be accessible. 2531 ASSERT( pLayout, "no layout, no access" ); 2532 ASSERT( GetWin(), "no window, no access" ); 2533 2534 // OD 15.01.2003 #103492# - add condition <IsPreView()> 2535 if ( IsPreView() && GetLayout()&& GetWin() ) 2536 { 2537 // OD 14.01.2003 #103492# - adjustment for new method signature 2538 return Imp()->GetAccessibleMap().GetDocumentPreview( 2539 PagePreviewLayout()->maPrevwPages, 2540 GetWin()->GetMapMode().GetScaleX(), 2541 GetLayout()->GetPageByPageNum( PagePreviewLayout()->mnSelectedPageNum ), 2542 PagePreviewLayout()->maWinSize ); //swmod 080305 2543 } 2544 return NULL; 2545 } 2546 2547 void ViewShell::InvalidateAccessibleFocus() 2548 { 2549 if( Imp()->IsAccessible() ) 2550 Imp()->GetAccessibleMap().InvalidateFocus(); 2551 } 2552 2553 /** invalidate CONTENT_FLOWS_FROM/_TO relation for paragraphs 2554 2555 OD 2005-12-01 #i27138# 2556 2557 @author OD 2558 */ 2559 void ViewShell::InvalidateAccessibleParaFlowRelation( const SwTxtFrm* _pFromTxtFrm, 2560 const SwTxtFrm* _pToTxtFrm ) 2561 { 2562 if ( GetLayout() && GetLayout()->IsAnyShellAccessible() ) 2563 { 2564 Imp()->_InvalidateAccessibleParaFlowRelation( _pFromTxtFrm, _pToTxtFrm ); 2565 } 2566 } 2567 2568 /** invalidate text selection for paragraphs 2569 2570 OD 2005-12-12 #i27301# 2571 2572 @author OD 2573 */ 2574 void ViewShell::InvalidateAccessibleParaTextSelection() 2575 { 2576 if ( GetLayout() && GetLayout()->IsAnyShellAccessible() ) 2577 { 2578 Imp()->_InvalidateAccessibleParaTextSelection(); 2579 } 2580 } 2581 2582 /** invalidate attributes for paragraphs 2583 2584 OD 2009-01-06 #i88069# 2585 2586 @author OD 2587 */ 2588 void ViewShell::InvalidateAccessibleParaAttrs( const SwTxtFrm& rTxtFrm ) 2589 { 2590 if ( GetLayout() && GetLayout()->IsAnyShellAccessible() ) 2591 { 2592 Imp()->_InvalidateAccessibleParaAttrs( rTxtFrm ); 2593 } 2594 } 2595 2596 SwAccessibleMap* ViewShell::GetAccessibleMap() 2597 { 2598 if ( Imp()->IsAccessible() ) 2599 { 2600 return &(Imp()->GetAccessibleMap()); 2601 } 2602 2603 return 0; 2604 } 2605 /* -----------------------------06.05.2002 13:23------------------------------ 2606 2607 ---------------------------------------------------------------------------*/ 2608 void ViewShell::ApplyAccessiblityOptions(SvtAccessibilityOptions& rAccessibilityOptions) 2609 { 2610 if(pOpt->IsPagePreview() && !rAccessibilityOptions.GetIsForPagePreviews()) 2611 { 2612 pAccOptions->SetAlwaysAutoColor(sal_False); 2613 pAccOptions->SetStopAnimatedGraphics(sal_False); 2614 pAccOptions->SetStopAnimatedText(sal_False); 2615 } 2616 else 2617 { 2618 pAccOptions->SetAlwaysAutoColor(rAccessibilityOptions.GetIsAutomaticFontColor()); 2619 pAccOptions->SetStopAnimatedGraphics(! rAccessibilityOptions.GetIsAllowAnimatedGraphics()); 2620 pAccOptions->SetStopAnimatedText(! rAccessibilityOptions.GetIsAllowAnimatedText()); 2621 2622 // --> FME 2004-06-29 #114856# Formular view 2623 // Always set this option, not only if document is read-only: 2624 pOpt->SetSelectionInReadonly(rAccessibilityOptions.IsSelectionInReadonly()); 2625 } 2626 } 2627 2628 ShellResource* ViewShell::GetShellRes() 2629 { 2630 return pShellRes; 2631 } 2632 2633 void ViewShell::SetCareWin( Window* pNew ) 2634 { 2635 pCareWindow = pNew; 2636 } 2637 2638 sal_uInt16 ViewShell::GetPageCount() const 2639 { 2640 return GetLayout() ? GetLayout()->GetPageNum() : 1; 2641 } 2642 2643 const Size ViewShell::GetPageSize( sal_uInt16 nPageNum, bool bSkipEmptyPages ) const 2644 { 2645 Size aSize; 2646 const SwRootFrm* pTmpRoot = GetLayout(); 2647 if( pTmpRoot && nPageNum ) 2648 { 2649 const SwPageFrm* pPage = static_cast<const SwPageFrm*> 2650 (pTmpRoot->Lower()); 2651 2652 while( --nPageNum && pPage->GetNext() ) 2653 pPage = static_cast<const SwPageFrm*>( pPage->GetNext() ); 2654 2655 if( !bSkipEmptyPages && pPage->IsEmptyPage() && pPage->GetNext() ) 2656 pPage = static_cast<const SwPageFrm*>( pPage->GetNext() ); 2657 2658 aSize = pPage->Frm().SSize(); 2659 } 2660 return aSize; 2661 } 2662 2663 // --> FME 2004-06-15 #i12836# enhanced pdf export 2664 sal_Int32 ViewShell::GetPageNumAndSetOffsetForPDF( OutputDevice& rOut, const SwRect& rRect ) const 2665 { 2666 ASSERT( GetLayout(), "GetPageNumAndSetOffsetForPDF assumes presence of layout" ) 2667 2668 sal_Int32 nRet = -1; 2669 2670 // --> FME 2005-01-07 #i40059# Position out of bounds: 2671 SwRect aRect( rRect ); 2672 aRect.Pos().X() = Max( aRect.Left(), GetLayout()->Frm().Left() ); 2673 // <-- 2674 2675 const SwPageFrm* pPage = GetLayout()->GetPageAtPos( aRect.Center() ); 2676 if ( pPage ) 2677 { 2678 ASSERT( pPage, "GetPageNumAndSetOffsetForPDF: No page found" ) 2679 2680 Point aOffset( pPage->Frm().Pos() ); 2681 aOffset.X() = -aOffset.X(); 2682 aOffset.Y() = -aOffset.Y(); 2683 2684 MapMode aMapMode( rOut.GetMapMode() ); 2685 aMapMode.SetOrigin( aOffset ); 2686 rOut.SetMapMode( aMapMode ); 2687 2688 nRet = pPage->GetPhyPageNum() - 1; 2689 } 2690 2691 return nRet; 2692 } 2693 // <-- 2694 2695 // --> PB 2007-05-30 #146850# 2696 const BitmapEx& ViewShell::GetReplacementBitmap( bool bIsErrorState ) 2697 { 2698 BitmapEx** ppRet; 2699 sal_uInt16 nResId = 0, nHCResId = 0; 2700 if( bIsErrorState ) 2701 { 2702 ppRet = &pErrorBmp; 2703 nResId = RID_GRAPHIC_ERRORBMP; 2704 nHCResId = RID_GRAPHIC_ERRORBMP_HC; 2705 } 2706 else 2707 { 2708 ppRet = &pReplaceBmp; 2709 nResId = RID_GRAPHIC_REPLACEBMP; 2710 nHCResId = RID_GRAPHIC_REPLACEBMP_HC; 2711 } 2712 2713 if( !*ppRet ) 2714 { 2715 sal_uInt16 nBmpResId = 2716 Application::GetSettings().GetStyleSettings().GetHighContrastMode() 2717 ? nHCResId : nResId; 2718 *ppRet = new BitmapEx( SW_RES( nBmpResId ) ); 2719 } 2720 return **ppRet; 2721 } 2722 2723 void ViewShell::DeleteReplacementBitmaps() 2724 { 2725 DELETEZ( pErrorBmp ); 2726 DELETEZ( pReplaceBmp ); 2727 } 2728 // <-- 2729 2730 SwPostItMgr* ViewShell::GetPostItMgr() 2731 { 2732 SwView* pView = GetDoc()->GetDocShell() ? GetDoc()->GetDocShell()->GetView() : 0; 2733 if ( pView ) 2734 return pView->GetPostItMgr(); 2735 2736 return 0; 2737 } 2738 2739 /* 2740 * Document Interface Access 2741 */ 2742 const IDocumentSettingAccess* ViewShell::getIDocumentSettingAccess() const { return pDoc; } 2743 IDocumentSettingAccess* ViewShell::getIDocumentSettingAccess() { return pDoc; } 2744 const IDocumentDeviceAccess* ViewShell::getIDocumentDeviceAccess() const { return pDoc; } 2745 IDocumentDeviceAccess* ViewShell::getIDocumentDeviceAccess() { return pDoc; } 2746 const IDocumentMarkAccess* ViewShell::getIDocumentMarkAccess() const { return pDoc->getIDocumentMarkAccess(); } 2747 IDocumentMarkAccess* ViewShell::getIDocumentMarkAccess() { return pDoc->getIDocumentMarkAccess(); } 2748 const IDocumentDrawModelAccess* ViewShell::getIDocumentDrawModelAccess() const { return pDoc; } 2749 IDocumentDrawModelAccess* ViewShell::getIDocumentDrawModelAccess() { return pDoc; } 2750 const IDocumentRedlineAccess* ViewShell::getIDocumentRedlineAccess() const { return pDoc; } 2751 IDocumentRedlineAccess* ViewShell::getIDocumentRedlineAccess() { return pDoc; } 2752 const IDocumentLayoutAccess* ViewShell::getIDocumentLayoutAccess() const { return pDoc; } 2753 IDocumentLayoutAccess* ViewShell::getIDocumentLayoutAccess() { return pDoc; } 2754 const IDocumentFieldsAccess* ViewShell::getIDocumentFieldsAccess() const { return pDoc; } 2755 IDocumentContentOperations* ViewShell::getIDocumentContentOperations() { return pDoc; } 2756 IDocumentStylePoolAccess* ViewShell::getIDocumentStylePoolAccess() { return pDoc; } 2757 const IDocumentStatistics* ViewShell::getIDocumentStatistics() const { return pDoc; } 2758 2759 IDocumentUndoRedo & ViewShell::GetIDocumentUndoRedo() 2760 { return pDoc->GetIDocumentUndoRedo(); } 2761 IDocumentUndoRedo const& ViewShell::GetIDocumentUndoRedo() const 2762 { return pDoc->GetIDocumentUndoRedo(); } 2763 2764 // --> OD 2007-11-14 #i83479# 2765 const IDocumentListItems* ViewShell::getIDocumentListItemsAccess() const 2766 { 2767 return pDoc; 2768 } 2769 const IDocumentOutlineNodes* ViewShell::getIDocumentOutlineNodesAccess() const 2770 { 2771 return pDoc; 2772 } 2773 // <-- 2774