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