?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 7.6.3.2-android, tag libreoffice-7.6.3.2-android
[LibreOffice.git] / svx / source / xoutdev / xattr.cxx
blobc7e1fed33ac24161de047f1b199ea1be58252034
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 <sal/config.h>
21
22 #include <utility>
23
24 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
25 #include <com/sun/star/drawing/Hatch.hpp>
26 #include <com/sun/star/drawing/LineStyle.hpp>
27 #include <com/sun/star/drawing/LineDash.hpp>
28 #include <com/sun/star/drawing/DashStyle.hpp>
29 #include <com/sun/star/drawing/FillStyle.hpp>
30 #include <com/sun/star/awt/Gradient2.hpp>
31 #include <com/sun/star/uno/Sequence.hxx>
32 #include <com/sun/star/beans/PropertyValue.hpp>
33
34 #include <comphelper/propertyvalue.hxx>
35 #include <o3tl/string_view.hxx>
36 #include <o3tl/any.hxx>
37 #include <svl/itempool.hxx>
38 #include <editeng/memberids.h>
39 #include <docmodel/uno/UnoGradientTools.hxx>
40 #include <docmodel/uno/UnoComplexColor.hxx>
41 #include <docmodel/color/ComplexColorJSON.hxx>
42 #include <tools/mapunit.hxx>
43 #include <tools/UnitConversion.hxx>
44 #include <osl/diagnose.h>
45
46 #include <svx/unoapi.hxx>
47 #include <svl/style.hxx>
48
49 #include <tools/bigint.hxx>
50 #include <svl/itemset.hxx>
51 #include <svx/strings.hrc>
52 #include <svx/xfillit0.hxx>
53 #include <svx/xflasit.hxx>
54 #include <svx/xlineit0.hxx>
55 #include <svx/xlnasit.hxx>
56 #include <svx/xtextit0.hxx>
57 #include <svx/xtable.hxx>
58 #include <svx/dialmgr.hxx>
59 #include <svx/xflclit.hxx>
60 #include <svx/xflgrit.hxx>
61 #include <svx/xflftrit.hxx>
62 #include <svx/xsflclit.hxx>
63 #include <svx/xflhtit.hxx>
64 #include <svx/xbtmpit.hxx>
65 #include <svx/xlndsit.hxx>
66 #include <svx/xlnwtit.hxx>
67 #include <svx/xlnclit.hxx>
68 #include <svx/xlnstit.hxx>
69 #include <svx/xlnedit.hxx>
70 #include <svx/xlnstwit.hxx>
71 #include <svx/xlnedwit.hxx>
72 #include <svx/xlnstcit.hxx>
73 #include <svx/xlnedcit.hxx>
74 #include <editeng/itemtype.hxx>
75 #include <editeng/eerdll.hxx>
76 #include <svx/xdef.hxx>
77 #include <svx/unomid.hxx>
78 #include <svx/svdmodel.hxx>
79 #include <svx/xftdiit.hxx>
80 #include <svx/xftstit.hxx>
81 #include <svx/xftmrit.hxx>
82 #include <svx/xftouit.hxx>
83 #include <svx/xftshit.hxx>
84 #include <svx/xftshcit.hxx>
85 #include <svx/xftshxy.hxx>
86 #include <svx/xftadit.hxx>
87 #include <svx/svddef.hxx>
88 #include <basegfx/polygon/b2dpolypolygontools.hxx>
89 #include <unotools/intlwrapper.hxx>
90 #include <unotools/syslocale.hxx>
91 #include <string>
92
93 #include <boost/property_tree/json_parser.hpp>
94 #include <libxml/xmlwriter.h>
95
96 using namespace ::com::sun::star;
97
98 typedef std::map<OUString, OUString> StringMap;
99
100 NameOrIndex::NameOrIndex(TypedWhichId<NameOrIndex> _nWhich, sal_Int32 nIndex) :
101 SfxStringItem(_nWhich, OUString()),
102 nPalIndex(nIndex)
103 {
104 }
105
106 NameOrIndex::NameOrIndex(TypedWhichId<NameOrIndex> _nWhich, const OUString& rName) :
107 SfxStringItem(_nWhich, rName),
108 nPalIndex(-1)
109 {
110 }
111
112 NameOrIndex::NameOrIndex(const NameOrIndex& rNameOrIndex) :
113 SfxStringItem(rNameOrIndex),
114 nPalIndex(rNameOrIndex.nPalIndex)
115 {
116 }
117
118 bool NameOrIndex::operator==(const SfxPoolItem& rItem) const
119 {
120 return ( SfxStringItem::operator==(rItem) &&
121 static_cast<const NameOrIndex&>(rItem).nPalIndex == nPalIndex );
122 }
123
124 NameOrIndex* NameOrIndex::Clone(SfxItemPool* /*pPool*/) const
125 {
126 return new NameOrIndex(*this);
127 }
128
129 /** this static checks if the given NameOrIndex item has a unique name for its value.
130 The returned String is a unique name for an item with this value in both given pools.
131 Argument pPool2 can be null.
132 If returned string equals NameOrIndex->GetName(), the name was already unique.
133 */
134 OUString NameOrIndex::CheckNamedItem( const NameOrIndex* pCheckItem, const sal_uInt16 nWhich, const SfxItemPool* pPool1, SvxCompareValueFunc pCompareValueFunc, TranslateId pPrefixResId, const XPropertyListRef &pDefaults )
135 {
136 bool bForceNew = false;
137
138 OUString aUniqueName = SvxUnogetInternalNameForItem(nWhich, pCheckItem->GetName());
139
140 // 2. if we have a name check if there is already an item with the
141 // same name in the documents pool with a different line end or start
142
143 if (!aUniqueName.isEmpty() && pPool1)
144 {
145 for (const SfxPoolItem* pItem : pPool1->GetItemSurrogates(nWhich))
146 {
147 const NameOrIndex *pNameOrIndex = static_cast<const NameOrIndex*>(pItem);
148
149 if( pNameOrIndex->GetName() == pCheckItem->GetName() )
150 {
151 // if there is already an item with the same name and the same
152 // value it's ok to set it
153 if( !pCompareValueFunc( pNameOrIndex, pCheckItem ) )
154 {
155 // same name but different value, we need a new name for this item
156 aUniqueName.clear();
157 bForceNew = true;
158 }
159 break;
160 }
161 }
162 }
163
164 // if we have no name yet, find existing item with same content or
165 // create a unique name
166 if (aUniqueName.isEmpty())
167 {
168 sal_Int32 nUserIndex = 1;
169 const OUString aUser(SvxResId(pPrefixResId) + " ");
170
171 if( pDefaults )
172 {
173 const int nCount = pDefaults->Count();
174 int nIndex;
175 for( nIndex = 0; nIndex < nCount; nIndex++ )
176 {
177 const XPropertyEntry* pEntry = pDefaults->Get(nIndex);
178 if( pEntry )
179 {
180 bool bFound = false;
181
182 switch( nWhich )
183 {
184 case XATTR_FILLBITMAP:
185 {
186 const GraphicObject& rGraphicObjectA(static_cast<const XFillBitmapItem*>(pCheckItem)->GetGraphicObject());
187 const GraphicObject& rGraphicObjectB(static_cast<const XBitmapEntry*>(pEntry)->GetGraphicObject());
188
189 bFound = (rGraphicObjectA == rGraphicObjectB);
190 break;
191 }
192 case XATTR_LINEDASH:
193 bFound = static_cast<const XLineDashItem*>(pCheckItem)->GetDashValue() == static_cast<const XDashEntry*>(pEntry)->GetDash();
194 break;
195 case XATTR_LINESTART:
196 bFound = static_cast<const XLineStartItem*>(pCheckItem)->GetLineStartValue() == static_cast<const XLineEndEntry*>(pEntry)->GetLineEnd();
197 break;
198 case XATTR_LINEEND:
199 bFound = static_cast<const XLineEndItem*>(pCheckItem)->GetLineEndValue() == static_cast<const XLineEndEntry*>(pEntry)->GetLineEnd();
200 break;
201 case XATTR_FILLGRADIENT:
202 bFound = static_cast<const XFillGradientItem*>(pCheckItem)->GetGradientValue() == static_cast<const XGradientEntry*>(pEntry)->GetGradient();
203 break;
204 case XATTR_FILLHATCH:
205 bFound = static_cast<const XFillHatchItem*>(pCheckItem)->GetHatchValue() == static_cast<const XHatchEntry*>(pEntry)->GetHatch();
206 break;
207 }
208
209 if( bFound )
210 {
211 aUniqueName = pEntry->GetName();
212 break;
213 }
214 else
215 {
216 const OUString& aEntryName = pEntry->GetName();
217 if(aEntryName.getLength() >= aUser.getLength())
218 {
219 sal_Int32 nThisIndex = o3tl::toInt32(aEntryName.subView( aUser.getLength() ));
220 if( nThisIndex >= nUserIndex )
221 nUserIndex = nThisIndex + 1;
222 }
223 }
224 }
225 }
226 }
227
228 if (aUniqueName.isEmpty() && pPool1)
229 {
230 for (const SfxPoolItem* pItem : pPool1->GetItemSurrogates(nWhich))
231 {
232 const NameOrIndex *pNameOrIndex = static_cast<const NameOrIndex*>(pItem);
233
234 if( !pNameOrIndex->GetName().isEmpty() )
235 {
236 if( !bForceNew && pCompareValueFunc( pNameOrIndex, pCheckItem ) )
237 return pNameOrIndex->GetName();
238
239 if( pNameOrIndex->GetName().startsWith( aUser ) )
240 {
241 sal_Int32 nThisIndex = o3tl::toInt32(pNameOrIndex->GetName().subView( aUser.getLength() ));
242 if( nThisIndex >= nUserIndex )
243 nUserIndex = nThisIndex + 1;
244 }
245 }
246 }
247 aUniqueName = aUser + OUString::number( nUserIndex );
248 }
249 }
250
251 return aUniqueName;
252 }
253
254 void NameOrIndex::dumpAsXml(xmlTextWriterPtr pWriter) const
255 {
256 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("NameOrIndex"));
257 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
258 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("isIndex"), BAD_CAST(OString::boolean(IsIndex()).getStr()));
259 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
260 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(nPalIndex).getStr()));
261 (void)xmlTextWriterEndElement(pWriter);
262 }
263
264 SfxPoolItem* XColorItem::CreateDefault() { return new XColorItem; }
265
266 XColorItem::XColorItem(TypedWhichId<XColorItem> _nWhich, sal_Int32 nIndex, const Color& rTheColor) :
267 NameOrIndex(_nWhich, nIndex),
268 aColor(rTheColor)
269 {
270 }
271
272 XColorItem::XColorItem(TypedWhichId<XColorItem> _nWhich, const OUString& rName, const Color& rTheColor) :
273 NameOrIndex(_nWhich, rName),
274 aColor(rTheColor)
275 {
276 }
277
278 XColorItem::XColorItem(TypedWhichId<XColorItem> _nWhich, const Color& rTheColor)
279 : NameOrIndex(_nWhich, OUString())
280 , aColor(rTheColor)
281 {
282 }
283
284 XColorItem::XColorItem(const XColorItem& rItem) :
285 NameOrIndex(rItem),
286 aColor(rItem.aColor),
287 maComplexColor(rItem.maComplexColor)
288 {
289 }
290
291 XColorItem* XColorItem::Clone(SfxItemPool* /*pPool*/) const
292 {
293 return new XColorItem(*this);
294 }
295
296 bool XColorItem::operator==(const SfxPoolItem& rItem) const
297 {
298 return ( NameOrIndex::operator==(rItem) &&
299 static_cast<const XColorItem&>(rItem).aColor == aColor ) &&
300 static_cast<const XColorItem&>(rItem).maComplexColor == maComplexColor;
301 }
302
303 const Color& XColorItem::GetColorValue() const
304 {
305 assert(!IsIndex());
306 return aColor;
307
308 }
309
310 bool XColorItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
311 {
312 rVal <<= GetColorValue().GetRGBColor();
313 return true;
314 }
315
316 bool XColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
317 {
318 Color nValue;
319 rVal >>= nValue;
320 SetColorValue( nValue );
321
322 return true;
323 }
324
325 void XColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
326 {
327 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XColorItem"));
328 if (Which() == SDRATTR_SHADOWCOLOR)
329 {
330 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("SDRATTR_SHADOWCOLOR"));
331 }
332 else if (Which() == XATTR_FILLCOLOR)
333 {
334 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST("XATTR_FILLCOLOR"));
335 }
336 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aColor"),
337 BAD_CAST(aColor.AsRGBHexString().toUtf8().getStr()));
338
339 NameOrIndex::dumpAsXml(pWriter);
340
341 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("complex-color"));
342
343 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("scheme-index"),
344 BAD_CAST(OString::number(sal_Int16(maComplexColor.getSchemeType())).getStr()));
345
346 for (auto const& rTransform : maComplexColor.getTransformations())
347 {
348 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("transformation"));
349 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("type"),
350 BAD_CAST(OString::number(sal_Int16(rTransform.meType)).getStr()));
351 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"),
352 BAD_CAST(OString::number(rTransform.mnValue).getStr()));
353 (void)xmlTextWriterEndElement(pWriter);
354 }
355
356 (void)xmlTextWriterEndElement(pWriter);
357
358 (void)xmlTextWriterEndElement(pWriter);
359 }
360
361 // --- line attributes ---
362
363
364 SfxPoolItem* XLineStyleItem::CreateDefault() { return new XLineStyleItem; }
365
366 XLineStyleItem::XLineStyleItem(css::drawing::LineStyle eTheLineStyle) :
367 SfxEnumItem(XATTR_LINESTYLE, eTheLineStyle)
368 {
369 }
370
371 XLineStyleItem* XLineStyleItem::Clone(SfxItemPool* /*pPool*/) const
372 {
373 return new XLineStyleItem( *this );
374 }
375
376 bool XLineStyleItem::GetPresentation
377 (
378 SfxItemPresentation /*ePres*/,
379 MapUnit /*eCoreUnit*/,
380 MapUnit /*ePresUnit*/,
381 OUString& rText, const IntlWrapper&
382 ) const
383 {
384 rText.clear();
385
386 TranslateId pId;
387
388 switch( GetValue() )
389 {
390 case css::drawing::LineStyle_NONE:
391 pId = RID_SVXSTR_INVISIBLE;
392 break;
393 case css::drawing::LineStyle_SOLID:
394 pId = RID_SVXSTR_SOLID;
395 break;
396 default: break;
397 }
398
399 if (pId)
400 rText = SvxResId(pId);
401 return true;
402 }
403
404 bool XLineStyleItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
405 {
406 css::drawing::LineStyle eLS = GetValue();
407 rVal <<= eLS;
408 return true;
409 }
410
411 bool XLineStyleItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
412 {
413 css::drawing::LineStyle eLS;
414 if(!(rVal >>= eLS ))
415 {
416 // also try an int (for Basic)
417 sal_Int32 nLS = 0;
418 if(!(rVal >>= nLS))
419 return false;
420 eLS = static_cast<css::drawing::LineStyle>(nLS);
421 }
422
423 SetValue( eLS );
424 return true;
425 }
426
427 sal_uInt16 XLineStyleItem::GetValueCount() const
428 {
429 return 3;
430 }
431
432 XDash::XDash(css::drawing::DashStyle eTheDash, sal_uInt16 nTheDots, double nTheDotLen,
433 sal_uInt16 nTheDashes, double nTheDashLen, double nTheDistance) :
434 eDash(eTheDash),
435 nDots(nTheDots),
436 nDashes(nTheDashes),
437 nDotLen(nTheDotLen),
438 nDashLen(nTheDashLen),
439 nDistance(nTheDistance)
440 {
441 }
442
443 bool XDash::operator==(const XDash& rDash) const
444 {
445 return ( eDash == rDash.eDash &&
446 nDots == rDash.nDots &&
447 nDotLen == rDash.nDotLen &&
448 nDashes == rDash.nDashes &&
449 nDashLen == rDash.nDashLen &&
450 nDistance == rDash.nDistance );
451 }
452
453 // XDash is translated into an array of doubles which describe the lengths of the
454 // dashes, dots and empty passages. It returns the complete length of the full DashDot
455 // sequence and fills the given vector of doubles accordingly (also resizing, so deleting it).
456 const double SMALLEST_DASH_WIDTH(26.95);
457
458 double XDash::CreateDotDashArray(::std::vector< double >& rDotDashArray, double fLineWidth) const
459 {
460 double fFullDotDashLen(0.0);
461 const sal_uInt16 nNumDotDashArray = (GetDots() + GetDashes()) * 2;
462 rDotDashArray.resize( nNumDotDashArray, 0.0 );
463 sal_uInt16 a;
464 sal_uInt16 nIns(0);
465 double fDashDotDistance = GetDistance();
466 double fSingleDashLen = GetDashLen();
467 double fSingleDotLen = GetDotLen();
468
469 if (fLineWidth == 0.0)
470 fLineWidth = SMALLEST_DASH_WIDTH;
471
472 if(GetDashStyle() == css::drawing::DashStyle_RECTRELATIVE || GetDashStyle() == css::drawing::DashStyle_ROUNDRELATIVE)
473 {
474 double fFactor = fLineWidth / 100.0;
475
476 if(GetDashes())
477 {
478 if(GetDashLen())
479 {
480 // is a dash
481 fSingleDashLen *= fFactor;
482 }
483 else
484 {
485 // is a dot
486 fSingleDashLen = fLineWidth;
487 }
488 }
489
490 if(GetDots())
491 {
492 if(GetDotLen())
493 {
494 // is a dash
495 fSingleDotLen *= fFactor;
496 }
497 else
498 {
499 // is a dot
500 fSingleDotLen = fLineWidth;
501 }
502 }
503
504 if(GetDashes() || GetDots())
505 {
506 if(GetDistance())
507 {
508 // dash as distance
509 fDashDotDistance *= fFactor;
510 }
511 else
512 {
513 // dot as distance
514 fDashDotDistance = fLineWidth;
515 }
516 }
517 }
518 else
519 {
520 // absolute values
521 if(GetDashes())
522 {
523 if(GetDashLen())
524 {
525 // is a dash
526 if(fSingleDashLen < SMALLEST_DASH_WIDTH)
527 {
528 fSingleDashLen = SMALLEST_DASH_WIDTH;
529 }
530 }
531 else
532 {
533 // is a dot
534 if(fSingleDashLen < fLineWidth)
535 {
536 fSingleDashLen = fLineWidth;
537 }
538 }
539 }
540
541 if(GetDots())
542 {
543 if(GetDotLen())
544 {
545 // is a dash
546 if(fSingleDotLen < SMALLEST_DASH_WIDTH)
547 {
548 fSingleDotLen = SMALLEST_DASH_WIDTH;
549 }
550 }
551 else
552 {
553 // is a dot
554 if(fSingleDotLen < fLineWidth)
555 {
556 fSingleDotLen = fLineWidth;
557 }
558 }
559 }
560
561 if(GetDashes() || GetDots())
562 {
563 if(GetDistance())
564 {
565 // dash as distance
566 if(fDashDotDistance < SMALLEST_DASH_WIDTH)
567 {
568 fDashDotDistance = SMALLEST_DASH_WIDTH;
569 }
570 }
571 else
572 {
573 // dot as distance
574 if(fDashDotDistance < fLineWidth)
575 {
576 fDashDotDistance = fLineWidth;
577 }
578 }
579 }
580 }
581
582 for(a=0;a<GetDots();a++)
583 {
584 rDotDashArray[nIns++] = fSingleDotLen;
585 fFullDotDashLen += fSingleDotLen;
586 rDotDashArray[nIns++] = fDashDotDistance;
587 fFullDotDashLen += fDashDotDistance;
588 }
589
590 for(a=0;a<GetDashes();a++)
591 {
592 rDotDashArray[nIns++] = fSingleDashLen;
593 fFullDotDashLen += fSingleDashLen;
594 rDotDashArray[nIns++] = fDashDotDistance;
595 fFullDotDashLen += fDashDotDistance;
596 }
597
598 return fFullDotDashLen;
599 }
600
601 SfxPoolItem* XLineDashItem::CreateDefault() {return new XLineDashItem;}
602
603 XLineDashItem::XLineDashItem(const OUString& rName, const XDash& rTheDash) :
604 NameOrIndex(XATTR_LINEDASH, rName),
605 aDash(rTheDash)
606 {
607 }
608
609 XLineDashItem::XLineDashItem(const XLineDashItem& rItem) :
610 NameOrIndex(rItem),
611 aDash(rItem.aDash)
612 {
613 }
614
615 XLineDashItem::XLineDashItem(const XDash& rTheDash)
616 : NameOrIndex( XATTR_LINEDASH, -1 ),
617 aDash(rTheDash)
618 {
619 }
620
621 XLineDashItem* XLineDashItem::Clone(SfxItemPool* /*pPool*/) const
622 {
623 return new XLineDashItem(*this);
624 }
625
626 bool XLineDashItem::operator==(const SfxPoolItem& rItem) const
627 {
628 return ( NameOrIndex::operator==(rItem) &&
629 aDash == static_cast<const XLineDashItem&>(rItem).aDash );
630 }
631
632 bool XLineDashItem::GetPresentation
633 (
634 SfxItemPresentation /*ePres*/,
635 MapUnit /*eCoreUnit*/,
636 MapUnit /*ePresUnit*/,
637 OUString& rText, const IntlWrapper&
638 ) const
639 {
640 rText = GetName();
641 return true;
642 }
643
644 bool XLineDashItem::HasMetrics() const
645 {
646 return true;
647 }
648
649 void XLineDashItem::ScaleMetrics(tools::Long nMul, tools::Long nDiv)
650 {
651 aDash.SetDotLen( BigInt::Scale( aDash.GetDotLen(), nMul, nDiv ) );
652 aDash.SetDashLen( BigInt::Scale( aDash.GetDashLen(), nMul, nDiv ) );
653 aDash.SetDistance( BigInt::Scale( aDash.GetDistance(), nMul, nDiv ) );
654 }
655
656 bool XLineDashItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
657 {
658 nMemberId &= ~CONVERT_TWIPS;
659
660 switch ( nMemberId )
661 {
662 case 0:
663 {
664 css::drawing::LineDash aLineDash;
665
666 const XDash& rXD = GetDashValue();
667 aLineDash.Style = static_cast<css::drawing::DashStyle>(static_cast<sal_uInt16>(rXD.GetDashStyle()));
668 aLineDash.Dots = rXD.GetDots();
669 aLineDash.DotLen = rXD.GetDotLen();
670 aLineDash.Dashes = rXD.GetDashes();
671 aLineDash.DashLen = rXD.GetDashLen();
672 aLineDash.Distance = rXD.GetDistance();
673
674 uno::Sequence< beans::PropertyValue > aPropSeq{
675 comphelper::makePropertyValue("Name", SvxUnogetApiNameForItem(Which(), GetName())),
676 comphelper::makePropertyValue("LineDash", aLineDash)
677 };
678 rVal <<= aPropSeq;
679 break;
680 }
681
682 case MID_NAME:
683 {
684 rVal <<= SvxUnogetApiNameForItem(Which(), GetName());
685 break;
686 }
687
688 case MID_LINEDASH:
689 {
690 const XDash& rXD = GetDashValue();
691
692 css::drawing::LineDash aLineDash;
693
694 aLineDash.Style = static_cast<css::drawing::DashStyle>(static_cast<sal_uInt16>(rXD.GetDashStyle()));
695 aLineDash.Dots = rXD.GetDots();
696 aLineDash.DotLen = rXD.GetDotLen();
697 aLineDash.Dashes = rXD.GetDashes();
698 aLineDash.DashLen = rXD.GetDashLen();
699 aLineDash.Distance = rXD.GetDistance();
700
701 rVal <<= aLineDash;
702 break;
703 }
704
705 case MID_LINEDASH_STYLE:
706 {
707 const XDash& rXD = GetDashValue();
708 rVal <<= static_cast<css::drawing::DashStyle>(static_cast<sal_Int16>(rXD.GetDashStyle()));
709 break;
710 }
711
712 case MID_LINEDASH_DOTS:
713 {
714 const XDash& rXD = GetDashValue();
715 rVal <<= rXD.GetDots();
716 break;
717 }
718
719 case MID_LINEDASH_DOTLEN:
720 {
721 const XDash& rXD = GetDashValue();
722 rVal <<= rXD.GetDotLen();
723 break;
724 }
725
726 case MID_LINEDASH_DASHES:
727 {
728 const XDash& rXD = GetDashValue();
729 rVal <<= rXD.GetDashes();
730 break;
731 }
732
733 case MID_LINEDASH_DASHLEN:
734 {
735 const XDash& rXD = GetDashValue();
736 rVal <<= rXD.GetDashLen();
737 break;
738 }
739
740 case MID_LINEDASH_DISTANCE:
741 {
742 const XDash& rXD = GetDashValue();
743 rVal <<= rXD.GetDistance();
744 break;
745 }
746
747 default: OSL_FAIL("Wrong MemberId!"); return false;
748 }
749
750 return true;
751 }
752
753 bool XLineDashItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
754 {
755 nMemberId &= ~CONVERT_TWIPS;
756
757 switch ( nMemberId )
758 {
759 case 0:
760 {
761 uno::Sequence< beans::PropertyValue > aPropSeq;
762
763 if ( rVal >>= aPropSeq )
764 {
765 css::drawing::LineDash aLineDash;
766 OUString aName;
767 bool bLineDash( false );
768 for ( const auto& rProp : std::as_const(aPropSeq) )
769 {
770 if ( rProp.Name == "Name" )
771 rProp.Value >>= aName;
772 else if ( rProp.Name == "LineDash" )
773 {
774 if ( rProp.Value >>= aLineDash )
775 bLineDash = true;
776 }
777 }
778
779 SetName( aName );
780 if ( bLineDash )
781 {
782 XDash aXDash;
783
784 aXDash.SetDashStyle(static_cast<css::drawing::DashStyle>(static_cast<sal_uInt16>(aLineDash.Style)));
785 aXDash.SetDots(aLineDash.Dots);
786 aXDash.SetDotLen(aLineDash.DotLen);
787 aXDash.SetDashes(aLineDash.Dashes);
788 aXDash.SetDashLen(aLineDash.DashLen);
789 aXDash.SetDistance(aLineDash.Distance);
790
791 if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
792 aXDash.SetDots(1);
793
794 SetDashValue( aXDash );
795 }
796
797 return true;
798 }
799
800 return false;
801 }
802
803 case MID_NAME:
804 {
805 OUString aName;
806 if (!(rVal >>= aName))
807 return false;
808 SetName( aName );
809 break;
810 }
811
812 case MID_LINEDASH:
813 {
814 css::drawing::LineDash aLineDash;
815 if(!(rVal >>= aLineDash))
816 return false;
817
818 XDash aXDash;
819
820 aXDash.SetDashStyle(static_cast<css::drawing::DashStyle>(static_cast<sal_uInt16>(aLineDash.Style)));
821 aXDash.SetDots(aLineDash.Dots);
822 aXDash.SetDotLen(aLineDash.DotLen);
823 aXDash.SetDashes(aLineDash.Dashes);
824 aXDash.SetDashLen(aLineDash.DashLen);
825 aXDash.SetDistance(aLineDash.Distance);
826
827 if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
828 aXDash.SetDots(1);
829
830 SetDashValue( aXDash );
831 break;
832 }
833
834 case MID_LINEDASH_STYLE:
835 {
836 sal_Int16 nVal = sal_Int16();
837 if(!(rVal >>= nVal))
838 return false;
839
840 XDash aXDash = GetDashValue();
841 aXDash.SetDashStyle(static_cast<css::drawing::DashStyle>(static_cast<sal_uInt16>(nVal)));
842
843 if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
844 aXDash.SetDots(1);
845
846 SetDashValue( aXDash );
847
848 break;
849 }
850
851 case MID_LINEDASH_DOTS:
852 case MID_LINEDASH_DASHES:
853 {
854 sal_Int16 nVal = sal_Int16();
855 if(!(rVal >>= nVal))
856 return false;
857
858 XDash aXDash = GetDashValue();
859 if ( nMemberId == MID_LINEDASH_DOTS )
860 aXDash.SetDots( nVal );
861 else
862 aXDash.SetDashes( nVal );
863
864 if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
865 aXDash.SetDots(1);
866
867 SetDashValue( aXDash );
868 break;
869 }
870
871 case MID_LINEDASH_DOTLEN:
872 case MID_LINEDASH_DASHLEN:
873 case MID_LINEDASH_DISTANCE:
874 {
875 sal_uInt32 nVal = 0;
876 if(!(rVal >>= nVal))
877 return false;
878
879 XDash aXDash = GetDashValue();
880 if ( nMemberId == MID_LINEDASH_DOTLEN )
881 aXDash.SetDotLen( nVal );
882 else if ( nMemberId == MID_LINEDASH_DASHLEN )
883 aXDash.SetDashLen( nVal );
884 else
885 aXDash.SetDistance( nVal );
886
887 if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
888 aXDash.SetDots(1);
889
890 SetDashValue( aXDash );
891 break;
892 }
893 }
894
895 return true;
896 }
897
898 bool XLineDashItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
899 {
900 return static_cast<const XLineDashItem*>(p1)->GetDashValue() == static_cast<const XLineDashItem*>(p2)->GetDashValue();
901 }
902
903 std::unique_ptr<XLineDashItem> XLineDashItem::checkForUniqueItem( SdrModel* pModel ) const
904 {
905 if( pModel )
906 {
907 const OUString aUniqueName = NameOrIndex::CheckNamedItem(
908 this, XATTR_LINEDASH, &pModel->GetItemPool(),
909 XLineDashItem::CompareValueFunc, RID_SVXSTR_DASH20,
910 pModel->GetPropertyList( XPropertyListType::Dash ) );
911
912 // if the given name is not valid, replace it!
913 if( aUniqueName != GetName() )
914 return std::make_unique<XLineDashItem>( aUniqueName, aDash );
915 }
916
917 return nullptr;
918 }
919
920 SfxPoolItem* XLineWidthItem::CreateDefault() {return new XLineWidthItem;}
921
922 XLineWidthItem::XLineWidthItem(tools::Long nWidth) :
923 SfxMetricItem(XATTR_LINEWIDTH, nWidth)
924 {
925 }
926
927 XLineWidthItem* XLineWidthItem::Clone(SfxItemPool* /*pPool*/) const
928 {
929 return new XLineWidthItem(*this);
930 }
931
932 bool XLineWidthItem::GetPresentation
933 (
934 SfxItemPresentation /*ePres*/,
935 MapUnit eCoreUnit,
936 MapUnit ePresUnit,
937 OUString& rText, const IntlWrapper& rIntl
938 ) const
939 {
940 rText = GetMetricText( static_cast<tools::Long>(GetValue()),
941 eCoreUnit, ePresUnit, &rIntl) +
942 " " + EditResId( GetMetricId( ePresUnit) );
943 return true;
944 }
945
946 bool XLineWidthItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
947 {
948 sal_Int32 nValue = GetValue();
949 if( 0 != (nMemberId&CONVERT_TWIPS) )
950 nValue = convertTwipToMm100(nValue);
951
952 rVal <<= nValue;
953 return true;
954 }
955
956 bool XLineWidthItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
957 {
958 sal_Int32 nValue = 0;
959 rVal >>= nValue;
960 if( 0 != (nMemberId&CONVERT_TWIPS) )
961 nValue = o3tl::toTwips(nValue, o3tl::Length::mm100);
962
963 SetValue( nValue );
964 return true;
965 }
966
967 SfxPoolItem* XLineColorItem::CreateDefault() { return new XLineColorItem; }
968
969 XLineColorItem::XLineColorItem(sal_Int32 nIndex, const Color& rTheColor) :
970 XColorItem(XATTR_LINECOLOR, nIndex, rTheColor)
971 {
972 }
973
974 XLineColorItem::XLineColorItem(const OUString& rName, const Color& rTheColor) :
975 XColorItem(XATTR_LINECOLOR, rName, rTheColor)
976 {
977 }
978
979 XLineColorItem* XLineColorItem::Clone(SfxItemPool* /*pPool*/) const
980 {
981 return new XLineColorItem(*this);
982 }
983
984 bool XLineColorItem::GetPresentation
985 (
986 SfxItemPresentation /*ePres*/,
987 MapUnit /*eCoreUnit*/,
988 MapUnit /*ePresUnit*/,
989 OUString& rText, const IntlWrapper&
990 ) const
991 {
992 rText = GetName();
993 return true;
994 }
995
996 bool XLineColorItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId) const
997 {
998 nMemberId &= ~CONVERT_TWIPS;
999 switch (nMemberId)
1000 {
1001 case MID_COMPLEX_COLOR:
1002 {
1003 auto xComplexColor = model::color::createXComplexColor(getComplexColor());
1004 rVal <<= xComplexColor;
1005 break;
1006 }
1007 case MID_COMPLEX_COLOR_JSON:
1008 {
1009 rVal <<= OStringToOUString(model::color::convertToJSON(getComplexColor()), RTL_TEXTENCODING_UTF8);
1010 break;
1011 }
1012 default:
1013 {
1014 rVal <<= GetColorValue().GetRGBColor();
1015 break;
1016 }
1017 }
1018 return true;
1019 }
1020
1021 bool XLineColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId)
1022 {
1023 nMemberId &= ~CONVERT_TWIPS;
1024 switch(nMemberId)
1025 {
1026 case MID_COMPLEX_COLOR:
1027 {
1028 css::uno::Reference<css::util::XComplexColor> xComplexColor;
1029 if (!(rVal >>= xComplexColor))
1030 return false;
1031 setComplexColor(model::color::getFromXComplexColor(xComplexColor));
1032 }
1033 break;
1034 case MID_COMPLEX_COLOR_JSON:
1035 {
1036 OUString sComplexColorJson;
1037 if (!(rVal >>= sComplexColorJson))
1038 return false;
1039
1040 if (sComplexColorJson.isEmpty())
1041 return false;
1042 model::ComplexColor aComplexColor;
1043 OString aJSON = OUStringToOString(sComplexColorJson, RTL_TEXTENCODING_ASCII_US);
1044 model::color::convertFromJSON(aJSON, aComplexColor);
1045 setComplexColor(aComplexColor);
1046 }
1047 break;
1048 default:
1049 {
1050 sal_Int32 nValue;
1051 if(!(rVal >>= nValue ))
1052 return false;
1053
1054 SetColorValue( Color(ColorTransparency, nValue) );
1055 break;
1056 }
1057 }
1058 return true;
1059 }
1060
1061
1062 SfxPoolItem* XLineStartItem::CreateDefault() {return new XLineStartItem;}
1063
1064 XLineStartItem::XLineStartItem(sal_Int32 nIndex)
1065 : NameOrIndex(XATTR_LINESTART, nIndex)
1066 {
1067 }
1068
1069 XLineStartItem::XLineStartItem(const OUString& rName, basegfx::B2DPolyPolygon aPolyPolygon)
1070 : NameOrIndex(XATTR_LINESTART, rName),
1071 maPolyPolygon(std::move(aPolyPolygon))
1072 {
1073 }
1074
1075 XLineStartItem::XLineStartItem(const XLineStartItem& rItem)
1076 : NameOrIndex(rItem),
1077 maPolyPolygon(rItem.maPolyPolygon)
1078 {
1079 }
1080
1081 XLineStartItem::XLineStartItem(basegfx::B2DPolyPolygon aPolyPolygon)
1082 : NameOrIndex( XATTR_LINESTART, -1 ),
1083 maPolyPolygon(std::move(aPolyPolygon))
1084 {
1085 }
1086
1087 XLineStartItem* XLineStartItem::Clone(SfxItemPool* /*pPool*/) const
1088 {
1089 return new XLineStartItem(*this);
1090 }
1091
1092 bool XLineStartItem::operator==(const SfxPoolItem& rItem) const
1093 {
1094 return ( NameOrIndex::operator==(rItem) && static_cast<const XLineStartItem&>(rItem).maPolyPolygon == maPolyPolygon );
1095 }
1096
1097 bool XLineStartItem::GetPresentation
1098 (
1099 SfxItemPresentation /*ePres*/,
1100 MapUnit /*eCoreUnit*/,
1101 MapUnit /*ePresUnit*/,
1102 OUString& rText, const IntlWrapper&
1103 ) const
1104 {
1105 rText = GetName();
1106 return true;
1107 }
1108
1109 bool XLineStartItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
1110 {
1111 nMemberId &= ~CONVERT_TWIPS;
1112 if( nMemberId == MID_NAME )
1113 {
1114 rVal <<= SvxUnogetApiNameForItem(Which(), GetName());
1115 }
1116 else
1117 {
1118 css::drawing::PolyPolygonBezierCoords aBezier;
1119 basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( maPolyPolygon, aBezier );
1120 rVal <<= aBezier;
1121 }
1122
1123 return true;
1124 }
1125
1126 bool XLineStartItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
1127 {
1128 nMemberId &= ~CONVERT_TWIPS;
1129 if( nMemberId == MID_NAME )
1130 {
1131 return false;
1132 }
1133 else
1134 {
1135 maPolyPolygon.clear();
1136
1137 if( rVal.hasValue() )
1138 {
1139 auto pCoords = o3tl::tryAccess<css::drawing::PolyPolygonBezierCoords>(
1140 rVal);
1141 if( !pCoords )
1142 return false;
1143
1144 if( pCoords->Coordinates.getLength() > 0 )
1145 {
1146 maPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon( *pCoords );
1147 // #i72807# close line start/end polygons hard
1148 // maPolyPolygon.setClosed(true);
1149 }
1150 }
1151 }
1152
1153 return true;
1154 }
1155
1156 /** this function searches in both the models pool and the styles pool for XLineStartItem
1157 and XLineEndItem with the same value or name and returns an item with the value of
1158 this item and a unique name for an item with this value. */
1159 std::unique_ptr<XLineStartItem> XLineStartItem::checkForUniqueItem( SdrModel* pModel ) const
1160 {
1161 if( pModel )
1162 {
1163 std::unique_ptr<XLineStartItem> pTempItem;
1164 const XLineStartItem* pLineStartItem = this;
1165
1166 OUString aUniqueName( GetName() );
1167
1168 if( !maPolyPolygon.count() )
1169 {
1170 // if the polygon is empty, check if the name is empty
1171 if( aUniqueName.isEmpty() )
1172 return nullptr;
1173
1174 // force empty name for empty polygons
1175 return std::make_unique<XLineStartItem>( "", maPolyPolygon );
1176 }
1177
1178 if( maPolyPolygon.count() > 1 )
1179 {
1180 // check if the polygon is closed
1181 if(!maPolyPolygon.isClosed())
1182 {
1183 // force a closed polygon
1184 basegfx::B2DPolyPolygon aNew(maPolyPolygon);
1185 aNew.setClosed(true);
1186 pTempItem.reset(new XLineStartItem( aUniqueName, std::move(aNew) ));
1187 pLineStartItem = pTempItem.get();
1188 }
1189 }
1190
1191 bool bForceNew = false;
1192
1193 // 2. if we have a name check if there is already an item with the
1194 // same name in the documents pool with a different line end or start
1195
1196 const SfxItemPool& rPool1 = pModel->GetItemPool();
1197 if (!aUniqueName.isEmpty())
1198 {
1199 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART))
1200 {
1201 auto pItem = dynamic_cast<const XLineStartItem*>(p);
1202
1203 if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1204 {
1205 // if there is already an item with the same name and the same
1206 // value it's ok to set it
1207 if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() )
1208 {
1209 // same name but different value, we need a new name for this item
1210 aUniqueName.clear();
1211 bForceNew = true;
1212 }
1213 break;
1214 }
1215 }
1216
1217 if( !bForceNew )
1218 {
1219 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND))
1220 {
1221 auto pItem = dynamic_cast<const XLineEndItem*>(p);
1222
1223 if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1224 {
1225 // if there is already an item with the same name and the same
1226 // value it's ok to set it
1227 if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() )
1228 {
1229 // same name but different value, we need a new name for this item
1230 aUniqueName.clear();
1231 bForceNew = true;
1232 }
1233 break;
1234 }
1235 }
1236 }
1237 }
1238
1239 const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : nullptr;
1240 if( !aUniqueName.isEmpty() && pPool2)
1241 {
1242 for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINESTART))
1243 {
1244 auto pItem = dynamic_cast<const XLineStartItem*>(p);
1245
1246 if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1247 {
1248 // if there is already an item with the same name and the same
1249 // value it's ok to set it
1250 if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() )
1251 {
1252 // same name but different value, we need a new name for this item
1253 aUniqueName.clear();
1254 bForceNew = true;
1255 }
1256 break;
1257 }
1258 }
1259
1260 if( !bForceNew )
1261 {
1262 for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINEEND))
1263 {
1264 auto pItem = dynamic_cast<const XLineEndItem*>(p);
1265
1266 if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1267 {
1268 // if there is already an item with the same name and the same
1269 // value it's ok to set it
1270 if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() )
1271 {
1272 // same name but different value, we need a new name for this item
1273 aUniqueName.clear();
1274 bForceNew = true;
1275 }
1276 break;
1277 }
1278 }
1279 }
1280 }
1281
1282 // if we have no name yet, find existing item with same content or
1283 // create a unique name
1284 if( aUniqueName.isEmpty() )
1285 {
1286 bool bFoundExisting = false;
1287
1288 sal_Int32 nUserIndex = 1;
1289 const OUString aUser(SvxResId(RID_SVXSTR_LINEEND));
1290
1291 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART))
1292 {
1293 auto pItem = dynamic_cast<const XLineStartItem*>(p);
1294
1295 if (pItem && !pItem->GetName().isEmpty())
1296 {
1297 if (!bForceNew && pItem->GetLineStartValue() == pLineStartItem->GetLineStartValue())
1298 {
1299 aUniqueName = pItem->GetName();
1300 bFoundExisting = true;
1301 break;
1302 }
1303
1304 if (pItem->GetName().startsWith(aUser))
1305 {
1306 sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength()));
1307 if (nThisIndex >= nUserIndex)
1308 nUserIndex = nThisIndex + 1;
1309 }
1310 }
1311 }
1312
1313 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND))
1314 {
1315 auto pItem = dynamic_cast<const XLineEndItem*>(p);
1316
1317 if (pItem && !pItem->GetName().isEmpty())
1318 {
1319 if (!bForceNew && pItem->GetLineEndValue() == pLineStartItem->GetLineStartValue())
1320 {
1321 aUniqueName = pItem->GetName();
1322 bFoundExisting = true;
1323 break;
1324 }
1325
1326 if (pItem->GetName().startsWith(aUser))
1327 {
1328 sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength()));
1329 if (nThisIndex >= nUserIndex)
1330 nUserIndex = nThisIndex + 1;
1331 }
1332 }
1333 }
1334
1335 if( !bFoundExisting )
1336 {
1337 aUniqueName = aUser + " " + OUString::number( nUserIndex );
1338 }
1339 }
1340
1341 // if the given name is not valid, replace it!
1342 if( aUniqueName != GetName() || pTempItem )
1343 {
1344 if( pTempItem )
1345 {
1346 pTempItem->SetName( aUniqueName );
1347 return pTempItem;
1348 }
1349 else
1350 {
1351 return std::make_unique<XLineStartItem>( aUniqueName, maPolyPolygon );
1352 }
1353 }
1354 }
1355
1356 return nullptr;
1357 }
1358
1359 SfxPoolItem* XLineEndItem::CreateDefault() {return new XLineEndItem;}
1360
1361 XLineEndItem::XLineEndItem(sal_Int32 nIndex)
1362 : NameOrIndex(XATTR_LINEEND, nIndex)
1363 {
1364 }
1365
1366 XLineEndItem::XLineEndItem(const OUString& rName, basegfx::B2DPolyPolygon aPolyPolygon)
1367 : NameOrIndex(XATTR_LINEEND, rName),
1368 maPolyPolygon(std::move(aPolyPolygon))
1369 {
1370 }
1371
1372 XLineEndItem::XLineEndItem(const XLineEndItem& rItem)
1373 : NameOrIndex(rItem),
1374 maPolyPolygon(rItem.maPolyPolygon)
1375 {
1376 }
1377
1378 XLineEndItem::XLineEndItem(basegfx::B2DPolyPolygon aPolyPolygon)
1379 : NameOrIndex( XATTR_LINEEND, -1 ),
1380 maPolyPolygon(std::move(aPolyPolygon))
1381 {
1382 }
1383
1384 XLineEndItem* XLineEndItem::Clone(SfxItemPool* /*pPool*/) const
1385 {
1386 return new XLineEndItem(*this);
1387 }
1388
1389 bool XLineEndItem::operator==(const SfxPoolItem& rItem) const
1390 {
1391 return ( NameOrIndex::operator==(rItem) && static_cast<const XLineEndItem&>(rItem).maPolyPolygon == maPolyPolygon );
1392 }
1393
1394
1395 /** this function searches in both the models pool and the styles pool for XLineStartItem
1396 and XLineEndItem with the same value or name and returns an item with the value of
1397 this item and a unique name for an item with this value. */
1398 std::unique_ptr<XLineEndItem> XLineEndItem::checkForUniqueItem( SdrModel* pModel ) const
1399 {
1400 if( pModel )
1401 {
1402 std::unique_ptr<XLineEndItem> pTempItem;
1403 const XLineEndItem* pLineEndItem = this;
1404
1405 OUString aUniqueName( GetName() );
1406
1407 if( !maPolyPolygon.count() )
1408 {
1409 // if the polygon is empty, check if the name is empty
1410 if( aUniqueName.isEmpty() )
1411 return nullptr;
1412
1413 // force empty name for empty polygons
1414 return std::make_unique<XLineEndItem>( "", maPolyPolygon );
1415 }
1416
1417 if( maPolyPolygon.count() > 1 )
1418 {
1419 // check if the polygon is closed
1420 if(!maPolyPolygon.isClosed())
1421 {
1422 // force a closed polygon
1423 basegfx::B2DPolyPolygon aNew(maPolyPolygon);
1424 aNew.setClosed(true);
1425 pTempItem.reset(new XLineEndItem( aUniqueName, std::move(aNew) ));
1426 pLineEndItem = pTempItem.get();
1427 }
1428 }
1429
1430 bool bForceNew = false;
1431
1432 // 2. if we have a name check if there is already an item with the
1433 // same name in the documents pool with a different line end or start
1434
1435 const SfxItemPool& rPool1 = pModel->GetItemPool();
1436 if (!aUniqueName.isEmpty())
1437 {
1438 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART))
1439 {
1440 auto pItem = dynamic_cast<const XLineStartItem*>(p);
1441
1442 if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1443 {
1444 // if there is already an item with the same name and the same
1445 // value it's ok to set it
1446 if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() )
1447 {
1448 // same name but different value, we need a new name for this item
1449 aUniqueName.clear();
1450 bForceNew = true;
1451 }
1452 break;
1453 }
1454 }
1455
1456 if( !bForceNew )
1457 {
1458 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND))
1459 {
1460 auto pItem = dynamic_cast<const XLineEndItem*>(p);
1461
1462 if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1463 {
1464 // if there is already an item with the same name and the same
1465 // value it's ok to set it
1466 if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() )
1467 {
1468 // same name but different value, we need a new name for this item
1469 aUniqueName.clear();
1470 bForceNew = true;
1471 }
1472 break;
1473 }
1474 }
1475 }
1476 }
1477
1478 const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : nullptr;
1479 if( !aUniqueName.isEmpty() && pPool2)
1480 {
1481 for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINESTART))
1482 {
1483 auto pItem = dynamic_cast<const XLineStartItem*>(p);
1484
1485 if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1486 {
1487 // if there is already an item with the same name and the same
1488 // value it's ok to set it
1489 if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() )
1490 {
1491 // same name but different value, we need a new name for this item
1492 aUniqueName.clear();
1493 bForceNew = true;
1494 }
1495 break;
1496 }
1497 }
1498
1499 if( !bForceNew )
1500 {
1501 for (const SfxPoolItem* p : pPool2->GetItemSurrogates(XATTR_LINEEND))
1502 {
1503 auto pItem = dynamic_cast<const XLineEndItem*>(p);
1504
1505 if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1506 {
1507 // if there is already an item with the same name and the same
1508 // value it's ok to set it
1509 if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() )
1510 {
1511 // same name but different value, we need a new name for this item
1512 aUniqueName.clear();
1513 bForceNew = true;
1514 }
1515 break;
1516 }
1517 }
1518 }
1519 }
1520
1521 // if we have no name yet, find existing item with same content or
1522 // create a unique name
1523 if( aUniqueName.isEmpty() )
1524 {
1525 bool bFoundExisting = false;
1526
1527 sal_Int32 nUserIndex = 1;
1528 const OUString aUser(SvxResId(RID_SVXSTR_LINEEND));
1529
1530 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINESTART))
1531 {
1532 auto pItem = dynamic_cast<const XLineStartItem*>(p);
1533
1534 if (pItem && !pItem->GetName().isEmpty())
1535 {
1536 if (!bForceNew && pItem->GetLineStartValue() == pLineEndItem->GetLineEndValue())
1537 {
1538 aUniqueName = pItem->GetName();
1539 bFoundExisting = true;
1540 break;
1541 }
1542
1543 if (pItem->GetName().startsWith(aUser))
1544 {
1545 sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength()));
1546 if (nThisIndex >= nUserIndex)
1547 nUserIndex = nThisIndex + 1;
1548 }
1549 }
1550 }
1551
1552 for (const SfxPoolItem* p : rPool1.GetItemSurrogates(XATTR_LINEEND))
1553 {
1554 auto pItem = dynamic_cast<const XLineEndItem*>(p);
1555
1556 if (pItem && !pItem->GetName().isEmpty())
1557 {
1558 if (!bForceNew && pItem->GetLineEndValue() == pLineEndItem->GetLineEndValue())
1559 {
1560 aUniqueName = pItem->GetName();
1561 bFoundExisting = true;
1562 break;
1563 }
1564
1565 if (pItem->GetName().startsWith(aUser))
1566 {
1567 sal_Int32 nThisIndex = o3tl::toInt32(pItem->GetName().subView(aUser.getLength()));
1568 if (nThisIndex >= nUserIndex)
1569 nUserIndex = nThisIndex + 1;
1570 }
1571 }
1572 }
1573
1574 if( !bFoundExisting )
1575 {
1576 aUniqueName = aUser + " " + OUString::number( nUserIndex );
1577 }
1578 }
1579
1580 // if the given name is not valid, replace it!
1581 if( aUniqueName != GetName() || pTempItem )
1582 {
1583 if( pTempItem )
1584 {
1585 pTempItem->SetName( aUniqueName );
1586 return pTempItem;
1587 }
1588 else
1589 {
1590 return std::make_unique<XLineEndItem>( aUniqueName, maPolyPolygon );
1591 }
1592 }
1593 }
1594
1595 return nullptr;
1596 }
1597
1598 bool XLineEndItem::GetPresentation
1599 (
1600 SfxItemPresentation /*ePres*/,
1601 MapUnit /*eCoreUnit*/,
1602 MapUnit /*ePresUnit*/,
1603 OUString& rText, const IntlWrapper&
1604 ) const
1605 {
1606 rText = GetName();
1607 return true;
1608 }
1609
1610 bool XLineEndItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
1611 {
1612 nMemberId &= ~CONVERT_TWIPS;
1613 if( nMemberId == MID_NAME )
1614 {
1615 rVal <<= SvxUnogetApiNameForItem(Which(), GetName());
1616 }
1617 else
1618 {
1619 css::drawing::PolyPolygonBezierCoords aBezier;
1620 basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( maPolyPolygon, aBezier );
1621 rVal <<= aBezier;
1622 }
1623 return true;
1624 }
1625
1626 bool XLineEndItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
1627 {
1628 nMemberId &= ~CONVERT_TWIPS;
1629 if( nMemberId == MID_NAME )
1630 {
1631 return false;
1632 }
1633 else
1634 {
1635 maPolyPolygon.clear();
1636
1637 if( rVal.hasValue() )
1638 {
1639 auto pCoords = o3tl::tryAccess<css::drawing::PolyPolygonBezierCoords>(
1640 rVal);
1641 if( !pCoords )
1642 return false;
1643
1644 if( pCoords->Coordinates.getLength() > 0 )
1645 {
1646 maPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon( *pCoords );
1647 // #i72807# close line start/end polygons hard
1648 // maPolyPolygon.setClosed(true);
1649 }
1650 }
1651 }
1652
1653 return true;
1654 }
1655
1656 XLineStartWidthItem::XLineStartWidthItem(tools::Long nWidth) :
1657 SfxMetricItem(XATTR_LINESTARTWIDTH, nWidth)
1658 {
1659 }
1660
1661 XLineStartWidthItem* XLineStartWidthItem::Clone(SfxItemPool* /*pPool*/) const
1662 {
1663 return new XLineStartWidthItem(*this);
1664 }
1665
1666 bool XLineStartWidthItem::GetPresentation
1667 (
1668 SfxItemPresentation /*ePres*/,
1669 MapUnit eCoreUnit,
1670 MapUnit ePresUnit,
1671 OUString& rText, const IntlWrapper& rIntl
1672 ) const
1673 {
1674 rText = GetMetricText( static_cast<tools::Long>(GetValue()),
1675 eCoreUnit, ePresUnit, &rIntl) +
1676 " " + EditResId( GetMetricId( ePresUnit) );
1677 return true;
1678 }
1679
1680 bool XLineStartWidthItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1681 {
1682 rVal <<= GetValue();
1683 return true;
1684 }
1685
1686 bool XLineStartWidthItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1687 {
1688 sal_Int32 nValue = 0;
1689 rVal >>= nValue;
1690 SetValue( nValue );
1691 return true;
1692 }
1693
1694 XLineEndWidthItem::XLineEndWidthItem(tools::Long nWidth) :
1695 SfxMetricItem(XATTR_LINEENDWIDTH, nWidth)
1696 {
1697 }
1698
1699 XLineEndWidthItem* XLineEndWidthItem::Clone(SfxItemPool* /*pPool*/) const
1700 {
1701 return new XLineEndWidthItem(*this);
1702 }
1703
1704 bool XLineEndWidthItem::GetPresentation
1705 (
1706 SfxItemPresentation /*ePres*/,
1707 MapUnit eCoreUnit,
1708 MapUnit ePresUnit,
1709 OUString& rText, const IntlWrapper& rIntl
1710 ) const
1711 {
1712 rText = GetMetricText( static_cast<tools::Long>(GetValue()),
1713 eCoreUnit, ePresUnit, &rIntl) +
1714 " " + EditResId( GetMetricId( ePresUnit) );
1715 return true;
1716 }
1717
1718 bool XLineEndWidthItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1719 {
1720 rVal <<= GetValue();
1721 return true;
1722 }
1723
1724 bool XLineEndWidthItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1725 {
1726 sal_Int32 nValue = 0;
1727 rVal >>= nValue;
1728 SetValue( nValue );
1729 return true;
1730 }
1731
1732 XLineStartCenterItem::XLineStartCenterItem(bool bStartCenter) :
1733 SfxBoolItem(XATTR_LINESTARTCENTER, bStartCenter)
1734 {
1735 }
1736
1737 XLineStartCenterItem* XLineStartCenterItem::Clone(SfxItemPool* /*pPool*/) const
1738 {
1739 return new XLineStartCenterItem(*this);
1740 }
1741
1742 bool XLineStartCenterItem::GetPresentation
1743 (
1744 SfxItemPresentation /*ePres*/,
1745 MapUnit /*eCoreUnit*/,
1746 MapUnit /*ePresUnit*/,
1747 OUString& rText, const IntlWrapper&
1748 ) const
1749 {
1750 rText = SvxResId(GetValue() ? RID_SVXSTR_CENTERED : RID_SVXSTR_NOTCENTERED);
1751 return true;
1752 }
1753
1754 bool XLineStartCenterItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1755 {
1756 bool bValue = GetValue();
1757 rVal <<= bValue;
1758 return true;
1759 }
1760
1761 bool XLineStartCenterItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1762 {
1763 auto b = o3tl::tryAccess<bool>(rVal);
1764 if( !b )
1765 return false;
1766
1767 SetValue( *b );
1768 return true;
1769 }
1770
1771 XLineEndCenterItem::XLineEndCenterItem(bool bEndCenter) :
1772 SfxBoolItem(XATTR_LINEENDCENTER, bEndCenter)
1773 {
1774 }
1775
1776 XLineEndCenterItem* XLineEndCenterItem::Clone(SfxItemPool* /*pPool*/) const
1777 {
1778 return new XLineEndCenterItem(*this);
1779 }
1780
1781 bool XLineEndCenterItem::GetPresentation
1782 (
1783 SfxItemPresentation /*ePres*/,
1784 MapUnit /*eCoreUnit*/,
1785 MapUnit /*ePresUnit*/,
1786 OUString& rText, const IntlWrapper&
1787 ) const
1788 {
1789 rText = SvxResId(GetValue() ? RID_SVXSTR_CENTERED : RID_SVXSTR_NOTCENTERED);
1790 return true;
1791 }
1792
1793 bool XLineEndCenterItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1794 {
1795 bool bValue = GetValue();
1796 rVal <<= bValue;
1797 return true;
1798 }
1799
1800 bool XLineEndCenterItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1801 {
1802 auto b = o3tl::tryAccess<bool>(rVal);
1803 if( !b )
1804 return false;
1805
1806 SetValue( *b );
1807 return true;
1808 }
1809
1810 // --- fill attributes ---
1811
1812
1813 SfxPoolItem* XFillStyleItem::CreateDefault() { return new XFillStyleItem; }
1814
1815 XFillStyleItem::XFillStyleItem(drawing::FillStyle eFillStyle) :
1816 SfxEnumItem(XATTR_FILLSTYLE, eFillStyle)
1817 {
1818 }
1819
1820 XFillStyleItem* XFillStyleItem::Clone(SfxItemPool* /*pPool*/) const
1821 {
1822 return new XFillStyleItem( *this );
1823 }
1824
1825 bool XFillStyleItem::GetPresentation
1826 (
1827 SfxItemPresentation /*ePres*/,
1828 MapUnit /*eCoreUnit*/,
1829 MapUnit /*ePresUnit*/,
1830 OUString& rText, const IntlWrapper&
1831 ) const
1832 {
1833 rText.clear();
1834
1835 TranslateId pId;
1836
1837 switch( GetValue() )
1838 {
1839 case drawing::FillStyle_NONE:
1840 pId = RID_SVXSTR_INVISIBLE;
1841 break;
1842 case drawing::FillStyle_SOLID:
1843 pId = RID_SVXSTR_SOLID;
1844 break;
1845 case drawing::FillStyle_GRADIENT:
1846 pId = RID_SVXSTR_GRADIENT;
1847 break;
1848 case drawing::FillStyle_HATCH:
1849 pId = RID_SVXSTR_HATCH;
1850 break;
1851 case drawing::FillStyle_BITMAP:
1852 pId = RID_SVXSTR_BITMAP;
1853 break;
1854 default: break;
1855 }
1856
1857 if (pId)
1858 rText = SvxResId(pId);
1859 return true;
1860 }
1861
1862 sal_uInt16 XFillStyleItem::GetValueCount() const
1863 {
1864 return 5;
1865 }
1866
1867 bool XFillStyleItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1868 {
1869 css::drawing::FillStyle eFS = GetValue();
1870
1871 rVal <<= eFS;
1872
1873 return true;
1874 }
1875
1876 bool XFillStyleItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1877 {
1878 css::drawing::FillStyle eFS;
1879 if(!(rVal >>= eFS))
1880 {
1881 // also try an int (for Basic)
1882 sal_Int32 nFS = 0;
1883 if(!(rVal >>= nFS))
1884 return false;
1885 eFS = static_cast<css::drawing::FillStyle>(nFS);
1886 }
1887
1888 SetValue( eFS );
1889
1890 return true;
1891 }
1892
1893 void XFillStyleItem::dumpAsXml(xmlTextWriterPtr pWriter) const
1894 {
1895 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillStyleItem"));
1896 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
1897 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(static_cast<sal_Int16>(GetValue())).getStr()));
1898
1899 OUString aPresentation;
1900 IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
1901 GetPresentation(SfxItemPresentation::Nameless, MapUnit::Map100thMM, MapUnit::Map100thMM, aPresentation, aIntlWrapper);
1902 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
1903
1904 (void)xmlTextWriterEndElement(pWriter);
1905 }
1906
1907 boost::property_tree::ptree XFillStyleItem::dumpAsJSON() const
1908 {
1909 boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON();
1910
1911 if (Which() == XATTR_FILLSTYLE)
1912 aTree.put("commandName", ".uno:FillStyle");
1913
1914 OUString sValue;
1915
1916 switch( GetValue() )
1917 {
1918 case drawing::FillStyle_NONE:
1919 sValue = "NONE";
1920 break;
1921 case drawing::FillStyle_SOLID:
1922 sValue = "SOLID";
1923 break;
1924 case drawing::FillStyle_GRADIENT:
1925 sValue = "GRADIENT";
1926 break;
1927 case drawing::FillStyle_HATCH:
1928 sValue = "HATCH";
1929 break;
1930 case drawing::FillStyle_BITMAP:
1931 sValue = "BITMAP";
1932 break;
1933 default: break;
1934 }
1935
1936 aTree.put("state", sValue);
1937
1938 return aTree;
1939 }
1940
1941
1942 SfxPoolItem* XFillColorItem::CreateDefault() { return new XFillColorItem; }
1943
1944 XFillColorItem::XFillColorItem(sal_Int32 nIndex, const Color& rTheColor) :
1945 XColorItem(XATTR_FILLCOLOR, nIndex, rTheColor)
1946 {
1947 }
1948
1949 XFillColorItem::XFillColorItem(const OUString& rName, const Color& rTheColor) :
1950 XColorItem(XATTR_FILLCOLOR, rName, rTheColor)
1951 {
1952 }
1953
1954 XFillColorItem* XFillColorItem::Clone(SfxItemPool* /*pPool*/) const
1955 {
1956 return new XFillColorItem(*this);
1957 }
1958
1959 bool XFillColorItem::GetPresentation
1960 (
1961 SfxItemPresentation /*ePres*/,
1962 MapUnit /*eCoreUnit*/,
1963 MapUnit /*ePresUnit*/,
1964 OUString& rText, const IntlWrapper&
1965 ) const
1966 {
1967 rText = GetName();
1968 return true;
1969 }
1970
1971 bool XFillColorItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
1972 {
1973 nMemberId &= ~CONVERT_TWIPS;
1974 switch (nMemberId)
1975 {
1976 case MID_COLOR_THEME_INDEX:
1977 {
1978 rVal <<= sal_Int16(getComplexColor().getSchemeType());
1979 break;
1980 }
1981 case MID_COLOR_LUM_MOD:
1982 {
1983 sal_Int16 nValue = 10000;
1984 for (auto const& rTransform : getComplexColor().getTransformations())
1985 {
1986 if (rTransform.meType == model::TransformationType::LumMod)
1987 nValue = rTransform.mnValue;
1988 }
1989 rVal <<= nValue;
1990 break;
1991 }
1992 case MID_COLOR_LUM_OFF:
1993 {
1994 sal_Int16 nValue = 0;
1995 for (auto const& rTransform : getComplexColor().getTransformations())
1996 {
1997 if (rTransform.meType == model::TransformationType::LumOff)
1998 nValue = rTransform.mnValue;
1999 }
2000 rVal <<= nValue;
2001 break;
2002 }
2003 case MID_COMPLEX_COLOR:
2004 {
2005 auto xComplexColor = model::color::createXComplexColor(getComplexColor());
2006 rVal <<= xComplexColor;
2007 break;
2008 }
2009 case MID_COMPLEX_COLOR_JSON:
2010 {
2011 rVal <<= OStringToOUString(model::color::convertToJSON(getComplexColor()), RTL_TEXTENCODING_UTF8);
2012 break;
2013 }
2014 default:
2015 {
2016 rVal <<= GetColorValue().GetRGBColor();
2017 break;
2018 }
2019 }
2020
2021 return true;
2022 }
2023
2024 bool XFillColorItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
2025 {
2026 nMemberId &= ~CONVERT_TWIPS;
2027 switch(nMemberId)
2028 {
2029 case MID_COLOR_THEME_INDEX:
2030 {
2031 sal_Int16 nIndex = -1;
2032 if (!(rVal >>= nIndex))
2033 return false;
2034 getComplexColor().setSchemeColor(model::convertToThemeColorType(nIndex));
2035 }
2036 break;
2037 case MID_COLOR_LUM_MOD:
2038 {
2039 sal_Int16 nLumMod = 10000;
2040 if (!(rVal >>= nLumMod))
2041 return false;
2042 getComplexColor().removeTransformations(model::TransformationType::LumMod);
2043 getComplexColor().addTransformation({model::TransformationType::LumMod, nLumMod});
2044 }
2045 break;
2046 case MID_COLOR_LUM_OFF:
2047 {
2048 sal_Int16 nLumOff = 0;
2049 if (!(rVal >>= nLumOff))
2050 return false;
2051 getComplexColor().removeTransformations(model::TransformationType::LumOff);
2052 getComplexColor().addTransformation({model::TransformationType::LumOff, nLumOff});
2053 }
2054 break;
2055 case MID_COMPLEX_COLOR:
2056 {
2057 css::uno::Reference<css::util::XComplexColor> xComplexColor;
2058 if (!(rVal >>= xComplexColor))
2059 return false;
2060 setComplexColor(model::color::getFromXComplexColor(xComplexColor));
2061 }
2062 break;
2063 case MID_COMPLEX_COLOR_JSON:
2064 {
2065 OUString sComplexColorJson;
2066 if (!(rVal >>= sComplexColorJson))
2067 return false;
2068
2069 if (sComplexColorJson.isEmpty())
2070 return false;
2071
2072 OString aJSON = OUStringToOString(sComplexColorJson, RTL_TEXTENCODING_ASCII_US);
2073 model::ComplexColor aComplexColor;
2074 model::color::convertFromJSON(aJSON, aComplexColor);
2075 setComplexColor(aComplexColor);
2076 }
2077 break;
2078 default:
2079 {
2080 Color nValue;
2081 if(!(rVal >>= nValue ))
2082 return false;
2083
2084 SetColorValue( nValue );
2085
2086 }
2087 break;
2088 }
2089 return true;
2090 }
2091
2092 void XFillColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
2093 {
2094 (void)xmlTextWriterStartElement(pWriter, BAD_CAST("XFillColorItem"));
2095 (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
2096
2097 XColorItem::dumpAsXml(pWriter);
2098
2099 (void)xmlTextWriterEndElement(pWriter);
2100 }
2101
2102 boost::property_tree::ptree XFillColorItem::dumpAsJSON() const
2103 {
2104 boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON();
2105
2106 if (Which() == XATTR_FILLCOLOR)
2107 aTree.put("commandName", ".uno:FillPageColor");
2108
2109 aTree.put("state", GetColorValue().AsRGBHexString());
2110
2111 return aTree;
2112 }
2113
2114 XSecondaryFillColorItem::XSecondaryFillColorItem(const OUString& rName, const Color& rTheColor) :
2115 XColorItem(XATTR_SECONDARYFILLCOLOR, rName, rTheColor)
2116 {
2117 }
2118
2119 XSecondaryFillColorItem* XSecondaryFillColorItem::Clone(SfxItemPool* /*pPool*/) const
2120 {
2121 return new XSecondaryFillColorItem(*this);
2122 }
2123
2124 bool XSecondaryFillColorItem::GetPresentation
2125 (
2126 SfxItemPresentation /*ePres*/,
2127 MapUnit /*eCoreUnit*/,
2128 MapUnit /*ePresUnit*/,
2129 OUString& rText, const IntlWrapper&
2130 ) const
2131 {
2132 rText = GetName();
2133 return true;
2134 }
2135
2136 SfxPoolItem* XFillGradientItem::CreateDefault() { return new XFillGradientItem; }
2137
2138 XFillGradientItem::XFillGradientItem(sal_Int32 nIndex,
2139 const basegfx::BGradient& rTheGradient) :
2140 NameOrIndex(XATTR_FILLGRADIENT, nIndex),
2141 aGradient(rTheGradient)
2142 {
2143 }
2144
2145 XFillGradientItem::XFillGradientItem(const OUString& rName,
2146 const basegfx::BGradient& rTheGradient, TypedWhichId<XFillGradientItem> nWhich)
2147 : NameOrIndex(nWhich, rName)
2148 , aGradient(rTheGradient)
2149 {
2150 }
2151
2152 XFillGradientItem::XFillGradientItem(const XFillGradientItem& rItem) :
2153 NameOrIndex(rItem),
2154 aGradient(rItem.aGradient)
2155 {
2156 }
2157
2158 XFillGradientItem::XFillGradientItem( const basegfx::BGradient& rTheGradient )
2159 : NameOrIndex( XATTR_FILLGRADIENT, -1 ),
2160 aGradient(rTheGradient)
2161 {
2162 }
2163
2164 XFillGradientItem* XFillGradientItem::Clone(SfxItemPool* /*pPool*/) const
2165 {
2166 return new XFillGradientItem(*this);
2167 }
2168
2169 bool XFillGradientItem::operator==(const SfxPoolItem& rItem) const
2170 {
2171 return ( NameOrIndex::operator==(rItem) &&
2172 aGradient == static_cast<const XFillGradientItem&>(rItem).aGradient );
2173 }
2174
2175 const basegfx::BGradient& XFillGradientItem::GetGradientValue() const // GetValue -> GetGradientValue
2176 {
2177 if (!IsIndex())
2178 return aGradient;
2179 // ToDo: This should fail. We never called this code with a table so this should always
2180 // have failed. Thus, I'm thinking that XFillGradientItem can't be an Index.
2181 return aGradient;
2182 }
2183
2184 bool XFillGradientItem::GetPresentation
2185 (
2186 SfxItemPresentation /*ePres*/,
2187 MapUnit /*eCoreUnit*/,
2188 MapUnit /*ePresUnit*/,
2189 OUString& rText, const IntlWrapper&
2190 ) const
2191 {
2192 rText = GetName();
2193 return true;
2194 }
2195
2196 bool XFillGradientItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
2197 {
2198 nMemberId &= ~CONVERT_TWIPS;
2199 switch ( nMemberId )
2200 {
2201 case 0:
2202 {
2203 // fill values
2204 const css::awt::Gradient2 aGradient2 = model::gradient::createUnoGradient2(GetGradientValue());
2205
2206 // create sequence
2207 uno::Sequence< beans::PropertyValue > aPropSeq{
2208 comphelper::makePropertyValue("Name", SvxUnogetApiNameForItem(Which(), GetName())),
2209 comphelper::makePropertyValue("FillGradient", aGradient2)
2210 };
2211 rVal <<= aPropSeq;
2212 break;
2213 }
2214
2215 case MID_FILLGRADIENT:
2216 {
2217 // fill values
2218 const css::awt::Gradient2 aGradient2 = model::gradient::createUnoGradient2(GetGradientValue());
2219
2220 // create sequence
2221 rVal <<= aGradient2;
2222 break;
2223 }
2224
2225 case MID_NAME:
2226 {
2227 rVal <<= SvxUnogetApiNameForItem(Which(), GetName());
2228 break;
2229 }
2230
2231 case MID_GRADIENT_COLORSTOPSEQUENCE:
2232 {
2233 // fill values
2234 const css::awt::ColorStopSequence aColorStopSequence = model::gradient::createColorStopSequence(GetGradientValue().GetColorStops());
2235
2236 // create sequence
2237 rVal <<= aColorStopSequence;
2238 break;
2239 }
2240
2241 case MID_GRADIENT_STYLE: rVal <<= static_cast<sal_Int16>(GetGradientValue().GetGradientStyle()); break;
2242 case MID_GRADIENT_STARTCOLOR: rVal <<= Color(GetGradientValue().GetColorStops().front().getStopColor()); break;
2243 case MID_GRADIENT_ENDCOLOR: rVal <<= Color(GetGradientValue().GetColorStops().back().getStopColor()); break;
2244 case MID_GRADIENT_ANGLE: rVal <<= static_cast<sal_Int16>(GetGradientValue().GetAngle()); break;
2245 case MID_GRADIENT_BORDER: rVal <<= GetGradientValue().GetBorder(); break;
2246 case MID_GRADIENT_XOFFSET: rVal <<= GetGradientValue().GetXOffset(); break;
2247 case MID_GRADIENT_YOFFSET: rVal <<= GetGradientValue().GetYOffset(); break;
2248 case MID_GRADIENT_STARTINTENSITY: rVal <<= GetGradientValue().GetStartIntens(); break;
2249 case MID_GRADIENT_ENDINTENSITY: rVal <<= GetGradientValue().GetEndIntens(); break;
2250 case MID_GRADIENT_STEPCOUNT: rVal <<= GetGradientValue().GetSteps(); break;
2251
2252 default: OSL_FAIL("Wrong MemberId!"); return false;
2253 }
2254
2255 return true;
2256 }
2257
2258 bool XFillGradientItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
2259 {
2260 nMemberId &= ~CONVERT_TWIPS;
2261
2262 switch ( nMemberId )
2263 {
2264 case 0:
2265 {
2266 uno::Sequence< beans::PropertyValue > aPropSeq;
2267 css::uno::Any aGradientAny;
2268
2269 if ( rVal >>= aPropSeq )
2270 {
2271 OUString aName;
2272
2273 for ( const auto& rProp : std::as_const(aPropSeq) )
2274 {
2275 if ( rProp.Name == "Name" )
2276 rProp.Value >>= aName;
2277 else if ( rProp.Name == "FillGradient" )
2278 aGradientAny = rProp.Value;
2279 }
2280
2281 SetName( aName );
2282
2283 if (aGradientAny.hasValue() && (aGradientAny.has<css::awt::Gradient>() || aGradientAny.has<css::awt::Gradient2>()))
2284 {
2285 SetGradientValue(model::gradient::getFromAny(aGradientAny));
2286 }
2287
2288 return true;
2289 }
2290
2291 return false;
2292 }
2293
2294 case MID_NAME:
2295 {
2296 OUString aName;
2297 if (!(rVal >>= aName ))
2298 return false;
2299 SetName( aName );
2300 break;
2301 }
2302
2303 case MID_FILLGRADIENT:
2304 {
2305 if (rVal.hasValue() && (rVal.has<css::awt::Gradient>() || rVal.has<css::awt::Gradient2>()))
2306 {
2307 SetGradientValue(model::gradient::getFromAny(rVal));
2308 }
2309
2310 break;
2311 }
2312
2313 case MID_GRADIENT_COLORSTOPSEQUENCE:
2314 {
2315 // check if we have a awt::ColorStopSequence
2316 if (rVal.hasValue() && rVal.has<css::awt::ColorStopSequence>())
2317 {
2318
2319 const basegfx::BColorStops aColorStops = model::gradient::getColorStopsFromAny(rVal);
2320
2321 if (!aColorStops.empty())
2322 {
2323 basegfx::BGradient aBGradient(GetGradientValue());
2324 aBGradient.SetColorStops(aColorStops);
2325 SetGradientValue(aBGradient);
2326 }
2327 }
2328 break;
2329 }
2330
2331 case MID_GRADIENT_STARTCOLOR:
2332 case MID_GRADIENT_ENDCOLOR:
2333 {
2334 Color nVal;
2335 if(!(rVal >>= nVal ))
2336 return false;
2337
2338 basegfx::BGradient aBGradient(GetGradientValue());
2339 basegfx::BColorStops aNewColorStops(aBGradient.GetColorStops());
2340
2341 if ( nMemberId == MID_GRADIENT_STARTCOLOR )
2342 {
2343 aNewColorStops.replaceStartColor(nVal.getBColor());
2344 }
2345 else
2346 {
2347 aNewColorStops.replaceEndColor(nVal.getBColor());
2348 }
2349
2350 aBGradient.SetColorStops(aNewColorStops);
2351 SetGradientValue( aBGradient );
2352 break;
2353 }
2354
2355 case MID_GRADIENT_STYLE:
2356 case MID_GRADIENT_ANGLE:
2357 case MID_GRADIENT_BORDER:
2358 case MID_GRADIENT_STARTINTENSITY:
2359 case MID_GRADIENT_ENDINTENSITY:
2360 case MID_GRADIENT_STEPCOUNT:
2361 case MID_GRADIENT_XOFFSET:
2362 case MID_GRADIENT_YOFFSET:
2363 {
2364 sal_Int16 nVal = sal_Int16();
2365 if(!(rVal >>= nVal ))
2366 return false;
2367
2368 basegfx::BGradient aBGradient = GetGradientValue();
2369
2370 switch ( nMemberId )
2371 {
2372 case MID_GRADIENT_STYLE:
2373 aBGradient.SetGradientStyle( static_cast<css::awt::GradientStyle>(nVal) ); break;
2374 case MID_GRADIENT_ANGLE:
2375 aBGradient.SetAngle( Degree10(nVal) ); break;
2376 case MID_GRADIENT_BORDER:
2377 aBGradient.SetBorder( nVal ); break;
2378 case MID_GRADIENT_STARTINTENSITY:
2379 aBGradient.SetStartIntens( nVal ); break;
2380 case MID_GRADIENT_ENDINTENSITY:
2381 aBGradient.SetEndIntens( nVal ); break;
2382 case MID_GRADIENT_STEPCOUNT:
2383 aBGradient.SetSteps( nVal ); break;
2384 case MID_GRADIENT_XOFFSET:
2385 aBGradient.SetXOffset( nVal ); break;
2386 case MID_GRADIENT_YOFFSET:
2387 aBGradient.SetYOffset( nVal ); break;
2388 }
2389
2390 SetGradientValue( aBGradient );
2391 break;
2392 }
2393 }
2394
2395 return true;
2396 }
2397
2398 bool XFillGradientItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
2399 {
2400 return static_cast<const XFillGradientItem*>(p1)->GetGradientValue() == static_cast<const XFillGradientItem*>(p2)->GetGradientValue();
2401 }
2402
2403 std::unique_ptr<XFillGradientItem> XFillGradientItem::checkForUniqueItem( SdrModel* pModel ) const
2404 {
2405 if( pModel )
2406 {
2407 const OUString aUniqueName = NameOrIndex::CheckNamedItem(
2408 this, Which(), &pModel->GetItemPool(),
2409 XFillGradientItem::CompareValueFunc, RID_SVXSTR_GRADIENT,
2410 pModel->GetPropertyList( XPropertyListType::Gradient ) );
2411
2412 // if the given name is not valid, replace it!
2413 if( aUniqueName != GetName() )
2414 return std::make_unique<XFillGradientItem>( aUniqueName, aGradient, TypedWhichId<XFillGradientItem>(Which()) );
2415 }
2416
2417 return nullptr;
2418 }
2419
2420 boost::property_tree::ptree XFillGradientItem::dumpAsJSON() const
2421 {
2422 boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON();
2423
2424 if (Which() == XATTR_FILLGRADIENT)
2425 aTree.put("commandName", ".uno:FillGradient");
2426
2427 aTree.push_back(std::make_pair("state", GetGradientValue().dumpAsJSON()));
2428
2429 return aTree;
2430 }
2431
2432
2433 SfxPoolItem* XFillFloatTransparenceItem::CreateDefault() { return new XFillFloatTransparenceItem; }
2434
2435 XFillFloatTransparenceItem::XFillFloatTransparenceItem() :
2436 bEnabled( false )
2437 {
2438 SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2439 }
2440
2441 XFillFloatTransparenceItem::XFillFloatTransparenceItem(const OUString& rName, const basegfx::BGradient& rGradient, bool bEnable ) :
2442 XFillGradientItem ( rName, rGradient ),
2443 bEnabled ( bEnable )
2444 {
2445 SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2446 }
2447
2448 XFillFloatTransparenceItem::XFillFloatTransparenceItem( const XFillFloatTransparenceItem& rItem ) :
2449 XFillGradientItem ( rItem ),
2450 bEnabled ( rItem.bEnabled )
2451 {
2452 SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2453 }
2454
2455 XFillFloatTransparenceItem::XFillFloatTransparenceItem(const basegfx::BGradient& rTheGradient, bool bEnable )
2456 : XFillGradientItem ( -1, rTheGradient ),
2457 bEnabled ( bEnable )
2458 {
2459 SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2460 }
2461
2462 bool XFillFloatTransparenceItem::operator==( const SfxPoolItem& rItem ) const
2463 {
2464 return ( NameOrIndex::operator==(rItem) ) &&
2465 ( GetGradientValue() == static_cast<const XFillGradientItem&>(rItem).GetGradientValue() ) &&
2466 ( bEnabled == static_cast<const XFillFloatTransparenceItem&>(rItem).bEnabled );
2467 }
2468
2469 XFillFloatTransparenceItem* XFillFloatTransparenceItem::Clone( SfxItemPool* /*pPool*/) const
2470 {
2471 return new XFillFloatTransparenceItem( *this );
2472 }
2473
2474 bool XFillFloatTransparenceItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
2475 {
2476 if (MID_GRADIENT_STARTINTENSITY == nMemberId
2477 || MID_GRADIENT_ENDINTENSITY == nMemberId
2478 || MID_GRADIENT_STEPCOUNT == nMemberId)
2479 {
2480 // tdf#155913 handle attributes not suppoted by transparency gradient as error
2481 return false;
2482 }
2483
2484 if (!IsEnabled() && nMemberId == MID_NAME)
2485 {
2486 // make sure that we return empty string in case of query for
2487 // "FillTransparenceGradientName" if the item is disabled
2488 rVal <<= OUString();
2489 return true;
2490 }
2491
2492 return XFillGradientItem::QueryValue( rVal, nMemberId );
2493 }
2494
2495 bool XFillFloatTransparenceItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
2496 {
2497 if (MID_GRADIENT_STARTINTENSITY == nMemberId
2498 || MID_GRADIENT_ENDINTENSITY == nMemberId
2499 || MID_GRADIENT_STEPCOUNT == nMemberId)
2500 {
2501 // tdf#155913 handle attributes not suppoted by transparency gradient as error
2502 return false;
2503 }
2504
2505 return XFillGradientItem::PutValue( rVal, nMemberId );
2506 }
2507
2508 bool XFillFloatTransparenceItem::GetPresentation( SfxItemPresentation ePres,
2509 MapUnit eCoreUnit, MapUnit ePresUnit,
2510 OUString& rText,
2511 const IntlWrapper& rIntlWrapper ) const
2512 {
2513 return XFillGradientItem::GetPresentation( ePres, eCoreUnit, ePresUnit, rText, rIntlWrapper );
2514 }
2515
2516 bool XFillFloatTransparenceItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
2517 {
2518 return static_cast<const XFillFloatTransparenceItem*>(p1)->IsEnabled() == static_cast<const XFillFloatTransparenceItem*>(p2)->IsEnabled() &&
2519 static_cast<const XFillFloatTransparenceItem*>(p1)->GetGradientValue() == static_cast<const XFillFloatTransparenceItem*>(p2)->GetGradientValue();
2520 }
2521
2522 std::unique_ptr<XFillFloatTransparenceItem> XFillFloatTransparenceItem::checkForUniqueItem( SdrModel* pModel ) const
2523 {
2524 // #85953# unique name only necessary when enabled
2525 if(IsEnabled())
2526 {
2527 if( pModel )
2528 {
2529 const OUString aUniqueName = NameOrIndex::CheckNamedItem( this,
2530 XATTR_FILLFLOATTRANSPARENCE,
2531 &pModel->GetItemPool(),
2532 XFillFloatTransparenceItem::CompareValueFunc,
2533 RID_SVXSTR_TRASNGR0,
2534 XPropertyListRef() );
2535
2536 // if the given name is not valid, replace it!
2537 if( aUniqueName != GetName() )
2538 {
2539 return std::make_unique<XFillFloatTransparenceItem>( aUniqueName, GetGradientValue(), true );
2540 }
2541 }
2542 }
2543 else
2544 {
2545 // #85953# if disabled, force name to empty string
2546 if( !GetName().isEmpty() )
2547 {
2548 return std::make_unique<XFillFloatTransparenceItem>(OUString(), GetGradientValue(), false);
2549 }
2550 }
2551
2552 return nullptr;
2553 }
2554
2555 boost::property_tree::ptree XFillFloatTransparenceItem::dumpAsJSON() const
2556 {
2557 boost::property_tree::ptree aTree = XFillGradientItem::dumpAsJSON();
2558 aTree.put("commandName", ".uno:FillFloatTransparence");
2559
2560 if (!bEnabled)
2561 {
2562 boost::property_tree::ptree& rState = aTree.get_child("state");
2563 // When gradient fill is disabled, the intensity fields contain the
2564 // constant encoded percent-transparency. However we use that here to just
2565 // distinguish between 'None' and 'Solid' types and correct the 'style'
2566 // property appropriately.
2567 if (GetGradientValue().GetStartIntens() == 100)
2568 rState.put("style", "NONE");
2569 else
2570 rState.put("style", "SOLID");
2571 }
2572
2573 return aTree;
2574 }
2575
2576 XHatch::XHatch(const Color& rCol, css::drawing::HatchStyle eTheStyle, tools::Long nTheDistance,
2577 Degree10 nTheAngle) :
2578 eStyle(eTheStyle),
2579 aColor(rCol),
2580 nDistance(nTheDistance),
2581 nAngle(nTheAngle)
2582 {
2583 }
2584
2585 bool XHatch::operator==(const XHatch& rHatch) const
2586 {
2587 return ( eStyle == rHatch.eStyle &&
2588 aColor == rHatch.aColor &&
2589 nDistance == rHatch.nDistance &&
2590 nAngle == rHatch.nAngle );
2591 }
2592
2593
2594 SfxPoolItem* XFillHatchItem::CreateDefault() { return new XFillHatchItem; }
2595
2596 XFillHatchItem::XFillHatchItem(const OUString& rName,
2597 const XHatch& rTheHatch) :
2598 NameOrIndex(XATTR_FILLHATCH, rName),
2599 aHatch(rTheHatch)
2600 {
2601 }
2602
2603 XFillHatchItem::XFillHatchItem(const XFillHatchItem& rItem) :
2604 NameOrIndex(rItem),
2605 aHatch(rItem.aHatch)
2606 {
2607 }
2608
2609 XFillHatchItem::XFillHatchItem(const XHatch& rTheHatch)
2610 : NameOrIndex( XATTR_FILLHATCH, -1 ),
2611 aHatch(rTheHatch)
2612 {
2613 }
2614
2615 XFillHatchItem* XFillHatchItem::Clone(SfxItemPool* /*pPool*/) const
2616 {
2617 return new XFillHatchItem(*this);
2618 }
2619
2620 bool XFillHatchItem::operator==(const SfxPoolItem& rItem) const
2621 {
2622 return ( NameOrIndex::operator==(rItem) &&
2623 aHatch == static_cast<const XFillHatchItem&>(rItem).aHatch );
2624 }
2625
2626 bool XFillHatchItem::GetPresentation
2627 (
2628 SfxItemPresentation /*ePres*/,
2629 MapUnit /*eCoreUnit*/,
2630 MapUnit /*ePresUnit*/,
2631 OUString& rText, const IntlWrapper&
2632 ) const
2633 {
2634 rText = GetName();
2635 return true;
2636 }
2637
2638 bool XFillHatchItem::HasMetrics() const
2639 {
2640 return true;
2641 }
2642
2643 void XFillHatchItem::ScaleMetrics(tools::Long nMul, tools::Long nDiv)
2644 {
2645 aHatch.SetDistance( BigInt::Scale( aHatch.GetDistance(), nMul, nDiv ) );
2646 }
2647
2648 bool XFillHatchItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
2649 {
2650 nMemberId &= ~CONVERT_TWIPS;
2651
2652 switch ( nMemberId )
2653 {
2654 case 0:
2655 {
2656 css::drawing::Hatch aUnoHatch;
2657
2658 aUnoHatch.Style = aHatch.GetHatchStyle();
2659 aUnoHatch.Color = sal_Int32(aHatch.GetColor());
2660 aUnoHatch.Distance = aHatch.GetDistance();
2661 aUnoHatch.Angle = aHatch.GetAngle().get();
2662
2663 uno::Sequence< beans::PropertyValue > aPropSeq{
2664 comphelper::makePropertyValue("Name", SvxUnogetApiNameForItem(Which(), GetName())),
2665 comphelper::makePropertyValue("FillHatch", aUnoHatch)
2666 };
2667 rVal <<= aPropSeq;
2668 break;
2669 }
2670
2671 case MID_FILLHATCH:
2672 {
2673 css::drawing::Hatch aUnoHatch;
2674
2675 aUnoHatch.Style = aHatch.GetHatchStyle();
2676 aUnoHatch.Color = sal_Int32(aHatch.GetColor());
2677 aUnoHatch.Distance = aHatch.GetDistance();
2678 aUnoHatch.Angle = aHatch.GetAngle().get();
2679 rVal <<= aUnoHatch;
2680 break;
2681 }
2682
2683 case MID_NAME:
2684 {
2685 rVal <<= SvxUnogetApiNameForItem(Which(), GetName());
2686 break;
2687 }
2688
2689 case MID_HATCH_STYLE:
2690 rVal <<= aHatch.GetHatchStyle(); break;
2691 case MID_HATCH_COLOR:
2692 rVal <<= aHatch.GetColor(); break;
2693 case MID_HATCH_DISTANCE:
2694 rVal <<= aHatch.GetDistance(); break;
2695 case MID_HATCH_ANGLE:
2696 rVal <<= aHatch.GetAngle().get(); break;
2697
2698 default: OSL_FAIL("Wrong MemberId!"); return false;
2699 }
2700
2701 return true;
2702 }
2703
2704 bool XFillHatchItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
2705 {
2706 nMemberId &= ~CONVERT_TWIPS;
2707
2708 switch ( nMemberId )
2709 {
2710 case 0:
2711 {
2712 uno::Sequence< beans::PropertyValue > aPropSeq;
2713 if ( rVal >>= aPropSeq )
2714 {
2715 css::drawing::Hatch aUnoHatch;
2716 OUString aName;
2717 bool bHatch( false );
2718 for ( const auto& rProp : std::as_const(aPropSeq) )
2719 {
2720 if ( rProp.Name == "Name" )
2721 rProp.Value >>= aName;
2722 else if ( rProp.Name == "FillHatch" )
2723 {
2724 if ( rProp.Value >>= aUnoHatch )
2725 bHatch = true;
2726 }
2727 }
2728
2729 SetName( aName );
2730 if ( bHatch )
2731 {
2732 aHatch.SetHatchStyle( aUnoHatch.Style );
2733 aHatch.SetColor( Color(ColorTransparency, aUnoHatch.Color) );
2734 aHatch.SetDistance( aUnoHatch.Distance );
2735 aHatch.SetAngle( Degree10(aUnoHatch.Angle) );
2736 }
2737
2738 return true;
2739 }
2740
2741 return false;
2742 }
2743
2744 case MID_FILLHATCH:
2745 {
2746 css::drawing::Hatch aUnoHatch;
2747 if(!(rVal >>= aUnoHatch))
2748 return false;
2749
2750 aHatch.SetHatchStyle( aUnoHatch.Style );
2751 aHatch.SetColor( Color(ColorTransparency, aUnoHatch.Color) );
2752 aHatch.SetDistance( aUnoHatch.Distance );
2753 aHatch.SetAngle( Degree10(aUnoHatch.Angle) );
2754 break;
2755 }
2756
2757 case MID_NAME:
2758 {
2759 OUString aName;
2760 if (!(rVal >>= aName ))
2761 return false;
2762 SetName( aName );
2763 break;
2764 }
2765
2766 case MID_HATCH_STYLE:
2767 {
2768 sal_Int16 nVal = sal_Int16();
2769 if (!(rVal >>= nVal ))
2770 return false;
2771 aHatch.SetHatchStyle( static_cast<css::drawing::HatchStyle>(nVal) );
2772 break;
2773 }
2774
2775 case MID_HATCH_COLOR:
2776 case MID_HATCH_DISTANCE:
2777 case MID_HATCH_ANGLE:
2778 {
2779 sal_Int32 nVal = 0;
2780 if (!(rVal >>= nVal ))
2781 return false;
2782
2783 if ( nMemberId == MID_HATCH_COLOR )
2784 aHatch.SetColor( Color(ColorTransparency, nVal) );
2785 else if ( nMemberId == MID_HATCH_DISTANCE )
2786 aHatch.SetDistance( nVal );
2787 else
2788 aHatch.SetAngle( Degree10(nVal) );
2789 break;
2790 }
2791
2792 default: OSL_FAIL("Wrong MemberId!"); return false;
2793 }
2794
2795 return true;
2796 }
2797
2798 bool XFillHatchItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
2799 {
2800 return static_cast<const XFillHatchItem*>(p1)->GetHatchValue() == static_cast<const XFillHatchItem*>(p2)->GetHatchValue();
2801 }
2802
2803 std::unique_ptr<XFillHatchItem> XFillHatchItem::checkForUniqueItem( SdrModel* pModel ) const
2804 {
2805 if( pModel )
2806 {
2807 const OUString aUniqueName = NameOrIndex::CheckNamedItem(
2808 this, XATTR_FILLHATCH, &pModel->GetItemPool(),
2809 XFillHatchItem::CompareValueFunc, RID_SVXSTR_HATCH10,
2810 pModel->GetPropertyList( XPropertyListType::Hatch ) );
2811
2812 // if the given name is not valid, replace it!
2813 if( aUniqueName != GetName() )
2814 return std::make_unique<XFillHatchItem>( aUniqueName, aHatch );
2815 }
2816
2817 return nullptr;
2818 }
2819
2820 // --- form text attributes ---
2821
2822
2823 SfxPoolItem* XFormTextStyleItem::CreateDefault() { return new XFormTextStyleItem; }
2824
2825 XFormTextStyleItem::XFormTextStyleItem(XFormTextStyle eTheStyle) :
2826 SfxEnumItem(XATTR_FORMTXTSTYLE, eTheStyle)
2827 {
2828 }
2829
2830 XFormTextStyleItem* XFormTextStyleItem::Clone(SfxItemPool* /*pPool*/) const
2831 {
2832 return new XFormTextStyleItem( *this );
2833 }
2834
2835 sal_uInt16 XFormTextStyleItem::GetValueCount() const
2836 {
2837 return 5;
2838 }
2839
2840 bool XFormTextStyleItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2841 {
2842 rVal <<= static_cast<sal_Int32>(GetValue());
2843 return true;
2844 }
2845
2846 bool XFormTextStyleItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2847 {
2848 sal_Int32 nValue = 0;
2849 rVal >>= nValue;
2850 SetValue(static_cast<XFormTextStyle>(nValue));
2851
2852 return true;
2853 }
2854
2855
2856 SfxPoolItem* XFormTextAdjustItem::CreateDefault() { return new XFormTextAdjustItem; }
2857
2858 XFormTextAdjustItem::XFormTextAdjustItem(XFormTextAdjust eTheAdjust) :
2859 SfxEnumItem(XATTR_FORMTXTADJUST, eTheAdjust)
2860 {
2861 }
2862
2863 XFormTextAdjustItem* XFormTextAdjustItem::Clone(SfxItemPool* /*pPool*/) const
2864 {
2865 return new XFormTextAdjustItem( *this );
2866 }
2867
2868 sal_uInt16 XFormTextAdjustItem::GetValueCount() const
2869 {
2870 return 4;
2871 }
2872
2873 bool XFormTextAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2874 {
2875 rVal <<= static_cast<sal_Int32>(GetValue());
2876 return true;
2877 }
2878
2879 bool XFormTextAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2880 {
2881 sal_Int32 nValue = 0;
2882 rVal >>= nValue;
2883 SetValue(static_cast<XFormTextAdjust>(nValue));
2884
2885 return true;
2886 }
2887
2888
2889 SfxPoolItem* XFormTextDistanceItem::CreateDefault() { return new XFormTextDistanceItem; }
2890
2891 XFormTextDistanceItem::XFormTextDistanceItem(tools::Long nDist) :
2892 SfxMetricItem(XATTR_FORMTXTDISTANCE, nDist)
2893 {
2894 }
2895
2896 XFormTextDistanceItem* XFormTextDistanceItem::Clone(SfxItemPool* /*pPool*/) const
2897 {
2898 return new XFormTextDistanceItem(*this);
2899 }
2900
2901 SfxPoolItem* XFormTextStartItem::CreateDefault() { return new XFormTextStartItem; }
2902
2903 XFormTextStartItem::XFormTextStartItem(tools::Long nStart) :
2904 SfxMetricItem(XATTR_FORMTXTSTART, nStart)
2905 {
2906 }
2907
2908 XFormTextStartItem* XFormTextStartItem::Clone(SfxItemPool* /*pPool*/) const
2909 {
2910 return new XFormTextStartItem(*this);
2911 }
2912
2913 SfxPoolItem* XFormTextMirrorItem::CreateDefault() { return new XFormTextMirrorItem; }
2914
2915 XFormTextMirrorItem::XFormTextMirrorItem(bool bMirror) :
2916 SfxBoolItem(XATTR_FORMTXTMIRROR, bMirror)
2917 {
2918 }
2919
2920 XFormTextMirrorItem* XFormTextMirrorItem::Clone(SfxItemPool* /*pPool*/) const
2921 {
2922 return new XFormTextMirrorItem(*this);
2923 }
2924
2925 SfxPoolItem* XFormTextOutlineItem::CreateDefault() { return new XFormTextOutlineItem; }
2926
2927 XFormTextOutlineItem::XFormTextOutlineItem(bool bOutline) :
2928 SfxBoolItem(XATTR_FORMTXTOUTLINE, bOutline)
2929 {
2930 }
2931
2932 XFormTextOutlineItem* XFormTextOutlineItem::Clone(SfxItemPool* /*pPool*/) const
2933 {
2934 return new XFormTextOutlineItem(*this);
2935 }
2936
2937 SfxPoolItem* XFormTextShadowItem::CreateDefault() { return new XFormTextShadowItem; }
2938
2939 XFormTextShadowItem::XFormTextShadowItem(XFormTextShadow eFormTextShadow) :
2940 SfxEnumItem(XATTR_FORMTXTSHADOW, eFormTextShadow)
2941 {
2942 }
2943
2944 XFormTextShadowItem* XFormTextShadowItem::Clone(SfxItemPool* /*pPool*/) const
2945 {
2946 return new XFormTextShadowItem( *this );
2947 }
2948
2949 sal_uInt16 XFormTextShadowItem::GetValueCount() const
2950 {
2951 return 3;
2952 }
2953
2954 bool XFormTextShadowItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2955 {
2956 rVal <<= static_cast<sal_Int32>(GetValue());
2957 return true;
2958 }
2959
2960 bool XFormTextShadowItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2961 {
2962 sal_Int32 nValue = 0;
2963 rVal >>= nValue;
2964 SetValue(static_cast<XFormTextShadow>(nValue));
2965
2966 return true;
2967 }
2968
2969
2970 SfxPoolItem* XFormTextShadowColorItem::CreateDefault() { return new XFormTextShadowColorItem; }
2971
2972 XFormTextShadowColorItem::XFormTextShadowColorItem(const OUString& rName,
2973 const Color& rTheColor) :
2974 XColorItem(XATTR_FORMTXTSHDWCOLOR, rName, rTheColor)
2975 {
2976 }
2977
2978 XFormTextShadowColorItem* XFormTextShadowColorItem::Clone(SfxItemPool* /*pPool*/) const
2979 {
2980 return new XFormTextShadowColorItem(*this);
2981 }
2982
2983 SfxPoolItem* XFormTextShadowXValItem::CreateDefault() { return new XFormTextShadowXValItem; }
2984
2985 XFormTextShadowXValItem::XFormTextShadowXValItem(tools::Long nVal) :
2986 SfxMetricItem(XATTR_FORMTXTSHDWXVAL, nVal)
2987 {
2988 }
2989
2990 XFormTextShadowXValItem* XFormTextShadowXValItem::Clone(SfxItemPool* /*pPool*/) const
2991 {
2992 return new XFormTextShadowXValItem(*this);
2993 }
2994
2995 SfxPoolItem* XFormTextShadowYValItem::CreateDefault() { return new XFormTextShadowYValItem; }
2996
2997 XFormTextShadowYValItem::XFormTextShadowYValItem(tools::Long nVal) :
2998 SfxMetricItem(XATTR_FORMTXTSHDWYVAL, nVal)
2999 {
3000 }
3001
3002 XFormTextShadowYValItem* XFormTextShadowYValItem::Clone(SfxItemPool* /*pPool*/) const
3003 {
3004 return new XFormTextShadowYValItem(*this);
3005 }
3006
3007 SfxPoolItem* XFormTextHideFormItem::CreateDefault() { return new XFormTextHideFormItem; }
3008
3009 XFormTextHideFormItem::XFormTextHideFormItem(bool bHide) :
3010 SfxBoolItem(XATTR_FORMTXTHIDEFORM, bHide)
3011 {
3012 }
3013
3014 XFormTextHideFormItem* XFormTextHideFormItem::Clone(SfxItemPool* /*pPool*/) const
3015 {
3016 return new XFormTextHideFormItem(*this);
3017 }
3018
3019 // --- SetItems ---
3020
3021
3022 /// a line attribute set item
3023 XLineAttrSetItem::XLineAttrSetItem( SfxItemSet&& pItemSet ) :
3024 SfxSetItem( XATTRSET_LINE, std::move(pItemSet))
3025 {
3026 }
3027
3028 XLineAttrSetItem::XLineAttrSetItem( SfxItemPool* pItemPool ) :
3029 SfxSetItem( XATTRSET_LINE,
3030 SfxItemSetFixed<XATTR_LINE_FIRST, XATTR_LINE_LAST>( *pItemPool ))
3031 {
3032 }
3033
3034 XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr ) :
3035 SfxSetItem( rLineAttr )
3036 {
3037 }
3038
3039 XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr,
3040 SfxItemPool* pItemPool) :
3041 SfxSetItem( rLineAttr, pItemPool )
3042 {
3043 }
3044
3045 XLineAttrSetItem* XLineAttrSetItem::Clone( SfxItemPool* pPool ) const
3046 {
3047 return new XLineAttrSetItem( *this, pPool );
3048 }
3049
3050 /// fill attribute set item
3051 XFillAttrSetItem::XFillAttrSetItem( SfxItemSet&& pItemSet ) :
3052 SfxSetItem( XATTRSET_FILL, std::move(pItemSet))
3053 {
3054 }
3055
3056 XFillAttrSetItem::XFillAttrSetItem( SfxItemPool* pItemPool ) :
3057 SfxSetItem( XATTRSET_FILL,
3058 SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST>( *pItemPool ))
3059 {
3060 }
3061
3062 XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr ) :
3063 SfxSetItem( rFillAttr )
3064 {
3065 }
3066
3067 XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr,
3068 SfxItemPool* pItemPool ) :
3069 SfxSetItem( rFillAttr, pItemPool )
3070 {
3071 }
3072
3073 XFillAttrSetItem* XFillAttrSetItem::Clone( SfxItemPool* pPool ) const
3074 {
3075 return new XFillAttrSetItem( *this, pPool );
3076 }
3077
3078 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE