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