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