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 <svx/svdpagv.hxx>
21 : #include <com/sun/star/awt/XWindow.hpp>
22 : #include <com/sun/star/awt/PosSize.hpp>
23 : #include <comphelper/processfactory.hxx>
24 : #include <svx/svdoutl.hxx>
25 : #include <svx/xpoly.hxx>
26 : #include <svx/svdouno.hxx>
27 : #include <svx/svdpage.hxx>
28 : #include <svx/svdview.hxx>
29 :
30 : #include <svx/svdedxv.hxx>
31 : #include <editeng/outliner.hxx>
32 : #include <svx/svdetc.hxx>
33 : #include <svx/svdobj.hxx>
34 : #include "svx/svditer.hxx"
35 : #include <svx/svdogrp.hxx>
36 : #include <svx/svdtypes.hxx>
37 : #include <svx/svdoole2.hxx>
38 :
39 : #include <sdr/contact/objectcontactofpageview.hxx>
40 : #include <svx/sdr/contact/viewobjectcontactredirector.hxx>
41 : #include <svx/fmview.hxx>
42 :
43 : #include <algorithm>
44 :
45 : #include <svx/sdrpagewindow.hxx>
46 : #include <svx/sdrpaintwindow.hxx>
47 :
48 :
49 : using namespace ::com::sun::star;
50 :
51 : // interface to SdrPageWindow
52 :
53 83836 : SdrPageWindow* SdrPageView::FindPageWindow(SdrPaintWindow& rPaintWindow) const
54 : {
55 83928 : for(SdrPageWindowVector::const_iterator a = maPageWindows.begin(); a != maPageWindows.end(); ++a)
56 : {
57 75981 : if(&((*a)->GetPaintWindow()) == &rPaintWindow)
58 : {
59 75889 : return *a;
60 : }
61 : }
62 :
63 7947 : return 0L;
64 : }
65 :
66 818 : const SdrPageWindow* SdrPageView::FindPatchedPageWindow( const OutputDevice& _rOutDev ) const
67 : {
68 2478 : for ( SdrPageWindowVector::const_iterator loop = maPageWindows.begin();
69 1652 : loop != maPageWindows.end();
70 : ++loop
71 : )
72 : {
73 826 : const SdrPageWindow& rPageWindow( *(*loop) );
74 826 : const SdrPaintWindow& rPaintWindow( rPageWindow.GetOriginalPaintWindow() ? *rPageWindow.GetOriginalPaintWindow() : rPageWindow.GetPaintWindow() );
75 826 : if ( &rPaintWindow.GetOutputDevice() == &_rOutDev )
76 : {
77 818 : return &rPageWindow;
78 : }
79 : }
80 :
81 0 : return NULL;
82 : }
83 :
84 76620 : SdrPageWindow* SdrPageView::FindPageWindow(const OutputDevice& rOutDev) const
85 : {
86 118846 : for(SdrPageWindowVector::const_iterator a = maPageWindows.begin(); a != maPageWindows.end(); ++a)
87 : {
88 77187 : if(&((*a)->GetPaintWindow().GetOutputDevice()) == &rOutDev)
89 : {
90 34961 : return *a;
91 : }
92 : }
93 :
94 41659 : return 0L;
95 : }
96 :
97 50117 : SdrPageWindow* SdrPageView::GetPageWindow(sal_uInt32 nIndex) const
98 : {
99 50117 : if(nIndex < maPageWindows.size())
100 : {
101 50117 : return maPageWindows[nIndex];
102 : }
103 :
104 0 : return 0L;
105 : }
106 :
107 15142 : void SdrPageView::ClearPageWindows()
108 : {
109 22173 : for(SdrPageWindowVector::const_iterator a = maPageWindows.begin(); a != maPageWindows.end(); ++a)
110 : {
111 7031 : delete *a;
112 : }
113 :
114 15142 : maPageWindows.clear();
115 15142 : }
116 :
117 7947 : void SdrPageView::AppendPageWindow(SdrPageWindow& rNew)
118 : {
119 7947 : maPageWindows.push_back(&rNew);
120 7947 : }
121 :
122 886 : SdrPageWindow* SdrPageView::RemovePageWindow(SdrPageWindow& rOld)
123 : {
124 886 : const SdrPageWindowVector::iterator aFindResult = ::std::find(maPageWindows.begin(), maPageWindows.end(), &rOld);
125 :
126 886 : if(aFindResult != maPageWindows.end())
127 : {
128 : // remember return value
129 886 : SdrPageWindow* pSdrPageWindow = *aFindResult;
130 886 : maPageWindows.erase(aFindResult);
131 886 : return pSdrPageWindow;
132 : }
133 :
134 0 : return 0L;
135 : }
136 :
137 :
138 :
139 8041 : SdrPageView::SdrPageView(SdrPage* pPage1, SdrView& rNewView)
140 : : mrView(rNewView),
141 : // col_auto color lets the view takes the default SvxColorConfig entry
142 : maDocumentColor( COL_AUTO ),
143 : maBackgroundColor(COL_AUTO ), // #i48367# also react on autocolor
144 8041 : mpPreparedPageWindow(0) // #i72752#
145 : {
146 8041 : mpPage = pPage1;
147 :
148 8041 : if(mpPage)
149 : {
150 8041 : aPgOrg.X()=mpPage->GetLftBorder();
151 8041 : aPgOrg.Y()=mpPage->GetUppBorder();
152 : }
153 8041 : mbHasMarked = false;
154 8041 : aLayerVisi.SetAll();
155 8041 : aLayerPrn.SetAll();
156 :
157 8041 : mbVisible = false;
158 8041 : pAktList = NULL;
159 8041 : pAktGroup = NULL;
160 8041 : SetAktGroupAndList(NULL, mpPage);
161 :
162 15982 : for(sal_uInt32 a(0L); a < rNewView.PaintWindowCount(); a++)
163 : {
164 7941 : AddPaintWindowToPageView(*rNewView.GetPaintWindow(a));
165 : }
166 8041 : }
167 :
168 16022 : SdrPageView::~SdrPageView()
169 : {
170 :
171 : // cleanup window vector
172 8011 : ClearPageWindows();
173 8011 : }
174 :
175 7947 : SdrPageWindow& SdrPageView::CreateNewPageWindowEntry(SdrPaintWindow& rPaintWindow)
176 : {
177 7947 : SdrPageWindow& rWindow = *(new SdrPageWindow(*this, rPaintWindow));
178 7947 : AppendPageWindow(rWindow);
179 :
180 7947 : return rWindow;
181 : }
182 :
183 15888 : void SdrPageView::AddPaintWindowToPageView(SdrPaintWindow& rPaintWindow)
184 : {
185 15888 : if(!FindPageWindow(rPaintWindow))
186 : {
187 7947 : CreateNewPageWindowEntry(rPaintWindow);
188 : }
189 15888 : }
190 :
191 886 : void SdrPageView::RemovePaintWindowFromPageView(SdrPaintWindow& rPaintWindow)
192 : {
193 886 : SdrPageWindow* pCandidate = FindPageWindow(rPaintWindow);
194 :
195 886 : if(pCandidate)
196 : {
197 886 : pCandidate = RemovePageWindow(*pCandidate);
198 :
199 886 : if(pCandidate)
200 : {
201 886 : delete pCandidate;
202 : }
203 : }
204 886 : }
205 :
206 818 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlContainer > SdrPageView::GetControlContainer( const OutputDevice& _rDevice ) const
207 : {
208 818 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlContainer > xReturn;
209 818 : const SdrPageWindow* pCandidate = FindPatchedPageWindow( _rDevice );
210 :
211 818 : if ( pCandidate )
212 818 : xReturn = pCandidate->GetControlContainer( true );
213 :
214 818 : return xReturn;
215 : }
216 :
217 3048 : void SdrPageView::ModelHasChanged()
218 : {
219 3048 : if (GetAktGroup()!=NULL) CheckAktGroup();
220 3048 : }
221 :
222 2 : bool SdrPageView::IsReadOnly() const
223 : {
224 2 : return (0L == GetPage() || GetView().GetModel()->IsReadOnly() || GetPage()->IsReadOnly() || GetObjList()->IsReadOnly());
225 : }
226 :
227 8041 : void SdrPageView::Show()
228 : {
229 8041 : if(!IsVisible())
230 : {
231 8041 : mbVisible = true;
232 8041 : InvalidateAllWin();
233 :
234 15982 : for(sal_uInt32 a(0L); a < GetView().PaintWindowCount(); a++)
235 : {
236 7941 : AddPaintWindowToPageView(*GetView().GetPaintWindow(a));
237 : }
238 : }
239 8041 : }
240 :
241 7131 : void SdrPageView::Hide()
242 : {
243 7131 : if(IsVisible())
244 : {
245 7131 : InvalidateAllWin();
246 7131 : mbVisible = false;
247 7131 : ClearPageWindows();
248 : }
249 7131 : }
250 :
251 0 : Rectangle SdrPageView::GetPageRect() const
252 : {
253 0 : if (GetPage()==NULL) return Rectangle();
254 0 : return Rectangle(Point(),Size(GetPage()->GetWdt()+1,GetPage()->GetHgt()+1));
255 : }
256 :
257 32892 : void SdrPageView::InvalidateAllWin()
258 : {
259 32892 : if(IsVisible() && GetPage())
260 : {
261 32892 : Rectangle aRect(Point(0,0),Size(GetPage()->GetWdt()+1,GetPage()->GetHgt()+1));
262 32892 : aRect.Union(GetPage()->GetAllObjBoundRect());
263 32892 : GetView().InvalidateAllWin(aRect);
264 : }
265 32892 : }
266 :
267 :
268 :
269 43463 : void SdrPageView::PrePaint()
270 : {
271 43463 : const sal_uInt32 nCount(PageWindowCount());
272 :
273 87064 : for(sal_uInt32 a(0); a < nCount; a++)
274 : {
275 43601 : SdrPageWindow* pCandidate = GetPageWindow(a);
276 :
277 43601 : if(pCandidate)
278 : {
279 43601 : pCandidate->PrePaint();
280 : }
281 : }
282 43463 : }
283 :
284 1019 : void SdrPageView::CompleteRedraw(SdrPaintWindow& rPaintWindow, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector) const
285 : {
286 1019 : if(GetPage())
287 : {
288 1019 : SdrPageWindow* pPageWindow = FindPageWindow(rPaintWindow);
289 1019 : bool bIsTempTarget(false);
290 :
291 1019 : if(!pPageWindow)
292 : {
293 : // create temp PageWindow
294 0 : pPageWindow = new SdrPageWindow(*((SdrPageView*)this), rPaintWindow);
295 0 : bIsTempTarget = true;
296 : }
297 :
298 : // do the redraw
299 1019 : pPageWindow->PrepareRedraw(rReg);
300 1019 : pPageWindow->RedrawAll(pRedirector);
301 :
302 : // get rid of temp PageWindow
303 1019 : if(bIsTempTarget)
304 : {
305 0 : delete pPageWindow;
306 0 : pPageWindow = 0L;
307 : }
308 : }
309 1019 : }
310 :
311 :
312 : // #i74769# use SdrPaintWindow directly
313 :
314 95788 : void SdrPageView::setPreparedPageWindow(SdrPageWindow* pKnownTarget)
315 : {
316 : // #i72752# remember prepared SdrPageWindow
317 95788 : mpPreparedPageWindow = pKnownTarget;
318 95788 : }
319 :
320 44116 : void SdrPageView::DrawLayer(SdrLayerID nID, OutputDevice* pGivenTarget, sdr::contact::ViewObjectContactRedirector* pRedirector, const Rectangle& rRect) const
321 : {
322 44116 : if(GetPage())
323 : {
324 44116 : if(pGivenTarget)
325 : {
326 44116 : const SdrPageWindow* pKnownTarget = FindPageWindow(*pGivenTarget);
327 :
328 44116 : if(pKnownTarget)
329 : {
330 : // paint known target
331 2457 : pKnownTarget->RedrawLayer(&nID, pRedirector);
332 : }
333 : else
334 : {
335 : // #i72752# DrawLayer() uses a OutputDevice different from BeginDrawLayer. This happens
336 : // e.g. when SW paints a single text line in text edit mode. Try to use it
337 41659 : SdrPageWindow* pPreparedTarget = mpPreparedPageWindow;
338 :
339 41659 : if(pPreparedTarget)
340 : {
341 : // if we have a prepared target, do not use a new SdrPageWindow since this
342 : // works but is expensive. Just use a temporary PaintWindow
343 41659 : SdrPaintWindow aTemporaryPaintWindow(mrView, *pGivenTarget);
344 :
345 : // Copy existing paint region to use the same as prepared in BeginDrawLayer
346 41659 : SdrPaintWindow& rExistingPaintWindow = pPreparedTarget->GetPaintWindow();
347 41659 : const vcl::Region& rExistingRegion = rExistingPaintWindow.GetRedrawRegion();
348 41659 : bool bUseRect(false);
349 41659 : if (!rRect.IsEmpty())
350 : {
351 24320 : vcl::Region r(rExistingRegion);
352 24320 : r.Intersect(rRect);
353 : // fdo#74435: FIXME: visibility check broken if empty
354 24320 : if (!r.IsEmpty())
355 24076 : bUseRect = true;
356 : }
357 41659 : if (!bUseRect)
358 17583 : aTemporaryPaintWindow.SetRedrawRegion(rExistingRegion);
359 : else
360 24076 : aTemporaryPaintWindow.SetRedrawRegion(vcl::Region(rRect));
361 :
362 : // patch the ExistingPageWindow
363 41659 : pPreparedTarget->patchPaintWindow(aTemporaryPaintWindow);
364 :
365 : // redraw the layer
366 41659 : pPreparedTarget->RedrawLayer(&nID, pRedirector);
367 :
368 : // restore the ExistingPageWindow
369 41659 : pPreparedTarget->unpatchPaintWindow();
370 : }
371 : else
372 : {
373 : OSL_FAIL("SdrPageView::DrawLayer: Creating temporary SdrPageWindow (ObjectContact), this should never be needed (!)");
374 :
375 : // None of the known OutputDevices is the target of this paint, use
376 : // a temporary SdrPageWindow for this Redraw.
377 0 : SdrPaintWindow aTemporaryPaintWindow(mrView, *pGivenTarget);
378 0 : SdrPageWindow aTemporaryPageWindow(*((SdrPageView*)this), aTemporaryPaintWindow);
379 :
380 : // #i72752#
381 : // Copy existing paint region if other PageWindows exist, this was created by
382 : // PrepareRedraw() from BeginDrawLayer(). Needs to be used e.g. when suddenly SW
383 : // paints into an unknown device other than the view was created for (e.g. VirtualDevice)
384 0 : if(PageWindowCount())
385 : {
386 0 : SdrPageWindow* pExistingPageWindow = GetPageWindow(0L);
387 0 : SdrPaintWindow& rExistingPaintWindow = pExistingPageWindow->GetPaintWindow();
388 0 : const vcl::Region& rExistingRegion = rExistingPaintWindow.GetRedrawRegion();
389 0 : aTemporaryPaintWindow.SetRedrawRegion(rExistingRegion);
390 : }
391 :
392 0 : aTemporaryPageWindow.RedrawLayer(&nID, pRedirector);
393 : }
394 : }
395 : }
396 : else
397 : {
398 : // paint in all known windows
399 0 : for(sal_uInt32 a(0L); a < PageWindowCount(); a++)
400 : {
401 0 : SdrPageWindow* pTarget = GetPageWindow(a);
402 0 : pTarget->RedrawLayer(&nID, pRedirector);
403 : }
404 : }
405 : }
406 44116 : }
407 :
408 46 : void SdrPageView::SetDesignMode( bool _bDesignMode ) const
409 : {
410 92 : for ( sal_uInt32 i = 0L; i < PageWindowCount(); ++i )
411 : {
412 46 : const SdrPageWindow& rPageViewWindow = *GetPageWindow(i);
413 46 : rPageViewWindow.SetDesignMode( _bDesignMode );
414 : }
415 46 : }
416 :
417 :
418 :
419 16 : void SdrPageView::DrawPageViewGrid(OutputDevice& rOut, const Rectangle& rRect, Color aColor)
420 : {
421 16 : if (GetPage()==NULL)
422 16 : return;
423 :
424 16 : long nx1=GetView().aGridBig.Width();
425 16 : long nx2=GetView().aGridFin.Width();
426 16 : long ny1=GetView().aGridBig.Height();
427 16 : long ny2=GetView().aGridFin.Height();
428 :
429 16 : if (nx1==0) nx1=nx2;
430 16 : if (nx2==0) nx2=nx1;
431 16 : if (ny1==0) ny1=ny2;
432 16 : if (ny2==0) ny2=ny1;
433 16 : if (nx1==0) { nx1=ny1; nx2=ny2; }
434 16 : if (ny1==0) { ny1=nx1; ny2=nx2; }
435 16 : if (nx1<0) nx1=-nx1;
436 16 : if (nx2<0) nx2=-nx2;
437 16 : if (ny1<0) ny1=-ny1;
438 16 : if (ny2<0) ny2=-ny2;
439 :
440 16 : if (nx1!=0)
441 : {
442 : // no more global output size, use window size instead to decide grid sizes
443 16 : long nScreenWdt = rOut.GetOutputSizePixel().Width();
444 :
445 16 : long nMinDotPix=2;
446 16 : long nMinLinPix=4;
447 :
448 16 : if (nScreenWdt>=1600)
449 : {
450 0 : nMinDotPix=4;
451 0 : nMinLinPix=8;
452 : }
453 16 : else if (nScreenWdt>=1024)
454 : {
455 0 : nMinDotPix=3;
456 0 : nMinLinPix=6;
457 : }
458 : else
459 : { // e. g. 640x480
460 16 : nMinDotPix=2;
461 16 : nMinLinPix=4;
462 : }
463 16 : Size aMinDotDist(rOut.PixelToLogic(Size(nMinDotPix,nMinDotPix)));
464 16 : Size aMinLinDist(rOut.PixelToLogic(Size(nMinLinPix,nMinLinPix)));
465 16 : bool bHoriSolid=nx2<aMinDotDist.Width();
466 16 : bool bVertSolid=ny2<aMinDotDist.Height();
467 : // enlarge line offset (minimum 4 pixels)
468 : // enlarge by: *2 *5 *10 *20 *50 *100 ...
469 16 : int nTgl=0;
470 16 : long nVal0=nx1;
471 32 : while (nx1<aMinLinDist.Width())
472 : {
473 0 : long a=nx1;
474 :
475 0 : if (nTgl==0) nx1*=2;
476 0 : if (nTgl==1) nx1=nVal0*5; // => nx1*=2.5
477 0 : if (nTgl==2) nx1*=2;
478 :
479 0 : nVal0=a;
480 0 : nTgl++; if (nTgl>=3) nTgl=0;
481 : }
482 16 : nTgl=0;
483 16 : nVal0=ny1;
484 32 : while (ny1<aMinLinDist.Height())
485 : {
486 0 : long a=ny1;
487 :
488 0 : if (nTgl==0) ny1*=2;
489 0 : if (nTgl==1) ny1=nVal0*5; // => ny1*=2.5
490 0 : if (nTgl==2) ny1*=2;
491 :
492 0 : nVal0=a;
493 0 : nTgl++;
494 :
495 0 : if (nTgl>=3) nTgl=0;
496 : }
497 :
498 16 : bool bHoriFine=nx2<nx1;
499 16 : bool bVertFine=ny2<ny1;
500 16 : bool bHoriLines=bHoriSolid || bHoriFine || !bVertFine;
501 16 : bool bVertLines=bVertSolid || bVertFine;
502 :
503 16 : Color aColorMerk( rOut.GetLineColor() );
504 16 : rOut.SetLineColor( aColor );
505 :
506 16 : bool bMap0=rOut.IsMapModeEnabled();
507 :
508 16 : long nWrX=0;
509 16 : long nWrY=0;
510 16 : Point aOrg(aPgOrg);
511 16 : long x1=GetPage()->GetLftBorder()+1+nWrX;
512 16 : long x2=GetPage()->GetWdt()-GetPage()->GetRgtBorder()-1+nWrY;
513 16 : long y1=GetPage()->GetUppBorder()+1+nWrX;
514 16 : long y2=GetPage()->GetHgt()-GetPage()->GetLwrBorder()-1+nWrY;
515 16 : const SdrPageGridFrameList* pFrames=GetPage()->GetGridFrameList(this,NULL);
516 :
517 16 : sal_uInt16 nGridPaintAnz=1;
518 16 : if (pFrames!=NULL) nGridPaintAnz=pFrames->GetCount();
519 32 : for (sal_uInt16 nGridPaintNum=0; nGridPaintNum<nGridPaintAnz; nGridPaintNum++) {
520 16 : if (pFrames!=NULL) {
521 16 : const SdrPageGridFrame& rGF=(*pFrames)[nGridPaintNum];
522 16 : nWrX=rGF.GetPaperRect().Left();
523 16 : nWrY=rGF.GetPaperRect().Top();
524 16 : x1=rGF.GetUserArea().Left();
525 16 : x2=rGF.GetUserArea().Right();
526 16 : y1=rGF.GetUserArea().Top();
527 16 : y2=rGF.GetUserArea().Bottom();
528 16 : aOrg=rGF.GetUserArea().TopLeft();
529 16 : aOrg-=rGF.GetPaperRect().TopLeft();
530 : }
531 16 : if (!rRect.IsEmpty()) {
532 16 : Size a1PixSiz(rOut.PixelToLogic(Size(1,1)));
533 16 : long nX1Pix=a1PixSiz.Width(); // add 1 pixel of tolerance
534 16 : long nY1Pix=a1PixSiz.Height();
535 16 : if (x1<rRect.Left() -nX1Pix) x1=rRect.Left() -nX1Pix;
536 16 : if (x2>rRect.Right() +nX1Pix) x2=rRect.Right() +nX1Pix;
537 16 : if (y1<rRect.Top() -nY1Pix) y1=rRect.Top() -nY1Pix;
538 16 : if (y2>rRect.Bottom()+nY1Pix) y2=rRect.Bottom()+nY1Pix;
539 : }
540 :
541 16 : long xBigOrg=aOrg.X()+nWrX;
542 16 : while (xBigOrg>=x1) xBigOrg-=nx1;
543 16 : while (xBigOrg<x1) xBigOrg+=nx1;
544 16 : long xFinOrg=xBigOrg;
545 16 : while (xFinOrg>=x1) xFinOrg-=nx2;
546 16 : while (xFinOrg<x1) xFinOrg+=nx2;
547 :
548 16 : long yBigOrg=aOrg.Y()+nWrY;
549 16 : while (yBigOrg>=y1) yBigOrg-=ny1;
550 16 : while (yBigOrg<y1) yBigOrg+=ny1;
551 16 : long yFinOrg=yBigOrg;
552 16 : while (yFinOrg>=y1) yFinOrg-=ny2;
553 16 : while (yFinOrg<y1) yFinOrg+=ny2;
554 :
555 16 : if( x1 <= x2 && y1 <= y2 )
556 : {
557 16 : if( bHoriLines )
558 : {
559 16 : sal_uIntPtr nGridFlags = ( bHoriSolid ? GRID_HORZLINES : GRID_DOTS );
560 16 : sal_uInt16 nSteps = sal_uInt16(nx1 / nx2);
561 16 : sal_uInt32 nRestPerStepMul1000 = nSteps ? ( ((nx1 * 1000L)/ nSteps) - (nx2 * 1000L) ) : 0;
562 16 : sal_uInt32 nStepOffset = 0;
563 16 : sal_uInt16 nPointOffset = 0;
564 :
565 173 : for(sal_uInt16 a=0;a<nSteps;a++)
566 : {
567 : // draw
568 : rOut.DrawGrid(
569 157 : Rectangle( xFinOrg + (a * nx2) + nPointOffset, yBigOrg, x2, y2 ),
570 314 : Size( nx1, ny1 ), nGridFlags );
571 :
572 : // do a step
573 157 : nStepOffset += nRestPerStepMul1000;
574 406 : while(nStepOffset >= 1000)
575 : {
576 92 : nStepOffset -= 1000;
577 92 : nPointOffset++;
578 : }
579 : }
580 : }
581 :
582 16 : if( bVertLines )
583 : {
584 16 : sal_uIntPtr nGridFlags = ( bVertSolid ? GRID_VERTLINES : GRID_DOTS );
585 16 : sal_uInt16 nSteps = sal_uInt16(ny1 / ny2);
586 16 : sal_uInt32 nRestPerStepMul1000 = nSteps ? ( ((ny1 * 1000L)/ nSteps) - (ny2 * 1000L) ) : 0;
587 16 : sal_uInt32 nStepOffset = 0;
588 16 : sal_uInt16 nPointOffset = 0;
589 :
590 123 : for(sal_uInt16 a=0;a<nSteps;a++)
591 : {
592 : // draw
593 : rOut.DrawGrid(
594 107 : Rectangle( xBigOrg, yFinOrg + (a * ny2) + nPointOffset, x2, y2 ),
595 214 : Size( nx1, ny1 ), nGridFlags );
596 :
597 : // do a step
598 107 : nStepOffset += nRestPerStepMul1000;
599 244 : while(nStepOffset >= 1000)
600 : {
601 30 : nStepOffset -= 1000;
602 30 : nPointOffset++;
603 : }
604 : }
605 : }
606 : }
607 : }
608 :
609 16 : rOut.EnableMapMode(bMap0);
610 16 : rOut.SetLineColor(aColorMerk);
611 : }
612 : }
613 :
614 19956 : void SdrPageView::AdjHdl()
615 : {
616 19956 : GetView().AdjustMarkHdl();
617 19956 : }
618 :
619 24520 : void SdrPageView::SetLayer(const OUString& rName, SetOfByte& rBS, bool bJa)
620 : {
621 24520 : if(!GetPage())
622 24520 : return;
623 :
624 24520 : SdrLayerID nID = GetPage()->GetLayerAdmin().GetLayerID(rName, true);
625 :
626 24520 : if(SDRLAYER_NOTFOUND != nID)
627 24520 : rBS.Set(nID, bJa);
628 : }
629 :
630 10248 : bool SdrPageView::IsLayer(const OUString& rName, const SetOfByte& rBS) const
631 : {
632 10248 : if(!GetPage())
633 0 : return false;
634 :
635 10248 : bool bRet(false);
636 :
637 10248 : if (!rName.isEmpty())
638 : {
639 10248 : SdrLayerID nId = GetPage()->GetLayerAdmin().GetLayerID(rName, true);
640 :
641 10248 : if(SDRLAYER_NOTFOUND != nId)
642 : {
643 10248 : bRet = rBS.IsSet(nId);
644 : }
645 : }
646 :
647 10248 : return bRet;
648 : }
649 :
650 1450 : bool SdrPageView::IsObjMarkable(SdrObject* pObj) const
651 : {
652 1450 : if(pObj)
653 : {
654 : // excluded from selection?
655 1450 : if(pObj->IsMarkProtect())
656 : {
657 0 : return false;
658 : }
659 :
660 : // only visible are selectable
661 1450 : if( !pObj->IsVisible() )
662 : {
663 0 : return false;
664 : }
665 :
666 1450 : if(pObj->ISA(SdrObjGroup))
667 : {
668 : // If object is a Group object, visibility may depend on
669 : // multiple layers. If one object is markable, Group is markable.
670 128 : SdrObjList* pObjList = static_cast<SdrObjGroup*>(pObj)->GetSubList();
671 :
672 128 : if(pObjList && pObjList->GetObjCount())
673 : {
674 128 : bool bGroupIsMarkable(false);
675 :
676 352 : for(size_t a = 0; !bGroupIsMarkable && a < pObjList->GetObjCount(); ++a)
677 : {
678 224 : SdrObject* pCandidate = pObjList->GetObj(a);
679 :
680 : // call recursively
681 224 : if(IsObjMarkable(pCandidate))
682 : {
683 106 : bGroupIsMarkable = true;
684 : }
685 : }
686 :
687 128 : return bGroupIsMarkable;
688 : }
689 : else
690 : {
691 : // #i43302#
692 : // Allow empty groups to be selected to be able to delete them
693 0 : return true;
694 : }
695 : }
696 : else
697 : {
698 : // the layer has to be visible and must not be locked
699 1322 : SdrLayerID nL = pObj->GetLayer();
700 1322 : return (aLayerVisi.IsSet(sal_uInt8(nL)) && !aLayerLock.IsSet(sal_uInt8(nL)));
701 : }
702 : }
703 :
704 0 : return false;
705 : }
706 :
707 0 : void SdrPageView::SetPageOrigin(const Point& rOrg)
708 : {
709 0 : if (rOrg!=aPgOrg) {
710 0 : aPgOrg=rOrg;
711 0 : if (GetView().IsGridVisible()) {
712 0 : InvalidateAllWin();
713 : }
714 : }
715 0 : }
716 :
717 0 : void SdrPageView::ImpInvalidateHelpLineArea(sal_uInt16 nNum) const
718 : {
719 0 : if (GetView().IsHlplVisible() && nNum<aHelpLines.GetCount()) {
720 0 : const SdrHelpLine& rHL=aHelpLines[nNum];
721 :
722 0 : for(sal_uInt32 a(0L); a < GetView().PaintWindowCount(); a++)
723 : {
724 0 : SdrPaintWindow* pCandidate = GetView().GetPaintWindow(a);
725 :
726 0 : if(pCandidate->OutputToWindow())
727 : {
728 0 : OutputDevice& rOutDev = pCandidate->GetOutputDevice();
729 0 : Rectangle aR(rHL.GetBoundRect(rOutDev));
730 0 : Size aSiz(rOutDev.PixelToLogic(Size(1,1)));
731 0 : aR.Left() -= aSiz.Width();
732 0 : aR.Right() += aSiz.Width();
733 0 : aR.Top() -= aSiz.Height();
734 0 : aR.Bottom() += aSiz.Height();
735 0 : ((SdrView&)GetView()).InvalidateOneWin(static_cast<vcl::Window&>(rOutDev), aR);
736 : }
737 : }
738 : }
739 0 : }
740 :
741 220 : void SdrPageView::SetHelpLines(const SdrHelpLineList& rHLL)
742 : {
743 220 : aHelpLines=rHLL;
744 220 : InvalidateAllWin();
745 220 : }
746 :
747 0 : void SdrPageView::SetHelpLine(sal_uInt16 nNum, const SdrHelpLine& rNewHelpLine)
748 : {
749 0 : if (nNum<aHelpLines.GetCount() && aHelpLines[nNum]!=rNewHelpLine) {
750 0 : bool bNeedRedraw = true;
751 0 : if (aHelpLines[nNum].GetKind()==rNewHelpLine.GetKind()) {
752 0 : switch (rNewHelpLine.GetKind()) {
753 0 : case SDRHELPLINE_VERTICAL : if (aHelpLines[nNum].GetPos().X()==rNewHelpLine.GetPos().X()) bNeedRedraw = false; break;
754 0 : case SDRHELPLINE_HORIZONTAL: if (aHelpLines[nNum].GetPos().Y()==rNewHelpLine.GetPos().Y()) bNeedRedraw = false; break;
755 0 : default: break;
756 : } // switch
757 : }
758 0 : if (bNeedRedraw) ImpInvalidateHelpLineArea(nNum);
759 0 : aHelpLines[nNum]=rNewHelpLine;
760 0 : if (bNeedRedraw) ImpInvalidateHelpLineArea(nNum);
761 : }
762 0 : }
763 :
764 0 : void SdrPageView::DeleteHelpLine(sal_uInt16 nNum)
765 : {
766 0 : if (nNum<aHelpLines.GetCount()) {
767 0 : ImpInvalidateHelpLineArea(nNum);
768 0 : aHelpLines.Delete(nNum);
769 : }
770 0 : }
771 :
772 0 : void SdrPageView::InsertHelpLine(const SdrHelpLine& rHL, sal_uInt16 nNum)
773 : {
774 0 : if (nNum > aHelpLines.GetCount())
775 0 : nNum = aHelpLines.GetCount();
776 0 : aHelpLines.Insert(rHL,nNum);
777 0 : if (GetView().IsHlplVisible())
778 0 : ImpInvalidateHelpLineArea(nNum);
779 0 : }
780 :
781 : // set current group and list
782 8041 : void SdrPageView::SetAktGroupAndList(SdrObject* pNewGroup, SdrObjList* pNewList)
783 : {
784 8041 : if(pAktGroup != pNewGroup)
785 : {
786 0 : pAktGroup = pNewGroup;
787 : }
788 8041 : if(pAktList != pNewList)
789 : {
790 8041 : pAktList = pNewList;
791 : }
792 8041 : }
793 :
794 0 : bool SdrPageView::EnterGroup(SdrObject* pObj)
795 : {
796 0 : bool bRet(false);
797 :
798 0 : if(pObj && pObj->IsGroupObject())
799 : {
800 0 : bool bGlueInvalidate(GetView().ImpIsGlueVisible());
801 :
802 0 : if(bGlueInvalidate)
803 : {
804 0 : GetView().GlueInvalidate();
805 : }
806 :
807 : // deselect all
808 0 : GetView().UnmarkAll();
809 :
810 : // set current group and list
811 0 : SdrObjList* pNewObjList = pObj->GetSubList();
812 0 : SetAktGroupAndList(pObj, pNewObjList);
813 :
814 : // select contained object if only one object is contained,
815 : // else select nothing and let the user decide what to do next
816 0 : if(pNewObjList && pNewObjList->GetObjCount() == 1)
817 : {
818 0 : SdrObject* pFirstObject = pNewObjList->GetObj(0);
819 :
820 0 : if(GetView().GetSdrPageView())
821 : {
822 0 : GetView().MarkObj(pFirstObject, GetView().GetSdrPageView());
823 : }
824 : }
825 :
826 : // build new handles
827 0 : GetView().AdjustMarkHdl();
828 :
829 : // invalidate only when view wants to visualize group entering
830 0 : if(GetView().DoVisualizeEnteredGroup())
831 : {
832 0 : InvalidateAllWin();
833 : }
834 :
835 0 : if (bGlueInvalidate)
836 : {
837 0 : GetView().GlueInvalidate();
838 : }
839 :
840 0 : bRet = true;
841 : }
842 :
843 0 : return bRet;
844 : }
845 :
846 0 : void SdrPageView::LeaveOneGroup()
847 : {
848 0 : if(GetAktGroup())
849 : {
850 0 : bool bGlueInvalidate = (GetView().ImpIsGlueVisible());
851 :
852 0 : if(bGlueInvalidate)
853 0 : GetView().GlueInvalidate();
854 :
855 0 : SdrObject* pLastGroup = GetAktGroup();
856 0 : SdrObject* pParentGroup = GetAktGroup()->GetUpGroup();
857 0 : SdrObjList* pParentList = GetPage();
858 :
859 0 : if(pParentGroup)
860 0 : pParentList = pParentGroup->GetSubList();
861 :
862 : // deselect everything
863 0 : GetView().UnmarkAll();
864 :
865 : // allocations, pAktGroup and pAktList need to be set
866 0 : SetAktGroupAndList(pParentGroup, pParentList);
867 :
868 : // select the group we just left
869 0 : if(pLastGroup)
870 0 : if(GetView().GetSdrPageView())
871 0 : GetView().MarkObj(pLastGroup, GetView().GetSdrPageView());
872 :
873 0 : GetView().AdjustMarkHdl();
874 :
875 : // invalidate only if view wants to visualize group entering
876 0 : if(GetView().DoVisualizeEnteredGroup())
877 0 : InvalidateAllWin();
878 :
879 0 : if(bGlueInvalidate)
880 0 : GetView().GlueInvalidate();
881 : }
882 0 : }
883 :
884 0 : void SdrPageView::LeaveAllGroup()
885 : {
886 0 : if(GetAktGroup())
887 : {
888 0 : bool bGlueInvalidate = (GetView().ImpIsGlueVisible());
889 :
890 0 : if(bGlueInvalidate)
891 0 : GetView().GlueInvalidate();
892 :
893 0 : SdrObject* pLastGroup = GetAktGroup();
894 :
895 : // deselect everything
896 0 : GetView().UnmarkAll();
897 :
898 : // allocations, pAktGroup and pAktList always need to be set
899 0 : SetAktGroupAndList(NULL, GetPage());
900 :
901 : // find and select uppermost group
902 0 : if(pLastGroup)
903 : {
904 0 : while(pLastGroup->GetUpGroup())
905 0 : pLastGroup = pLastGroup->GetUpGroup();
906 :
907 0 : if(GetView().GetSdrPageView())
908 0 : GetView().MarkObj(pLastGroup, GetView().GetSdrPageView());
909 : }
910 :
911 0 : GetView().AdjustMarkHdl();
912 :
913 : // invalidate only when view wants to visualize group entering
914 0 : if(GetView().DoVisualizeEnteredGroup())
915 0 : InvalidateAllWin();
916 :
917 0 : if(bGlueInvalidate)
918 0 : GetView().GlueInvalidate();
919 : }
920 0 : }
921 :
922 4227 : sal_uInt16 SdrPageView::GetEnteredLevel() const
923 : {
924 4227 : sal_uInt16 nAnz=0;
925 4227 : SdrObject* pGrp=GetAktGroup();
926 8454 : while (pGrp!=NULL) {
927 0 : nAnz++;
928 0 : pGrp=pGrp->GetUpGroup();
929 : }
930 4227 : return nAnz;
931 : }
932 :
933 0 : void SdrPageView::CheckAktGroup()
934 : {
935 0 : SdrObject* pGrp=GetAktGroup();
936 0 : while (pGrp!=NULL &&
937 0 : (!pGrp->IsInserted() || pGrp->GetObjList()==NULL ||
938 0 : pGrp->GetPage()==NULL || pGrp->GetModel()==NULL)) { // anything outside of the borders?
939 0 : pGrp=pGrp->GetUpGroup();
940 : }
941 0 : if (pGrp!=GetAktGroup()) {
942 0 : if (pGrp!=NULL) EnterGroup(pGrp);
943 0 : else LeaveAllGroup();
944 : }
945 0 : }
946 :
947 : // Set background color for svx at SdrPageViews
948 716 : void SdrPageView::SetApplicationBackgroundColor(Color aBackgroundColor)
949 : {
950 716 : maBackgroundColor = aBackgroundColor;
951 716 : }
952 :
953 :
954 : // Set document color for svx at SdrPageViews
955 181 : void SdrPageView::SetApplicationDocumentColor(Color aDocumentColor)
956 : {
957 181 : maDocumentColor = aDocumentColor;
958 832 : }
959 :
960 :
961 :
962 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
