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