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