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/sdrfillgraphicattribute.hxx>
50 : #include <basegfx/polygon/b2dlinegeometry.hxx>
51 : #include <svx/svdotext.hxx>
52 : #include <drawinglayer/attribute/fillgraphicattribute.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 <sdr/attribute/sdrfilltextattribute.hxx>
77 : #include <com/sun/star/drawing/LineCap.hpp>
78 :
79 : using namespace com::sun::star;
80 :
81 : namespace drawinglayer
82 : {
83 : namespace
84 : {
85 6842 : attribute::GradientStyle XGradientStyleToGradientStyle(css::awt::GradientStyle eStyle)
86 : {
87 6842 : switch(eStyle)
88 : {
89 : case css::awt::GradientStyle_LINEAR :
90 : {
91 4374 : return attribute::GRADIENTSTYLE_LINEAR;
92 : }
93 : case css::awt::GradientStyle_AXIAL :
94 : {
95 2451 : return attribute::GRADIENTSTYLE_AXIAL;
96 : }
97 : case css::awt::GradientStyle_RADIAL :
98 : {
99 7 : return attribute::GRADIENTSTYLE_RADIAL;
100 : }
101 : case css::awt::GradientStyle_ELLIPTICAL :
102 : {
103 7 : return attribute::GRADIENTSTYLE_ELLIPTICAL;
104 : }
105 : case css::awt::GradientStyle_SQUARE :
106 : {
107 1 : return attribute::GRADIENTSTYLE_SQUARE;
108 : }
109 : default :
110 : {
111 2 : return attribute::GRADIENTSTYLE_RECT; // css::awt::GradientStyle_RECT
112 : }
113 : }
114 : }
115 :
116 2987 : attribute::HatchStyle XHatchStyleToHatchStyle(css::drawing::HatchStyle eStyle)
117 : {
118 2987 : switch(eStyle)
119 : {
120 : case css::drawing::HatchStyle_SINGLE :
121 : {
122 2959 : return attribute::HATCHSTYLE_SINGLE;
123 : }
124 : case css::drawing::HatchStyle_DOUBLE :
125 : {
126 28 : return attribute::HATCHSTYLE_DOUBLE;
127 : }
128 : default :
129 : {
130 0 : return attribute::HATCHSTYLE_TRIPLE; // css::drawing::HatchStyle_TRIPLE
131 : }
132 : }
133 : }
134 :
135 28463 : basegfx::B2DLineJoin LineJointToB2DLineJoin(com::sun::star::drawing::LineJoint eLineJoint)
136 : {
137 28463 : switch(eLineJoint)
138 : {
139 : case com::sun::star::drawing::LineJoint_MIDDLE :
140 : {
141 0 : return basegfx::B2DLineJoin::Middle;
142 : }
143 : case com::sun::star::drawing::LineJoint_BEVEL :
144 : {
145 198 : return basegfx::B2DLineJoin::Bevel;
146 : }
147 : case com::sun::star::drawing::LineJoint_MITER :
148 : {
149 784 : return basegfx::B2DLineJoin::Miter;
150 : }
151 : case com::sun::star::drawing::LineJoint_ROUND :
152 : {
153 27481 : return basegfx::B2DLineJoin::Round;
154 : }
155 : default : // com::sun::star::drawing::LineJoint_NONE
156 : {
157 0 : return basegfx::B2DLineJoin::NONE;
158 : }
159 : }
160 : }
161 :
162 753 : basegfx::B2DVector RectPointToB2DVector(RECT_POINT eRectPoint)
163 : {
164 753 : basegfx::B2DVector aRetval(0.0, 0.0);
165 :
166 : // position changes X
167 753 : switch(eRectPoint)
168 : {
169 : case RP_LT: case RP_LM: case RP_LB:
170 : {
171 10 : aRetval.setX(-1.0);
172 10 : 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 743 : break;
184 : }
185 : }
186 :
187 : // position changes Y
188 753 : switch(eRectPoint)
189 : {
190 : case RP_LT: case RP_MT: case RP_RT:
191 : {
192 10 : aRetval.setY(-1.0);
193 10 : 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 743 : break;
205 : }
206 : }
207 :
208 753 : 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 98071 : attribute::SdrLineAttribute createNewSdrLineAttribute(const SfxItemSet& rSet)
220 : {
221 98071 : const com::sun::star::drawing::LineStyle eStyle(static_cast<const XLineStyleItem&>(rSet.Get(XATTR_LINESTYLE)).GetValue());
222 :
223 98071 : if(drawing::LineStyle_NONE != eStyle)
224 : {
225 28463 : sal_uInt16 nTransparence(static_cast<const XLineTransparenceItem&>(rSet.Get(XATTR_LINETRANSPARENCE)).GetValue());
226 :
227 28463 : if(nTransparence > 100)
228 : {
229 0 : nTransparence = 100;
230 : }
231 :
232 28463 : if(100 != nTransparence)
233 : {
234 28463 : const sal_uInt32 nWidth(static_cast<const XLineWidthItem&>(rSet.Get(XATTR_LINEWIDTH)).GetValue());
235 28463 : const Color aColor(static_cast<const XLineColorItem&>(rSet.Get(XATTR_LINECOLOR)).GetColorValue());
236 28463 : const com::sun::star::drawing::LineJoint eJoint(static_cast<const XLineJointItem&>(rSet.Get(XATTR_LINEJOINT)).GetValue());
237 28463 : const com::sun::star::drawing::LineCap eCap(static_cast<const XLineCapItem&>(rSet.Get(XATTR_LINECAP)).GetValue());
238 28463 : ::std::vector< double > aDotDashArray;
239 28463 : double fFullDotDashLen(0.0);
240 :
241 28463 : if(drawing::LineStyle_DASH == eStyle)
242 : {
243 317 : const XDash& rDash = static_cast<const XLineDashItem&>(rSet.Get(XATTR_LINEDASH)).GetDashValue();
244 :
245 317 : if(rDash.GetDots() || rDash.GetDashes())
246 : {
247 317 : fFullDotDashLen = rDash.CreateDotDashArray(aDotDashArray, (double)nWidth);
248 : }
249 : }
250 :
251 : return attribute::SdrLineAttribute(
252 : LineJointToB2DLineJoin(eJoint),
253 : (double)nWidth,
254 : (double)nTransparence * 0.01,
255 : aColor.getBColor(),
256 : eCap,
257 : aDotDashArray,
258 28463 : fFullDotDashLen);
259 : }
260 : }
261 :
262 69608 : return attribute::SdrLineAttribute();
263 : }
264 :
265 28463 : attribute::SdrLineStartEndAttribute createNewSdrLineStartEndAttribute(
266 : const SfxItemSet& rSet,
267 : double fWidth)
268 : {
269 28463 : const sal_Int32 nTempStartWidth(static_cast<const XLineStartWidthItem&>(rSet.Get(XATTR_LINESTARTWIDTH)).GetValue());
270 28463 : const sal_Int32 nTempEndWidth(static_cast<const XLineEndWidthItem&>(rSet.Get(XATTR_LINEENDWIDTH)).GetValue());
271 28463 : basegfx::B2DPolyPolygon aStartPolyPolygon;
272 56926 : basegfx::B2DPolyPolygon aEndPolyPolygon;
273 28463 : double fStartWidth(0.0);
274 28463 : double fEndWidth(0.0);
275 28463 : bool bStartActive(false);
276 28463 : bool bEndActive(false);
277 28463 : bool bStartCentered(true);
278 28463 : bool bEndCentered(true);
279 :
280 28463 : if(nTempStartWidth)
281 : {
282 28463 : if(nTempStartWidth < 0L)
283 : {
284 0 : fStartWidth = ((double)(-nTempStartWidth) * fWidth) * 0.01;
285 : }
286 : else
287 : {
288 28463 : fStartWidth = (double)nTempStartWidth;
289 : }
290 :
291 28463 : if(0.0 != fStartWidth)
292 : {
293 28463 : aStartPolyPolygon = basegfx::B2DPolyPolygon(static_cast<const XLineStartItem&>(rSet.Get(XATTR_LINESTART)).GetLineStartValue());
294 :
295 28463 : if(aStartPolyPolygon.count() && aStartPolyPolygon.getB2DPolygon(0L).count())
296 : {
297 115 : bStartActive = true;
298 115 : bStartCentered = static_cast<const XLineStartCenterItem&>(rSet.Get(XATTR_LINESTARTCENTER)).GetValue();
299 : }
300 : }
301 : }
302 :
303 28463 : if(nTempEndWidth)
304 : {
305 28463 : if(nTempEndWidth < 0L)
306 : {
307 0 : fEndWidth = ((double)(-nTempEndWidth) * fWidth) * 0.01;
308 : }
309 : else
310 : {
311 28463 : fEndWidth = (double)nTempEndWidth;
312 : }
313 :
314 28463 : if(0.0 != fEndWidth)
315 : {
316 28463 : aEndPolyPolygon = basegfx::B2DPolyPolygon(static_cast<const XLineEndItem&>(rSet.Get(XATTR_LINEEND)).GetLineEndValue());
317 :
318 28463 : if(aEndPolyPolygon.count() && aEndPolyPolygon.getB2DPolygon(0L).count())
319 : {
320 196 : bEndActive = true;
321 196 : bEndCentered = static_cast<const XLineEndCenterItem&>(rSet.Get(XATTR_LINEENDCENTER)).GetValue();
322 : }
323 : }
324 : }
325 :
326 28463 : if(bStartActive || bEndActive)
327 : {
328 : return attribute::SdrLineStartEndAttribute(
329 : aStartPolyPolygon, aEndPolyPolygon, fStartWidth, fEndWidth,
330 217 : bStartActive, bEndActive, bStartCentered, bEndCentered);
331 : }
332 :
333 56709 : return attribute::SdrLineStartEndAttribute();
334 : }
335 :
336 94430 : attribute::SdrShadowAttribute createNewSdrShadowAttribute(const SfxItemSet& rSet)
337 : {
338 94430 : const bool bShadow(static_cast<const SdrOnOffItem&>(rSet.Get(SDRATTR_SHADOW)).GetValue());
339 :
340 94430 : if(bShadow)
341 : {
342 531 : sal_uInt16 nTransparence(static_cast<const SdrPercentItem&>(rSet.Get(SDRATTR_SHADOWTRANSPARENCE)).GetValue());
343 :
344 531 : if(nTransparence > 100)
345 : {
346 0 : nTransparence = 100;
347 : }
348 :
349 531 : if(nTransparence)
350 : {
351 140 : sal_uInt16 nFillTransparence(static_cast<const XFillTransparenceItem&>(rSet.Get(XATTR_FILLTRANSPARENCE)).GetValue());
352 :
353 140 : if(nFillTransparence > 100)
354 : {
355 0 : nFillTransparence = 100;
356 : }
357 :
358 140 : 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 531 : if(100 != nTransparence)
369 : {
370 : const basegfx::B2DVector aOffset(
371 531 : (double)static_cast<const SdrMetricItem&>(rSet.Get(SDRATTR_SHADOWXDIST)).GetValue(),
372 1062 : (double)static_cast<const SdrMetricItem&>(rSet.Get(SDRATTR_SHADOWYDIST)).GetValue());
373 531 : const Color aColor(static_cast<const XColorItem&>(rSet.Get(SDRATTR_SHADOWCOLOR)).GetColorValue());
374 :
375 531 : return attribute::SdrShadowAttribute(aOffset, (double)nTransparence * 0.01, aColor.getBColor());
376 : }
377 : }
378 :
379 93899 : return attribute::SdrShadowAttribute();
380 : }
381 :
382 140062 : attribute::SdrFillAttribute createNewSdrFillAttribute(const SfxItemSet& rSet)
383 : {
384 140062 : const drawing::FillStyle eStyle(static_cast<const XFillStyleItem&>(rSet.Get(XATTR_FILLSTYLE)).GetValue());
385 :
386 140062 : sal_uInt16 nTransparence(static_cast<const XFillTransparenceItem&>(rSet.Get(XATTR_FILLTRANSPARENCE)).GetValue());
387 :
388 140062 : if(nTransparence > 100)
389 : {
390 0 : nTransparence = 100;
391 : }
392 :
393 140062 : if(drawing::FillStyle_NONE != eStyle)
394 : {
395 52815 : if(100 != nTransparence)
396 : {
397 : // need to check XFillFloatTransparence, object fill may still be completely transparent
398 : const SfxPoolItem* pGradientItem;
399 :
400 105098 : if(SfxItemState::SET == rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, true, &pGradientItem)
401 52549 : && static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->IsEnabled())
402 : {
403 5723 : const XGradient& rGradient = static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->GetGradientValue();
404 5723 : const sal_uInt8 nStartLuminance(rGradient.GetStartColor().GetLuminance());
405 5723 : const sal_uInt8 nEndLuminance(rGradient.GetEndColor().GetLuminance());
406 5723 : const bool bCompletelyTransparent(0xff == nStartLuminance && 0xff == nEndLuminance);
407 :
408 5723 : if(bCompletelyTransparent)
409 : {
410 0 : nTransparence = 100;
411 : }
412 : }
413 : }
414 :
415 52815 : if(100 != nTransparence)
416 : {
417 52549 : const Color aColor(static_cast<const XFillColorItem&>(rSet.Get(XATTR_FILLCOLOR)).GetColorValue());
418 52549 : attribute::FillGradientAttribute aGradient;
419 105098 : attribute::FillHatchAttribute aHatch;
420 105098 : attribute::SdrFillGraphicAttribute aFillGraphic;
421 :
422 52549 : switch(eStyle)
423 : {
424 : default:
425 : {
426 : // nothing to do, color is defined
427 47687 : break;
428 : }
429 : case drawing::FillStyle_GRADIENT :
430 : {
431 1119 : XGradient aXGradient(static_cast<const XFillGradientItem&>(rSet.Get(XATTR_FILLGRADIENT)).GetGradientValue());
432 :
433 1119 : const Color aStartColor(aXGradient.GetStartColor());
434 1119 : const sal_uInt16 nStartIntens(aXGradient.GetStartIntens());
435 1119 : basegfx::BColor aStart(aStartColor.getBColor());
436 :
437 1119 : if(nStartIntens != 100)
438 : {
439 0 : const basegfx::BColor aBlack;
440 0 : aStart = interpolate(aBlack, aStart, (double)nStartIntens * 0.01);
441 : }
442 :
443 1119 : const Color aEndColor(aXGradient.GetEndColor());
444 1119 : const sal_uInt16 nEndIntens(aXGradient.GetEndIntens());
445 2238 : basegfx::BColor aEnd(aEndColor.getBColor());
446 :
447 1119 : if(nEndIntens != 100)
448 : {
449 0 : const basegfx::BColor aBlack;
450 0 : aEnd = interpolate(aBlack, aEnd, (double)nEndIntens * 0.01);
451 : }
452 :
453 6714 : aGradient = attribute::FillGradientAttribute(
454 : XGradientStyleToGradientStyle(aXGradient.GetGradientStyle()),
455 1119 : (double)aXGradient.GetBorder() * 0.01,
456 1119 : (double)aXGradient.GetXOffset() * 0.01,
457 1119 : (double)aXGradient.GetYOffset() * 0.01,
458 1119 : (double)aXGradient.GetAngle() * F_PI1800,
459 : aStart,
460 : aEnd,
461 2238 : static_cast<const XGradientStepCountItem&>(rSet.Get(XATTR_GRADIENTSTEPCOUNT)).GetValue());
462 :
463 2238 : break;
464 : }
465 : case drawing::FillStyle_HATCH :
466 : {
467 2987 : const XHatch& rHatch(static_cast<const XFillHatchItem&>(rSet.Get(XATTR_FILLHATCH)).GetHatchValue());
468 2987 : const Color aColorB(rHatch.GetColor());
469 :
470 11948 : aHatch = attribute::FillHatchAttribute(
471 : XHatchStyleToHatchStyle(rHatch.GetHatchStyle()),
472 2987 : (double)rHatch.GetDistance(),
473 2987 : (double)rHatch.GetAngle() * F_PI1800,
474 : aColorB.getBColor(),
475 : 3, // same default as VCL, a minimum of three discrete units (pixels) offset
476 5974 : static_cast<const XFillBackgroundItem&>(rSet.Get(XATTR_FILLBACKGROUND)).GetValue());
477 :
478 2987 : break;
479 : }
480 : case drawing::FillStyle_BITMAP :
481 : {
482 756 : aFillGraphic = createNewSdrFillGraphicAttribute(rSet);
483 756 : break;
484 : }
485 : }
486 :
487 : return attribute::SdrFillAttribute(
488 : (double)nTransparence * 0.01,
489 : aColor.getBColor(),
490 : aGradient,
491 : aHatch,
492 105098 : aFillGraphic);
493 : }
494 : }
495 :
496 87513 : if(nTransparence == 100)
497 : {
498 756 : attribute::FillGradientAttribute aGradient;
499 1512 : attribute::FillHatchAttribute aHatch;
500 1512 : attribute::SdrFillGraphicAttribute aFillGraphic;
501 : return attribute::SdrFillAttribute(
502 : 1,
503 : basegfx::BColor( 0, 0, 0 ),
504 : aGradient,
505 : aHatch,
506 1512 : aFillGraphic);
507 : }
508 :
509 86757 : return attribute::SdrFillAttribute();
510 : }
511 :
512 : // #i101508# Support handing over given text-to-border distances
513 95784 : attribute::SdrTextAttribute createNewSdrTextAttribute(
514 : const SfxItemSet& rSet,
515 : const SdrText& rText,
516 : const sal_Int32* pLeft,
517 : const sal_Int32* pUpper,
518 : const sal_Int32* pRight,
519 : const sal_Int32* pLower)
520 : {
521 95784 : const SdrTextObj& rTextObj = rText.GetObject();
522 :
523 95784 : if(rText.GetOutlinerParaObject() && rText.GetModel())
524 : {
525 : // added TextEdit text suppression
526 29180 : bool bInEditMode(false);
527 :
528 29180 : if(rText.GetObject().getTextCount() > 1)
529 : {
530 0 : bInEditMode = rTextObj.IsInEditMode() && rText.GetObject().getActiveText() == &rText;
531 : }
532 : else
533 : {
534 29180 : bInEditMode = rTextObj.IsInEditMode();
535 : }
536 :
537 29180 : OutlinerParaObject aOutlinerParaObject(*rText.GetOutlinerParaObject());
538 :
539 29180 : if(bInEditMode)
540 : {
541 44 : OutlinerParaObject* pTempObj = rTextObj.GetEditOutlinerParaObject();
542 :
543 44 : if(pTempObj)
544 : {
545 44 : aOutlinerParaObject = *pTempObj;
546 44 : delete pTempObj;
547 : }
548 : else
549 : {
550 : // #i100537#
551 : // GetEditOutlinerParaObject() returning no object does not mean that
552 : // text edit mode is not active. Do not reset the flag here
553 : // bInEditMode = false;
554 : }
555 : }
556 :
557 29180 : const SdrTextAniKind eAniKind(rTextObj.GetTextAniKind());
558 :
559 : // #i107346#
560 29180 : const SdrOutliner& rDrawTextOutliner = rText.GetModel()->GetDrawOutliner(&rTextObj);
561 29180 : const bool bWrongSpell(rDrawTextOutliner.GetControlWord() & EEControlBits::ONLINESPELLING);
562 :
563 : return attribute::SdrTextAttribute(
564 : rText,
565 : aOutlinerParaObject,
566 29180 : static_cast<const XFormTextStyleItem&>(rSet.Get(XATTR_FORMTXTSTYLE)).GetValue(),
567 29180 : pLeft ? *pLeft : rTextObj.GetTextLeftDistance(),
568 29180 : pUpper ? *pUpper : rTextObj.GetTextUpperDistance(),
569 29180 : pRight ? *pRight : rTextObj.GetTextRightDistance(),
570 29180 : pLower ? *pLower : rTextObj.GetTextLowerDistance(),
571 : rTextObj.GetTextHorizontalAdjust(rSet),
572 : rTextObj.GetTextVerticalAdjust(rSet),
573 29180 : static_cast<const SdrOnOffItem&>(rSet.Get(SDRATTR_TEXT_CONTOURFRAME)).GetValue(),
574 29180 : rTextObj.IsFitToSize(),
575 29180 : rTextObj.IsAutoFit(),
576 29180 : static_cast<const XFormTextHideFormItem&>(rSet.Get(XATTR_FORMTXTHIDEFORM)).GetValue(),
577 : SDRTEXTANI_BLINK == eAniKind,
578 29180 : SDRTEXTANI_SCROLL == eAniKind || SDRTEXTANI_ALTERNATE == eAniKind || SDRTEXTANI_SLIDE == eAniKind,
579 : bInEditMode,
580 29180 : static_cast<const SdrTextFixedCellHeightItem&>(rSet.Get(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue(),
581 350160 : bWrongSpell);
582 : }
583 :
584 66604 : return attribute::SdrTextAttribute();
585 : }
586 :
587 93359 : attribute::FillGradientAttribute createNewTransparenceGradientAttribute(const SfxItemSet& rSet)
588 : {
589 : const SfxPoolItem* pGradientItem;
590 :
591 186718 : if(SfxItemState::SET == rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, true, &pGradientItem)
592 93359 : && static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->IsEnabled())
593 : {
594 : // test if float transparence is completely transparent
595 5723 : const XGradient& rGradient = static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->GetGradientValue();
596 5723 : const sal_uInt8 nStartLuminance(rGradient.GetStartColor().GetLuminance());
597 5723 : const sal_uInt8 nEndLuminance(rGradient.GetEndColor().GetLuminance());
598 5723 : const bool bCompletelyTransparent(0xff == nStartLuminance && 0xff == nEndLuminance);
599 5723 : const bool bNotTransparent(0x00 == nStartLuminance && 0x00 == nEndLuminance);
600 :
601 : // create nothing when completely transparent: This case is already checked for the
602 : // normal fill attributes, XFILL_NONE will be used.
603 : // create nothing when not transparent: use normal fill, no need t create a FillGradientAttribute.
604 : // Both cases are optimizations, always creating FillGradientAttribute will work, too
605 5723 : if(!bNotTransparent && !bCompletelyTransparent)
606 : {
607 5723 : const double fStartLum(nStartLuminance / 255.0);
608 5723 : const double fEndLum(nEndLuminance / 255.0);
609 :
610 : return attribute::FillGradientAttribute(
611 : XGradientStyleToGradientStyle(rGradient.GetGradientStyle()),
612 5723 : (double)rGradient.GetBorder() * 0.01,
613 5723 : (double)rGradient.GetXOffset() * 0.01,
614 5723 : (double)rGradient.GetYOffset() * 0.01,
615 5723 : (double)rGradient.GetAngle() * F_PI1800,
616 : basegfx::BColor(fStartLum, fStartLum, fStartLum),
617 : basegfx::BColor(fEndLum, fEndLum, fEndLum),
618 28615 : 0);
619 : }
620 : }
621 :
622 87636 : return attribute::FillGradientAttribute();
623 : }
624 :
625 756 : attribute::SdrFillGraphicAttribute createNewSdrFillGraphicAttribute(const SfxItemSet& rSet)
626 : {
627 756 : Graphic aGraphic(static_cast<const XFillBitmapItem&>(rSet.Get(XATTR_FILLBITMAP)).GetGraphicObject().GetGraphic());
628 :
629 756 : if(!(GRAPHIC_BITMAP == aGraphic.GetType() || GRAPHIC_GDIMETAFILE == aGraphic.GetType()))
630 : {
631 : // no content if not bitmap or metafile
632 : OSL_ENSURE(false, "No fill graphic in SfxItemSet (!)");
633 3 : return attribute::SdrFillGraphicAttribute();
634 : }
635 :
636 753 : Size aPrefSize(aGraphic.GetPrefSize());
637 :
638 753 : if(!aPrefSize.Width() || !aPrefSize.Height())
639 : {
640 : // if there is no logical size, create a size from pixel size and set MapMode accordingly
641 0 : if(GRAPHIC_BITMAP == aGraphic.GetType())
642 : {
643 0 : aGraphic.SetPrefSize(aGraphic.GetBitmapEx().GetSizePixel());
644 0 : aGraphic.SetPrefMapMode(MAP_PIXEL);
645 : }
646 : }
647 :
648 753 : if(!aPrefSize.Width() || !aPrefSize.Height())
649 : {
650 : // no content if no size
651 : OSL_ENSURE(false, "Graphic has no size in SfxItemSet (!)");
652 0 : return attribute::SdrFillGraphicAttribute();
653 : }
654 :
655 : // convert size and MapMode to destination logical size and MapMode
656 753 : const MapUnit aDestinationMapUnit((MapUnit)rSet.GetPool()->GetMetric(0));
657 1506 : basegfx::B2DVector aGraphicLogicSize(aGraphic.GetPrefSize().Width(), aGraphic.GetPrefSize().Height());
658 :
659 753 : if(aGraphic.GetPrefMapMode() != aDestinationMapUnit)
660 : {
661 : // #i100360# for MAP_PIXEL, LogicToLogic will not work properly,
662 : // so fallback to Application::GetDefaultDevice()
663 601 : Size aNewSize(0, 0);
664 :
665 601 : if(MAP_PIXEL == aGraphic.GetPrefMapMode().GetMapUnit())
666 : {
667 : aNewSize = Application::GetDefaultDevice()->PixelToLogic(
668 : aGraphic.GetPrefSize(),
669 601 : aDestinationMapUnit);
670 : }
671 : else
672 : {
673 : aNewSize = OutputDevice::LogicToLogic(
674 : aGraphic.GetPrefSize(),
675 : aGraphic.GetPrefMapMode(),
676 0 : aDestinationMapUnit);
677 : }
678 :
679 : // #i124002# do not set new size using SetPrefSize at the graphic, this will lead to problems.
680 : // Instead, adapt the GraphicLogicSize which will be used for further decompositions
681 601 : aGraphicLogicSize = basegfx::B2DVector(aNewSize.Width(), aNewSize.Height());
682 : }
683 :
684 : // get size
685 : const basegfx::B2DVector aSize(
686 753 : (double) static_cast<const SfxMetricItem&>(rSet.Get(XATTR_FILLBMP_SIZEX)).GetValue(),
687 2259 : (double) static_cast<const SfxMetricItem&>(rSet.Get(XATTR_FILLBMP_SIZEY)).GetValue());
688 : const basegfx::B2DVector aOffset(
689 753 : (double) static_cast<const SfxUInt16Item&>(rSet.Get(XATTR_FILLBMP_TILEOFFSETX)).GetValue(),
690 2259 : (double) static_cast<const SfxUInt16Item&>(rSet.Get(XATTR_FILLBMP_TILEOFFSETY)).GetValue());
691 : const basegfx::B2DVector aOffsetPosition(
692 753 : (double) static_cast<const SfxUInt16Item&>(rSet.Get(XATTR_FILLBMP_POSOFFSETX)).GetValue(),
693 2259 : (double) static_cast<const SfxUInt16Item&>(rSet.Get(XATTR_FILLBMP_POSOFFSETY)).GetValue());
694 :
695 : return attribute::SdrFillGraphicAttribute(
696 : aGraphic,
697 : aGraphicLogicSize,
698 : aSize,
699 : aOffset,
700 : aOffsetPosition,
701 : RectPointToB2DVector(
702 753 : (RECT_POINT)static_cast<const SfxEnumItem&>(rSet.Get(XATTR_FILLBMP_POS)).GetValue()),
703 753 : static_cast<const SfxBoolItem&>(rSet.Get(XATTR_FILLBMP_TILE)).GetValue(),
704 753 : static_cast<const SfxBoolItem&>(rSet.Get(XATTR_FILLBMP_STRETCH)).GetValue(),
705 3768 : static_cast<const SfxBoolItem&>(rSet.Get(XATTR_FILLBMP_SIZELOG)).GetValue());
706 : }
707 :
708 7429 : attribute::SdrShadowTextAttribute createNewSdrShadowTextAttribute(
709 : const SfxItemSet& rSet,
710 : const SdrText* pText,
711 : bool bSuppressText)
712 : {
713 7429 : attribute::SdrTextAttribute aText;
714 :
715 : // #i98072# added option to suppress text
716 : // look for text first
717 7429 : if(!bSuppressText && pText)
718 : {
719 7301 : aText = createNewSdrTextAttribute(rSet, *pText);
720 : }
721 :
722 : // try shadow
723 14858 : const attribute::SdrShadowAttribute aShadow(createNewSdrShadowAttribute(rSet));
724 :
725 14858 : return attribute::SdrShadowTextAttribute(aShadow, aText);
726 : }
727 :
728 72 : attribute::SdrLineShadowTextAttribute createNewSdrLineShadowTextAttribute(
729 : const SfxItemSet& rSet,
730 : const SdrText* pText)
731 : {
732 72 : attribute::SdrLineAttribute aLine;
733 144 : attribute::SdrLineStartEndAttribute aLineStartEnd;
734 144 : attribute::SdrTextAttribute aText;
735 72 : bool bFontworkHideContour(false);
736 :
737 : // look for text first
738 72 : if(pText)
739 : {
740 72 : aText = createNewSdrTextAttribute(rSet, *pText);
741 :
742 : // when object has text and text is fontwork and hide contour is set for fontwork, force
743 : // line and fill style to empty
744 144 : if(!aText.isDefault()
745 13 : && !aText.getSdrFormTextAttribute().isDefault()
746 72 : && aText.isHideContour())
747 : {
748 0 : bFontworkHideContour = true;
749 : }
750 : }
751 :
752 : // try line style
753 72 : if(!bFontworkHideContour)
754 : {
755 72 : aLine = createNewSdrLineAttribute(rSet);
756 :
757 72 : if(!aLine.isDefault())
758 : {
759 : // try LineStartEnd
760 72 : aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth());
761 : }
762 : }
763 :
764 72 : if(!aLine.isDefault() || !aText.isDefault())
765 : {
766 : // try shadow
767 72 : const attribute::SdrShadowAttribute aShadow(createNewSdrShadowAttribute(rSet));
768 :
769 72 : return attribute::SdrLineShadowTextAttribute(aLine, aLineStartEnd, aShadow, aText);
770 : }
771 :
772 72 : return attribute::SdrLineShadowTextAttribute();
773 : }
774 :
775 88398 : attribute::SdrLineFillShadowTextAttribute createNewSdrLineFillShadowTextAttribute(
776 : const SfxItemSet& rSet,
777 : const SdrText* pText,
778 : bool bHasContent)
779 : {
780 88398 : attribute::SdrLineAttribute aLine;
781 176796 : attribute::SdrFillAttribute aFill;
782 176796 : attribute::SdrLineStartEndAttribute aLineStartEnd;
783 176796 : attribute::SdrShadowAttribute aShadow;
784 176796 : attribute::FillGradientAttribute aFillFloatTransGradient;
785 176796 : attribute::SdrTextAttribute aText;
786 88398 : bool bFontworkHideContour(false);
787 :
788 : // look for text first
789 88398 : if(pText)
790 : {
791 88398 : aText = createNewSdrTextAttribute(rSet, *pText);
792 :
793 : // when object has text and text is fontwork and hide contour is set for fontwork, force
794 : // line and fill style to empty
795 88398 : if(!aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour())
796 : {
797 0 : bFontworkHideContour = true;
798 : }
799 : }
800 :
801 88398 : if(!bFontworkHideContour)
802 : {
803 : // try line style
804 88398 : aLine = createNewSdrLineAttribute(rSet);
805 :
806 88398 : if(!aLine.isDefault())
807 : {
808 : // try LineStartEnd
809 20260 : aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth());
810 : }
811 :
812 : // try fill style
813 88398 : aFill = createNewSdrFillAttribute(rSet);
814 :
815 88398 : if(!aFill.isDefault())
816 : {
817 : // try fillfloattransparence
818 45202 : aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
819 : }
820 : }
821 :
822 : // bHasContent is used from OLE and graphic objects. Normally a possible shadow
823 : // depends on line, fill or text to be set, but for these objects it is possible
824 : // to have none of these, but still content which needs to have a shadow (if set),
825 : // so shadow needs to be tried
826 88398 : if(bHasContent || !aLine.isDefault() || !aFill.isDefault() || !aText.isDefault())
827 : {
828 : // try shadow
829 77748 : aShadow = createNewSdrShadowAttribute(rSet);
830 :
831 : return attribute::SdrLineFillShadowTextAttribute(
832 77748 : aLine, aFill, aLineStartEnd, aShadow, aFillFloatTransGradient, aText);
833 : }
834 :
835 99048 : return attribute::SdrLineFillShadowTextAttribute();
836 : }
837 :
838 9601 : attribute::SdrLineFillShadowAttribute3D createNewSdrLineFillShadowAttribute(const SfxItemSet& rSet, bool bSuppressFill)
839 : {
840 9601 : attribute::SdrFillAttribute aFill;
841 19202 : attribute::SdrLineStartEndAttribute aLineStartEnd;
842 19202 : attribute::SdrShadowAttribute aShadow;
843 19202 : attribute::FillGradientAttribute aFillFloatTransGradient;
844 :
845 : // try line style
846 19202 : const attribute::SdrLineAttribute aLine(createNewSdrLineAttribute(rSet));
847 :
848 9601 : if(!aLine.isDefault())
849 : {
850 : // try LineStartEnd
851 8131 : aLineStartEnd = createNewSdrLineStartEndAttribute(rSet, aLine.getWidth());
852 : }
853 :
854 : // try fill style
855 9601 : if(!bSuppressFill)
856 : {
857 9401 : aFill = createNewSdrFillAttribute(rSet);
858 :
859 9401 : if(!aFill.isDefault())
860 : {
861 : // try fillfloattransparence
862 7262 : aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
863 : }
864 : }
865 :
866 9601 : if(!aLine.isDefault() || !aFill.isDefault())
867 : {
868 : // try shadow
869 9181 : aShadow = createNewSdrShadowAttribute(rSet);
870 :
871 : return attribute::SdrLineFillShadowAttribute3D(
872 9181 : aLine, aFill, aLineStartEnd, aShadow, aFillFloatTransGradient);
873 : }
874 :
875 10021 : return attribute::SdrLineFillShadowAttribute3D();
876 : }
877 :
878 627 : attribute::SdrSceneAttribute createNewSdrSceneAttribute(const SfxItemSet& rSet)
879 : {
880 : // get perspective
881 627 : ::com::sun::star::drawing::ProjectionMode aProjectionMode(::com::sun::star::drawing::ProjectionMode_PARALLEL);
882 627 : const sal_uInt16 nProjectionValue(static_cast<const Svx3DPerspectiveItem&>(rSet.Get(SDRATTR_3DSCENE_PERSPECTIVE)).GetValue());
883 :
884 627 : if(1L == nProjectionValue)
885 : {
886 225 : aProjectionMode = ::com::sun::star::drawing::ProjectionMode_PERSPECTIVE;
887 : }
888 :
889 : // get distance
890 627 : const double fDistance(static_cast<const SfxUInt32Item&>(rSet.Get(SDRATTR_3DSCENE_DISTANCE)).GetValue());
891 :
892 : // get shadow slant
893 627 : const double fShadowSlant(F_PI180 * static_cast<const SfxUInt16Item&>(rSet.Get(SDRATTR_3DSCENE_SHADOW_SLANT)).GetValue());
894 :
895 : // get shade mode
896 627 : ::com::sun::star::drawing::ShadeMode aShadeMode(::com::sun::star::drawing::ShadeMode_FLAT);
897 627 : const sal_uInt16 nShadeValue(static_cast<const Svx3DShadeModeItem&>(rSet.Get(SDRATTR_3DSCENE_SHADE_MODE)).GetValue());
898 :
899 627 : if(1L == nShadeValue)
900 : {
901 0 : aShadeMode = ::com::sun::star::drawing::ShadeMode_PHONG;
902 : }
903 627 : else if(2L == nShadeValue)
904 : {
905 171 : aShadeMode = ::com::sun::star::drawing::ShadeMode_SMOOTH;
906 : }
907 456 : else if(3L == nShadeValue)
908 : {
909 0 : aShadeMode = ::com::sun::star::drawing::ShadeMode_DRAFT;
910 : }
911 :
912 : // get two sided lighting
913 627 : const bool bTwoSidedLighting(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING)).GetValue());
914 :
915 627 : return attribute::SdrSceneAttribute(fDistance, fShadowSlant, aProjectionMode, aShadeMode, bTwoSidedLighting);
916 : }
917 :
918 19 : attribute::SdrLightingAttribute createNewSdrLightingAttribute(const SfxItemSet& rSet)
919 : {
920 : // extract lights from given SfxItemSet (from scene)
921 19 : ::std::vector< attribute::Sdr3DLightAttribute > aLightVector;
922 :
923 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_1)).GetValue())
924 : {
925 0 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1)).GetValue().getBColor());
926 0 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1)).GetValue());
927 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, true));
928 : }
929 :
930 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_2)).GetValue())
931 : {
932 19 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2)).GetValue().getBColor());
933 38 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2)).GetValue());
934 38 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
935 : }
936 :
937 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_3)).GetValue())
938 : {
939 0 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3)).GetValue().getBColor());
940 0 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3)).GetValue());
941 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
942 : }
943 :
944 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_4)).GetValue())
945 : {
946 0 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4)).GetValue().getBColor());
947 0 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4)).GetValue());
948 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
949 : }
950 :
951 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_5)).GetValue())
952 : {
953 0 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5)).GetValue().getBColor());
954 0 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5)).GetValue());
955 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
956 : }
957 :
958 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_6)).GetValue())
959 : {
960 0 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6)).GetValue().getBColor());
961 0 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6)).GetValue());
962 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
963 : }
964 :
965 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_7)).GetValue())
966 : {
967 0 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7)).GetValue().getBColor());
968 0 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7)).GetValue());
969 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
970 : }
971 :
972 19 : if(static_cast<const SfxBoolItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTON_8)).GetValue())
973 : {
974 0 : const basegfx::BColor aColor(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8)).GetValue().getBColor());
975 0 : const basegfx::B3DVector aDirection(static_cast<const SvxB3DVectorItem&>(rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8)).GetValue());
976 0 : aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
977 : }
978 :
979 : // get ambient color
980 19 : const Color aAmbientValue(static_cast<const SvxColorItem&>(rSet.Get(SDRATTR_3DSCENE_AMBIENTCOLOR)).GetValue());
981 38 : const basegfx::BColor aAmbientLight(aAmbientValue.getBColor());
982 :
983 38 : return attribute::SdrLightingAttribute(aAmbientLight, aLightVector);
984 : }
985 :
986 49151 : void calculateRelativeCornerRadius(sal_Int32 nRadius, const basegfx::B2DRange& rObjectRange, double& rfCornerRadiusX, double& rfCornerRadiusY)
987 : {
988 49151 : rfCornerRadiusX = rfCornerRadiusY = (double)nRadius;
989 :
990 49151 : if(0.0 != rfCornerRadiusX)
991 : {
992 16 : const double fHalfObjectWidth(rObjectRange.getWidth() * 0.5);
993 :
994 16 : if(0.0 != fHalfObjectWidth)
995 : {
996 16 : if(rfCornerRadiusX < 0.0)
997 : {
998 0 : rfCornerRadiusX = 0.0;
999 : }
1000 :
1001 16 : if(rfCornerRadiusX > fHalfObjectWidth)
1002 : {
1003 0 : rfCornerRadiusX = fHalfObjectWidth;
1004 : }
1005 :
1006 16 : rfCornerRadiusX /= fHalfObjectWidth;
1007 : }
1008 : else
1009 : {
1010 0 : rfCornerRadiusX = 0.0;
1011 : }
1012 : }
1013 :
1014 49151 : if(0.0 != rfCornerRadiusY)
1015 : {
1016 16 : const double fHalfObjectHeight(rObjectRange.getHeight() * 0.5);
1017 :
1018 16 : if(0.0 != fHalfObjectHeight)
1019 : {
1020 16 : if(rfCornerRadiusY < 0.0)
1021 : {
1022 0 : rfCornerRadiusY = 0.0;
1023 : }
1024 :
1025 16 : if(rfCornerRadiusY > fHalfObjectHeight)
1026 : {
1027 4 : rfCornerRadiusY = fHalfObjectHeight;
1028 : }
1029 :
1030 16 : rfCornerRadiusY /= fHalfObjectHeight;
1031 : }
1032 : else
1033 : {
1034 0 : rfCornerRadiusY = 0.0;
1035 : }
1036 : }
1037 49151 : }
1038 :
1039 : // #i101508# Support handing over given text-to-border distances
1040 0 : attribute::SdrFillTextAttribute createNewSdrFillTextAttribute(
1041 : const SfxItemSet& rSet,
1042 : const SdrText* pText,
1043 : const sal_Int32* pLeft,
1044 : const sal_Int32* pUpper,
1045 : const sal_Int32* pRight,
1046 : const sal_Int32* pLower)
1047 : {
1048 0 : attribute::SdrFillAttribute aFill;
1049 0 : attribute::FillGradientAttribute aFillFloatTransGradient;
1050 0 : attribute::SdrTextAttribute aText;
1051 0 : bool bFontworkHideContour(false);
1052 :
1053 : // look for text first
1054 0 : if(pText)
1055 : {
1056 0 : aText = createNewSdrTextAttribute(rSet, *pText, pLeft, pUpper, pRight, pLower);
1057 :
1058 : // when object has text and text is fontwork and hide contour is set for fontwork, force
1059 : // fill style to empty
1060 0 : if(!aText.getSdrFormTextAttribute().isDefault() && aText.isHideContour())
1061 : {
1062 0 : bFontworkHideContour = true;
1063 : }
1064 : }
1065 :
1066 0 : if(!bFontworkHideContour)
1067 : {
1068 : // try fill style
1069 0 : aFill = createNewSdrFillAttribute(rSet);
1070 :
1071 0 : if(!aFill.isDefault())
1072 : {
1073 : // try fillfloattransparence
1074 0 : aFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
1075 : }
1076 : }
1077 :
1078 0 : if(!aFill.isDefault() || !aText.isDefault())
1079 : {
1080 0 : return attribute::SdrFillTextAttribute(aFill, aFillFloatTransGradient, aText);
1081 : }
1082 :
1083 0 : return attribute::SdrFillTextAttribute();
1084 : }
1085 :
1086 : } // end of namespace primitive2d
1087 435 : } // end of namespace drawinglayer
1088 :
1089 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
