svx/source/svdraw/svdpntv.cxx

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