svx/source/svdraw/svdpntv.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/awt/XWindow.hpp>
  21 #include <svx/svdpntv.hxx>
  22 #include <vcl/msgbox.hxx>
  23 #include <svx/sdrpaintwindow.hxx>
  24 #include <svtools/grfmgr.hxx>
  25 #include <svx/svdmodel.hxx>
  26
  27 #ifdef DBG_UTIL
  28 #include <svdibrow.hxx>
  29 #endif
  30 #include <svx/svdpage.hxx>
  31 #include <svx/svdpagv.hxx>
  32 #include <svl/smplhint.hxx>
  33
  34 #include <editeng/editdata.hxx>
  35 #include <svx/svdmrkv.hxx>
  36 #include <svx/svdundo.hxx>
  37 #include <svx/svdview.hxx>
  38 #include <svx/svdglue.hxx>
  39 #include <svx/svdobj.hxx>
  40 #include <svx/svdograf.hxx>
  41 #include <svx/svdattrx.hxx>
  42 #include "svdibrow.hxx"
  43 #include "svx/svditer.hxx"
  44 #include <svx/svdouno.hxx>
  45 #include <svx/sdr/overlay/overlayobjectlist.hxx>
  46 #include <svx/sdr/overlay/overlayrollingrectangle.hxx>
  47 #include <svx/sdr/overlay/overlaymanager.hxx>
  48 #include <svx/sxlayitm.hxx>
  49 #include <svl/itemiter.hxx>
  50 #include <editeng/eeitem.hxx>
  51 #include <svl/whiter.hxx>
  52 #include <svl/style.hxx>
  53 #include <svx/sdrpagewindow.hxx>
  54 #include <vcl/svapp.hxx>
  55 #include <com/sun/star/awt/PosSize.hpp>
  56 #include <com/sun/star/awt/XControl.hpp>
  57 #include <svx/sdr/contact/objectcontact.hxx>
  58 #include <svx/sdr/animation/objectanimator.hxx>
  59 #include <svx/sdr/contact/viewcontact.hxx>
  60 #include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
  61 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  62
  63 using namespace ::rtl;
  64 using namespace ::com::sun::star;
  65
  66 ////////////////////////////////////////////////////////////////////////////////////////////////////
  67 // interface to SdrPaintWindow
  68
  69 SdrPaintWindow* SdrPaintView::FindPaintWindow(const OutputDevice& rOut) const
  70 {
  71     for(SdrPaintWindowVector::const_iterator a = maPaintWindows.begin(); a != maPaintWindows.end(); ++a)
  72     {
  73         if(&((*a)->GetOutputDevice()) == &rOut)
  74         {
  75             return *a;
  76         }
  77     }
  78
  79     return 0L;
  80 }
  81
  82 SdrPaintWindow* SdrPaintView::GetPaintWindow(sal_uInt32 nIndex) const
  83 {
  84     if(nIndex < maPaintWindows.size())
  85     {
  86         return maPaintWindows[nIndex];
  87     }
  88
  89     return 0L;
  90 }
  91
  92 void SdrPaintView::AppendPaintWindow(SdrPaintWindow& rNew)
  93 {
  94     maPaintWindows.push_back(&rNew);
  95 }
  96
  97 SdrPaintWindow* SdrPaintView::RemovePaintWindow(SdrPaintWindow& rOld)
  98 {
  99     SdrPaintWindow* pRetval = 0L;
 100     const SdrPaintWindowVector::iterator aFindResult = ::std::find(maPaintWindows.begin(), maPaintWindows.end(), &rOld);
 101
 102     if(aFindResult != maPaintWindows.end())
 103     {
 104         // remember return value, aFindResult is no longer valid after deletion
 105         pRetval = *aFindResult;
 106         maPaintWindows.erase(aFindResult);
 107     }
 108
 109     return pRetval;
 110 }
 111
 112 OutputDevice* SdrPaintView::GetFirstOutputDevice() const
 113 {
 114     if(PaintWindowCount())
 115     {
 116         return &(GetPaintWindow(0)->GetOutputDevice());
 117     }
 118
 119     return 0L;
 120 }
 121
 122 ////////////////////////////////////////////////////////////////////////////////////////////////////
 123
 124 TYPEINIT1( SvxViewHint, SfxHint );
 125
 126 SvxViewHint::SvxViewHint (HintType eHintType)
 127     : meHintType(eHintType)
 128 {
 129 }
 130
 131 SvxViewHint::HintType SvxViewHint::GetHintType (void) const
 132 {
 133     return meHintType;
 134 }
 135
 136
 137 ////////////////////////////////////////////////////////////////////////////////////////////////////
 138
 139 BitmapEx convertMetafileToBitmapEx(
 140     const GDIMetaFile& rMtf,
 141     const basegfx::B2DRange& rTargetRange,
 142     const sal_uInt32 nMaximumQuadraticPixels)
 143 {
 144     BitmapEx aBitmapEx;
 145
 146     if(rMtf.GetActionSize())
 147     {
 148         const drawinglayer::primitive2d::Primitive2DReference aMtf(
 149             new drawinglayer::primitive2d::MetafilePrimitive2D(
 150                 basegfx::tools::createScaleTranslateB2DHomMatrix(
 151                     rTargetRange.getRange(),
 152                     rTargetRange.getMinimum()),
 153                 rMtf));
 154         aBitmapEx = convertPrimitive2DSequenceToBitmapEx(
 155             drawinglayer::primitive2d::Primitive2DSequence(&aMtf, 1),
 156             rTargetRange,
 157             nMaximumQuadraticPixels);
 158     }
 159
 160     return aBitmapEx;
 161 }
 162
 163 ////////////////////////////////////////////////////////////////////////////////////////////////////
 164
 165 TYPEINIT2(SdrPaintView,SfxListener,SfxRepeatTarget);
 166
 167 DBG_NAME(SdrPaintView);
 168
 169 void SdrPaintView::ImpClearVars()
 170 {
 171 #ifdef DBG_UTIL
 172     pItemBrowser=NULL;
 173 #endif
 174     bPageVisible=sal_True;
 175     bPageBorderVisible=sal_True;
 176     bBordVisible=sal_True;
 177     bGridVisible=sal_True;
 178     bGridFront  =sal_False;
 179     bHlplVisible=sal_True;
 180     bHlplFront  =sal_True;
 181     bGlueVisible=sal_False;
 182     bGlueVisible2=sal_False;
 183     bGlueVisible3=sal_False;
 184     bGlueVisible4=sal_False;
 185     bSwapAsynchron=sal_False;
 186     bPrintPreview=sal_False;
 187     mbPreviewRenderer=sal_False;
 188
 189     eAnimationMode = SDR_ANIMATION_ANIMATE;
 190     bAnimationPause = sal_False;
 191
 192     nHitTolPix=2;
 193     nMinMovPix=3;
 194     nHitTolLog=0;
 195     nMinMovLog=0;
 196     pActualOutDev=NULL;
 197     pDragWin=NULL;
 198     bRestoreColors=sal_True;
 199     pDefaultStyleSheet=NULL;
 200     bSomeObjChgdFlag=sal_False;
 201     nGraphicManagerDrawMode = GRFMGR_DRAW_STANDARD;
 202     aComeBackTimer.SetTimeout(1);
 203     aComeBackTimer.SetTimeoutHdl(LINK(this,SdrPaintView,ImpComeBackHdl));
 204
 205     if (pMod)
 206         SetDefaultStyleSheet(pMod->GetDefaultStyleSheet(), sal_True);
 207
 208     maGridColor = Color( COL_BLACK );
 209 }
 210
 211 SdrPaintView::SdrPaintView(SdrModel* pModel1, OutputDevice* pOut)
 212 :   mpPageView(NULL),
 213     aDefaultAttr(pModel1->GetItemPool()),
 214     mbBufferedOutputAllowed(false),
 215     mbBufferedOverlayAllowed(false),
 216     mbPagePaintingAllowed(true),
 217     mbHideOle(false),
 218     mbHideChart(false),
 219     mbHideDraw(false),
 220     mbHideFormControl(false)
 221 {
 222     DBG_CTOR(SdrPaintView,NULL);
 223     pMod=pModel1;
 224     ImpClearVars();
 225
 226     if(pOut)
 227     {
 228         AddWindowToPaintView(pOut);
 229     }
 230
 231     // flag to visualize groups
 232     bVisualizeEnteredGroup = sal_True;
 233
 234     maColorConfig.AddListener(this);
 235     onChangeColorConfig();
 236 }
 237
 238 SdrPaintView::~SdrPaintView()
 239 {
 240     DBG_DTOR(SdrPaintView,NULL);
 241     if (pDefaultStyleSheet)
 242         EndListening(*pDefaultStyleSheet);
 243
 244     maColorConfig.RemoveListener(this);
 245     ClearPageView();
 246
 247 #ifdef DBG_UTIL
 248     if(pItemBrowser)
 249     {
 250         delete pItemBrowser;
 251     }
 252 #endif
 253
 254     // delete existing SdrPaintWindows
 255     while(!maPaintWindows.empty())
 256     {
 257         delete maPaintWindows.back();
 258         maPaintWindows.pop_back();
 259     }
 260 }
 261
 262 ////////////////////////////////////////////////////////////////////////////////////////////////////
 263
 264 void SdrPaintView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
 265 {
 266     //If the stylesheet has been destroyed
 267     if (&rBC == pDefaultStyleSheet)
 268     {
 269         if (rHint.ISA(SfxSimpleHint) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING)
 270             pDefaultStyleSheet = NULL;
 271         return;
 272     }
 273
 274     bool bObjChg=!bSomeObjChgdFlag; // if true, evaluate for ComeBack timer
 275     if (bObjChg) {
 276         SdrHint* pSdrHint=PTR_CAST(SdrHint,&rHint);
 277         if (pSdrHint!=NULL) {
 278             SdrHintKind eKind=pSdrHint->GetKind();
 279             if (eKind==HINT_OBJCHG || eKind==HINT_OBJINSERTED || eKind==HINT_OBJREMOVED) {
 280                 if (bObjChg) {
 281                     bSomeObjChgdFlag=sal_True;
 282                     aComeBackTimer.Start();
 283                 }
 284             }
 285             if (eKind==HINT_PAGEORDERCHG) {
 286                 const SdrPage* pPg=pSdrHint->GetPage();
 287
 288                 if(pPg && !pPg->IsInserted())
 289                 {
 290                     if(mpPageView && mpPageView->GetPage() == pPg)
 291                     {
 292                         HideSdrPage();
 293                     }
 294                 }
 295             }
 296         }
 297     }
 298 }
 299
 300 void SdrPaintView::ConfigurationChanged( ::utl::ConfigurationBroadcaster* , sal_uInt32 )
 301 {
 302     onChangeColorConfig();
 303     InvalidateAllWin();
 304 }
 305
 306 ////////////////////////////////////////////////////////////////////////////////////////////////////
 307
 308 IMPL_LINK_NOARG_INLINE_START(SdrPaintView, ImpComeBackHdl)
 309 {
 310     if (bSomeObjChgdFlag) {
 311         bSomeObjChgdFlag=sal_False;
 312         ModelHasChanged();
 313     }
 314     return 0;
 315 }
 316 IMPL_LINK_NOARG_INLINE_END(SdrPaintView,ImpComeBackHdl)
 317
 318 void SdrPaintView::FlushComeBackTimer() const
 319 {
 320     if (bSomeObjChgdFlag) {
 321         // casting to nonconst
 322         ((SdrPaintView*)this)->ImpComeBackHdl(&((SdrPaintView*)this)->aComeBackTimer);
 323         ((SdrPaintView*)this)->aComeBackTimer.Stop();
 324     }
 325 }
 326
 327 void SdrPaintView::ModelHasChanged()
 328 {
 329     // broadcast to all PageViews
 330     if(mpPageView && !mpPageView->GetPage()->IsInserted())
 331     {
 332         HideSdrPage();
 333     }
 334
 335     // test mpPageView here again, HideSdrPage() may have invalidated it.
 336     if(mpPageView)
 337     {
 338         mpPageView->ModelHasChanged();
 339     }
 340
 341 #ifdef DBG_UTIL
 342     if(pItemBrowser)
 343     {
 344         pItemBrowser->SetDirty();
 345     }
 346 #endif
 347 }
 348
 349 ////////////////////////////////////////////////////////////////////////////////////////////////////
 350
 351 sal_Bool SdrPaintView::IsAction() const
 352 {
 353     return false;
 354 }
 355
 356 void SdrPaintView::MovAction(const Point&)
 357 {
 358 }
 359
 360 void SdrPaintView::EndAction()
 361 {
 362 }
 363
 364 void SdrPaintView::BckAction()
 365 {
 366 }
 367
 368 void SdrPaintView::BrkAction()
 369 {
 370 }
 371
 372 void SdrPaintView::TakeActionRect(Rectangle&) const
 373 {
 374 }
 375
 376 ////////////////////////////////////////////////////////////////////////////////////////////////////
 377 // info about TextEdit. Default is sal_False.
 378 bool SdrPaintView::IsTextEdit() const
 379 {
 380     return false;
 381 }
 382
 383 // info about TextEditPageView. Default is 0L.
 384 SdrPageView* SdrPaintView::GetTextEditPageView() const
 385 {
 386     return 0L;
 387 }
 388
 389 ////////////////////////////////////////////////////////////////////////////////////////////////////
 390
 391 sal_uInt16 SdrPaintView::ImpGetMinMovLogic(short nMinMov, const OutputDevice* pOut) const
 392 {
 393     if (nMinMov>=0) return sal_uInt16(nMinMov);
 394     if (pOut==NULL)
 395     {
 396         pOut = GetFirstOutputDevice();
 397     }
 398     if (pOut!=NULL) {
 399         return short(-pOut->PixelToLogic(Size(nMinMov,0)).Width());
 400     } else {
 401         return 0;
 402     }
 403 }
 404
 405 sal_uInt16 SdrPaintView::ImpGetHitTolLogic(short nHitTol, const OutputDevice* pOut) const
 406 {
 407     if (nHitTol>=0) return sal_uInt16(nHitTol);
 408     if (pOut==NULL)
 409     {
 410         pOut = GetFirstOutputDevice();
 411     }
 412     if (pOut!=NULL) {
 413         return short(-pOut->PixelToLogic(Size(nHitTol,0)).Width());
 414     } else {
 415         return 0;
 416     }
 417 }
 418
 419 void SdrPaintView::TheresNewMapMode()
 420 {
 421     if (pActualOutDev!=NULL) {
 422         nHitTolLog=(sal_uInt16)((OutputDevice*)pActualOutDev)->PixelToLogic(Size(nHitTolPix,0)).Width();
 423         nMinMovLog=(sal_uInt16)((OutputDevice*)pActualOutDev)->PixelToLogic(Size(nMinMovPix,0)).Width();
 424     }
 425 }
 426
 427 void SdrPaintView::SetActualWin(const OutputDevice* pWin)
 428 {
 429     pActualOutDev=pWin;
 430     TheresNewMapMode();
 431 }
 432
 433 ////////////////////////////////////////////////////////////////////////////////////////////////////
 434
 435 void SdrPaintView::ClearPageView()
 436 {
 437     BrkAction();
 438
 439     if(mpPageView)
 440     {
 441         InvalidateAllWin();
 442         delete mpPageView;
 443         mpPageView = 0L;
 444     }
 445 }
 446
 447 SdrPageView* SdrPaintView::ShowSdrPage(SdrPage* pPage)
 448 {
 449     if(pPage && (!mpPageView || mpPageView->GetPage() != pPage))
 450     {
 451         if(mpPageView)
 452         {
 453             InvalidateAllWin();
 454             delete mpPageView;
 455         }
 456
 457         mpPageView = new SdrPageView(pPage, *((SdrView*)this));
 458         mpPageView->Show();
 459     }
 460
 461     return mpPageView;
 462 }
 463
 464 void SdrPaintView::HideSdrPage()
 465 {
 466     if(mpPageView)
 467     {
 468         mpPageView->Hide();
 469         delete mpPageView;
 470         mpPageView = 0L;
 471     }
 472 }
 473
 474 void SdrPaintView::AddWindowToPaintView(OutputDevice* pNewWin)
 475 {
 476     DBG_ASSERT(pNewWin, "SdrPaintView::AddWindowToPaintView: No OutputDevice(!)");
 477     SdrPaintWindow* pNewPaintWindow = new SdrPaintWindow(*this, *pNewWin);
 478     AppendPaintWindow(*pNewPaintWindow);
 479
 480     if(mpPageView)
 481     {
 482         mpPageView->AddPaintWindowToPageView(*pNewPaintWindow);
 483     }
 484
 485 #ifdef DBG_UTIL
 486     if (pItemBrowser!=NULL)
 487         pItemBrowser->ForceParent();
 488 #endif
 489 }
 490
 491 void SdrPaintView::DeleteWindowFromPaintView(OutputDevice* pOldWin)
 492 {
 493     DBG_ASSERT(pOldWin, "SdrPaintView::DeleteWindowFromPaintView: No OutputDevice(!)");
 494     SdrPaintWindow* pCandidate = FindPaintWindow(*pOldWin);
 495
 496     if(pCandidate)
 497     {
 498         if(mpPageView)
 499         {
 500             mpPageView->RemovePaintWindowFromPageView(*pCandidate);
 501         }
 502
 503         RemovePaintWindow(*pCandidate);
 504         delete pCandidate;
 505     }
 506
 507 #ifdef DBG_UTIL
 508     if (pItemBrowser!=NULL)
 509         pItemBrowser->ForceParent();
 510 #endif
 511 }
 512
 513 void SdrPaintView::SetLayerVisible(const XubString& rName, sal_Bool bShow)
 514 {
 515     if(mpPageView)
 516     {
 517         mpPageView->SetLayerVisible(rName,bShow);
 518     }
 519
 520     InvalidateAllWin();
 521 }
 522
 523 bool SdrPaintView::IsLayerVisible(const XubString& rName) const
 524 {
 525     if(mpPageView)
 526     {
 527         return mpPageView->IsLayerVisible(rName);
 528     }
 529
 530     return false;
 531 }
 532
 533 void SdrPaintView::SetLayerLocked(const XubString& rName, sal_Bool bLock)
 534 {
 535     if(mpPageView)
 536     {
 537         mpPageView->SetLayerLocked(rName,bLock);
 538     }
 539 }
 540
 541 bool SdrPaintView::IsLayerLocked(const XubString& rName) const
 542 {
 543     if(mpPageView)
 544     {
 545         return mpPageView->IsLayerLocked(rName);
 546     }
 547
 548     return false;
 549 }
 550
 551 void SdrPaintView::SetLayerPrintable(const XubString& rName, sal_Bool bPrn)
 552 {
 553     if(mpPageView)
 554     {
 555         mpPageView->SetLayerPrintable(rName,bPrn);
 556     }
 557 }
 558
 559 bool SdrPaintView::IsLayerPrintable(const XubString& rName) const
 560 {
 561     if(mpPageView)
 562     {
 563         return mpPageView->IsLayerPrintable(rName);
 564     }
 565
 566     return false;
 567 }
 568
 569 void SdrPaintView::PrePaint()
 570 {
 571     if(mpPageView)
 572     {
 573         mpPageView->PrePaint();
 574     }
 575 }
 576
 577 ////////////////////////////////////////////////////////////////////////////////////////////////////
 578 // #define SVX_REPAINT_TIMER_TEST
 579
 580 void SdrPaintView::CompleteRedraw(OutputDevice* pOut, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector)
 581 {
 582 #ifdef SVX_REPAINT_TIMER_TEST
 583 #define REMEMBERED_TIMES_COUNT  (10)
 584     static bool bDoTimerTest(false);
 585     static bool bTimesInited(false);
 586     static sal_uInt32 nRepeatCount(10L);
 587     static double fLastTimes[REMEMBERED_TIMES_COUNT];
 588     const sal_uInt32 nStartTime(Time::GetSystemTicks());
 589     sal_uInt32 count(1L);
 590     sal_uInt32 a;
 591
 592     if(bDoTimerTest)
 593     {
 594         count = nRepeatCount;
 595     }
 596
 597     for(a = 0L; a < count; a++)
 598     {
 599 #endif // SVX_REPAINT_TIMER_TEST
 600
 601     // #i74769# check if pOut is a win and has a ClipRegion. If Yes, the Region
 602     // rReg may be made more granular (fine) with using it. Normally, rReg
 603     // does come from Window::Paint() anyways and thus is based on a single
 604     // rectangle which was derived from exactly that repaint region
 605     Region aOptimizedRepaintRegion(rReg);
 606
 607     if(pOut && OUTDEV_WINDOW == pOut->GetOutDevType())
 608     {
 609         Window* pWindow = (Window*)pOut;
 610
 611         if(pWindow->IsInPaint())
 612         {
 613             if(!pWindow->GetPaintRegion().IsEmpty())
 614             {
 615                 aOptimizedRepaintRegion.Intersect(pWindow->GetPaintRegion());
 616
 617 #ifdef DBG_UTIL
 618                 // #i74769# test-paint repaint region
 619                 static bool bDoPaintForVisualControl(false);
 620                 if(bDoPaintForVisualControl)
 621                 {
 622                     RegionHandle aRegionHandle(aOptimizedRepaintRegion.BeginEnumRects());
 623                     Rectangle aRegionRectangle;
 624
 625                     while(aOptimizedRepaintRegion.GetEnumRects(aRegionHandle, aRegionRectangle))
 626                     {
 627                         pWindow->SetLineColor(COL_LIGHTGREEN);
 628                         pWindow->SetFillColor();
 629                         pWindow->DrawRect(aRegionRectangle);
 630                     }
 631
 632                     aOptimizedRepaintRegion.EndEnumRects(aRegionHandle);
 633                 }
 634 #endif
 635             }
 636         }
 637     }
 638
 639     SdrPaintWindow* pPaintWindow = BeginCompleteRedraw(pOut);
 640     OSL_ENSURE(pPaintWindow, "SdrPaintView::CompleteRedraw: No OutDev (!)");
 641
 642     DoCompleteRedraw(*pPaintWindow, aOptimizedRepaintRegion, pRedirector);
 643     EndCompleteRedraw(*pPaintWindow, true);
 644
 645 #ifdef SVX_REPAINT_TIMER_TEST
 646     }
 647
 648     if(bDoTimerTest)
 649     {
 650         const sal_uInt32 nStopTime(Time::GetSystemTicks());
 651         const sal_uInt32 nNeededTime(nStopTime - nStartTime);
 652         const double fTimePerPaint((double)nNeededTime / (double)nRepeatCount);
 653
 654         if(!bTimesInited)
 655         {
 656             for(a = 0L; a < REMEMBERED_TIMES_COUNT; a++)
 657             {
 658                 fLastTimes[a] = fTimePerPaint;
 659             }
 660
 661             bTimesInited = true;
 662         }
 663         else
 664         {
 665             for(a = 1L; a < REMEMBERED_TIMES_COUNT; a++)
 666             {
 667                 fLastTimes[a - 1L] = fLastTimes[a];
 668             }
 669
 670             fLastTimes[REMEMBERED_TIMES_COUNT - 1L] = fTimePerPaint;
 671         }
 672
 673         double fAddedTimes(0.0);
 674
 675         for(a = 0L; a < REMEMBERED_TIMES_COUNT; a++)
 676         {
 677             fAddedTimes += fLastTimes[a];
 678         }
 679
 680         const double fAverageTimePerPaint(fAddedTimes / (double)REMEMBERED_TIMES_COUNT);
 681
 682         fprintf(stderr, "-----------(start result)----------\n");
 683         fprintf(stderr, "StartTime : %u, StopTime: %u, NeededTime: %u, TimePerPaint: %f\n", nStartTime, nStopTime, nNeededTime, fTimePerPaint);
 684         fprintf(stderr, "Remembered times: ");
 685
 686         for(a = 0L; a < REMEMBERED_TIMES_COUNT; a++)
 687         {
 688             fprintf(stderr, "%d: %f ", a, fLastTimes[a]);
 689         }
 690
 691         fprintf(stderr, "\n");
 692         fprintf(stderr, "AverageTimePerPaint: %f\n", fAverageTimePerPaint);
 693         fprintf(stderr, "-----------(stop result)----------\n");
 694     }
 695 #endif // SVX_REPAINT_TIMER_TEST
 696 }
 697
 698 ////////////////////////////////////////////////////////////////////////////////////////////////////
 699 // #i72889#
 700
 701 SdrPaintWindow* SdrPaintView::BeginCompleteRedraw(OutputDevice* pOut)
 702 {
 703     OSL_ENSURE(pOut, "SdrPaintView::BeginCompleteRedraw: No OutDev (!)");
 704     SdrPaintWindow* pPaintWindow = FindPaintWindow(*pOut);
 705
 706     if(pPaintWindow)
 707     {
 708         // draw preprocessing, only for known devices
 709         // prepare PreRendering
 710         pPaintWindow->PreparePreRenderDevice();
 711     }
 712     else
 713     {
 714         // None of the known OutputDevices is the target of this paint, use
 715         // a temporary SdrPaintWindow for this Redraw.
 716         pPaintWindow = new SdrPaintWindow(*this, *pOut);
 717         pPaintWindow->setTemporaryTarget(true);
 718     }
 719
 720     return pPaintWindow;
 721 }
 722
 723 void SdrPaintView::DoCompleteRedraw(SdrPaintWindow& rPaintWindow, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector)
 724 {
 725     // redraw all PageViews with the target. This may expand the RedrawRegion
 726     // at the PaintWindow, plus taking care of FormLayer expansion
 727     if(mpPageView)
 728     {
 729         mpPageView->CompleteRedraw(rPaintWindow, rReg, pRedirector);
 730     }
 731 }
 732
 733 void SdrPaintView::EndCompleteRedraw(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer)
 734 {
 735     if(rPaintWindow.getTemporaryTarget())
 736     {
 737         // get rid of temp target again
 738         delete (&rPaintWindow);
 739     }
 740     else
 741     {
 742         // draw postprocessing, only for known devices
 743         // it is necessary to always paint FormLayer
 744         if(bPaintFormLayer)
 745         {
 746             ImpFormLayerDrawing(rPaintWindow);
 747         }
 748
 749         // look for active TextEdit. As long as this cannot be painted to a VDev,
 750         // it cannot get part of buffering. In that case, output evtl. prerender
 751         // early and paint text edit to window.
 752         if(IsTextEdit() && GetSdrPageView())
 753         {
 754             static_cast< SdrView* >(this)->TextEditDrawing(rPaintWindow);
 755         }
 756
 757         // draw Overlay, also to PreRender device if exists
 758         rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion());
 759
 760         // output PreRendering
 761         rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());
 762     }
 763 }
 764
 765 ////////////////////////////////////////////////////////////////////////////////////////////////////
 766
 767 SdrPaintWindow* SdrPaintView::BeginDrawLayers(OutputDevice* pOut, const Region& rReg, bool bDisableIntersect)
 768 {
 769     // #i74769# use BeginCompleteRedraw() as common base
 770     SdrPaintWindow* pPaintWindow = BeginCompleteRedraw(pOut);
 771     OSL_ENSURE(pPaintWindow, "SdrPaintView::BeginDrawLayers: No SdrPaintWindow (!)");
 772
 773     if(mpPageView)
 774     {
 775         SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(*pPaintWindow);
 776
 777         if(pKnownTarget)
 778         {
 779             Region aOptimizedRepaintRegion = OptimizeDrawLayersRegion( pOut, rReg, bDisableIntersect );
 780
 781             // prepare redraw
 782             pKnownTarget->PrepareRedraw(aOptimizedRepaintRegion);
 783
 784             // remember prepared SdrPageWindow
 785             mpPageView->setPreparedPageWindow(pKnownTarget);
 786         }
 787     }
 788
 789     return pPaintWindow;
 790 }
 791
 792 void SdrPaintView::EndDrawLayers(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer)
 793 {
 794     // #i74769# use EndCompleteRedraw() as common base
 795     EndCompleteRedraw(rPaintWindow, bPaintFormLayer);
 796
 797     if(mpPageView)
 798     {
 799         // forget prepared SdrPageWindow
 800         mpPageView->setPreparedPageWindow(0);
 801     }
 802 }
 803
 804 void SdrPaintView::UpdateDrawLayersRegion(OutputDevice* pOut, const Region& rReg, bool bDisableIntersect)
 805 {
 806     SdrPaintWindow* pPaintWindow = FindPaintWindow(*pOut);
 807     OSL_ENSURE(pPaintWindow, "SdrPaintView::UpdateDrawLayersRegion: No SdrPaintWindow (!)");
 808
 809     if(mpPageView)
 810     {
 811         SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(*pPaintWindow);
 812
 813         if(pKnownTarget)
 814         {
 815             Region aOptimizedRepaintRegion = OptimizeDrawLayersRegion( pOut, rReg, bDisableIntersect );
 816             pKnownTarget->GetPaintWindow().SetRedrawRegion(aOptimizedRepaintRegion);
 817             mpPageView->setPreparedPageWindow(pKnownTarget); // already set actually
 818         }
 819     }
 820 }
 821
 822 Region SdrPaintView::OptimizeDrawLayersRegion(OutputDevice* pOut, const Region& rReg, bool bDisableIntersect)
 823 {
 824     // #i74769# check if pOut is a win and has a ClipRegion. If Yes, the Region
 825     // rReg may be made more granular (fine) with using it. Normally, rReg
 826     // does come from Window::Paint() anyways and thus is based on a single
 827     // rectangle which was derived from exactly that repaint region
 828     Region aOptimizedRepaintRegion(rReg);
 829
 830     // #i76114# Intersecting the region with the Window's paint region is disabled
 831     // for print preview in Calc, because the intersection can be empty (if the paint
 832     // region is outside of the table area of the page), and then no clip region
 833     // would be set.
 834     if(pOut && OUTDEV_WINDOW == pOut->GetOutDevType() && !bDisableIntersect)
 835     {
 836         Window* pWindow = (Window*)pOut;
 837
 838         if(pWindow->IsInPaint())
 839         {
 840             if(!pWindow->GetPaintRegion().IsEmpty())
 841             {
 842                 aOptimizedRepaintRegion.Intersect(pWindow->GetPaintRegion());
 843
 844 #ifdef DBG_UTIL
 845                 // #i74769# test-paint repaint region
 846                 static bool bDoPaintForVisualControl(false);
 847                 if(bDoPaintForVisualControl)
 848                 {
 849                     RegionHandle aRegionHandle(aOptimizedRepaintRegion.BeginEnumRects());
 850                     Rectangle aRegionRectangle;
 851
 852                     while(aOptimizedRepaintRegion.GetEnumRects(aRegionHandle, aRegionRectangle))
 853                     {
 854                         pWindow->SetLineColor(COL_LIGHTGREEN);
 855                         pWindow->SetFillColor();
 856                         pWindow->DrawRect(aRegionRectangle);
 857                     }
 858
 859                     aOptimizedRepaintRegion.EndEnumRects(aRegionHandle);
 860                 }
 861 #endif
 862             }
 863         }
 864     }
 865     return aOptimizedRepaintRegion;
 866 }
 867
 868 ////////////////////////////////////////////////////////////////////////////////////////////////////
 869
 870 void SdrPaintView::ImpFormLayerDrawing(SdrPaintWindow& rPaintWindow) const
 871 {
 872     if(mpPageView)
 873     {
 874         SdrPageWindow* pKnownTarget = mpPageView->FindPageWindow(rPaintWindow);
 875
 876         if(pKnownTarget)
 877         {
 878             const SdrModel& rModel = *(GetModel());
 879             const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin();
 880             const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName(), sal_False);
 881
 882             // BUFFERED use GetTargetOutputDevice() now, it may be targeted to VDevs, too
 883             // need to set PreparedPageWindow to make DrawLayer use the correct ObjectContact
 884             mpPageView->setPreparedPageWindow(pKnownTarget);
 885             mpPageView->DrawLayer(nControlLayerId, &rPaintWindow.GetTargetOutputDevice());
 886             mpPageView->setPreparedPageWindow(0);
 887         }
 888     }
 889 }
 890
 891 ////////////////////////////////////////////////////////////////////////////////////////////////////
 892
 893 sal_Bool SdrPaintView::KeyInput(const KeyEvent& /*rKEvt*/, Window* /*pWin*/)
 894 {
 895     return sal_False;
 896 }
 897
 898 void SdrPaintView::GlueInvalidate() const
 899 {
 900     const sal_uInt32 nWindowCount(PaintWindowCount());
 901
 902     for(sal_uInt32 nWinNum(0L); nWinNum < nWindowCount; nWinNum++)
 903     {
 904         SdrPaintWindow* pPaintWindow = GetPaintWindow(nWinNum);
 905
 906         if(pPaintWindow->OutputToWindow())
 907         {
 908             OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
 909
 910             if(mpPageView)
 911             {
 912                 const SdrObjList* pOL=mpPageView->GetObjList();
 913                 sal_uIntPtr nObjAnz=pOL->GetObjCount();
 914                 for (sal_uIntPtr nObjNum=0; nObjNum<nObjAnz; nObjNum++) {
 915                     const SdrObject* pObj=pOL->GetObj(nObjNum);
 916                     const SdrGluePointList* pGPL=pObj->GetGluePointList();
 917                     if (pGPL!=NULL && pGPL->GetCount()!=0) {
 918                         pGPL->Invalidate((Window&)rOutDev, pObj);
 919                     }
 920                 }
 921             }
 922         }
 923     }
 924 }
 925
 926 void SdrPaintView::InvalidateAllWin()
 927 {
 928     const sal_uInt32 nWindowCount(PaintWindowCount());
 929
 930     for(sal_uInt32 a(0L); a < nWindowCount; a++)
 931     {
 932         SdrPaintWindow* pPaintWindow = GetPaintWindow(a);
 933
 934         if(pPaintWindow->OutputToWindow())
 935         {
 936             InvalidateOneWin((Window&)pPaintWindow->GetOutputDevice());
 937         }
 938     }
 939 }
 940
 941 void SdrPaintView::InvalidateAllWin(const Rectangle& rRect, sal_Bool bPlus1Pix)
 942 {
 943     const sal_uInt32 nWindowCount(PaintWindowCount());
 944
 945     for(sal_uInt32 a(0L); a < nWindowCount; a++)
 946     {
 947         SdrPaintWindow* pPaintWindow = GetPaintWindow(a);
 948
 949         if(pPaintWindow->OutputToWindow())
 950         {
 951             OutputDevice& rOutDev = pPaintWindow->GetOutputDevice();
 952             Rectangle aRect(rRect);
 953
 954             if(bPlus1Pix)
 955             {
 956                 Size aPixSiz(1,1);
 957                 Size aSiz(rOutDev.PixelToLogic(aPixSiz));
 958                 aRect.Left  ()-=aSiz.Width();
 959                 aRect.Top   ()-=aSiz.Height();
 960                 aRect.Right ()+=aSiz.Width();
 961                 aRect.Bottom()+=aSiz.Height();
 962             }
 963
 964             Point aOrg(rOutDev.GetMapMode().GetOrigin());
 965             aOrg.X()=-aOrg.X(); aOrg.Y()=-aOrg.Y();
 966             Rectangle aOutRect(aOrg, rOutDev.GetOutputSize());
 967
 968             if (aRect.IsOver(aOutRect))
 969             {
 970                 InvalidateOneWin((Window&)rOutDev, aRect);
 971             }
 972         }
 973     }
 974 }
 975
 976 void SdrPaintView::InvalidateOneWin(Window& rWin)
 977 {
 978     // do not erase background, that causes flicker (!)
 979     rWin.Invalidate(INVALIDATE_NOERASE);
 980 }
 981
 982 void SdrPaintView::InvalidateOneWin(Window& rWin, const Rectangle& rRect)
 983 {
 984     // do not erase background, that causes flicker (!)
 985     rWin.Invalidate(rRect, INVALIDATE_NOERASE);
 986 }
 987
 988 void SdrPaintView::LeaveOneGroup()
 989 {
 990     if(mpPageView)
 991     {
 992         mpPageView->LeaveOneGroup();
 993     }
 994 }
 995
 996 void SdrPaintView::LeaveAllGroup()
 997 {
 998     if(mpPageView)
 999     {
1000         mpPageView->LeaveAllGroup();
1001     }
1002 }
1003
1004 bool SdrPaintView::IsGroupEntered() const
1005 {
1006     if(mpPageView)
1007     {
1008         return (mpPageView->GetEnteredLevel() != 0);
1009     }
1010
1011     return false;
1012 }
1013
1014 void SdrPaintView::SetNotPersistDefaultAttr(const SfxItemSet& rAttr, sal_Bool /*bReplaceAll*/)
1015 {
1016     // bReplaceAll has no effect here at all.
1017     bool bMeasure=ISA(SdrView) && ((SdrView*)this)->IsMeasureTool();
1018     const SfxPoolItem *pPoolItem=NULL;
1019     if (rAttr.GetItemState(SDRATTR_LAYERID,sal_True,&pPoolItem)==SFX_ITEM_SET) {
1020         SdrLayerID nLayerId=((const SdrLayerIdItem*)pPoolItem)->GetValue();
1021         const SdrLayer* pLayer=pMod->GetLayerAdmin().GetLayerPerID(nLayerId);
1022         if (pLayer!=NULL) {
1023             if (bMeasure) aMeasureLayer=pLayer->GetName();
1024             else aAktLayer=pLayer->GetName();
1025         }
1026     }
1027     if (rAttr.GetItemState(SDRATTR_LAYERNAME,sal_True,&pPoolItem)==SFX_ITEM_SET) {
1028         if (bMeasure) aMeasureLayer=((const SdrLayerNameItem*)pPoolItem)->GetValue();
1029         else aAktLayer=((const SdrLayerNameItem*)pPoolItem)->GetValue();
1030     }
1031 }
1032
1033 void SdrPaintView::MergeNotPersistDefaultAttr(SfxItemSet& rAttr, sal_Bool /*bOnlyHardAttr*/) const
1034 {
1035     // bOnlyHardAttr has no effect here at all.
1036     bool bMeasure=ISA(SdrView) && ((SdrView*)this)->IsMeasureTool();
1037     const XubString& aNam=bMeasure?aMeasureLayer:aAktLayer;
1038     rAttr.Put(SdrLayerNameItem(aNam));
1039     SdrLayerID nLayer=pMod->GetLayerAdmin().GetLayerID(aNam,sal_True);
1040     if (nLayer!=SDRLAYER_NOTFOUND) {
1041         rAttr.Put(SdrLayerIdItem(nLayer));
1042     }
1043 }
1044
1045 void SdrPaintView::SetDefaultAttr(const SfxItemSet& rAttr, sal_Bool bReplaceAll)
1046 {
1047 #ifdef DBG_UTIL
1048     {
1049         bool bHasEEFeatureItems=false;
1050         SfxItemIter aIter(rAttr);
1051         const SfxPoolItem* pItem=aIter.FirstItem();
1052         while (!bHasEEFeatureItems && pItem!=NULL) {
1053             if (!IsInvalidItem(pItem)) {
1054                 sal_uInt16 nW=pItem->Which();
1055                 if (nW>=EE_FEATURE_START && nW<=EE_FEATURE_END) bHasEEFeatureItems=true;
1056             }
1057             pItem=aIter.NextItem();
1058         }
1059
1060         if(bHasEEFeatureItems)
1061         {
1062             String aMessage;
1063             aMessage.AppendAscii("SdrPaintView::SetDefaultAttr(): Setting EE_FEATURE items at the SdrView does not make sense! It only leads to overhead and unreadable documents.");
1064             InfoBox(NULL, aMessage).Execute();
1065         }
1066     }
1067 #endif
1068     if (bReplaceAll) aDefaultAttr.Set(rAttr);
1069     else aDefaultAttr.Put(rAttr,sal_False); // if FALSE, regard InvalidItems as "holes," not as Default
1070     SetNotPersistDefaultAttr(rAttr,bReplaceAll);
1071 #ifdef DBG_UTIL
1072     if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
1073 #endif
1074 }
1075
1076 void SdrPaintView::SetDefaultStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr)
1077 {
1078     if (pDefaultStyleSheet)
1079         EndListening(*pDefaultStyleSheet);
1080     pDefaultStyleSheet=pStyleSheet;
1081     if (pDefaultStyleSheet)
1082         StartListening(*pDefaultStyleSheet);
1083
1084     if (pStyleSheet!=NULL && !bDontRemoveHardAttr) {
1085         SfxWhichIter aIter(pStyleSheet->GetItemSet());
1086         sal_uInt16 nWhich=aIter.FirstWhich();
1087         while (nWhich!=0) {
1088             if (pStyleSheet->GetItemSet().GetItemState(nWhich,sal_True)==SFX_ITEM_SET) {
1089                 aDefaultAttr.ClearItem(nWhich);
1090             }
1091             nWhich=aIter.NextWhich();
1092         }
1093     }
1094 #ifdef DBG_UTIL
1095     if (pItemBrowser!=NULL) pItemBrowser->SetDirty();
1096 #endif
1097 }
1098
1099 sal_Bool SdrPaintView::GetAttributes(SfxItemSet& rTargetSet, sal_Bool bOnlyHardAttr) const
1100 {
1101     if(bOnlyHardAttr || !pDefaultStyleSheet)
1102     {
1103         rTargetSet.Put(aDefaultAttr, sal_False);
1104     }
1105     else
1106     {
1107         // else merge with DefStyleSheet
1108         rTargetSet.Put(pDefaultStyleSheet->GetItemSet(), sal_False);
1109         rTargetSet.Put(aDefaultAttr, sal_False);
1110     }
1111     MergeNotPersistDefaultAttr(rTargetSet, bOnlyHardAttr);
1112     return sal_True;
1113 }
1114
1115 sal_Bool SdrPaintView::SetAttributes(const SfxItemSet& rSet, sal_Bool bReplaceAll)
1116 {
1117     SetDefaultAttr(rSet,bReplaceAll);
1118     return sal_True;
1119 }
1120
1121 SfxStyleSheet* SdrPaintView::GetStyleSheet() const
1122 {
1123     return GetDefaultStyleSheet();
1124 }
1125
1126 sal_Bool SdrPaintView::SetStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr)
1127 {
1128     SetDefaultStyleSheet(pStyleSheet,bDontRemoveHardAttr);
1129     return sal_True;
1130 }
1131
1132 ////////////////////////////////////////////////////////////////////////////////////////////////////
1133
1134 #ifdef DBG_UTIL
1135 void SdrPaintView::ShowItemBrowser(sal_Bool bShow)
1136 {
1137     if (bShow) {
1138         if (pItemBrowser==NULL) {
1139             pItemBrowser=new SdrItemBrowser(*(SdrView*)this);
1140             pItemBrowser->SetFloatingMode(sal_True);
1141         }
1142         pItemBrowser->Show();
1143         pItemBrowser->GrabFocus();
1144     } else {
1145         if (pItemBrowser!=NULL) {
1146             pItemBrowser->Hide();
1147             delete pItemBrowser;
1148             pItemBrowser=NULL;
1149         }
1150     }
1151 }
1152 #endif
1153
1154 void SdrPaintView::MakeVisible(const Rectangle& rRect, Window& rWin)
1155 {
1156     MapMode aMap(rWin.GetMapMode());
1157     Size aActualSize(rWin.GetOutputSize());
1158
1159     if( aActualSize.Height() > 0 && aActualSize.Width() > 0 )
1160     {
1161         Size aNewSize(rRect.GetSize());
1162         bool bNewScale=false;
1163         bool bNeedMoreX=aNewSize.Width()>aActualSize.Width();
1164         bool bNeedMoreY=aNewSize.Height()>aActualSize.Height();
1165         if (bNeedMoreX || bNeedMoreY)
1166         {
1167             bNewScale=true;
1168             // set new MapMode (Size+Org) and invalidate everything
1169             Fraction aXFact(aNewSize.Width(),aActualSize.Width());
1170             Fraction aYFact(aNewSize.Height(),aActualSize.Height());
1171             if (aYFact>aXFact) aXFact=aYFact;
1172             aXFact*=aMap.GetScaleX();
1173             aXFact.ReduceInaccurate(10); // to avoid runovers and BigInt mapping
1174             aMap.SetScaleX(aXFact);
1175             aMap.SetScaleY(aYFact);
1176             rWin.SetMapMode(aMap);
1177             aActualSize=rWin.GetOutputSize();
1178         }
1179         Point aOrg(aMap.GetOrigin());
1180         long dx=0,dy=0;
1181         long l=-aOrg.X();
1182         long r=-aOrg.X()+aActualSize.Width()-1;
1183         long o=-aOrg.Y();
1184         long u=-aOrg.Y()+aActualSize.Height()-1;
1185         if (l>rRect.Left()) dx=rRect.Left()-l;
1186         else if (r<rRect.Right()) dx=rRect.Right()-r;
1187         if (o>rRect.Top()) dy=rRect.Top()-o;
1188         else if (u<rRect.Bottom()) dy=rRect.Bottom()-u;
1189         aMap.SetOrigin(Point(aOrg.X()-dx,aOrg.Y()-dy));
1190         if (!bNewScale) {
1191             if (dx!=0 || dy!=0) {
1192                 rWin.Scroll(-dx,-dy);
1193                 rWin.SetMapMode(aMap);
1194                 rWin.Update();
1195             }
1196         } else {
1197             rWin.SetMapMode(aMap);
1198             InvalidateOneWin(rWin);
1199         }
1200     }
1201 }
1202
1203 void SdrPaintView::DoConnect(SdrOle2Obj* /*pOleObj*/)
1204 {
1205 }
1206
1207 void SdrPaintView::SetAnimationEnabled( sal_Bool bEnable )
1208 {
1209     SetAnimationMode( bEnable ? SDR_ANIMATION_ANIMATE : SDR_ANIMATION_DISABLE );
1210 }
1211
1212 void SdrPaintView::SetAnimationPause( bool bSet )
1213 {
1214     if((bool)bAnimationPause != bSet)
1215     {
1216         bAnimationPause = bSet;
1217
1218         if(mpPageView)
1219         {
1220             for(sal_uInt32 b(0L); b < mpPageView->PageWindowCount(); b++)
1221             {
1222                 const SdrPageWindow& rPageWindow = *(mpPageView->GetPageWindow(b));
1223                 sdr::contact::ObjectContact& rObjectContact = rPageWindow.GetObjectContact();
1224                 sdr::animation::primitiveAnimator& rAnimator = rObjectContact.getPrimitiveAnimator();
1225
1226                 if(rAnimator.IsPaused() != bSet)
1227                 {
1228                     rAnimator.SetPaused(bSet);
1229                 }
1230             }
1231         }
1232     }
1233 }
1234
1235 void SdrPaintView::SetAnimationMode( const SdrAnimationMode eMode )
1236 {
1237     eAnimationMode = eMode;
1238 }
1239
1240 void SdrPaintView::VisAreaChanged(const OutputDevice* pOut)
1241 {
1242     if(mpPageView)
1243     {
1244         if (pOut)
1245         {
1246             SdrPageWindow* pWindow = mpPageView->FindPageWindow(*((OutputDevice*)pOut));
1247
1248             if(pWindow)
1249             {
1250                 VisAreaChanged(*pWindow);
1251             }
1252         }
1253         else
1254         {
1255             for(sal_uInt32 a(0L); a < mpPageView->PageWindowCount(); a++)
1256             {
1257                 VisAreaChanged(*mpPageView->GetPageWindow(a));
1258             }
1259         }
1260     }
1261 }
1262
1263 void SdrPaintView::VisAreaChanged(const SdrPageWindow& /*rWindow*/)
1264 {
1265     // notify SfxListener
1266     Broadcast(SvxViewHint(SvxViewHint::SVX_HINT_VIEWCHANGED));
1267 }
1268
1269 void SdrPaintView::onChangeColorConfig()
1270 {
1271     SetGridColor( Color( maColorConfig.GetColorValue( svtools::DRAWGRID ).nColor ) );
1272 }
1273
1274 void SdrPaintView::SetGridColor( Color aColor )
1275 {
1276     maGridColor = aColor;
1277 }
1278
1279 Color SdrPaintView::GetGridColor() const
1280 {
1281     return maGridColor;
1282 }
1283
1284 // Set background color for svx at SdrPageViews
1285 void SdrPaintView::SetApplicationBackgroundColor(Color aBackgroundColor)
1286 {
1287     if(mpPageView)
1288     {
1289         mpPageView->SetApplicationBackgroundColor(aBackgroundColor);
1290     }
1291 }
1292
1293 // Set document color for svx at SdrPageViews
1294 void SdrPaintView::SetApplicationDocumentColor(Color aDocumentColor)
1295 {
1296     if(mpPageView)
1297     {
1298         mpPageView->SetApplicationDocumentColor(aDocumentColor);
1299     }
1300 }
1301
1302 bool SdrPaintView::IsBufferedOutputAllowed() const
1303 {
1304     return (mbBufferedOutputAllowed && maDrawinglayerOpt.IsPaintBuffer());
1305 }
1306
1307 void SdrPaintView::SetBufferedOutputAllowed(bool bNew)
1308 {
1309     if(bNew != (bool)mbBufferedOutputAllowed)
1310     {
1311         mbBufferedOutputAllowed = bNew;
1312     }
1313 }
1314
1315 bool SdrPaintView::IsBufferedOverlayAllowed() const
1316 {
1317     return (mbBufferedOverlayAllowed && maDrawinglayerOpt.IsOverlayBuffer());
1318 }
1319
1320 void SdrPaintView::SetBufferedOverlayAllowed(bool bNew)
1321 {
1322     if(bNew != (bool)mbBufferedOverlayAllowed)
1323     {
1324         mbBufferedOverlayAllowed = bNew;
1325     }
1326 }
1327
1328 sal_Bool SdrPaintView::IsPagePaintingAllowed() const
1329 {
1330     return mbPagePaintingAllowed;
1331 }
1332
1333 void SdrPaintView::SetPagePaintingAllowed(bool bNew)
1334 {
1335     if(bNew != (bool)mbPagePaintingAllowed)
1336     {
1337         mbPagePaintingAllowed = bNew;
1338     }
1339 }
1340
1341 // #i38135# Sets the timer for Object animations and restarts.
1342 void SdrPaintView::SetAnimationTimer(sal_uInt32 nTime)
1343 {
1344     if(mpPageView)
1345     {
1346         // first, reset all timers at all windows to 0L
1347         for(sal_uInt32 a(0L); a < mpPageView->PageWindowCount(); a++)
1348         {
1349             const SdrPageWindow& rPageWindow = *mpPageView->GetPageWindow(a);
1350             sdr::contact::ObjectContact& rObjectContact = rPageWindow.GetObjectContact();
1351             sdr::animation::primitiveAnimator& rAnimator = rObjectContact.getPrimitiveAnimator();
1352             rAnimator.SetTime(nTime);
1353         }
1354     }
1355 }
1356
1357 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */