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/sdr/primitive2d/sdrattributecreator.hxx>
21 : #include <svl/itemset.hxx>
22 : #include <svx/xdef.hxx>
23 : #include <basegfx/polygon/b2dpolygon.hxx>
24 : #include <svx/xlineit0.hxx>
25 : #include <svx/xfillit0.hxx>
26 : #include <svx/xlntrit.hxx>
27 : #include <svx/xlnwtit.hxx>
28 : #include <svx/xlinjoit.hxx>
29 : #include <svx/xlncapit.hxx>
30 : #include <svx/xlnclit.hxx>
31 : #include <svx/xlnstwit.hxx>
32 : #include <svx/xlnedwit.hxx>
33 : #include <svx/xlnstit.hxx>
34 : #include <svx/xlnstcit.hxx>
35 : #include <svx/xlnedit.hxx>
36 : #include <svx/xlnedcit.hxx>
37 : #include <svx/xdash.hxx>
38 : #include <svx/xlndsit.hxx>
39 : #include <svx/xfltrit.hxx>
40 : #include <svx/xflftrit.hxx>
41 : #include <svx/xflclit.hxx>
42 : #include <svx/xgrscit.hxx>
43 : #include <svx/xflhtit.hxx>
44 : #include <svx/xflbckit.hxx>
45 : #include <svx/sdshitm.hxx>
46 : #include <svx/sdsxyitm.hxx>
47 : #include <svx/sdshcitm.hxx>
48 : #include <svx/sdshtitm.hxx>
49 : #include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
50 : #include <basegfx/polygon/b2dlinegeometry.hxx>
51 : #include <svx/svdotext.hxx>
52 : #include <drawinglayer/attribute/fillbitmapattribute.hxx>
53 : #include <svx/sdr/attribute/sdrtextattribute.hxx>
54 : #include <svx/xbtmpit.hxx>
55 : #include <svl/itempool.hxx>
56 : #include <vcl/svapp.hxx>
57 : #include <basegfx/range/b2drange.hxx>
58 : #include <svx/svx3ditems.hxx>
59 : #include <com/sun/star/drawing/ProjectionMode.hpp>
60 : #include <com/sun/star/drawing/ShadeMode.hpp>
61 : #include <drawinglayer/attribute/sdrallattribute3d.hxx>
62 : #include <svx/rectenum.hxx>
63 : #include <svx/sdtfchim.hxx>
64 : #include <svx/svdoutl.hxx>
65 : #include <svx/svdmodel.hxx>
66 : #include <editeng/editstat.hxx>
67 : #include <drawinglayer/attribute/fillhatchattribute.hxx>
68 : #include <drawinglayer/attribute/fillgradientattribute.hxx>
69 : #include <svx/sdr/attribute/sdrshadowtextattribute.hxx>
70 : #include <svx/sdr/attribute/sdrlineshadowtextattribute.hxx>
71 : #include <svx/sdr/attribute/sdrformtextattribute.hxx>
72 : #include <svx/sdr/attribute/sdrlinefillshadowtextattribute.hxx>
73 : #include <drawinglayer/attribute/sdrsceneattribute3d.hxx>
74 : #include <drawinglayer/attribute/sdrlightingattribute3d.hxx>
75 : #include <drawinglayer/attribute/sdrlightattribute3d.hxx>
76 : #include <svx/sdr/attribute/sdrfilltextattribute.hxx>
77 : #include <com/sun/star/drawing/LineCap.hpp>
78 :
79 : //////////////////////////////////////////////////////////////////////////////
80 :
81 : namespace drawinglayer
82 : {
83 : namespace
84 : {
85 0 : attribute::GradientStyle XGradientStyleToGradientStyle(XGradientStyle eStyle)
86 : {
87 0 : switch(eStyle)
88 : {
89 : case XGRAD_LINEAR :
90 : {
91 0 : return attribute::GRADIENTSTYLE_LINEAR;
92 : }
93 : case XGRAD_AXIAL :
94 : {
95 0 : return attribute::GRADIENTSTYLE_AXIAL;
96 : }
97 : case XGRAD_RADIAL :
98 : {
99 0 : return attribute::GRADIENTSTYLE_RADIAL;
100 : }
101 : case XGRAD_ELLIPTICAL :
102 : {
103 0 : return attribute::GRADIENTSTYLE_ELLIPTICAL;
104 : }
105 : case XGRAD_SQUARE :
106 : {
107 0 : return attribute::GRADIENTSTYLE_SQUARE;
108 : }
109 : default :
110 : {
111 0 : return attribute::GRADIENTSTYLE_RECT; // XGRAD_RECT
112 : }
113 : }
114 : }
115 :
116 0 : attribute::HatchStyle XHatchStyleToHatchStyle(XHatchStyle eStyle)
117 : {
118 0 : switch(eStyle)
119 : {
120 : case XHATCH_SINGLE :
121 : {
122 0 : return attribute::HATCHSTYLE_SINGLE;
123 : }
124 : case XHATCH_DOUBLE :
125 : {
126 0 : return attribute::HATCHSTYLE_DOUBLE;
127 : }
128 : default :
129 : {
130 0 : return attribute::HATCHSTYLE_TRIPLE; // XHATCH_TRIPLE
131 : }
132 : }
133 : }
134 :
135 141 : basegfx::B2DLineJoin XLineJointtoB2DLineJoin(XLineJoint eLineJoint)
136 : {
137 141 : switch(eLineJoint)
138 : {
139 : case XLINEJOINT_MIDDLE :
140 : {
141 0 : return basegfx::B2DLINEJOIN_MIDDLE;
142 : }
143 : case XLINEJOINT_BEVEL :
144 : {
145 0 : return basegfx::B2DLINEJOIN_BEVEL;
146 : }
147 : case XLINEJOINT_MITER :
148 : {
149 80 : return basegfx::B2DLINEJOIN_MITER;
150 : }
151 : case XLINEJOINT_ROUND :
152 : {
153 61 : return basegfx::B2DLINEJOIN_ROUND;
154 : }
155 : default :
156 : {
157 0 : return basegfx::B2DLINEJOIN_NONE; // XLINEJOINT_NONE
158 : }
159 : }
160 : }
161 :
162 0 : basegfx::B2DVector RectPointToB2DVector(RECT_POINT eRectPoint)
163 : {
164 0 : basegfx::B2DVector aRetval(0.0, 0.0);
165 :
166 : // position changes X
167 0 : switch(eRectPoint)
168 : {
169 : case RP_LT: case RP_LM: case RP_LB:
170 : {
171 0 : aRetval.setX(-1.0);
172 0 : break;
173 : }
174 :
175 : case RP_RT: case RP_RM: case RP_RB:
176 : {
177 0 : aRetval.setX(1.0);
178 0 : break;
179 : }
180 :
181 : default :
182 : {
183 0 : break;
184 : }
185 : }
186 :
187 : // position changes Y
188 0 : switch(eRectPoint)
189 : {
190 : case RP_LT: case RP_MT: case RP_RT:
191 : {
192 0 : aRetval.setY(-1.0);
193 0 : break;
194 : }
195 :
196 : case RP_LB: case RP_MB: case RP_RB:
197 : {
198 0 : aRetval.setY(1.0);
199 0 : break;
200 : }
201 :
202 : default :
203 : {
204 0 : break;
205 : }
206 : }
207 :
208 0 : return aRetval;
209 : }
210 : } // end of anonymous namespace
211 : } // end of namespace drawinglayer
212 :
213 : //////////////////////////////////////////////////////////////////////////////
214 :
215 : namespace drawinglayer
216 : {
217 : namespace primitive2d
218 : {
219 348 : attribute::SdrLineAttribute createNewSdrLineAttribute(const SfxItemSet& rSet)
220 : {
221 348 : const XLineStyle eStyle(((XLineStyleItem&)(rSet.Get(XATTR_LINESTYLE))).GetValue());
222 :
223 348 : if(XLINE_NONE != eStyle)
224 : {
225 141 : sal_uInt16 nTransparence(((const XLineTransparenceItem&)(rSet.Get(XATTR_LINETRANSPARENCE))).GetValue());
226 :
227 141 : if(nTransparence > 100)
228 : {
229 0 : nTransparence = 100;
230 : }
231 :
232 141 : if(100 != nTransparence)
233 : {
234 141 : const sal_uInt32 nWidth(((const XLineWidthItem&)(rSet.Get(XATTR_LINEWIDTH))).GetValue());
235 141 : const Color aColor(((const XLineColorItem&)(rSet.Get(XATTR_LINECOLOR))).GetColorValue());
236 141 : const XLineJoint eJoint(((const XLineJointItem&)(rSet.Get(XATTR_LINEJOINT))).GetValue());
237 141 : const com::sun::star::drawing::LineCap eCap(((const XLineCapItem&)(rSet.Get(XATTR_LINECAP))).GetValue());
238 141 : ::std::vector< double > aDotDashArray;
239 141 : double fFullDotDashLen(0.0);
240 :
241 141 : if(XLINE_DASH == eStyle)
242 : {
243 0 : const XDash& rDash = ((const XLineDashItem&)(rSet.Get(XATTR_LINEDASH))).GetDashValue();
244 :
245 0 : if(rDash.GetDots() || rDash.GetDashes())
246 : {
247 0 : fFullDotDashLen = rDash.CreateDotDashArray(aDotDashArray, (double)nWidth);
248 : }
249 : }
250 :
251 : return attribute::SdrLineAttribute(
252 : XLineJointtoB2DLineJoin(eJoint),
253 : (double)nWidth,
254 : (double)nTransparence * 0.01,
255 : aColor.getBColor(),
256 : eCap,
257 : aDotDashArray,
258 141 : fFullDotDashLen);
259 : }
260 : }
261 :
262 207 : return attribute::SdrLineAttribute();
263 : }
264 :
265 141 : attribute::SdrLineStartEndAttribute createNewSdrLineStartEndAttribute(
266 : const SfxItemSet& rSet,
267 : double fWidth)
268 : {
269 141 : const sal_Int32 nTempStartWidth(((const XLineStartWidthItem&)(rSet.Get(XATTR_LINESTARTWIDTH))).GetValue());
270 141 : const sal_Int32 nTempEndWidth(((const XLineEndWidthItem&)(rSet.Get(XATTR_LINEENDWIDTH))).GetValue());
271 141 : basegfx::B2DPolyPolygon aStartPolyPolygon;
272 141 : basegfx::B2DPolyPolygon aEndPolyPolygon;
273 141 : double fStartWidth(0.0);
274 141 : double fEndWidth(0.0);
275 141 : bool bStartActive(false);
276 141 : bool bEndActive(false);
277 141 : bool bStartCentered(true);
278 141 : bool bEndCentered(true);
279 :
280 141 : if(nTempStartWidth)
281 : {
282 141 : if(nTempStartWidth < 0L)
283 : {
284 0 : fStartWidth = ((double)(-nTempStartWidth) * fWidth) * 0.01;
285 : }
286 : else
287 : {
288 141 : fStartWidth = (double)nTempStartWidth;
289 : }
290 :
291 141 : if(0.0 != fStartWidth)
292 : {
293 141 : aStartPolyPolygon = basegfx::B2DPolyPolygon(((const XLineStartItem&)(rSet.Get(XATTR_LINESTART))).GetLineStartValue());
294 :
295 141 : if(aStartPolyPolygon.count() && aStartPolyPolygon.getB2DPolygon(0L).count())
296 : {
297 1 : bStartActive = true;
298 1 : bStartCentered = ((const XLineStartCenterItem&)(rSet.Get(XATTR_LINESTARTCENTER))).GetValue();
299 : }
300 : }
301 : }
302 :
303 141 : if(nTempEndWidth)
304 : {
305 141 : if(nTempEndWidth < 0L)
306 : {
307 0 : fEndWidth = ((double)(-nTempEndWidth) * fWidth) * 0.01;
308 : }
309 : else
310 : {
311 141 : fEndWidth = (double)nTempEndWidth;
312 : }
313 :
314 141 : if(0.0 != fEndWidth)
315 : {
316 141 : aEndPolyPolygon = basegfx::B2DPolyPolygon(((const XLineEndItem&)(rSet.Get(XATTR_LINEEND))).GetLineEndValue());
317 :
318 141 : if(aEndPolyPolygon.count() && aEndPolyPolygon.getB2DPolygon(0L).count())
319 : {
320 4 : bEndActive = true;
321 4 : bEndCentered = ((const XLineEndCenterItem&)(rSet.Get(XATTR_LINEENDCENTER))).GetValue();
322 : }
323 : }
324 : }
325 :
326 141 : if(bStartActive || bEndActive)
327 : {
328 : return attribute::SdrLineStartEndAttribute(
329 : aStartPolyPolygon, aEndPolyPolygon, fStartWidth, fEndWidth,
330 5 : bStartActive, bEndActive, bStartCentered, bEndCentered);
331 : }
332 :
333 136 : return attribute::SdrLineStartEndAttribute();
334 : }
335 :
336 510 : attribute::SdrShadowAttribute createNewSdrShadowAttribute(const SfxItemSet& rSet)
337 : {
338 510 : const bool bShadow(((SdrShadowItem&)rSet.Get(SDRATTR_SHADOW)).GetValue());
339 :
340 510 : if(bShadow)
341 : {
342 0 : sal_uInt16 nTransparence(((SdrShadowTransparenceItem&)(rSet.Get(SDRATTR_SHADOWTRANSPARENCE))).GetValue());
343 :
344 0 : if(nTransparence > 100)
345 : {
346 0 : nTransparence = 100;
347 : }
348 :
349 0 : if(nTransparence)
350 : {
351 0 : sal_uInt16 nFillTransparence(((const XFillTransparenceItem&)(rSet.Get(XATTR_FILLTRANSPARENCE))).GetValue());
352 :
353 0 : if(nFillTransparence > 100)
354 : {
355 0 : nFillTransparence = 100;
356 : }
357 :
358 0 : if(nTransparence == nFillTransparence)
359 : {
360 : // shadow does not really have an own transparence, but the application
361 : // sets the shadow transparence equal to the object transparence for
362 : // convenience. This is not useful for primitive creation, so take
363 : // this as no shadow transparence
364 0 : nTransparence = 0;
365 : }
366 : }
367 :
368 0 : if(100 != nTransparence)
369 : {
370 : const basegfx::B2DVector aOffset(
371 0 : (double)((SdrShadowXDistItem&)(rSet.Get(SDRATTR_SHADOWXDIST))).GetValue(),
372 0 : (double)((SdrShadowYDistItem&)(rSet.Get(SDRATTR_SHADOWYDIST))).GetValue());
373 0 : const Color aColor(((SdrShadowColorItem&)(rSet.Get(SDRATTR_SHADOWCOLOR))).GetColorValue());
374 :
375 0 : return attribute::SdrShadowAttribute(aOffset, (double)nTransparence * 0.01, aColor.getBColor());
376 : }
377 : }
378 :
379 510 : return attribute::SdrShadowAttribute();
380 : }
381 :
382 345 : attribute::SdrFillAttribute createNewSdrFillAttribute(const SfxItemSet& rSet)
383 : {
384 345 : const XFillStyle eStyle(((XFillStyleItem&)(rSet.Get(XATTR_FILLSTYLE))).GetValue());
385 :
386 345 : if(XFILL_NONE != eStyle)
387 : {
388 54 : sal_uInt16 nTransparence(((const XFillTransparenceItem&)(rSet.Get(XATTR_FILLTRANSPARENCE))).GetValue());
389 :
390 54 : if(nTransparence > 100)
391 : {
392 0 : nTransparence = 100;
393 : }
394 :
395 54 : if(100 != nTransparence)
396 : {
397 39 : const Color aColor(((const XFillColorItem&)(rSet.Get(XATTR_FILLCOLOR))).GetColorValue());
398 39 : attribute::FillGradientAttribute aGradient;
399 39 : attribute::FillHatchAttribute aHatch;
400 39 : attribute::SdrFillBitmapAttribute aBitmap;
401 :
402 39 : switch(eStyle)
403 : {
404 : case XFILL_NONE : // for warnings
405 : case XFILL_SOLID :
406 : {
407 : // nothing to do, color is defined
408 39 : break;
409 : }
410 : case XFILL_GRADIENT :
411 : {
412 0 : XGradient aXGradient(((XFillGradientItem&)(rSet.Get(XATTR_FILLGRADIENT))).GetGradientValue());
413 :
414 0 : const Color aStartColor(aXGradient.GetStartColor());
415 0 : const sal_uInt16 nStartIntens(aXGradient.GetStartIntens());
416 0 : basegfx::BColor aStart(aStartColor.getBColor());
417 :
418 0 : if(nStartIntens != 100)
419 : {
420 0 : const basegfx::BColor aBlack;
421 0 : aStart = interpolate(aBlack, aStart, (double)nStartIntens * 0.01);
422 : }
423 :
424 0 : const Color aEndColor(aXGradient.GetEndColor());
425 0 : const sal_uInt16 nEndIntens(aXGradient.GetEndIntens());
426 0 : basegfx::BColor aEnd(aEndColor.getBColor());
427 :
428 0 : if(nEndIntens != 100)
429 : {
430 0 : const basegfx::BColor aBlack;
431 0 : aEnd = interpolate(aBlack, aEnd, (double)nEndIntens * 0.01);
432 : }
433 :
434 : aGradient = attribute::FillGradientAttribute(
435 : XGradientStyleToGradientStyle(aXGradient.GetGradientStyle()),
436 0 : (double)aXGradient.GetBorder() * 0.01,
437 0 : (double)aXGradient.GetXOffset() * 0.01,
438 0 : (double)aXGradient.GetYOffset() * 0.01,
439 0 : (double)aXGradient.GetAngle() * F_PI1800,
440 : aStart,
441 : aEnd,
442 0 : ((const XGradientStepCountItem&)rSet.Get(XATTR_GRADIENTSTEPCOUNT)).GetValue());
443 :
444 0 : break;
445 : }
446 : case XFILL_HATCH :
447 : {
448 0 : const XHatch& rHatch(((XFillHatchItem&)(rSet.Get(XATTR_FILLHATCH))).GetHatchValue());
449 0 : const Color aColorB(rHatch.GetColor());
450 :
451 : aHatch = attribute::FillHatchAttribute(
452 : XHatchStyleToHatchStyle(rHatch.GetHatchStyle()),
453 0 : (double)rHatch.GetDistance(),
454 0 : (double)rHatch.GetAngle() * F_PI1800,
455 : aColorB.getBColor(),
456 0 : ((const XFillBackgroundItem&)(rSet.Get(XATTR_FILLBACKGROUND))).GetValue());
457 :
458 : break;
459 : }
460 : case XFILL_BITMAP :
461 : {
462 0 : aBitmap = createNewSdrFillBitmapAttribute(rSet);
463 0 : break;
464 : }
465 : }
466 :
467 : return attribute::SdrFillAttribute(
468 : (double)nTransparence * 0.01,
469 : aColor.getBColor(),
470 : aGradient,
471 : aHatch,
472 39 : aBitmap);
473 : }
474 : }
475 :
476 306 : return attribute::SdrFillAttribute();
477 : }
478 :
479 : // #i101508# Support handing over given text-to-border distances
480 601 : attribute::SdrTextAttribute createNewSdrTextAttribute(
481 : const SfxItemSet& rSet,
482 : const SdrText& rText,
483 : const sal_Int32* pLeft,
484 : const sal_Int32* pUpper,
485 : const sal_Int32* pRight,
486 : const sal_Int32* pLower)
487 : {
488 601 : const SdrTextObj& rTextObj = rText.GetObject();
489 :
490 601 : if(rText.GetOutlinerParaObject() && rText.GetModel())
491 : {
492 : // added TextEdit text suppression
493 88 : bool bInEditMode(false);
494 :
495 88 : if(rText.GetObject().getTextCount() > 1)
496 : {
497 0 : bInEditMode = rTextObj.IsInEditMode() && rText.GetObject().getActiveText() == &rText;
498 : }
499 : else
500 : {
501 88 : bInEditMode = rTextObj.IsInEditMode();
502 : }
503 :
504 88 : OutlinerParaObject aOutlinerParaObject(*rText.GetOutlinerParaObject());
505 :
506 88 : if(bInEditMode)
507 : {
508 0 : OutlinerParaObject* pTempObj = rTextObj.GetEditOutlinerParaObject();
509 :
510 0 : if(pTempObj)
511 : {
512 0 : aOutlinerParaObject = *pTempObj;
513 0 : delete pTempObj;
514 : }
515 : else
516 : {
517 : // #i100537#
518 : // GetEditOutlinerParaObject() returning no object does not mean that
519 : // text edit mode is not active. Do not reset the flag here
520 : // bInEditMode = false;
521 : }
522 : }
523 :
524 88 : const SdrTextAniKind eAniKind(rTextObj.GetTextAniKind());
525 :
526 : // #i107346#
527 88 : const SdrOutliner& rDrawTextOutliner = rText.GetModel()->GetDrawOutliner(&rTextObj);
528 88 : const bool bWrongSpell(rDrawTextOutliner.GetControlWord() & EE_CNTRL_ONLINESPELLING);
529 :
530 : return attribute::SdrTextAttribute(
531 : rText,
532 : aOutlinerParaObject,
533 88 : ((const XFormTextStyleItem&)rSet.Get(XATTR_FORMTXTSTYLE)).GetValue(),
534 : pLeft ? *pLeft : rTextObj.GetTextLeftDistance(),
535 : pUpper ? *pUpper : rTextObj.GetTextUpperDistance(),
536 : pRight ? *pRight : rTextObj.GetTextRightDistance(),
537 : pLower ? *pLower : rTextObj.GetTextLowerDistance(),
538 : rTextObj.GetTextHorizontalAdjust(rSet),
539 : rTextObj.GetTextVerticalAdjust(rSet),
540 88 : ((const SdrTextContourFrameItem&)rSet.Get(SDRATTR_TEXT_CONTOURFRAME)).GetValue(),
541 88 : rTextObj.IsFitToSize(),
542 88 : rTextObj.IsAutoFit(),
543 88 : ((const XFormTextHideFormItem&)rSet.Get(XATTR_FORMTXTHIDEFORM)).GetValue(),
544 : SDRTEXTANI_BLINK == eAniKind,
545 : SDRTEXTANI_SCROLL == eAniKind || SDRTEXTANI_ALTERNATE == eAniKind || SDRTEXTANI_SLIDE == eAniKind,
546 : bInEditMode,
547 88 : ((const SdrTextFixedCellHeightItem&)rSet.Get(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue(),
548 616 : bWrongSpell);
549 : }
550 :
551 513 : return attribute::SdrTextAttribute();
552 : }
553 :
554 39 : attribute::FillGradientAttribute createNewTransparenceGradientAttribute(const SfxItemSet& rSet)
555 : {
556 : const SfxPoolItem* pGradientItem;
557 :
558 39 : if(SFX_ITEM_SET == rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, sal_True, &pGradientItem)
559 0 : && ((XFillFloatTransparenceItem*)pGradientItem)->IsEnabled())
560 : {
561 : // test if float transparence is completely transparent
562 0 : const XGradient& rGradient = ((XFillFloatTransparenceItem*)pGradientItem)->GetGradientValue();
563 0 : const sal_uInt8 nStartLuminance(rGradient.GetStartColor().GetLuminance());
564 0 : const sal_uInt8 nEndLuminance(rGradient.GetEndColor().GetLuminance());
565 0 : const bool bCompletelyTransparent(0xff == nStartLuminance && 0xff == nEndLuminance);
566 :
567 0 : if(!bCompletelyTransparent)
568 : {
569 0 : const double fStartLum(nStartLuminance / 255.0);
570 0 : const double fEndLum(nEndLuminance / 255.0);
571 :
572 : return attribute::FillGradientAttribute(
573 : XGradientStyleToGradientStyle(rGradient.GetGradientStyle()),
574 0 : (double)rGradient.GetBorder() * 0.01,
575 0 : (double)rGradient.GetXOffset() * 0.01,
576 0 : (double)rGradient.GetYOffset() * 0.01,
577 0 : (double)rGradient.GetAngle() * F_PI1800,
578 : basegfx::BColor(fStartLum, fStartLum, fStartLum),
579 : basegfx::BColor(fEndLum, fEndLum, fEndLum),
580 0 : 0);
581 : }
582 : }
583 :
584 39 : return attribute::FillGradientAttribute();
585 : }
586 :
587 0 : attribute::SdrFillBitmapAttribute createNewSdrFillBitmapAttribute(const SfxItemSet& rSet)
588 : {
589 0 : Bitmap aBitmap((((const XFillBitmapItem&)(rSet.Get(XATTR_FILLBITMAP))).GetBitmapValue()).GetBitmap());
590 :
591 : // make sure it's not empty, use default instead
592 0 : if(aBitmap.IsEmpty())
593 : {
594 : // #i118485# Add PrefMapMode and PrefSize to avoid mini-tiling and
595 : // expensive primitive processing in this case. Use 10x10 cm
596 0 : aBitmap = Bitmap(Size(4,4), 8);
597 0 : aBitmap.SetPrefMapMode(MapMode(MAP_100TH_MM));
598 0 : aBitmap.SetPrefSize(Size(10000.0, 10000.0));
599 : }
600 :
601 : // if there is no logical size, create a size from pixel size and set MapMode accordingly
602 0 : if(0L == aBitmap.GetPrefSize().Width() || 0L == aBitmap.GetPrefSize().Height())
603 : {
604 0 : aBitmap.SetPrefSize(aBitmap.GetSizePixel());
605 0 : aBitmap.SetPrefMapMode(MAP_PIXEL);
606 : }
607 :
608 : // convert size and MapMode to destination logical size and MapMode. The created
609 : // bitmap must have a valid logical size (PrefSize)
610 0 : const MapUnit aDestinationMapUnit((MapUnit)rSet.GetPool()->GetMetric(0));
611 :
612 0 : if(aBitmap.GetPrefMapMode() != aDestinationMapUnit)
613 : {
614 : // #i100360# for MAP_PIXEL, LogicToLogic will not work properly,
615 : // so fallback to Application::GetDefaultDevice()
616 0 : if(MAP_PIXEL == aBitmap.GetPrefMapMode().GetMapUnit())
617 : {
618 : aBitmap.SetPrefSize(Application::GetDefaultDevice()->PixelToLogic(
619 0 : aBitmap.GetPrefSize(), aDestinationMapUnit));
620 : }
621 : else
622 : {
623 : aBitmap.SetPrefSize(OutputDevice::LogicToLogic(
624 0 : aBitmap.GetPrefSize(), aBitmap.GetPrefMapMode(), aDestinationMapUnit));
625 : }
626 : }
627 :
628 : // get size
629 : const basegfx::B2DVector aSize(
630 0 : (double)((const SfxMetricItem&)(rSet.Get(XATTR_FILLBMP_SIZEX))).GetValue(),
631 0 : (double)((const SfxMetricItem&)(rSet.Get(XATTR_FILLBMP_SIZEY))).GetValue());
632 : const basegfx::B2DVector aOffset(
633 0 : (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_TILEOFFSETX))).GetValue(),
634 0 : (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_TILEOFFSETY))).GetValue());
635 : const basegfx::B2DVector aOffsetPosition(
636 0 : (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_POSOFFSETX))).GetValue(),
637 0 : (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_POSOFFSETY))).GetValue());
638 :
639 : return attribute::SdrFillBitmapAttribute(
640 : aBitmap,
641 : aSize,
642 : aOffset,
643 : aOffsetPosition,
644 0 : RectPointToB2DVector((RECT_POINT)((const SfxEnumItem&)(rSet.Get(XATTR_FILLBMP_POS))).GetValue()),
645 0 : ((const SfxBoolItem&) (rSet.Get(XATTR_FILLBMP_TILE))).GetValue(),
646 0 : ((const SfxBoolItem&) (rSet.Get(XATTR_FILLBMP_STRETCH))).GetValue(),
647 0 : ((const SfxBoolItem&) (rSet.Get(XATTR_FILLBMP_SIZELOG))).GetValue());
648 : }
649 :
650 253 : attribute::SdrShadowTextAttribute createNewSdrShadowTextAttribute(
651 : const SfxItemSet& rSet,
652 : const SdrText* pText,
653 : bool bSuppressText)
654 : {
655 253 : attribute::SdrTextAttribute aText;
656 :
657 : // #i98072# added option to suppress text
658 : // look for text first
659 253 : if(!bSuppressText && pText)
660 : {
661 253 : aText = createNewSdrTextAttribute(rSet, *pText);
662 : }
663 :
664 : // try shadow
665 253 : const attribute::SdrShadowAttribute aShadow(createNewSdrShadowAttribute(rSet));
666 :
667 253 : return attribute::SdrShadowTextAttribute(aShadow, aText);
668 : }
669 :
670 3 : attribute::SdrLineShadowTextAttribute createNewSdrLineShadowTextAttribute(
671 : const SfxItemSet& rSet,
672 : const SdrText* pText)
673 : {
674 3 : attribute::SdrLineAttribute aLine;
675 3 : attribute::SdrLineStartEndAttribute aLineStartEnd;
676 3 : attribute::SdrTextAttribute aText;
677 3 : bool bFontworkHideContour(false);
678 :
679 : // look for text first
680 3 : if(pText)
681 : {
682 3 : aText = createNewSdrTextAttribute(rSet, *pText);
683 :
684 : // when object has text and text is fontwork and hide contour is set for fontwork, force
685 : // line and fill style to empty
686 3 : if(!aText.isDefault()
687 0 : && !aText.getSdrFormTextAttribute().isDefault()
688 0 : && aText.isHideContour())
689 : {
690 0 : bFontworkHideContour = true;
691 : }
692 : }
693 :
694 : // try line style
695 3 : if(!bFontworkHideContour)
696 : {
697 3 : aLine = createNewSdrLineAttribute(rSet);
698 :
699 3 : if(!aLine.isDefault())
700 : {
701 : // try LineStartEnd
702 3 : aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth());
703 : }
704 : }
705 :
706 3 : if(!aLine.isDefault() || !aText.isDefault())
707 : {
708 : // try shadow
709 3 : const attribute::SdrShadowAttribute aShadow(createNewSdrShadowAttribute(rSet));
710 :
711 3 : return attribute::SdrLineShadowTextAttribute(aLine, aLineStartEnd, aShadow, aText);
712 : }
713 :
714 0 : return attribute::SdrLineShadowTextAttribute();
715 : }
716 :
717 345 : attribute::SdrLineFillShadowTextAttribute createNewSdrLineFillShadowTextAttribute(
718 : const SfxItemSet& rSet,
719 : const SdrText* pText)
720 : {
721 345 : attribute::SdrLineAttribute aLine;
722 345 : attribute::SdrFillAttribute aFill;
723 345 : attribute::SdrLineStartEndAttribute aLineStartEnd;
724 345 : attribute::SdrShadowAttribute aShadow;
725 345 : attribute::FillGradientAttribute aFillFloatTransGradient;
726 345 : attribute::SdrTextAttribute aText;
727 345 : bool bFontworkHideContour(false);
728 :
729 : // look for text first
730 345 : if(pText)
731 : {
732 345 : aText = createNewSdrTextAttribute(rSet, *pText);
733 :
734 : // when object has text and text is fontwork and hide contour is set for fontwork, force
735 : // line and fill style to empty
736 345 : if(!aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour())
737 : {
738 0 : bFontworkHideContour = true;
739 : }
740 : }
741 :
742 345 : if(!bFontworkHideContour)
743 : {
744 : // try line style
745 345 : aLine = createNewSdrLineAttribute(rSet);
746 :
747 345 : if(!aLine.isDefault())
748 : {
749 : // try LineStartEnd
750 138 : aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth());
751 : }
752 :
753 : // try fill style
754 345 : aFill = createNewSdrFillAttribute(rSet);
755 :
756 345 : if(!aFill.isDefault())
757 : {
758 : // try fillfloattransparence
759 39 : aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
760 : }
761 : }
762 :
763 345 : if(!aLine.isDefault() || !aFill.isDefault() || !aText.isDefault())
764 : {
765 : // try shadow
766 208 : aShadow = createNewSdrShadowAttribute(rSet);
767 :
768 : return attribute::SdrLineFillShadowTextAttribute(
769 208 : aLine, aFill, aLineStartEnd, aShadow, aFillFloatTransGradient, aText);
770 : }
771 :
772 137 : return attribute::SdrLineFillShadowTextAttribute();
773 : }
774 :
775 0 : attribute::SdrLineFillShadowAttribute3D createNewSdrLineFillShadowAttribute(const SfxItemSet& rSet, bool bSuppressFill)
776 : {
777 0 : attribute::SdrFillAttribute aFill;
778 0 : attribute::SdrLineStartEndAttribute aLineStartEnd;
779 0 : attribute::SdrShadowAttribute aShadow;
780 0 : attribute::FillGradientAttribute aFillFloatTransGradient;
781 :
782 : // try line style
783 0 : const attribute::SdrLineAttribute aLine(createNewSdrLineAttribute(rSet));
784 :
785 0 : if(!aLine.isDefault())
786 : {
787 : // try LineStartEnd
788 0 : aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth());
789 : }
790 :
791 : // try fill style
792 0 : if(!bSuppressFill)
793 : {
794 0 : aFill = createNewSdrFillAttribute(rSet);
795 :
796 0 : if(!aFill.isDefault())
797 : {
798 : // try fillfloattransparence
799 0 : aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
800 : }
801 : }
802 :
803 0 : if(!aLine.isDefault() || !aFill.isDefault())
804 : {
805 : // try shadow
806 0 : aShadow = createNewSdrShadowAttribute(rSet);
807 :
808 : return attribute::SdrLineFillShadowAttribute3D(
809 0 : aLine, aFill, aLineStartEnd, aShadow, aFillFloatTransGradient);
810 : }
811 :
812 0 : return attribute::SdrLineFillShadowAttribute3D();
813 : }
814 :
815 0 : attribute::SdrSceneAttribute createNewSdrSceneAttribute(const SfxItemSet& rSet)
816 : {
817 : // get perspective
818 0 : ::com::sun::star::drawing::ProjectionMode aProjectionMode(::com::sun::star::drawing::ProjectionMode_PARALLEL);
819 0 : const sal_uInt16 nProjectionValue(((const Svx3DPerspectiveItem&)rSet.Get(SDRATTR_3DSCENE_PERSPECTIVE)).GetValue());
820 :
821 0 : if(1L == nProjectionValue)
822 : {
823 0 : aProjectionMode = ::com::sun::star::drawing::ProjectionMode_PERSPECTIVE;
824 : }
825 :
826 : // get distance
827 0 : const double fDistance(((const Svx3DDistanceItem&)rSet.Get(SDRATTR_3DSCENE_DISTANCE)).GetValue());
828 :
829 : // get shadow slant
830 0 : const double fShadowSlant(F_PI180 * ((const Svx3DShadowSlantItem&)rSet.Get(SDRATTR_3DSCENE_SHADOW_SLANT)).GetValue());
831 :
832 : // get shade mode
833 0 : ::com::sun::star::drawing::ShadeMode aShadeMode(::com::sun::star::drawing::ShadeMode_FLAT);
834 0 : const sal_uInt16 nShadeValue(((const Svx3DShadeModeItem&)rSet.Get(SDRATTR_3DSCENE_SHADE_MODE)).GetValue());
835 :
836 0 : if(1L == nShadeValue)
837 : {
838 0 : aShadeMode = ::com::sun::star::drawing::ShadeMode_PHONG;
839 : }
840 0 : else if(2L == nShadeValue)
841 : {
842 0 : aShadeMode = ::com::sun::star::drawing::ShadeMode_SMOOTH;
843 : }
844 0 : else if(3L == nShadeValue)
845 : {
846 0 : aShadeMode = ::com::sun::star::drawing::ShadeMode_DRAFT;
847 : }
848 :
849 : // get two sided lighting
850 0 : const bool bTwoSidedLighting(((const Svx3DTwoSidedLightingItem&)rSet.Get(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING)).GetValue());
851 :
852 0 : return attribute::SdrSceneAttribute(fDistance, fShadowSlant, aProjectionMode, aShadeMode, bTwoSidedLighting);
853 : }
854 :
855 0 : attribute::SdrLightingAttribute createNewSdrLightingAttribute(const SfxItemSet& rSet)
856 : {
857 : // extract lights from given SfxItemSet (from scene)
858 0 : ::std::vector< attribute::Sdr3DLightAttribute > aLightVector;
859 :
860 0 : if(((const Svx3DLightOnOff1Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_1)).GetValue())
861 : {
862 0 : const basegfx::BColor aColor(((const Svx3DLightcolor1Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1)).GetValue().getBColor());
863 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection1Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1)).GetValue());
864 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, true));
865 : }
866 :
867 0 : if(((const Svx3DLightOnOff2Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_2)).GetValue())
868 : {
869 0 : const basegfx::BColor aColor(((const Svx3DLightcolor2Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2)).GetValue().getBColor());
870 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection2Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2)).GetValue());
871 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
872 : }
873 :
874 0 : if(((const Svx3DLightOnOff3Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_3)).GetValue())
875 : {
876 0 : const basegfx::BColor aColor(((const Svx3DLightcolor3Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3)).GetValue().getBColor());
877 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection3Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3)).GetValue());
878 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
879 : }
880 :
881 0 : if(((const Svx3DLightOnOff4Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_4)).GetValue())
882 : {
883 0 : const basegfx::BColor aColor(((const Svx3DLightcolor4Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4)).GetValue().getBColor());
884 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection4Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4)).GetValue());
885 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
886 : }
887 :
888 0 : if(((const Svx3DLightOnOff5Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_5)).GetValue())
889 : {
890 0 : const basegfx::BColor aColor(((const Svx3DLightcolor5Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5)).GetValue().getBColor());
891 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection5Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5)).GetValue());
892 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
893 : }
894 :
895 0 : if(((const Svx3DLightOnOff6Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_6)).GetValue())
896 : {
897 0 : const basegfx::BColor aColor(((const Svx3DLightcolor6Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6)).GetValue().getBColor());
898 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection6Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6)).GetValue());
899 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
900 : }
901 :
902 0 : if(((const Svx3DLightOnOff7Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_7)).GetValue())
903 : {
904 0 : const basegfx::BColor aColor(((const Svx3DLightcolor7Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7)).GetValue().getBColor());
905 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection7Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7)).GetValue());
906 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
907 : }
908 :
909 0 : if(((const Svx3DLightOnOff8Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_8)).GetValue())
910 : {
911 0 : const basegfx::BColor aColor(((const Svx3DLightcolor8Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8)).GetValue().getBColor());
912 0 : const basegfx::B3DVector aDirection(((const Svx3DLightDirection8Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8)).GetValue());
913 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
914 : }
915 :
916 : // get ambient color
917 0 : const Color aAmbientValue(((const Svx3DAmbientcolorItem&)rSet.Get(SDRATTR_3DSCENE_AMBIENTCOLOR)).GetValue());
918 0 : const basegfx::BColor aAmbientLight(aAmbientValue.getBColor());
919 :
920 0 : return attribute::SdrLightingAttribute(aAmbientLight, aLightVector);
921 : }
922 :
923 152 : void calculateRelativeCornerRadius(sal_Int32 nRadius, const basegfx::B2DRange& rObjectRange, double& rfCornerRadiusX, double& rfCornerRadiusY)
924 : {
925 152 : rfCornerRadiusX = rfCornerRadiusY = (double)nRadius;
926 :
927 152 : if(0.0 != rfCornerRadiusX)
928 : {
929 4 : const double fHalfObjectWidth(rObjectRange.getWidth() * 0.5);
930 :
931 4 : if(0.0 != fHalfObjectWidth)
932 : {
933 4 : if(rfCornerRadiusX < 0.0)
934 : {
935 0 : rfCornerRadiusX = 0.0;
936 : }
937 :
938 4 : if(rfCornerRadiusX > fHalfObjectWidth)
939 : {
940 0 : rfCornerRadiusX = fHalfObjectWidth;
941 : }
942 :
943 4 : rfCornerRadiusX /= fHalfObjectWidth;
944 : }
945 : else
946 : {
947 0 : rfCornerRadiusX = 0.0;
948 : }
949 : }
950 :
951 152 : if(0.0 != rfCornerRadiusY)
952 : {
953 4 : const double fHalfObjectHeight(rObjectRange.getHeight() * 0.5);
954 :
955 4 : if(0.0 != fHalfObjectHeight)
956 : {
957 4 : if(rfCornerRadiusY < 0.0)
958 : {
959 0 : rfCornerRadiusY = 0.0;
960 : }
961 :
962 4 : if(rfCornerRadiusY > fHalfObjectHeight)
963 : {
964 0 : rfCornerRadiusY = fHalfObjectHeight;
965 : }
966 :
967 4 : rfCornerRadiusY /= fHalfObjectHeight;
968 : }
969 : else
970 : {
971 0 : rfCornerRadiusY = 0.0;
972 : }
973 : }
974 152 : }
975 :
976 : // #i101508# Support handing over given text-to-border distances
977 0 : attribute::SdrFillTextAttribute createNewSdrFillTextAttribute(
978 : const SfxItemSet& rSet,
979 : const SdrText* pText,
980 : const sal_Int32* pLeft,
981 : const sal_Int32* pUpper,
982 : const sal_Int32* pRight,
983 : const sal_Int32* pLower)
984 : {
985 0 : attribute::SdrFillAttribute aFill;
986 0 : attribute::FillGradientAttribute aFillFloatTransGradient;
987 0 : attribute::SdrTextAttribute aText;
988 0 : bool bFontworkHideContour(false);
989 :
990 : // look for text first
991 0 : if(pText)
992 : {
993 0 : aText = createNewSdrTextAttribute(rSet, *pText, pLeft, pUpper, pRight, pLower);
994 :
995 : // when object has text and text is fontwork and hide contour is set for fontwork, force
996 : // fill style to empty
997 0 : if(!aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour())
998 : {
999 0 : bFontworkHideContour = true;
1000 : }
1001 : }
1002 :
1003 0 : if(!bFontworkHideContour)
1004 : {
1005 : // try fill style
1006 0 : aFill = createNewSdrFillAttribute(rSet);
1007 :
1008 0 : if(!aFill.isDefault())
1009 : {
1010 : // try fillfloattransparence
1011 0 : aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
1012 : }
1013 : }
1014 :
1015 0 : if(!aFill.isDefault() || !aText.isDefault())
1016 : {
1017 0 : return attribute::SdrFillTextAttribute(aFill, aFillFloatTransGradient, aText);
1018 : }
1019 :
1020 0 : return attribute::SdrFillTextAttribute();
1021 : }
1022 :
1023 : } // end of namespace primitive2d
1024 : } // end of namespace drawinglayer
1025 :
1026 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
