svx/source/svdraw/svdpntv.cxx

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