Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
21 : #include <com/sun/star/drawing/Hatch.hpp>
22 : #include <com/sun/star/drawing/LineStyle.hpp>
23 : #include <com/sun/star/drawing/LineDash.hpp>
24 : #include <com/sun/star/drawing/DashStyle.hpp>
25 : #include <com/sun/star/awt/Point.hpp>
26 : #include <com/sun/star/drawing/PointSequence.hpp>
27 : #include <com/sun/star/drawing/FillStyle.hpp>
28 : #include <com/sun/star/awt/Gradient.hpp>
29 : #include <com/sun/star/uno/Sequence.hxx>
30 : #include <com/sun/star/beans/PropertyValue.hpp>
31 : #include <svl/itempool.hxx>
32 : #include <editeng/memberids.hrc>
33 : #include <tools/stream.hxx>
34 : #include <tools/mapunit.hxx>
35 :
36 : #include "svx/unoapi.hxx"
37 : #include <svl/style.hxx>
38 :
39 : #include <tools/bigint.hxx>
40 : #include <svl/itemset.hxx>
41 : #include <svx/dialogs.hrc>
42 : #include "svx/svdstr.hrc"
43 : #include "svx/xattr.hxx"
44 : #include <svx/xtable.hxx>
45 : #include <svx/dialmgr.hxx>
46 : #include <editeng/itemtype.hxx>
47 : #include <svx/xdef.hxx>
48 : #include <svx/unomid.hxx>
49 : #include <svx/svdmodel.hxx>
50 : #include <basegfx/polygon/b2dpolygon.hxx>
51 : #include <basegfx/point/b2dpoint.hxx>
52 : #include <basegfx/vector/b2dvector.hxx>
53 : #include <basegfx/tools/unotools.hxx>
54 : #include <vcl/gradient.hxx>
55 :
56 : #include <stdio.h>
57 : #include <libxml/xmlwriter.h>
58 :
59 : using namespace ::com::sun::star;
60 :
61 : #define VCLTOSVCOL( rCol ) (sal_uInt16)((((sal_uInt16)(rCol))<<8)|(rCol))
62 :
63 114066 : TYPEINIT1_AUTOFACTORY(NameOrIndex, SfxStringItem);
64 :
65 0 : long ScaleMetricValue( long nVal, long nMul, long nDiv )
66 : {
67 0 : BigInt aVal( nVal );
68 :
69 0 : aVal *= nMul;
70 :
71 0 : if ( aVal.IsNeg() != ( nDiv < 0 ) )
72 0 : aVal-=nDiv/2; // for correct rounding
73 : else
74 0 : aVal+=nDiv/2; // for correct rounding
75 :
76 0 : aVal/=nDiv;
77 :
78 0 : return long( aVal );
79 : }
80 :
81 36140 : NameOrIndex::NameOrIndex(sal_uInt16 _nWhich, sal_Int32 nIndex) :
82 : SfxStringItem(_nWhich, OUString()),
83 36140 : nPalIndex(nIndex)
84 : {
85 36140 : }
86 :
87 70091 : NameOrIndex::NameOrIndex(sal_uInt16 _nWhich, const OUString& rName) :
88 : SfxStringItem(_nWhich, rName),
89 70091 : nPalIndex(-1)
90 : {
91 70091 : }
92 :
93 0 : NameOrIndex::NameOrIndex(sal_uInt16 _nWhich, SvStream& rIn)
94 : : SfxStringItem(_nWhich, rIn)
95 0 : , nPalIndex(-1)
96 : {
97 0 : rIn.ReadInt32( nPalIndex );
98 0 : }
99 :
100 130263 : NameOrIndex::NameOrIndex(const NameOrIndex& rNameOrIndex) :
101 : SfxStringItem(rNameOrIndex),
102 130263 : nPalIndex(rNameOrIndex.nPalIndex)
103 : {
104 130263 : }
105 :
106 593059 : bool NameOrIndex::operator==(const SfxPoolItem& rItem) const
107 : {
108 1175954 : return ( SfxStringItem::operator==(rItem) &&
109 1175954 : static_cast<const NameOrIndex&>(rItem).nPalIndex == nPalIndex );
110 : }
111 :
112 0 : SfxPoolItem* NameOrIndex::Clone(SfxItemPool* /*pPool*/) const
113 : {
114 :
115 0 : return new NameOrIndex(*this);
116 : }
117 :
118 0 : SfxPoolItem* NameOrIndex::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
119 : {
120 0 : return new NameOrIndex(Which(), rIn);
121 : }
122 :
123 0 : SvStream& NameOrIndex::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
124 : {
125 0 : SfxStringItem::Store( rOut, nItemVersion );
126 0 : rOut.WriteInt32( nPalIndex );
127 0 : return rOut;
128 : }
129 :
130 : /** this static checks if the given NameOrIndex item has a unique name for its value.
131 : The returned String is a unique name for an item with this value in both given pools.
132 : Argument pPool2 can be null.
133 : If returned string equals NameOrIndex->GetName(), the name was already unique.
134 : */
135 28333 : OUString NameOrIndex::CheckNamedItem( const NameOrIndex* pCheckItem, const sal_uInt16 nWhich, const SfxItemPool* pPool1, const SfxItemPool* /*pPool2*/, SvxCompareValueFunc pCompareValueFunc, sal_uInt16 nPrefixResId, const XPropertyListRef &pDefaults )
136 : {
137 28333 : bool bForceNew = false;
138 :
139 28333 : OUString aUniqueName = SvxUnogetInternalNameForItem(nWhich, pCheckItem->GetName());
140 :
141 : // 2. if we have a name check if there is already an item with the
142 : // same name in the documents pool with a different line end or start
143 :
144 28333 : if (!aUniqueName.isEmpty() && pPool1)
145 : {
146 27847 : const sal_uInt32 nCount = pPool1->GetItemCount2( nWhich );
147 :
148 53909 : for( sal_uInt32 nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
149 : {
150 53909 : const NameOrIndex *pItem = static_cast<const NameOrIndex*>(pPool1->GetItem2( nWhich, nSurrogate ));
151 :
152 53909 : if( pItem && ( pItem->GetName() == pCheckItem->GetName() ) )
153 : {
154 : // if there is already an item with the same name and the same
155 : // value its ok to set it
156 27847 : if( !pCompareValueFunc( pItem, pCheckItem ) )
157 : {
158 : // same name but different value, we need a new name for this item
159 0 : aUniqueName.clear();
160 0 : bForceNew = true;
161 : }
162 27847 : break;
163 : }
164 : }
165 : }
166 :
167 : // if we have no name yet, find existing item with same content or
168 : // create a unique name
169 28333 : if (aUniqueName.isEmpty())
170 : {
171 486 : sal_Int32 nUserIndex = 1;
172 486 : const ResId aRes(SVX_RES(nPrefixResId));
173 486 : OUString aUser( aRes.toString() );
174 486 : aUser += " ";
175 :
176 486 : if( pDefaults.get() )
177 : {
178 486 : const int nCount = pDefaults->Count();
179 : int nIndex;
180 7259 : for( nIndex = 0; nIndex < nCount; nIndex++ )
181 : {
182 6775 : XPropertyEntry* pEntry = pDefaults->Get(nIndex);
183 6775 : if( pEntry )
184 : {
185 6775 : bool bFound = false;
186 :
187 6775 : switch( nWhich )
188 : {
189 : case XATTR_FILLBITMAP:
190 : {
191 275 : const GraphicObject& rGraphicObjectA(static_cast<const XFillBitmapItem*>(pCheckItem)->GetGraphicObject());
192 275 : const GraphicObject& rGraphicObjectB(static_cast<XBitmapEntry*>(pEntry)->GetGraphicObject());
193 :
194 275 : bFound = (rGraphicObjectA == rGraphicObjectB);
195 275 : break;
196 : }
197 : case XATTR_LINEDASH:
198 1520 : bFound = static_cast<const XLineDashItem*>(pCheckItem)->GetDashValue() == static_cast<XDashEntry*>(pEntry)->GetDash();
199 1520 : break;
200 : case XATTR_LINESTART:
201 0 : bFound = static_cast<const XLineStartItem*>(pCheckItem)->GetLineStartValue() == static_cast<XLineEndEntry*>(pEntry)->GetLineEnd();
202 0 : break;
203 : case XATTR_LINEEND:
204 0 : bFound = static_cast<const XLineEndItem*>(pCheckItem)->GetLineEndValue() == static_cast<XLineEndEntry*>(pEntry)->GetLineEnd();
205 0 : break;
206 : case XATTR_FILLGRADIENT:
207 3570 : bFound = static_cast<const XFillGradientItem*>(pCheckItem)->GetGradientValue() == static_cast<XGradientEntry*>(pEntry)->GetGradient();
208 3570 : break;
209 : case XATTR_FILLHATCH:
210 1410 : bFound = static_cast<const XFillHatchItem*>(pCheckItem)->GetHatchValue() == static_cast<XHatchEntry*>(pEntry)->GetHatch();
211 1410 : break;
212 : }
213 :
214 6775 : if( bFound )
215 : {
216 2 : aUniqueName = pEntry->GetName();
217 2 : break;
218 : }
219 : else
220 : {
221 6773 : OUString aEntryName = pEntry->GetName();
222 6773 : if(aEntryName.getLength() >= aUser.getLength())
223 : {
224 5534 : sal_Int32 nThisIndex = aEntryName.copy( aUser.getLength() ).toInt32();
225 5534 : if( nThisIndex >= nUserIndex )
226 330 : nUserIndex = nThisIndex + 1;
227 6773 : }
228 : }
229 : }
230 : }
231 : }
232 :
233 486 : if (aUniqueName.isEmpty() && pPool1)
234 : {
235 484 : const sal_uInt32 nCount = pPool1->GetItemCount2( nWhich );
236 : const NameOrIndex *pItem;
237 2629 : for( sal_uInt32 nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
238 : {
239 2371 : pItem = static_cast<const NameOrIndex*>(pPool1->GetItem2( nWhich, nSurrogate ));
240 :
241 2371 : if( pItem && !pItem->GetName().isEmpty() )
242 : {
243 1591 : if( !bForceNew && pCompareValueFunc( pItem, pCheckItem ) )
244 226 : return pItem->GetName();
245 :
246 1365 : if( pItem->GetName().startsWith( aUser ) )
247 : {
248 1361 : sal_Int32 nThisIndex = pItem->GetName().copy( aUser.getLength() ).toInt32();
249 1361 : if( nThisIndex >= nUserIndex )
250 1361 : nUserIndex = nThisIndex + 1;
251 : }
252 : }
253 : }
254 258 : aUniqueName = aUser;
255 258 : aUniqueName += OUString::number( nUserIndex );
256 260 : }
257 : }
258 :
259 28107 : return aUniqueName;
260 : }
261 :
262 0 : void NameOrIndex::dumpAsXml(xmlTextWriterPtr pWriter) const
263 : {
264 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("nameOrIndex"));
265 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("isIndex"), BAD_CAST(OString::boolean(IsIndex()).getStr()));
266 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
267 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("index"), BAD_CAST(OString::number(GetIndex()).getStr()));
268 0 : xmlTextWriterEndElement(pWriter);
269 0 : }
270 :
271 59775 : TYPEINIT1_AUTOFACTORY(XColorItem, NameOrIndex);
272 :
273 0 : XColorItem::XColorItem(sal_uInt16 _nWhich, sal_Int32 nIndex, const Color& rTheColor) :
274 : NameOrIndex(_nWhich, nIndex),
275 0 : aColor(rTheColor)
276 : {
277 0 : }
278 :
279 59984 : XColorItem::XColorItem(sal_uInt16 _nWhich, const OUString& rName, const Color& rTheColor) :
280 : NameOrIndex(_nWhich, rName),
281 59984 : aColor(rTheColor)
282 : {
283 59984 : }
284 :
285 8269 : XColorItem::XColorItem(sal_uInt16 _nWhich, const Color& rTheColor)
286 : : NameOrIndex(_nWhich, OUString())
287 8269 : , aColor(rTheColor)
288 : {
289 8269 : }
290 :
291 121676 : XColorItem::XColorItem(const XColorItem& rItem) :
292 : NameOrIndex(rItem),
293 121676 : aColor(rItem.aColor)
294 : {
295 121676 : }
296 :
297 0 : XColorItem::XColorItem(sal_uInt16 _nWhich, SvStream& rIn) :
298 0 : NameOrIndex(_nWhich, rIn)
299 : {
300 0 : if (!IsIndex())
301 : {
302 0 : ReadColor( rIn, aColor );
303 : }
304 0 : }
305 :
306 1530 : SfxPoolItem* XColorItem::Clone(SfxItemPool* /*pPool*/) const
307 : {
308 1530 : return new XColorItem(*this);
309 : }
310 :
311 578928 : bool XColorItem::operator==(const SfxPoolItem& rItem) const
312 : {
313 1157856 : return ( NameOrIndex::operator==(rItem) &&
314 1157856 : static_cast<const XColorItem&>(rItem).aColor == aColor );
315 : }
316 :
317 0 : SfxPoolItem* XColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
318 : {
319 0 : return new XColorItem(Which(), rIn);
320 : }
321 :
322 0 : SvStream& XColorItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
323 : {
324 0 : NameOrIndex::Store( rOut, nItemVersion );
325 :
326 0 : if ( !IsIndex() )
327 : {
328 0 : WriteColor( rOut, aColor );
329 : }
330 :
331 0 : return rOut;
332 : }
333 :
334 103816 : const Color& XColorItem::GetColorValue(const XColorList* pTable) const
335 : {
336 103816 : if (!IsIndex())
337 103816 : return aColor;
338 : else
339 0 : return pTable->GetColor(GetIndex())->GetColor();
340 :
341 : }
342 :
343 181 : bool XColorItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
344 : {
345 181 : rVal <<= (sal_Int32)GetColorValue().GetRGBColor();
346 181 : return true;
347 : }
348 :
349 576 : bool XColorItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
350 : {
351 576 : sal_Int32 nValue = 0;
352 576 : rVal >>= nValue;
353 576 : SetColorValue( nValue );
354 :
355 576 : return true;
356 : }
357 :
358 : // --- line attributes ---
359 :
360 242358 : TYPEINIT1_AUTOFACTORY(XLineStyleItem, SfxEnumItem);
361 :
362 39829 : XLineStyleItem::XLineStyleItem(com::sun::star::drawing::LineStyle eTheLineStyle) :
363 39829 : SfxEnumItem(XATTR_LINESTYLE, sal::static_int_cast< sal_uInt16 >(eTheLineStyle))
364 : {
365 39829 : }
366 :
367 0 : XLineStyleItem::XLineStyleItem(SvStream& rIn) :
368 0 : SfxEnumItem(XATTR_LINESTYLE, rIn)
369 : {
370 0 : }
371 :
372 57262 : SfxPoolItem* XLineStyleItem::Clone(SfxItemPool* /*pPool*/) const
373 : {
374 57262 : return new XLineStyleItem( *this );
375 : }
376 :
377 0 : SfxPoolItem* XLineStyleItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
378 : {
379 0 : return new XLineStyleItem(rIn);
380 : }
381 :
382 0 : bool XLineStyleItem::GetPresentation
383 : (
384 : SfxItemPresentation /*ePres*/,
385 : SfxMapUnit /*eCoreUnit*/,
386 : SfxMapUnit /*ePresUnit*/,
387 : OUString& rText, const IntlWrapper *
388 : ) const
389 : {
390 0 : rText.clear();
391 :
392 0 : sal_uInt16 nId = 0;
393 :
394 0 : switch( (sal_uInt16)GetValue() )
395 : {
396 : case com::sun::star::drawing::LineStyle_NONE:
397 0 : nId = RID_SVXSTR_INVISIBLE;
398 0 : break;
399 : case com::sun::star::drawing::LineStyle_SOLID:
400 0 : nId = RID_SVXSTR_SOLID;
401 0 : break;
402 : }
403 :
404 0 : if ( nId )
405 0 : rText = SVX_RESSTR( nId );
406 0 : return true;
407 : }
408 :
409 2606 : bool XLineStyleItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
410 : {
411 2606 : ::com::sun::star::drawing::LineStyle eLS = (::com::sun::star::drawing::LineStyle)GetValue();
412 2606 : rVal <<= eLS;
413 2606 : return true;
414 : }
415 :
416 37355 : bool XLineStyleItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
417 : {
418 : ::com::sun::star::drawing::LineStyle eLS;
419 37355 : if(!(rVal >>= eLS ))
420 : {
421 : // also try an int (for Basic)
422 1656 : sal_Int32 nLS = 0;
423 1656 : if(!(rVal >>= nLS))
424 0 : return false;
425 1656 : eLS = (::com::sun::star::drawing::LineStyle)nLS;
426 : }
427 :
428 37355 : SetValue( sal::static_int_cast< sal_uInt16 >( eLS ) );
429 37355 : return true;
430 : }
431 :
432 0 : sal_uInt16 XLineStyleItem::GetValueCount() const
433 : {
434 0 : return 3;
435 : }
436 :
437 6136 : XDash::XDash(css::drawing::DashStyle eTheDash, sal_uInt16 nTheDots, sal_uIntPtr nTheDotLen,
438 : sal_uInt16 nTheDashes, sal_uIntPtr nTheDashLen, sal_uIntPtr nTheDistance) :
439 : eDash(eTheDash),
440 : nDots(nTheDots),
441 : nDotLen(nTheDotLen),
442 : nDashes(nTheDashes),
443 : nDashLen(nTheDashLen),
444 6136 : nDistance(nTheDistance)
445 : {
446 6136 : }
447 :
448 2305 : bool XDash::operator==(const XDash& rDash) const
449 : {
450 3541 : return ( eDash == rDash.eDash &&
451 2040 : nDots == rDash.nDots &&
452 1327 : nDotLen == rDash.nDotLen &&
453 1046 : nDashes == rDash.nDashes &&
454 3349 : nDashLen == rDash.nDashLen &&
455 2826 : nDistance == rDash.nDistance );
456 : }
457 :
458 : // XDash is translated into an array of doubles which describe the lengths of the
459 : // dashes, dots and empty passages. It returns the complete length of the full DashDot
460 : // sequence and fills the given vetor of doubles accordingly (also resizing, so deleting it).
461 : static double SMALLEST_DASH_WIDTH(26.95);
462 :
463 327 : double XDash::CreateDotDashArray(::std::vector< double >& rDotDashArray, double fLineWidth) const
464 : {
465 327 : double fFullDotDashLen(0.0);
466 327 : const sal_uInt16 nNumDotDashArray = (GetDots() + GetDashes()) * 2;
467 327 : rDotDashArray.resize( nNumDotDashArray, 0.0 );
468 : sal_uInt16 a;
469 327 : sal_uInt16 nIns(0);
470 327 : double fDashDotDistance = (double)GetDistance();
471 327 : double fSingleDashLen = (double)GetDashLen();
472 327 : double fSingleDotLen = (double)GetDotLen();
473 :
474 327 : if(GetDashStyle() == css::drawing::DashStyle_RECTRELATIVE || GetDashStyle() == css::drawing::DashStyle_ROUNDRELATIVE)
475 : {
476 196 : if(fLineWidth != 0.0)
477 : {
478 196 : double fFactor = fLineWidth / 100.0;
479 :
480 196 : if(GetDashes())
481 : {
482 181 : if(GetDashLen())
483 : {
484 : // is a dash
485 180 : fSingleDashLen *= fFactor;
486 : }
487 : else
488 : {
489 : // is a dot
490 1 : fSingleDashLen = fLineWidth;
491 : }
492 : }
493 :
494 196 : if(GetDots())
495 : {
496 142 : if(GetDotLen())
497 : {
498 : // is a dash
499 141 : fSingleDotLen *= fFactor;
500 : }
501 : else
502 : {
503 : // is a dot
504 1 : fSingleDotLen = fLineWidth;
505 : }
506 : }
507 :
508 196 : if(GetDashes() || GetDots())
509 : {
510 196 : if(GetDistance())
511 : {
512 196 : fDashDotDistance *= fFactor;
513 : }
514 : else
515 : {
516 0 : fDashDotDistance = fLineWidth;
517 : }
518 : }
519 : }
520 : else
521 : {
522 0 : if(GetDashes())
523 : {
524 0 : if(GetDashLen())
525 : {
526 : // is a dash
527 0 : fSingleDashLen = (SMALLEST_DASH_WIDTH * fSingleDashLen) / 100.0;
528 : }
529 : else
530 : {
531 : // is a dot
532 0 : fSingleDashLen = SMALLEST_DASH_WIDTH;
533 : }
534 : }
535 :
536 0 : if(GetDots())
537 : {
538 0 : if(GetDotLen())
539 : {
540 : // is a dash
541 0 : fSingleDotLen = (SMALLEST_DASH_WIDTH * fSingleDotLen) / 100.0;
542 : }
543 : else
544 : {
545 : // is a dot
546 0 : fSingleDotLen = SMALLEST_DASH_WIDTH;
547 : }
548 : }
549 :
550 0 : if(GetDashes() || GetDots())
551 : {
552 0 : if(GetDistance())
553 : {
554 : // dash as distance
555 0 : fDashDotDistance = (SMALLEST_DASH_WIDTH * fDashDotDistance) / 100.0;
556 : }
557 : else
558 : {
559 : // dot as distance
560 0 : fDashDotDistance = SMALLEST_DASH_WIDTH;
561 : }
562 : }
563 : }
564 : }
565 : else
566 : {
567 : // smallest dot size compare value
568 131 : double fDotCompVal(fLineWidth != 0.0 ? fLineWidth : SMALLEST_DASH_WIDTH);
569 :
570 : // absolute values
571 131 : if(GetDashes())
572 : {
573 104 : if(GetDashLen())
574 : {
575 : // is a dash
576 103 : if(fSingleDashLen < SMALLEST_DASH_WIDTH)
577 : {
578 38 : fSingleDashLen = SMALLEST_DASH_WIDTH;
579 : }
580 : }
581 : else
582 : {
583 : // is a dot
584 1 : if(fSingleDashLen < fDotCompVal)
585 : {
586 1 : fSingleDashLen = fDotCompVal;
587 : }
588 : }
589 : }
590 :
591 131 : if(GetDots())
592 : {
593 85 : if(GetDotLen())
594 : {
595 : // is a dash
596 83 : if(fSingleDotLen < SMALLEST_DASH_WIDTH)
597 : {
598 60 : fSingleDotLen = SMALLEST_DASH_WIDTH;
599 : }
600 : }
601 : else
602 : {
603 : // is a dot
604 2 : if(fSingleDotLen < fDotCompVal)
605 : {
606 2 : fSingleDotLen = fDotCompVal;
607 : }
608 : }
609 : }
610 :
611 131 : if(GetDashes() || GetDots())
612 : {
613 131 : if(GetDistance())
614 : {
615 : // dash as distance
616 131 : if(fDashDotDistance < SMALLEST_DASH_WIDTH)
617 : {
618 60 : fDashDotDistance = SMALLEST_DASH_WIDTH;
619 : }
620 : }
621 : else
622 : {
623 : // dot as distance
624 0 : if(fDashDotDistance < fDotCompVal)
625 : {
626 0 : fDashDotDistance = fDotCompVal;
627 : }
628 : }
629 : }
630 : }
631 :
632 574 : for(a=0;a<GetDots();a++)
633 : {
634 247 : rDotDashArray[nIns++] = fSingleDotLen;
635 247 : fFullDotDashLen += fSingleDotLen;
636 247 : rDotDashArray[nIns++] = fDashDotDistance;
637 247 : fFullDotDashLen += fDashDotDistance;
638 : }
639 :
640 877 : for(a=0;a<GetDashes();a++)
641 : {
642 550 : rDotDashArray[nIns++] = fSingleDashLen;
643 550 : fFullDotDashLen += fSingleDashLen;
644 550 : rDotDashArray[nIns++] = fDashDotDistance;
645 550 : fFullDotDashLen += fDashDotDistance;
646 : }
647 :
648 327 : return fFullDotDashLen;
649 : }
650 :
651 15861 : TYPEINIT1_AUTOFACTORY(XLineDashItem, NameOrIndex);
652 :
653 202 : XLineDashItem::XLineDashItem(const OUString& rName, const XDash& rTheDash) :
654 : NameOrIndex(XATTR_LINEDASH, rName),
655 202 : aDash(rTheDash)
656 : {
657 202 : }
658 :
659 708 : XLineDashItem::XLineDashItem(const XLineDashItem& rItem) :
660 : NameOrIndex(rItem),
661 708 : aDash(rItem.aDash)
662 : {
663 708 : }
664 :
665 0 : XLineDashItem::XLineDashItem(SvStream& rIn) :
666 0 : NameOrIndex(XATTR_LINEDASH, rIn)
667 : {
668 0 : if (!IsIndex())
669 : {
670 : sal_uInt16 nSTemp;
671 : sal_uInt32 nLTemp;
672 : sal_Int32 nITemp;
673 :
674 0 : rIn.ReadInt32( nITemp ); aDash.SetDashStyle((css::drawing::DashStyle)nITemp);
675 0 : rIn.ReadUInt16( nSTemp ); aDash.SetDots(nSTemp);
676 0 : rIn.ReadUInt32( nLTemp ); aDash.SetDotLen(nLTemp);
677 0 : rIn.ReadUInt16( nSTemp ); aDash.SetDashes(nSTemp);
678 0 : rIn.ReadUInt32( nLTemp ); aDash.SetDashLen(nLTemp);
679 0 : rIn.ReadUInt32( nLTemp ); aDash.SetDistance(nLTemp);
680 : }
681 0 : }
682 :
683 5069 : XLineDashItem::XLineDashItem(SfxItemPool* /*pPool*/, const XDash& rTheDash)
684 : : NameOrIndex( XATTR_LINEDASH, -1 ),
685 5069 : aDash(rTheDash)
686 : {
687 5069 : }
688 :
689 708 : SfxPoolItem* XLineDashItem::Clone(SfxItemPool* /*pPool*/) const
690 : {
691 708 : return new XLineDashItem(*this);
692 : }
693 :
694 984 : bool XLineDashItem::operator==(const SfxPoolItem& rItem) const
695 : {
696 1544 : return ( NameOrIndex::operator==(rItem) &&
697 1544 : aDash == static_cast<const XLineDashItem&>(rItem).aDash );
698 : }
699 :
700 0 : SfxPoolItem* XLineDashItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
701 : {
702 0 : return new XLineDashItem(rIn);
703 : }
704 :
705 0 : SvStream& XLineDashItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
706 : {
707 0 : NameOrIndex::Store( rOut, nItemVersion );
708 :
709 0 : if (!IsIndex())
710 : {
711 0 : rOut.WriteInt32( aDash.GetDashStyle() );
712 0 : rOut.WriteUInt16( aDash.GetDots() );
713 0 : rOut.WriteUInt32( aDash.GetDotLen() );
714 0 : rOut.WriteUInt16( aDash.GetDashes() );
715 0 : rOut.WriteUInt32( aDash.GetDashLen() );
716 0 : rOut.WriteUInt32( aDash.GetDistance() );
717 : }
718 :
719 0 : return rOut;
720 : }
721 :
722 :
723 0 : bool XLineDashItem::GetPresentation
724 : (
725 : SfxItemPresentation /*ePres*/,
726 : SfxMapUnit /*eCoreUnit*/,
727 : SfxMapUnit /*ePresUnit*/,
728 : OUString& rText, const IntlWrapper *
729 : ) const
730 : {
731 0 : rText = GetName();
732 0 : return true;
733 : }
734 :
735 0 : bool XLineDashItem::HasMetrics() const
736 : {
737 0 : return true;
738 : }
739 :
740 0 : bool XLineDashItem::ScaleMetrics(long nMul, long nDiv)
741 : {
742 0 : aDash.SetDotLen( ScaleMetricValue( aDash.GetDotLen(), nMul, nDiv ) );
743 0 : aDash.SetDashLen( ScaleMetricValue( aDash.GetDashLen(), nMul, nDiv ) );
744 0 : aDash.SetDistance( ScaleMetricValue( aDash.GetDistance(), nMul, nDiv ) );
745 0 : return true;
746 : }
747 :
748 580 : bool XLineDashItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
749 : {
750 580 : nMemberId &= ~CONVERT_TWIPS;
751 :
752 580 : switch ( nMemberId )
753 : {
754 : case 0:
755 : {
756 0 : uno::Sequence< beans::PropertyValue > aPropSeq( 2 );
757 :
758 0 : ::com::sun::star::drawing::LineDash aLineDash;
759 :
760 0 : const XDash& rXD = GetDashValue();
761 0 : aLineDash.Style = (::com::sun::star::drawing::DashStyle)((sal_uInt16)rXD.GetDashStyle());
762 0 : aLineDash.Dots = rXD.GetDots();
763 0 : aLineDash.DotLen = rXD.GetDotLen();
764 0 : aLineDash.Dashes = rXD.GetDashes();
765 0 : aLineDash.DashLen = rXD.GetDashLen();
766 0 : aLineDash.Distance = rXD.GetDistance();
767 :
768 0 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
769 0 : aPropSeq[0].Name = "Name";
770 0 : aPropSeq[0].Value = uno::makeAny( aApiName );
771 0 : aPropSeq[1].Name = "LineDash";
772 0 : aPropSeq[1].Value = uno::makeAny( aLineDash );
773 0 : rVal = uno::makeAny( aPropSeq );
774 0 : break;
775 : }
776 :
777 : case MID_NAME:
778 : {
779 258 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
780 258 : rVal <<= aApiName;
781 258 : break;
782 : }
783 :
784 : case MID_LINEDASH:
785 : {
786 322 : const XDash& rXD = GetDashValue();
787 :
788 322 : ::com::sun::star::drawing::LineDash aLineDash;
789 :
790 322 : aLineDash.Style = (::com::sun::star::drawing::DashStyle)((sal_uInt16)rXD.GetDashStyle());
791 322 : aLineDash.Dots = rXD.GetDots();
792 322 : aLineDash.DotLen = rXD.GetDotLen();
793 322 : aLineDash.Dashes = rXD.GetDashes();
794 322 : aLineDash.DashLen = rXD.GetDashLen();
795 322 : aLineDash.Distance = rXD.GetDistance();
796 :
797 322 : rVal <<= aLineDash;
798 322 : break;
799 : }
800 :
801 : case MID_LINEDASH_STYLE:
802 : {
803 0 : const XDash& rXD = GetDashValue();
804 0 : rVal <<= (::com::sun::star::drawing::DashStyle)((sal_Int16)rXD.GetDashStyle());
805 0 : break;
806 : }
807 :
808 : case MID_LINEDASH_DOTS:
809 : {
810 0 : const XDash& rXD = GetDashValue();
811 0 : rVal <<= rXD.GetDots();
812 0 : break;
813 : }
814 :
815 : case MID_LINEDASH_DOTLEN:
816 : {
817 0 : const XDash& rXD = GetDashValue();
818 0 : rVal <<= rXD.GetDotLen();
819 0 : break;
820 : }
821 :
822 : case MID_LINEDASH_DASHES:
823 : {
824 0 : const XDash& rXD = GetDashValue();
825 0 : rVal <<= rXD.GetDashes();
826 0 : break;
827 : }
828 :
829 : case MID_LINEDASH_DASHLEN:
830 : {
831 0 : const XDash& rXD = GetDashValue();
832 0 : rVal <<= rXD.GetDashLen();
833 0 : break;
834 : }
835 :
836 : case MID_LINEDASH_DISTANCE:
837 : {
838 0 : const XDash& rXD = GetDashValue();
839 0 : rVal <<= rXD.GetDistance();
840 0 : break;
841 : }
842 :
843 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
844 : }
845 :
846 580 : return true;
847 : }
848 :
849 135 : bool XLineDashItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
850 : {
851 135 : nMemberId &= ~CONVERT_TWIPS;
852 :
853 135 : switch ( nMemberId )
854 : {
855 : case 0:
856 : {
857 0 : uno::Sequence< beans::PropertyValue > aPropSeq;
858 0 : ::com::sun::star::drawing::LineDash aLineDash;
859 0 : OUString aName;
860 0 : bool bLineDash( false );
861 :
862 0 : if ( rVal >>= aPropSeq )
863 : {
864 0 : for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
865 : {
866 0 : if ( aPropSeq[n].Name == "Name" )
867 0 : aPropSeq[n].Value >>= aName;
868 0 : else if ( aPropSeq[n].Name == "LineDash" )
869 : {
870 0 : if ( aPropSeq[n].Value >>= aLineDash )
871 0 : bLineDash = true;
872 : }
873 : }
874 :
875 0 : SetName( aName );
876 0 : if ( bLineDash )
877 : {
878 0 : XDash aXDash;
879 :
880 0 : aXDash.SetDashStyle((css::drawing::DashStyle)((sal_uInt16)(aLineDash.Style)));
881 0 : aXDash.SetDots(aLineDash.Dots);
882 0 : aXDash.SetDotLen(aLineDash.DotLen);
883 0 : aXDash.SetDashes(aLineDash.Dashes);
884 0 : aXDash.SetDashLen(aLineDash.DashLen);
885 0 : aXDash.SetDistance(aLineDash.Distance);
886 :
887 0 : if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
888 0 : aXDash.SetDots(1);
889 :
890 0 : SetDashValue( aXDash );
891 : }
892 :
893 0 : return true;
894 : }
895 :
896 0 : return false;
897 : }
898 :
899 : case MID_NAME:
900 : {
901 0 : OUString aName;
902 0 : if (!(rVal >>= aName))
903 0 : return false;
904 0 : SetName( aName );
905 0 : break;
906 : }
907 :
908 : case MID_LINEDASH:
909 : {
910 135 : ::com::sun::star::drawing::LineDash aLineDash;
911 135 : if(!(rVal >>= aLineDash))
912 0 : return false;
913 :
914 135 : XDash aXDash;
915 :
916 135 : aXDash.SetDashStyle((css::drawing::DashStyle)((sal_uInt16)(aLineDash.Style)));
917 135 : aXDash.SetDots(aLineDash.Dots);
918 135 : aXDash.SetDotLen(aLineDash.DotLen);
919 135 : aXDash.SetDashes(aLineDash.Dashes);
920 135 : aXDash.SetDashLen(aLineDash.DashLen);
921 135 : aXDash.SetDistance(aLineDash.Distance);
922 :
923 135 : if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
924 0 : aXDash.SetDots(1);
925 :
926 135 : SetDashValue( aXDash );
927 135 : break;
928 : }
929 :
930 : case MID_LINEDASH_STYLE:
931 : {
932 0 : sal_Int16 nVal = sal_Int16();
933 0 : if(!(rVal >>= nVal))
934 0 : return false;
935 :
936 0 : XDash aXDash = GetDashValue();
937 0 : aXDash.SetDashStyle((css::drawing::DashStyle)((sal_uInt16)(nVal)));
938 :
939 0 : if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
940 0 : aXDash.SetDots(1);
941 :
942 0 : SetDashValue( aXDash );
943 :
944 0 : break;
945 : }
946 :
947 : case MID_LINEDASH_DOTS:
948 : case MID_LINEDASH_DASHES:
949 : {
950 0 : sal_Int16 nVal = sal_Int16();
951 0 : if(!(rVal >>= nVal))
952 0 : return false;
953 :
954 0 : XDash aXDash = GetDashValue();
955 0 : if ( nMemberId == MID_LINEDASH_DOTS )
956 0 : aXDash.SetDots( nVal );
957 : else
958 0 : aXDash.SetDashes( nVal );
959 :
960 0 : if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
961 0 : aXDash.SetDots(1);
962 :
963 0 : SetDashValue( aXDash );
964 0 : break;
965 : }
966 :
967 : case MID_LINEDASH_DOTLEN:
968 : case MID_LINEDASH_DASHLEN:
969 : case MID_LINEDASH_DISTANCE:
970 : {
971 0 : sal_Int32 nVal = 0;
972 0 : if(!(rVal >>= nVal))
973 0 : return false;
974 :
975 0 : XDash aXDash = GetDashValue();
976 0 : if ( nMemberId == MID_LINEDASH_DOTLEN )
977 0 : aXDash.SetDotLen( nVal );
978 0 : else if ( nMemberId == MID_LINEDASH_DASHLEN )
979 0 : aXDash.SetDashLen( nVal );
980 : else
981 0 : aXDash.SetDistance( nVal );
982 :
983 0 : if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
984 0 : aXDash.SetDots(1);
985 :
986 0 : SetDashValue( aXDash );
987 0 : break;
988 : }
989 : }
990 :
991 135 : return true;
992 : }
993 :
994 225 : bool XLineDashItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
995 : {
996 225 : return static_cast<const XLineDashItem*>(p1)->GetDashValue() == static_cast<const XLineDashItem*>(p2)->GetDashValue();
997 : }
998 :
999 367 : XLineDashItem* XLineDashItem::checkForUniqueItem( SdrModel* pModel ) const
1000 : {
1001 367 : if( pModel )
1002 : {
1003 : const OUString aUniqueName = NameOrIndex::CheckNamedItem(
1004 262 : this, XATTR_LINEDASH, &pModel->GetItemPool(),
1005 393 : pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
1006 : XLineDashItem::CompareValueFunc, RID_SVXSTR_DASH11,
1007 917 : pModel->GetPropertyList( XDASH_LIST ) );
1008 :
1009 : // if the given name is not valid, replace it!
1010 262 : if( aUniqueName != GetName() )
1011 152 : return new XLineDashItem( aUniqueName, aDash );
1012 : }
1013 :
1014 215 : return NULL;
1015 : }
1016 :
1017 175218 : TYPEINIT1_AUTOFACTORY(XLineWidthItem, SfxMetricItem);
1018 :
1019 6546 : XLineWidthItem::XLineWidthItem(long nWidth) :
1020 6546 : SfxMetricItem(XATTR_LINEWIDTH, nWidth)
1021 : {
1022 6546 : }
1023 :
1024 0 : XLineWidthItem::XLineWidthItem(SvStream& rIn) :
1025 0 : SfxMetricItem(XATTR_LINEWIDTH, rIn)
1026 : {
1027 0 : }
1028 :
1029 36461 : SfxPoolItem* XLineWidthItem::Clone(SfxItemPool* /*pPool*/) const
1030 : {
1031 36461 : return new XLineWidthItem(*this);
1032 : }
1033 :
1034 0 : SfxPoolItem* XLineWidthItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1035 : {
1036 0 : return new XLineWidthItem(rIn);
1037 : }
1038 :
1039 0 : bool XLineWidthItem::GetPresentation
1040 : (
1041 : SfxItemPresentation /*ePres*/,
1042 : SfxMapUnit eCoreUnit,
1043 : SfxMapUnit ePresUnit,
1044 : OUString& rText, const IntlWrapper * pIntl
1045 : ) const
1046 : {
1047 0 : rText = GetMetricText( (long) GetValue(),
1048 0 : eCoreUnit, ePresUnit, pIntl) +
1049 0 : " " + EE_RESSTR( GetMetricId( ePresUnit) );
1050 0 : return true;
1051 : }
1052 :
1053 2052 : bool XLineWidthItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
1054 : {
1055 2052 : sal_Int32 nValue = GetValue();
1056 2052 : if( 0 != (nMemberId&CONVERT_TWIPS) )
1057 0 : nValue = convertTwipToMm100(nValue);
1058 :
1059 2052 : rVal <<= nValue;
1060 2052 : return true;
1061 : }
1062 :
1063 30324 : bool XLineWidthItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
1064 : {
1065 30324 : sal_Int32 nValue = 0;
1066 30324 : rVal >>= nValue;
1067 30324 : if( 0 != (nMemberId&CONVERT_TWIPS) )
1068 0 : nValue = convertMm100ToTwip(nValue);
1069 :
1070 30324 : SetValue( nValue );
1071 30324 : return true;
1072 : }
1073 :
1074 158492 : TYPEINIT1_AUTOFACTORY(XLineColorItem, XColorItem);
1075 :
1076 0 : XLineColorItem::XLineColorItem(sal_Int32 nIndex, const Color& rTheColor) :
1077 0 : XColorItem(XATTR_LINECOLOR, nIndex, rTheColor)
1078 : {
1079 0 : }
1080 :
1081 6824 : XLineColorItem::XLineColorItem(const OUString& rName, const Color& rTheColor) :
1082 6824 : XColorItem(XATTR_LINECOLOR, rName, rTheColor)
1083 : {
1084 6824 : }
1085 :
1086 0 : XLineColorItem::XLineColorItem(SvStream& rIn) :
1087 0 : XColorItem(XATTR_LINECOLOR, rIn)
1088 : {
1089 0 : }
1090 :
1091 59126 : SfxPoolItem* XLineColorItem::Clone(SfxItemPool* /*pPool*/) const
1092 : {
1093 59126 : return new XLineColorItem(*this);
1094 : }
1095 :
1096 0 : SfxPoolItem* XLineColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1097 : {
1098 0 : return new XLineColorItem(rIn);
1099 : }
1100 :
1101 0 : bool XLineColorItem::GetPresentation
1102 : (
1103 : SfxItemPresentation /*ePres*/,
1104 : SfxMapUnit /*eCoreUnit*/,
1105 : SfxMapUnit /*ePresUnit*/,
1106 : OUString& rText, const IntlWrapper *
1107 : ) const
1108 : {
1109 0 : rText = GetName();
1110 0 : return true;
1111 : }
1112 :
1113 1908 : bool XLineColorItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1114 : {
1115 1908 : rVal <<= (sal_Int32)GetColorValue().GetRGBColor();
1116 1908 : return true;
1117 : }
1118 :
1119 27649 : bool XLineColorItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1120 : {
1121 27649 : sal_Int32 nValue = 0;
1122 27649 : if(!(rVal >>= nValue))
1123 0 : return false;
1124 :
1125 27649 : SetColorValue( nValue );
1126 27649 : return true;
1127 : }
1128 :
1129 : // --- tooling for simple spooling B2DPolygon to file and back ---
1130 :
1131 : namespace
1132 : {
1133 0 : void streamOutB2DPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon, SvStream& rOut)
1134 : {
1135 0 : const sal_uInt32 nPolygonCount(rPolyPolygon.count());
1136 0 : rOut.WriteUInt32( nPolygonCount );
1137 :
1138 0 : for(sal_uInt32 a(0L); a < nPolygonCount; a++)
1139 : {
1140 0 : const basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(a));
1141 0 : const sal_uInt32 nPointCount(aCandidate.count());
1142 0 : const sal_uInt8 bClosed(aCandidate.isClosed() ? 1 : 0);
1143 0 : const sal_uInt8 bControlPoints(aCandidate.areControlPointsUsed() ? 1 : 0);
1144 0 : rOut.WriteUInt32( nPointCount );
1145 0 : rOut.WriteUChar( bClosed );
1146 0 : rOut.WriteUChar( bControlPoints );
1147 :
1148 0 : for(sal_uInt32 b(0L); b < nPointCount; b++)
1149 : {
1150 0 : const basegfx::B2DPoint aPoint(aCandidate.getB2DPoint(b));
1151 0 : rOut.WriteDouble( aPoint.getX() );
1152 0 : rOut.WriteDouble( aPoint.getY() );
1153 :
1154 0 : if(bControlPoints)
1155 : {
1156 0 : const sal_uInt8 bEdgeIsCurve(aCandidate.isPrevControlPointUsed(b) || aCandidate.isNextControlPointUsed(b) ? 1 : 0);
1157 0 : rOut.WriteUChar( bEdgeIsCurve );
1158 :
1159 0 : if(bEdgeIsCurve)
1160 : {
1161 0 : const basegfx::B2DVector aControlVectorA(aCandidate.getPrevControlPoint(b));
1162 0 : rOut.WriteDouble( aControlVectorA.getX() );
1163 0 : rOut.WriteDouble( aControlVectorA.getY() );
1164 :
1165 0 : const basegfx::B2DVector aControlVectorB(aCandidate.getNextControlPoint(b));
1166 0 : rOut.WriteDouble( aControlVectorB.getX() );
1167 0 : rOut.WriteDouble( aControlVectorB.getY() );
1168 : }
1169 : }
1170 0 : }
1171 0 : }
1172 0 : }
1173 :
1174 0 : basegfx::B2DPolyPolygon streamInB2DPolyPolygon(SvStream& rIn)
1175 : {
1176 0 : basegfx::B2DPolyPolygon aRetval;
1177 : sal_uInt32 nPolygonCount;
1178 0 : rIn.ReadUInt32( nPolygonCount );
1179 :
1180 0 : for(sal_uInt32 a(0L); a < nPolygonCount; a++)
1181 : {
1182 : sal_uInt32 nPointCount;
1183 : sal_uInt8 bClosed;
1184 : sal_uInt8 bControlPoints;
1185 :
1186 0 : rIn.ReadUInt32( nPointCount );
1187 0 : rIn.ReadUChar( bClosed );
1188 0 : rIn.ReadUChar( bControlPoints );
1189 :
1190 0 : basegfx::B2DPolygon aCandidate;
1191 0 : aCandidate.setClosed(0 != bClosed);
1192 :
1193 0 : for(sal_uInt32 b(0L); b < nPointCount; b++)
1194 : {
1195 : double fX, fY;
1196 0 : rIn.ReadDouble( fX );
1197 0 : rIn.ReadDouble( fY );
1198 0 : aCandidate.append(basegfx::B2DPoint(fX, fY));
1199 :
1200 0 : if(0 != bControlPoints)
1201 : {
1202 : sal_uInt8 bEdgeIsCurve;
1203 0 : rIn.ReadUChar( bEdgeIsCurve );
1204 :
1205 0 : if(0 != bEdgeIsCurve)
1206 : {
1207 0 : rIn.ReadDouble( fX );
1208 0 : rIn.ReadDouble( fY );
1209 0 : aCandidate.setPrevControlPoint(b, basegfx::B2DVector(fX, fY));
1210 :
1211 0 : rIn.ReadDouble( fX );
1212 0 : rIn.ReadDouble( fY );
1213 0 : aCandidate.setNextControlPoint(b, basegfx::B2DVector(fX, fY));
1214 : }
1215 : }
1216 : }
1217 :
1218 0 : aRetval.append(aCandidate);
1219 0 : }
1220 :
1221 0 : return aRetval;
1222 : }
1223 : }
1224 :
1225 17079 : TYPEINIT1_AUTOFACTORY(XLineStartItem, NameOrIndex);
1226 :
1227 152 : XLineStartItem::XLineStartItem(sal_Int32 nIndex)
1228 152 : : NameOrIndex(XATTR_LINESTART, nIndex)
1229 : {
1230 152 : }
1231 :
1232 739 : XLineStartItem::XLineStartItem(const OUString& rName, const basegfx::B2DPolyPolygon& rPolyPolygon)
1233 : : NameOrIndex(XATTR_LINESTART, rName),
1234 739 : maPolyPolygon(rPolyPolygon)
1235 : {
1236 739 : }
1237 :
1238 2119 : XLineStartItem::XLineStartItem(const XLineStartItem& rItem)
1239 : : NameOrIndex(rItem),
1240 2119 : maPolyPolygon(rItem.maPolyPolygon)
1241 : {
1242 2119 : }
1243 :
1244 0 : XLineStartItem::XLineStartItem(SvStream& rIn) :
1245 0 : NameOrIndex(XATTR_LINESTART, rIn)
1246 : {
1247 0 : if (!IsIndex())
1248 : {
1249 0 : maPolyPolygon = streamInB2DPolyPolygon(rIn);
1250 : }
1251 0 : }
1252 :
1253 5069 : XLineStartItem::XLineStartItem(SfxItemPool* /*pPool*/, const basegfx::B2DPolyPolygon& rPolyPolygon)
1254 : : NameOrIndex( XATTR_LINESTART, -1 ),
1255 5069 : maPolyPolygon(rPolyPolygon)
1256 : {
1257 5069 : }
1258 :
1259 2119 : SfxPoolItem* XLineStartItem::Clone(SfxItemPool* /*pPool*/) const
1260 : {
1261 2119 : return new XLineStartItem(*this);
1262 : }
1263 :
1264 2837 : bool XLineStartItem::operator==(const SfxPoolItem& rItem) const
1265 : {
1266 2837 : return ( NameOrIndex::operator==(rItem) && static_cast<const XLineStartItem&>(rItem).maPolyPolygon == maPolyPolygon );
1267 : }
1268 :
1269 0 : SfxPoolItem* XLineStartItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1270 : {
1271 0 : return new XLineStartItem(rIn);
1272 : }
1273 :
1274 0 : SvStream& XLineStartItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
1275 : {
1276 0 : NameOrIndex::Store( rOut, nItemVersion );
1277 :
1278 0 : if (!IsIndex())
1279 : {
1280 0 : streamOutB2DPolyPolygon(maPolyPolygon, rOut);
1281 : }
1282 :
1283 0 : return rOut;
1284 : }
1285 :
1286 :
1287 0 : bool XLineStartItem::GetPresentation
1288 : (
1289 : SfxItemPresentation /*ePres*/,
1290 : SfxMapUnit /*eCoreUnit*/,
1291 : SfxMapUnit /*ePresUnit*/,
1292 : OUString& rText, const IntlWrapper *
1293 : ) const
1294 : {
1295 0 : rText = GetName();
1296 0 : return true;
1297 : }
1298 :
1299 1986 : bool XLineStartItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
1300 : {
1301 1986 : nMemberId &= ~CONVERT_TWIPS;
1302 1986 : if( nMemberId == MID_NAME )
1303 : {
1304 314 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
1305 314 : rVal <<= aApiName;
1306 : }
1307 : else
1308 : {
1309 1672 : com::sun::star::drawing::PolyPolygonBezierCoords aBezier;
1310 1672 : basegfx::unotools::b2DPolyPolygonToPolyPolygonBezier( maPolyPolygon, aBezier );
1311 1672 : rVal <<= aBezier;
1312 : }
1313 :
1314 1986 : return true;
1315 : }
1316 :
1317 196 : bool XLineStartItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
1318 : {
1319 196 : nMemberId &= ~CONVERT_TWIPS;
1320 196 : if( nMemberId == MID_NAME )
1321 : {
1322 0 : return false;
1323 : }
1324 : else
1325 : {
1326 196 : maPolyPolygon.clear();
1327 :
1328 196 : if( rVal.hasValue() && rVal.getValue() )
1329 : {
1330 196 : if( rVal.getValueType() != cppu::UnoType<com::sun::star::drawing::PolyPolygonBezierCoords>::get())
1331 0 : return false;
1332 :
1333 196 : com::sun::star::drawing::PolyPolygonBezierCoords const * pCoords = static_cast<com::sun::star::drawing::PolyPolygonBezierCoords const *>(rVal.getValue());
1334 196 : if( pCoords->Coordinates.getLength() > 0 )
1335 : {
1336 196 : maPolyPolygon = basegfx::unotools::polyPolygonBezierToB2DPolyPolygon( *pCoords );
1337 : // #i72807# close line start/end polygons hard
1338 : // maPolyPolygon.setClosed(true);
1339 : }
1340 : }
1341 : }
1342 :
1343 196 : return true;
1344 : }
1345 :
1346 : /** this function searches in both the models pool and the styles pool for XLineStartItem
1347 : and XLineEndItem with the same value or name and returns an item with the value of
1348 : this item and a unique name for an item with this value. */
1349 334 : XLineStartItem* XLineStartItem::checkForUniqueItem( SdrModel* pModel ) const
1350 : {
1351 334 : if( pModel )
1352 : {
1353 223 : XLineStartItem* pTempItem = NULL;
1354 223 : const XLineStartItem* pLineStartItem = this;
1355 :
1356 223 : OUString aUniqueName( GetName() );
1357 :
1358 223 : if( !maPolyPolygon.count() )
1359 : {
1360 : // if the polygon is empty, check if the name is empty
1361 0 : if( aUniqueName.isEmpty() )
1362 0 : return NULL;
1363 :
1364 : // force empty name for empty polygons
1365 0 : return new XLineStartItem( "", maPolyPolygon );
1366 : }
1367 :
1368 223 : if( maPolyPolygon.count() > 1L )
1369 : {
1370 : // check if the polygon is closed
1371 0 : if(!maPolyPolygon.isClosed())
1372 : {
1373 : // force a closed polygon
1374 0 : basegfx::B2DPolyPolygon aNew(maPolyPolygon);
1375 0 : aNew.setClosed(true);
1376 0 : pTempItem = new XLineStartItem( aUniqueName, aNew );
1377 0 : pLineStartItem = pTempItem;
1378 : }
1379 : }
1380 :
1381 223 : bool bForceNew = false;
1382 :
1383 : // 2. if we have a name check if there is already an item with the
1384 : // same name in the documents pool with a different line end or start
1385 :
1386 : sal_uInt32 nCount, nSurrogate;
1387 :
1388 223 : const SfxItemPool* pPool1 = &pModel->GetItemPool();
1389 223 : if( !aUniqueName.isEmpty() && pPool1 )
1390 : {
1391 141 : nCount = pPool1->GetItemCount2( XATTR_LINESTART );
1392 :
1393 181 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1394 : {
1395 177 : const XLineStartItem* pItem = static_cast<const XLineStartItem*>(pPool1->GetItem2( XATTR_LINESTART, nSurrogate ));
1396 :
1397 177 : if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1398 : {
1399 : // if there is already an item with the same name and the same
1400 : // value its ok to set it
1401 137 : if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() )
1402 : {
1403 : // same name but different value, we need a new name for this item
1404 0 : aUniqueName.clear();
1405 0 : bForceNew = true;
1406 : }
1407 137 : break;
1408 : }
1409 : }
1410 :
1411 141 : if( !bForceNew )
1412 : {
1413 141 : nCount = pPool1->GetItemCount2( XATTR_LINEEND );
1414 :
1415 181 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1416 : {
1417 160 : const XLineEndItem* pItem = static_cast<const XLineEndItem*>(pPool1->GetItem2( XATTR_LINEEND, nSurrogate ));
1418 :
1419 160 : if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1420 : {
1421 : // if there is already an item with the same name and the same
1422 : // value its ok to set it
1423 120 : if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() )
1424 : {
1425 : // same name but different value, we need a new name for this item
1426 0 : aUniqueName.clear();
1427 0 : bForceNew = true;
1428 : }
1429 120 : break;
1430 : }
1431 : }
1432 : }
1433 : }
1434 :
1435 223 : const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL;
1436 223 : if( !aUniqueName.isEmpty() && pPool2)
1437 : {
1438 14 : nCount = pPool2->GetItemCount2( XATTR_LINESTART );
1439 45 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1440 : {
1441 44 : const XLineStartItem* pItem = static_cast<const XLineStartItem*>(pPool2->GetItem2( XATTR_LINESTART, nSurrogate ));
1442 :
1443 44 : if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1444 : {
1445 : // if there is already an item with the same name and the same
1446 : // value its ok to set it
1447 13 : if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() )
1448 : {
1449 : // same name but different value, we need a new name for this item
1450 0 : aUniqueName.clear();
1451 0 : bForceNew = true;
1452 : }
1453 13 : break;
1454 : }
1455 : }
1456 :
1457 14 : if( !bForceNew )
1458 : {
1459 14 : nCount = pPool2->GetItemCount2( XATTR_LINEEND );
1460 48 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1461 : {
1462 41 : const XLineEndItem* pItem = static_cast<const XLineEndItem*>(pPool2->GetItem2( XATTR_LINEEND, nSurrogate ));
1463 :
1464 41 : if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
1465 : {
1466 : // if there is already an item with the same name and the same
1467 : // value its ok to set it
1468 7 : if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() )
1469 : {
1470 : // same name but different value, we need a new name for this item
1471 0 : aUniqueName.clear();
1472 0 : bForceNew = true;
1473 : }
1474 7 : break;
1475 : }
1476 : }
1477 : }
1478 : }
1479 :
1480 : // if we have no name yet, find existing item with same content or
1481 : // create a unique name
1482 223 : if( aUniqueName.isEmpty() )
1483 : {
1484 82 : bool bFoundExisting = false;
1485 :
1486 82 : sal_Int32 nUserIndex = 1;
1487 82 : const ResId aRes(SVX_RES(RID_SVXSTR_LINEEND));
1488 82 : const OUString aUser( aRes.toString() );
1489 :
1490 82 : if( pPool1 )
1491 : {
1492 82 : nCount = pPool1->GetItemCount2( XATTR_LINESTART );
1493 : sal_uInt32 nSurrogate2;
1494 :
1495 469 : for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
1496 : {
1497 452 : const XLineStartItem* pItem = static_cast<const XLineStartItem*>(pPool1->GetItem2( XATTR_LINESTART, nSurrogate2 ));
1498 :
1499 452 : if( pItem && !pItem->GetName().isEmpty() )
1500 : {
1501 349 : if( !bForceNew && pItem->GetLineStartValue() == pLineStartItem->GetLineStartValue() )
1502 : {
1503 65 : aUniqueName = pItem->GetName();
1504 65 : bFoundExisting = true;
1505 65 : break;
1506 : }
1507 :
1508 284 : if( pItem->GetName().startsWith( aUser ) )
1509 : {
1510 76 : sal_Int32 nThisIndex = pItem->GetName().copy( aUser.getLength() ).toInt32();
1511 76 : if( nThisIndex >= nUserIndex )
1512 76 : nUserIndex = nThisIndex + 1;
1513 : }
1514 : }
1515 : }
1516 :
1517 82 : nCount = pPool1->GetItemCount2( XATTR_LINEEND );
1518 448 : for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
1519 : {
1520 387 : const XLineEndItem* pItem = static_cast<const XLineEndItem*>(pPool1->GetItem2( XATTR_LINEEND, nSurrogate2 ));
1521 :
1522 387 : if( pItem && !pItem->GetName().isEmpty() )
1523 : {
1524 305 : if( !bForceNew && pItem->GetLineEndValue() == pLineStartItem->GetLineStartValue() )
1525 : {
1526 21 : aUniqueName = pItem->GetName();
1527 21 : bFoundExisting = true;
1528 21 : break;
1529 : }
1530 :
1531 284 : if( pItem->GetName().startsWith( aUser ) )
1532 : {
1533 76 : sal_Int32 nThisIndex = pItem->GetName().copy( aUser.getLength() ).toInt32();
1534 76 : if( nThisIndex >= nUserIndex )
1535 13 : nUserIndex = nThisIndex + 1;
1536 : }
1537 : }
1538 : }
1539 : }
1540 :
1541 82 : if( !bFoundExisting )
1542 : {
1543 17 : aUniqueName = aUser;
1544 17 : aUniqueName += " ";
1545 17 : aUniqueName += OUString::number( nUserIndex );
1546 82 : }
1547 : }
1548 :
1549 : // if the given name is not valid, replace it!
1550 223 : if( aUniqueName != GetName() || pTempItem )
1551 : {
1552 82 : if( pTempItem )
1553 : {
1554 0 : pTempItem->SetName( aUniqueName );
1555 0 : return pTempItem;
1556 : }
1557 : else
1558 : {
1559 82 : return new XLineStartItem( aUniqueName, maPolyPolygon );
1560 : }
1561 141 : }
1562 : }
1563 :
1564 252 : return NULL;
1565 : }
1566 :
1567 17119 : TYPEINIT1_AUTOFACTORY(XLineEndItem, NameOrIndex);
1568 :
1569 152 : XLineEndItem::XLineEndItem(sal_Int32 nIndex)
1570 152 : : NameOrIndex(XATTR_LINEEND, nIndex)
1571 : {
1572 152 : }
1573 :
1574 408 : XLineEndItem::XLineEndItem(const OUString& rName, const basegfx::B2DPolyPolygon& rPolyPolygon)
1575 : : NameOrIndex(XATTR_LINEEND, rName),
1576 408 : maPolyPolygon(rPolyPolygon)
1577 : {
1578 408 : }
1579 :
1580 2149 : XLineEndItem::XLineEndItem(const XLineEndItem& rItem)
1581 : : NameOrIndex(rItem),
1582 2149 : maPolyPolygon(rItem.maPolyPolygon)
1583 : {
1584 2149 : }
1585 :
1586 0 : XLineEndItem::XLineEndItem(SvStream& rIn) :
1587 0 : NameOrIndex(XATTR_LINEEND, rIn)
1588 : {
1589 0 : if (!IsIndex())
1590 : {
1591 0 : maPolyPolygon = streamInB2DPolyPolygon(rIn);
1592 : }
1593 0 : }
1594 :
1595 5069 : XLineEndItem::XLineEndItem(SfxItemPool* /*pPool*/, const basegfx::B2DPolyPolygon& rPolyPolygon)
1596 : : NameOrIndex( XATTR_LINEEND, -1 ),
1597 5069 : maPolyPolygon(rPolyPolygon)
1598 : {
1599 5069 : }
1600 :
1601 2149 : SfxPoolItem* XLineEndItem::Clone(SfxItemPool* /*pPool*/) const
1602 : {
1603 2149 : return new XLineEndItem(*this);
1604 : }
1605 :
1606 2099 : bool XLineEndItem::operator==(const SfxPoolItem& rItem) const
1607 : {
1608 2099 : return ( NameOrIndex::operator==(rItem) && static_cast<const XLineEndItem&>(rItem).maPolyPolygon == maPolyPolygon );
1609 : }
1610 :
1611 0 : SfxPoolItem* XLineEndItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1612 : {
1613 0 : return new XLineEndItem(rIn);
1614 : }
1615 :
1616 0 : SvStream& XLineEndItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
1617 : {
1618 0 : NameOrIndex::Store( rOut, nItemVersion );
1619 :
1620 0 : if (!IsIndex())
1621 : {
1622 0 : streamOutB2DPolyPolygon(maPolyPolygon, rOut);
1623 : }
1624 :
1625 0 : return rOut;
1626 : }
1627 :
1628 :
1629 : /** this function searches in both the models pool and the styles pool for XLineStartItem
1630 : and XLineEndItem with the same value or name and returns an item with the value of
1631 : this item and a unique name for an item with this value. */
1632 495 : XLineEndItem* XLineEndItem::checkForUniqueItem( SdrModel* pModel ) const
1633 : {
1634 495 : if( pModel )
1635 : {
1636 239 : XLineEndItem* pTempItem = NULL;
1637 239 : const XLineEndItem* pLineEndItem = this;
1638 :
1639 239 : OUString aUniqueName( GetName() );
1640 :
1641 239 : if( !maPolyPolygon.count() )
1642 : {
1643 : // if the polygon is empty, check if the name is empty
1644 0 : if( aUniqueName.isEmpty() )
1645 0 : return NULL;
1646 :
1647 : // force empty name for empty polygons
1648 0 : return new XLineEndItem( "", maPolyPolygon );
1649 : }
1650 :
1651 239 : if( maPolyPolygon.count() > 1L )
1652 : {
1653 : // check if the polygon is closed
1654 0 : if(!maPolyPolygon.isClosed())
1655 : {
1656 : // force a closed polygon
1657 0 : basegfx::B2DPolyPolygon aNew(maPolyPolygon);
1658 0 : aNew.setClosed(true);
1659 0 : pTempItem = new XLineEndItem( aUniqueName, aNew );
1660 0 : pLineEndItem = pTempItem;
1661 : }
1662 : }
1663 :
1664 239 : bool bForceNew = false;
1665 :
1666 : // 2. if we have a name check if there is already an item with the
1667 : // same name in the documents pool with a different line end or start
1668 :
1669 : sal_uInt16 nCount, nSurrogate;
1670 :
1671 239 : const SfxItemPool* pPool1 = &pModel->GetItemPool();
1672 239 : if( !aUniqueName.isEmpty() && pPool1 )
1673 : {
1674 198 : nCount = pPool1->GetItemCount2( XATTR_LINESTART );
1675 :
1676 304 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1677 : {
1678 298 : const XLineStartItem* pItem = static_cast<const XLineStartItem*>(pPool1->GetItem2( XATTR_LINESTART, nSurrogate ));
1679 :
1680 298 : if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1681 : {
1682 : // if there is already an item with the same name and the same
1683 : // value its ok to set it
1684 192 : if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() )
1685 : {
1686 : // same name but different value, we need a new name for this item
1687 2 : aUniqueName.clear();
1688 2 : bForceNew = true;
1689 : }
1690 192 : break;
1691 : }
1692 : }
1693 :
1694 198 : if( !bForceNew )
1695 : {
1696 196 : nCount = pPool1->GetItemCount2( XATTR_LINEEND );
1697 :
1698 301 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1699 : {
1700 300 : const XLineEndItem* pItem = static_cast<const XLineEndItem*>(pPool1->GetItem2( XATTR_LINEEND, nSurrogate ));
1701 :
1702 300 : if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1703 : {
1704 : // if there is already an item with the same name and the same
1705 : // value its ok to set it
1706 195 : if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() )
1707 : {
1708 : // same name but different value, we need a new name for this item
1709 0 : aUniqueName.clear();
1710 0 : bForceNew = true;
1711 : }
1712 195 : break;
1713 : }
1714 : }
1715 : }
1716 : }
1717 :
1718 239 : const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL;
1719 239 : if( !aUniqueName.isEmpty() && pPool2)
1720 : {
1721 45 : nCount = pPool2->GetItemCount2( XATTR_LINESTART );
1722 144 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1723 : {
1724 138 : const XLineStartItem* pItem = static_cast<const XLineStartItem*>(pPool2->GetItem2( XATTR_LINESTART, nSurrogate ));
1725 :
1726 138 : if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1727 : {
1728 : // if there is already an item with the same name and the same
1729 : // value its ok to set it
1730 39 : if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() )
1731 : {
1732 : // same name but different value, we need a new name for this item
1733 0 : aUniqueName.clear();
1734 0 : bForceNew = true;
1735 : }
1736 39 : break;
1737 : }
1738 : }
1739 :
1740 45 : if( !bForceNew )
1741 : {
1742 45 : nCount = pPool2->GetItemCount2( XATTR_LINEEND );
1743 146 : for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1744 : {
1745 146 : const XLineEndItem* pItem = static_cast<const XLineEndItem*>(pPool2->GetItem2( XATTR_LINEEND, nSurrogate ));
1746 :
1747 146 : if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
1748 : {
1749 : // if there is already an item with the same name and the same
1750 : // value its ok to set it
1751 45 : if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() )
1752 : {
1753 : // same name but different value, we need a new name for this item
1754 0 : aUniqueName.clear();
1755 0 : bForceNew = true;
1756 : }
1757 45 : break;
1758 : }
1759 : }
1760 : }
1761 : }
1762 :
1763 : // if we have no name yet, find existing item with same content or
1764 : // create a unique name
1765 239 : if( aUniqueName.isEmpty() )
1766 : {
1767 43 : bool bFoundExisting = false;
1768 :
1769 43 : sal_Int32 nUserIndex = 1;
1770 43 : const ResId aRes(SVX_RES(RID_SVXSTR_LINEEND));
1771 43 : const OUString aUser( aRes.toString() );
1772 :
1773 43 : if( pPool1 )
1774 : {
1775 43 : nCount = pPool1->GetItemCount2( XATTR_LINESTART );
1776 : sal_uInt32 nSurrogate2;
1777 :
1778 199 : for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
1779 : {
1780 183 : const XLineStartItem* pItem = static_cast<const XLineStartItem*>(pPool1->GetItem2( XATTR_LINESTART, nSurrogate2 ));
1781 :
1782 183 : if( pItem && !pItem->GetName().isEmpty() )
1783 : {
1784 152 : if( !bForceNew && pItem->GetLineStartValue() == pLineEndItem->GetLineEndValue() )
1785 : {
1786 27 : aUniqueName = pItem->GetName();
1787 27 : bFoundExisting = true;
1788 27 : break;
1789 : }
1790 :
1791 125 : if( pItem->GetName().startsWith( aUser ) )
1792 : {
1793 90 : sal_Int32 nThisIndex = pItem->GetName().copy( aUser.getLength() ).toInt32();
1794 90 : if( nThisIndex >= nUserIndex )
1795 90 : nUserIndex = nThisIndex + 1;
1796 : }
1797 : }
1798 : }
1799 :
1800 43 : nCount = pPool1->GetItemCount2( XATTR_LINEEND );
1801 175 : for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
1802 : {
1803 172 : const XLineEndItem* pItem = static_cast<const XLineEndItem*>(pPool1->GetItem2( XATTR_LINEEND, nSurrogate2 ));
1804 :
1805 172 : if( pItem && !pItem->GetName().isEmpty() )
1806 : {
1807 141 : if( !bForceNew && pItem->GetLineEndValue() == pLineEndItem->GetLineEndValue() )
1808 : {
1809 40 : aUniqueName = pItem->GetName();
1810 40 : bFoundExisting = true;
1811 40 : break;
1812 : }
1813 :
1814 101 : if( pItem->GetName().startsWith( aUser ) )
1815 : {
1816 63 : sal_Int32 nThisIndex = pItem->GetName().copy( aUser.getLength() ).toInt32();
1817 63 : if( nThisIndex >= nUserIndex )
1818 0 : nUserIndex = nThisIndex + 1;
1819 : }
1820 : }
1821 : }
1822 : }
1823 :
1824 43 : if( !bFoundExisting )
1825 : {
1826 3 : aUniqueName = aUser;
1827 3 : aUniqueName += " ";
1828 3 : aUniqueName += OUString::number( nUserIndex );
1829 43 : }
1830 : }
1831 :
1832 : // if the given name is not valid, replace it!
1833 239 : if( aUniqueName != GetName() || pTempItem )
1834 : {
1835 43 : if( pTempItem )
1836 : {
1837 0 : pTempItem->SetName( aUniqueName );
1838 0 : return pTempItem;
1839 : }
1840 : else
1841 : {
1842 43 : return new XLineEndItem( aUniqueName, maPolyPolygon );
1843 : }
1844 196 : }
1845 : }
1846 :
1847 452 : return NULL;
1848 : }
1849 :
1850 0 : bool XLineEndItem::GetPresentation
1851 : (
1852 : SfxItemPresentation /*ePres*/,
1853 : SfxMapUnit /*eCoreUnit*/,
1854 : SfxMapUnit /*ePresUnit*/,
1855 : OUString& rText, const IntlWrapper *
1856 : ) const
1857 : {
1858 0 : rText = GetName();
1859 0 : return true;
1860 : }
1861 :
1862 1979 : bool XLineEndItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
1863 : {
1864 1979 : nMemberId &= ~CONVERT_TWIPS;
1865 1979 : if( nMemberId == MID_NAME )
1866 : {
1867 326 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
1868 326 : rVal <<= aApiName;
1869 : }
1870 : else
1871 : {
1872 1653 : com::sun::star::drawing::PolyPolygonBezierCoords aBezier;
1873 1653 : basegfx::unotools::b2DPolyPolygonToPolyPolygonBezier( maPolyPolygon, aBezier );
1874 1653 : rVal <<= aBezier;
1875 : }
1876 1979 : return true;
1877 : }
1878 :
1879 196 : bool XLineEndItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
1880 : {
1881 196 : nMemberId &= ~CONVERT_TWIPS;
1882 196 : if( nMemberId == MID_NAME )
1883 : {
1884 0 : return false;
1885 : }
1886 : else
1887 : {
1888 196 : maPolyPolygon.clear();
1889 :
1890 196 : if( rVal.hasValue() && rVal.getValue() )
1891 : {
1892 196 : if( rVal.getValueType() != cppu::UnoType<com::sun::star::drawing::PolyPolygonBezierCoords>::get())
1893 0 : return false;
1894 :
1895 196 : com::sun::star::drawing::PolyPolygonBezierCoords const * pCoords = static_cast<com::sun::star::drawing::PolyPolygonBezierCoords const *>(rVal.getValue());
1896 196 : if( pCoords->Coordinates.getLength() > 0 )
1897 : {
1898 196 : maPolyPolygon = basegfx::unotools::polyPolygonBezierToB2DPolyPolygon( *pCoords );
1899 : // #i72807# close line start/end polygons hard
1900 : // maPolyPolygon.setClosed(true);
1901 : }
1902 : }
1903 : }
1904 :
1905 196 : return true;
1906 : }
1907 :
1908 16103 : TYPEINIT1_AUTOFACTORY(XLineStartWidthItem, SfxMetricItem);
1909 :
1910 5726 : XLineStartWidthItem::XLineStartWidthItem(long nWidth) :
1911 5726 : SfxMetricItem(XATTR_LINESTARTWIDTH, nWidth)
1912 : {
1913 5726 : }
1914 :
1915 0 : XLineStartWidthItem::XLineStartWidthItem(SvStream& rIn) :
1916 0 : SfxMetricItem(XATTR_LINESTARTWIDTH, rIn)
1917 : {
1918 0 : }
1919 :
1920 1132 : SfxPoolItem* XLineStartWidthItem::Clone(SfxItemPool* /*pPool*/) const
1921 : {
1922 1132 : return new XLineStartWidthItem(*this);
1923 : }
1924 :
1925 0 : SfxPoolItem* XLineStartWidthItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1926 : {
1927 0 : return new XLineStartWidthItem(rIn);
1928 : }
1929 :
1930 0 : bool XLineStartWidthItem::GetPresentation
1931 : (
1932 : SfxItemPresentation /*ePres*/,
1933 : SfxMapUnit eCoreUnit,
1934 : SfxMapUnit ePresUnit,
1935 : OUString& rText, const IntlWrapper * pIntl
1936 : ) const
1937 : {
1938 0 : rText = GetMetricText( (long) GetValue(),
1939 0 : eCoreUnit, ePresUnit, pIntl) +
1940 0 : " " + EE_RESSTR( GetMetricId( ePresUnit) );
1941 0 : return true;
1942 : }
1943 :
1944 309 : bool XLineStartWidthItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1945 : {
1946 309 : rVal <<= (sal_Int32)GetValue();
1947 309 : return true;
1948 : }
1949 :
1950 289 : bool XLineStartWidthItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1951 : {
1952 289 : sal_Int32 nValue = 0;
1953 289 : rVal >>= nValue;
1954 289 : SetValue( nValue );
1955 289 : return true;
1956 : }
1957 :
1958 16534 : TYPEINIT1_AUTOFACTORY(XLineEndWidthItem, SfxMetricItem);
1959 :
1960 5689 : XLineEndWidthItem::XLineEndWidthItem(long nWidth) :
1961 5689 : SfxMetricItem(XATTR_LINEENDWIDTH, nWidth)
1962 : {
1963 5689 : }
1964 :
1965 0 : XLineEndWidthItem::XLineEndWidthItem(SvStream& rIn) :
1966 0 : SfxMetricItem(XATTR_LINEENDWIDTH, rIn)
1967 : {
1968 0 : }
1969 :
1970 1369 : SfxPoolItem* XLineEndWidthItem::Clone(SfxItemPool* /*pPool*/) const
1971 : {
1972 1369 : return new XLineEndWidthItem(*this);
1973 : }
1974 :
1975 0 : SfxPoolItem* XLineEndWidthItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1976 : {
1977 0 : return new XLineEndWidthItem(rIn);
1978 : }
1979 :
1980 0 : bool XLineEndWidthItem::GetPresentation
1981 : (
1982 : SfxItemPresentation /*ePres*/,
1983 : SfxMapUnit eCoreUnit,
1984 : SfxMapUnit ePresUnit,
1985 : OUString& rText, const IntlWrapper *pIntl
1986 : ) const
1987 : {
1988 0 : rText = GetMetricText( (long) GetValue(),
1989 0 : eCoreUnit, ePresUnit, pIntl) +
1990 0 : " " + EE_RESSTR( GetMetricId( ePresUnit) );
1991 0 : return true;
1992 : }
1993 :
1994 307 : bool XLineEndWidthItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1995 : {
1996 307 : rVal <<= (sal_Int32)GetValue();
1997 307 : return true;
1998 : }
1999 :
2000 353 : bool XLineEndWidthItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2001 : {
2002 353 : sal_Int32 nValue = 0;
2003 353 : rVal >>= nValue;
2004 353 : SetValue( nValue );
2005 353 : return true;
2006 : }
2007 :
2008 15965 : TYPEINIT1_AUTOFACTORY(XLineStartCenterItem, SfxBoolItem);
2009 :
2010 5464 : XLineStartCenterItem::XLineStartCenterItem(bool bStartCenter) :
2011 5464 : SfxBoolItem(XATTR_LINESTARTCENTER, bStartCenter)
2012 : {
2013 5464 : }
2014 :
2015 0 : XLineStartCenterItem::XLineStartCenterItem(SvStream& rIn) :
2016 0 : SfxBoolItem(XATTR_LINESTARTCENTER, rIn)
2017 : {
2018 0 : }
2019 :
2020 969 : SfxPoolItem* XLineStartCenterItem::Clone(SfxItemPool* /*pPool*/) const
2021 : {
2022 969 : return new XLineStartCenterItem(*this);
2023 : }
2024 :
2025 0 : SfxPoolItem* XLineStartCenterItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2026 : {
2027 0 : return new XLineStartCenterItem(rIn);
2028 : }
2029 :
2030 0 : bool XLineStartCenterItem::GetPresentation
2031 : (
2032 : SfxItemPresentation /*ePres*/,
2033 : SfxMapUnit /*eCoreUnit*/,
2034 : SfxMapUnit /*ePresUnit*/,
2035 : OUString& rText, const IntlWrapper *
2036 : ) const
2037 : {
2038 0 : rText = OUString( ResId( GetValue() ? RID_SVXSTR_CENTERED :
2039 0 : RID_SVXSTR_NOTCENTERED, DIALOG_MGR() ) );
2040 0 : return true;
2041 : }
2042 :
2043 294 : bool XLineStartCenterItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2044 : {
2045 294 : sal_Bool bValue = GetValue();
2046 294 : rVal.setValue( &bValue, cppu::UnoType<bool>::get() );
2047 294 : return true;
2048 : }
2049 :
2050 245 : bool XLineStartCenterItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2051 : {
2052 245 : if( !rVal.hasValue() || rVal.getValueType() != cppu::UnoType<bool>::get() )
2053 0 : return false;
2054 :
2055 245 : SetValue( *static_cast<sal_Bool const *>(rVal.getValue()) );
2056 245 : return true;
2057 : }
2058 :
2059 16246 : TYPEINIT1_AUTOFACTORY(XLineEndCenterItem, SfxBoolItem);
2060 :
2061 5172 : XLineEndCenterItem::XLineEndCenterItem(bool bEndCenter) :
2062 5172 : SfxBoolItem(XATTR_LINEENDCENTER, bEndCenter)
2063 : {
2064 5172 : }
2065 :
2066 0 : XLineEndCenterItem::XLineEndCenterItem(SvStream& rIn) :
2067 0 : SfxBoolItem(XATTR_LINEENDCENTER, rIn)
2068 : {
2069 0 : }
2070 :
2071 798 : SfxPoolItem* XLineEndCenterItem::Clone(SfxItemPool* /*pPool*/) const
2072 : {
2073 798 : return new XLineEndCenterItem(*this);
2074 : }
2075 :
2076 0 : SfxPoolItem* XLineEndCenterItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2077 : {
2078 0 : return new XLineEndCenterItem(rIn);
2079 : }
2080 :
2081 0 : bool XLineEndCenterItem::GetPresentation
2082 : (
2083 : SfxItemPresentation /*ePres*/,
2084 : SfxMapUnit /*eCoreUnit*/,
2085 : SfxMapUnit /*ePresUnit*/,
2086 : OUString& rText, const IntlWrapper *
2087 : ) const
2088 : {
2089 0 : rText = OUString( ResId( GetValue() ? RID_SVXSTR_CENTERED :
2090 0 : RID_SVXSTR_NOTCENTERED, DIALOG_MGR() ) );
2091 0 : return true;
2092 : }
2093 :
2094 277 : bool XLineEndCenterItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2095 : {
2096 277 : sal_Bool bValue = GetValue();
2097 277 : rVal.setValue( &bValue, cppu::UnoType<bool>::get() );
2098 277 : return true;
2099 : }
2100 :
2101 263 : bool XLineEndCenterItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2102 : {
2103 263 : if( !rVal.hasValue() || rVal.getValueType() != cppu::UnoType<bool>::get() )
2104 0 : return false;
2105 :
2106 263 : SetValue( *static_cast<sal_Bool const *>(rVal.getValue()) );
2107 263 : return true;
2108 : }
2109 :
2110 : // --- fill attributes ---
2111 :
2112 299152 : TYPEINIT1_AUTOFACTORY(XFillStyleItem, SfxEnumItem);
2113 :
2114 61885 : XFillStyleItem::XFillStyleItem(drawing::FillStyle eFillStyle) :
2115 61885 : SfxEnumItem(XATTR_FILLSTYLE, sal::static_int_cast< sal_uInt16 >(eFillStyle))
2116 : {
2117 61885 : }
2118 :
2119 0 : XFillStyleItem::XFillStyleItem(SvStream& rIn) :
2120 0 : SfxEnumItem(XATTR_FILLSTYLE, rIn)
2121 : {
2122 0 : }
2123 :
2124 44936 : SfxPoolItem* XFillStyleItem::Clone(SfxItemPool* /*pPool*/) const
2125 : {
2126 44936 : return new XFillStyleItem( *this );
2127 : }
2128 :
2129 0 : SfxPoolItem* XFillStyleItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2130 : {
2131 0 : return new XFillStyleItem(rIn);
2132 : }
2133 :
2134 0 : bool XFillStyleItem::GetPresentation
2135 : (
2136 : SfxItemPresentation /*ePres*/,
2137 : SfxMapUnit /*eCoreUnit*/,
2138 : SfxMapUnit /*ePresUnit*/,
2139 : OUString& rText, const IntlWrapper *
2140 : ) const
2141 : {
2142 0 : rText.clear();
2143 :
2144 0 : sal_uInt16 nId = 0;
2145 :
2146 0 : switch( (sal_uInt16)GetValue() )
2147 : {
2148 : case drawing::FillStyle_NONE:
2149 0 : nId = RID_SVXSTR_INVISIBLE;
2150 0 : break;
2151 : case drawing::FillStyle_SOLID:
2152 0 : nId = RID_SVXSTR_SOLID;
2153 0 : break;
2154 : case drawing::FillStyle_GRADIENT:
2155 0 : nId = RID_SVXSTR_GRADIENT;
2156 0 : break;
2157 : case drawing::FillStyle_HATCH:
2158 0 : nId = RID_SVXSTR_HATCH;
2159 0 : break;
2160 : case drawing::FillStyle_BITMAP:
2161 0 : nId = RID_SVXSTR_BITMAP;
2162 0 : break;
2163 : }
2164 :
2165 0 : if ( nId )
2166 0 : rText = SVX_RESSTR( nId );
2167 0 : return true;
2168 : }
2169 :
2170 0 : sal_uInt16 XFillStyleItem::GetValueCount() const
2171 : {
2172 0 : return 5;
2173 : }
2174 :
2175 3292 : bool XFillStyleItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2176 : {
2177 3292 : ::com::sun::star::drawing::FillStyle eFS = (::com::sun::star::drawing::FillStyle)GetValue();
2178 :
2179 3292 : rVal <<= eFS;
2180 :
2181 3292 : return true;
2182 : }
2183 :
2184 31171 : bool XFillStyleItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2185 : {
2186 : ::com::sun::star::drawing::FillStyle eFS;
2187 31171 : if(!(rVal >>= eFS))
2188 : {
2189 : // also try an int (for Basic)
2190 2 : sal_Int32 nFS = 0;
2191 2 : if(!(rVal >>= nFS))
2192 2 : return false;
2193 0 : eFS = (::com::sun::star::drawing::FillStyle)nFS;
2194 : }
2195 :
2196 31169 : SetValue( sal::static_int_cast< sal_uInt16 >( eFS ) );
2197 :
2198 31169 : return true;
2199 : }
2200 :
2201 0 : void XFillStyleItem::dumpAsXml(xmlTextWriterPtr pWriter) const
2202 : {
2203 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("xFillStyleItem"));
2204 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
2205 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
2206 :
2207 0 : OUString aPresentation;
2208 0 : GetPresentation(SFX_ITEM_PRESENTATION_NAMELESS, SFX_MAPUNIT_100TH_MM, SFX_MAPUNIT_100TH_MM, aPresentation);
2209 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(aPresentation.toUtf8().getStr()));
2210 :
2211 0 : xmlTextWriterEndElement(pWriter);
2212 0 : }
2213 :
2214 167996 : TYPEINIT1_AUTOFACTORY(XFillColorItem, XColorItem);
2215 :
2216 0 : XFillColorItem::XFillColorItem(sal_Int32 nIndex, const Color& rTheColor) :
2217 0 : XColorItem(XATTR_FILLCOLOR, nIndex, rTheColor)
2218 : {
2219 0 : }
2220 :
2221 43532 : XFillColorItem::XFillColorItem(const OUString& rName, const Color& rTheColor) :
2222 43532 : XColorItem(XATTR_FILLCOLOR, rName, rTheColor)
2223 : {
2224 43532 : }
2225 :
2226 0 : XFillColorItem::XFillColorItem(SvStream& rIn) :
2227 0 : XColorItem(XATTR_FILLCOLOR, rIn)
2228 : {
2229 0 : }
2230 :
2231 60940 : SfxPoolItem* XFillColorItem::Clone(SfxItemPool* /*pPool*/) const
2232 : {
2233 60940 : return new XFillColorItem(*this);
2234 : }
2235 :
2236 0 : SfxPoolItem* XFillColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2237 : {
2238 0 : return new XFillColorItem(rIn);
2239 : }
2240 :
2241 0 : bool XFillColorItem::GetPresentation
2242 : (
2243 : SfxItemPresentation /*ePres*/,
2244 : SfxMapUnit /*eCoreUnit*/,
2245 : SfxMapUnit /*ePresUnit*/,
2246 : OUString& rText, const IntlWrapper *
2247 : ) const
2248 : {
2249 0 : rText = GetName();
2250 0 : return true;
2251 : }
2252 :
2253 1829 : bool XFillColorItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2254 : {
2255 1829 : rVal <<= (sal_Int32)GetColorValue().GetRGBColor();
2256 :
2257 1829 : return true;
2258 : }
2259 :
2260 22832 : bool XFillColorItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2261 : {
2262 22832 : sal_Int32 nValue = 0;
2263 22832 : if(!(rVal >>= nValue ))
2264 0 : return false;
2265 :
2266 22832 : SetColorValue( nValue );
2267 22832 : return true;
2268 : }
2269 :
2270 0 : void XFillColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
2271 : {
2272 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("xFillColorItem"));
2273 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
2274 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(GetColorValue().AsRGBHexString().toUtf8().getStr()));
2275 0 : xmlTextWriterEndElement(pWriter);
2276 0 : }
2277 :
2278 16624 : TYPEINIT1_AUTOFACTORY(XSecondaryFillColorItem, XColorItem);
2279 :
2280 4814 : XSecondaryFillColorItem::XSecondaryFillColorItem(const OUString& rName, const Color& rTheColor) :
2281 4814 : XColorItem(XATTR_SECONDARYFILLCOLOR, rName, rTheColor)
2282 : {
2283 4814 : }
2284 :
2285 0 : XSecondaryFillColorItem::XSecondaryFillColorItem( SvStream& rIn ) :
2286 0 : XColorItem(XATTR_SECONDARYFILLCOLOR, rIn)
2287 : {
2288 0 : }
2289 :
2290 48 : SfxPoolItem* XSecondaryFillColorItem::Clone(SfxItemPool* /*pPool*/) const
2291 : {
2292 48 : return new XSecondaryFillColorItem(*this);
2293 : }
2294 :
2295 0 : SfxPoolItem* XSecondaryFillColorItem::Create( SvStream& rIn, sal_uInt16 nVer ) const
2296 : {
2297 0 : if ( nVer >= 2 )
2298 0 : return new XSecondaryFillColorItem( rIn );
2299 : else
2300 0 : return new XSecondaryFillColorItem( "", Color(0,184,255) );
2301 : }
2302 :
2303 0 : sal_uInt16 XSecondaryFillColorItem::GetVersion( sal_uInt16 /*nFileFormatVersion*/ ) const
2304 : {
2305 0 : return 2;
2306 : }
2307 :
2308 0 : bool XSecondaryFillColorItem::GetPresentation
2309 : (
2310 : SfxItemPresentation /*ePres*/,
2311 : SfxMapUnit /*eCoreUnit*/,
2312 : SfxMapUnit /*ePresUnit*/,
2313 : OUString& rText, const IntlWrapper *
2314 : ) const
2315 : {
2316 0 : rText = GetName();
2317 0 : return true;
2318 : }
2319 :
2320 1640 : XGradient::XGradient() :
2321 : eStyle( css::awt::GradientStyle_LINEAR ),
2322 : aStartColor( Color( COL_BLACK ) ),
2323 : aEndColor( Color( COL_WHITE ) ),
2324 : nAngle( 0 ),
2325 : nBorder( 0 ),
2326 : nOfsX( 50 ),
2327 : nOfsY( 50 ),
2328 : nIntensStart( 100 ),
2329 : nIntensEnd( 100 ),
2330 1640 : nStepCount( 0 )
2331 : {
2332 1640 : }
2333 :
2334 5339 : XGradient::XGradient(const Color& rStart, const Color& rEnd,
2335 : css::awt::GradientStyle eTheStyle, long nTheAngle, sal_uInt16 nXOfs,
2336 : sal_uInt16 nYOfs, sal_uInt16 nTheBorder,
2337 : sal_uInt16 nStartIntens, sal_uInt16 nEndIntens,
2338 : sal_uInt16 nSteps) :
2339 : eStyle(eTheStyle),
2340 : aStartColor(rStart),
2341 : aEndColor(rEnd),
2342 : nAngle(nTheAngle),
2343 : nBorder(nTheBorder),
2344 : nOfsX(nXOfs),
2345 : nOfsY(nYOfs),
2346 : nIntensStart(nStartIntens),
2347 : nIntensEnd(nEndIntens),
2348 5339 : nStepCount(nSteps)
2349 : {
2350 5339 : }
2351 :
2352 15111 : bool XGradient::operator==(const XGradient& rGradient) const
2353 : {
2354 29294 : return ( eStyle == rGradient.eStyle &&
2355 25431 : aStartColor == rGradient.aStartColor &&
2356 22494 : aEndColor == rGradient.aEndColor &&
2357 22404 : nAngle == rGradient.nAngle &&
2358 22316 : nBorder == rGradient.nBorder &&
2359 22316 : nOfsX == rGradient.nOfsX &&
2360 22316 : nOfsY == rGradient.nOfsY &&
2361 22316 : nIntensStart == rGradient.nIntensStart &&
2362 37427 : nIntensEnd == rGradient.nIntensEnd &&
2363 26269 : nStepCount == rGradient.nStepCount );
2364 : }
2365 :
2366 37297 : TYPEINIT1_AUTOFACTORY(XFillGradientItem, NameOrIndex);
2367 :
2368 4814 : XFillGradientItem::XFillGradientItem(sal_Int32 nIndex,
2369 : const XGradient& rTheGradient) :
2370 : NameOrIndex(XATTR_FILLGRADIENT, nIndex),
2371 4814 : aGradient(rTheGradient)
2372 : {
2373 4814 : }
2374 :
2375 319 : XFillGradientItem::XFillGradientItem(const OUString& rName,
2376 : const XGradient& rTheGradient, sal_uInt16 nWhich)
2377 : : NameOrIndex(nWhich, rName)
2378 319 : , aGradient(rTheGradient)
2379 : {
2380 319 : }
2381 :
2382 1931 : XFillGradientItem::XFillGradientItem(const XFillGradientItem& rItem) :
2383 : NameOrIndex(rItem),
2384 1931 : aGradient(rItem.aGradient)
2385 : {
2386 1931 : }
2387 :
2388 0 : XFillGradientItem::XFillGradientItem(SvStream& rIn, sal_uInt16 nVer) :
2389 : NameOrIndex(XATTR_FILLGRADIENT, rIn),
2390 0 : aGradient(COL_BLACK, COL_WHITE)
2391 : {
2392 0 : if (!IsIndex())
2393 : {
2394 : sal_uInt16 nUSTemp;
2395 : sal_uInt16 nRed;
2396 : sal_uInt16 nGreen;
2397 : sal_uInt16 nBlue;
2398 : sal_Int16 nITemp;
2399 : sal_Int32 nLTemp;
2400 :
2401 0 : rIn.ReadInt16( nITemp ); aGradient.SetGradientStyle((css::awt::GradientStyle)nITemp);
2402 0 : rIn.ReadUInt16( nRed );
2403 0 : rIn.ReadUInt16( nGreen );
2404 0 : rIn.ReadUInt16( nBlue );
2405 0 : Color aCol;
2406 0 : aCol = Color( (sal_uInt8)( nRed >> 8 ), (sal_uInt8)( nGreen >> 8 ), (sal_uInt8)( nBlue >> 8 ) );
2407 0 : aGradient.SetStartColor( aCol );
2408 :
2409 0 : rIn.ReadUInt16( nRed );
2410 0 : rIn.ReadUInt16( nGreen );
2411 0 : rIn.ReadUInt16( nBlue );
2412 0 : aCol = Color( (sal_uInt8)( nRed >> 8 ), (sal_uInt8)( nGreen >> 8 ), (sal_uInt8)( nBlue >> 8 ) );
2413 0 : aGradient.SetEndColor(aCol);
2414 0 : rIn.ReadInt32( nLTemp ); aGradient.SetAngle(nLTemp);
2415 0 : rIn.ReadUInt16( nUSTemp ); aGradient.SetBorder(nUSTemp);
2416 0 : rIn.ReadUInt16( nUSTemp ); aGradient.SetXOffset(nUSTemp);
2417 0 : rIn.ReadUInt16( nUSTemp ); aGradient.SetYOffset(nUSTemp);
2418 0 : rIn.ReadUInt16( nUSTemp ); aGradient.SetStartIntens(nUSTemp);
2419 0 : rIn.ReadUInt16( nUSTemp ); aGradient.SetEndIntens(nUSTemp);
2420 :
2421 : // for newer versions consider the step width as well
2422 0 : if (nVer >= 1)
2423 : {
2424 0 : rIn.ReadUInt16( nUSTemp ); aGradient.SetSteps(nUSTemp);
2425 : }
2426 : }
2427 0 : }
2428 :
2429 5081 : XFillGradientItem::XFillGradientItem( const XGradient& rTheGradient )
2430 : : NameOrIndex( XATTR_FILLGRADIENT, -1 ),
2431 5081 : aGradient(rTheGradient)
2432 : {
2433 5081 : }
2434 :
2435 1316 : SfxPoolItem* XFillGradientItem::Clone(SfxItemPool* /*pPool*/) const
2436 : {
2437 1316 : return new XFillGradientItem(*this);
2438 : }
2439 :
2440 2806 : bool XFillGradientItem::operator==(const SfxPoolItem& rItem) const
2441 : {
2442 4001 : return ( NameOrIndex::operator==(rItem) &&
2443 4001 : aGradient == static_cast<const XFillGradientItem&>(rItem).aGradient );
2444 : }
2445 :
2446 0 : SfxPoolItem* XFillGradientItem::Create(SvStream& rIn, sal_uInt16 nVer) const
2447 : {
2448 0 : return new XFillGradientItem(rIn, nVer);
2449 : }
2450 :
2451 0 : SvStream& XFillGradientItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
2452 : {
2453 0 : NameOrIndex::Store( rOut, nItemVersion );
2454 :
2455 0 : if (!IsIndex())
2456 : {
2457 0 : rOut.WriteInt16( aGradient.GetGradientStyle() );
2458 :
2459 : sal_uInt16 nTmp;
2460 :
2461 0 : nTmp = VCLTOSVCOL( aGradient.GetStartColor().GetRed() ); rOut.WriteUInt16( nTmp );
2462 0 : nTmp = VCLTOSVCOL( aGradient.GetStartColor().GetGreen() ); rOut.WriteUInt16( nTmp );
2463 0 : nTmp = VCLTOSVCOL( aGradient.GetStartColor().GetBlue() ); rOut.WriteUInt16( nTmp );
2464 0 : nTmp = VCLTOSVCOL( aGradient.GetEndColor().GetRed() ); rOut.WriteUInt16( nTmp );
2465 0 : nTmp = VCLTOSVCOL( aGradient.GetEndColor().GetGreen() ); rOut.WriteUInt16( nTmp );
2466 0 : nTmp = VCLTOSVCOL( aGradient.GetEndColor().GetBlue() ); rOut.WriteUInt16( nTmp );
2467 :
2468 0 : rOut.WriteInt32( aGradient.GetAngle() );
2469 0 : rOut.WriteUInt16( aGradient.GetBorder() );
2470 0 : rOut.WriteUInt16( aGradient.GetXOffset() );
2471 0 : rOut.WriteUInt16( aGradient.GetYOffset() );
2472 0 : rOut.WriteUInt16( aGradient.GetStartIntens() );
2473 0 : rOut.WriteUInt16( aGradient.GetEndIntens() );
2474 0 : rOut.WriteUInt16( aGradient.GetSteps() );
2475 : }
2476 :
2477 0 : return rOut;
2478 : }
2479 :
2480 37907 : const XGradient& XFillGradientItem::GetGradientValue() const // GetValue -> GetGradientValue
2481 : {
2482 37907 : if (!IsIndex())
2483 37907 : return aGradient;
2484 : // ToDo: This should fail. We never called this code with a table so this should always
2485 : // have failed. Thus, I'm thinking that XFillGradientItem can't be an Index.
2486 0 : return aGradient;
2487 : }
2488 :
2489 0 : sal_uInt16 XFillGradientItem::GetVersion( sal_uInt16 /*nFileFormatVersion*/) const
2490 : {
2491 : // !!! this version number also represents the version number of superclasses
2492 : // !!! (e.g. XFillFloatTransparenceItem); if you make any changes here,
2493 : // !!! the superclass is also affected
2494 0 : return 1;
2495 : }
2496 :
2497 0 : bool XFillGradientItem::GetPresentation
2498 : (
2499 : SfxItemPresentation /*ePres*/,
2500 : SfxMapUnit /*eCoreUnit*/,
2501 : SfxMapUnit /*ePresUnit*/,
2502 : OUString& rText, const IntlWrapper *
2503 : ) const
2504 : {
2505 0 : rText = GetName();
2506 0 : return true;
2507 : }
2508 :
2509 1365 : bool XFillGradientItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
2510 : {
2511 1365 : nMemberId &= ~CONVERT_TWIPS;
2512 1365 : switch ( nMemberId )
2513 : {
2514 : case 0:
2515 : {
2516 79 : uno::Sequence< beans::PropertyValue > aPropSeq( 2 );
2517 :
2518 79 : ::com::sun::star::awt::Gradient aGradient2;
2519 :
2520 79 : const XGradient& aXGradient = GetGradientValue();
2521 79 : aGradient2.Style = (::com::sun::star::awt::GradientStyle) aXGradient.GetGradientStyle();
2522 79 : aGradient2.StartColor = (sal_Int32)aXGradient.GetStartColor().GetColor();
2523 79 : aGradient2.EndColor = (sal_Int32)aXGradient.GetEndColor().GetColor();
2524 79 : aGradient2.Angle = (short)aXGradient.GetAngle();
2525 79 : aGradient2.Border = aXGradient.GetBorder();
2526 79 : aGradient2.XOffset = aXGradient.GetXOffset();
2527 79 : aGradient2.YOffset = aXGradient.GetYOffset();
2528 79 : aGradient2.StartIntensity = aXGradient.GetStartIntens();
2529 79 : aGradient2.EndIntensity = aXGradient.GetEndIntens();
2530 79 : aGradient2.StepCount = aXGradient.GetSteps();
2531 :
2532 158 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
2533 79 : aPropSeq[0].Name = "Name";
2534 79 : aPropSeq[0].Value = uno::makeAny( aApiName );
2535 79 : aPropSeq[1].Name = "FillGradient";
2536 79 : aPropSeq[1].Value = uno::makeAny( aGradient2 );
2537 79 : rVal = uno::makeAny( aPropSeq );
2538 158 : break;
2539 : }
2540 :
2541 : case MID_FILLGRADIENT:
2542 : {
2543 712 : const XGradient& aXGradient = GetGradientValue();
2544 712 : ::com::sun::star::awt::Gradient aGradient2;
2545 :
2546 712 : aGradient2.Style = (::com::sun::star::awt::GradientStyle) aXGradient.GetGradientStyle();
2547 712 : aGradient2.StartColor = (sal_Int32)aXGradient.GetStartColor().GetColor();
2548 712 : aGradient2.EndColor = (sal_Int32)aXGradient.GetEndColor().GetColor();
2549 712 : aGradient2.Angle = (short)aXGradient.GetAngle();
2550 712 : aGradient2.Border = aXGradient.GetBorder();
2551 712 : aGradient2.XOffset = aXGradient.GetXOffset();
2552 712 : aGradient2.YOffset = aXGradient.GetYOffset();
2553 712 : aGradient2.StartIntensity = aXGradient.GetStartIntens();
2554 712 : aGradient2.EndIntensity = aXGradient.GetEndIntens();
2555 712 : aGradient2.StepCount = aXGradient.GetSteps();
2556 :
2557 712 : rVal <<= aGradient2;
2558 712 : break;
2559 : }
2560 :
2561 : case MID_NAME:
2562 : {
2563 574 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
2564 574 : rVal <<= aApiName;
2565 574 : break;
2566 : }
2567 :
2568 0 : case MID_GRADIENT_STYLE: rVal <<= (sal_Int16)GetGradientValue().GetGradientStyle(); break;
2569 0 : case MID_GRADIENT_STARTCOLOR: rVal <<= (sal_Int32)GetGradientValue().GetStartColor().GetColor(); break;
2570 0 : case MID_GRADIENT_ENDCOLOR: rVal <<= (sal_Int32)GetGradientValue().GetEndColor().GetColor(); break;
2571 0 : case MID_GRADIENT_ANGLE: rVal <<= (sal_Int16)GetGradientValue().GetAngle(); break;
2572 0 : case MID_GRADIENT_BORDER: rVal <<= GetGradientValue().GetBorder(); break;
2573 0 : case MID_GRADIENT_XOFFSET: rVal <<= GetGradientValue().GetXOffset(); break;
2574 0 : case MID_GRADIENT_YOFFSET: rVal <<= GetGradientValue().GetYOffset(); break;
2575 0 : case MID_GRADIENT_STARTINTENSITY: rVal <<= GetGradientValue().GetStartIntens(); break;
2576 0 : case MID_GRADIENT_ENDINTENSITY: rVal <<= GetGradientValue().GetEndIntens(); break;
2577 0 : case MID_GRADIENT_STEPCOUNT: rVal <<= GetGradientValue().GetSteps(); break;
2578 :
2579 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
2580 : }
2581 :
2582 1365 : return true;
2583 : }
2584 :
2585 396 : bool XFillGradientItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
2586 : {
2587 396 : nMemberId &= ~CONVERT_TWIPS;
2588 :
2589 396 : switch ( nMemberId )
2590 : {
2591 : case 0:
2592 : {
2593 79 : uno::Sequence< beans::PropertyValue > aPropSeq;
2594 79 : ::com::sun::star::awt::Gradient aGradient2;
2595 158 : OUString aName;
2596 79 : bool bGradient( false );
2597 :
2598 79 : if ( rVal >>= aPropSeq )
2599 : {
2600 237 : for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
2601 : {
2602 158 : if ( aPropSeq[n].Name == "Name" )
2603 79 : aPropSeq[n].Value >>= aName;
2604 79 : else if ( aPropSeq[n].Name == "FillGradient" )
2605 : {
2606 79 : if ( aPropSeq[n].Value >>= aGradient2 )
2607 79 : bGradient = true;
2608 : }
2609 : }
2610 :
2611 79 : SetName( aName );
2612 79 : if ( bGradient )
2613 : {
2614 79 : XGradient aXGradient;
2615 :
2616 79 : aXGradient.SetGradientStyle( (css::awt::GradientStyle) aGradient2.Style );
2617 79 : aXGradient.SetStartColor( aGradient2.StartColor );
2618 79 : aXGradient.SetEndColor( aGradient2.EndColor );
2619 79 : aXGradient.SetAngle( aGradient2.Angle );
2620 79 : aXGradient.SetBorder( aGradient2.Border );
2621 79 : aXGradient.SetXOffset( aGradient2.XOffset );
2622 79 : aXGradient.SetYOffset( aGradient2.YOffset );
2623 79 : aXGradient.SetStartIntens( aGradient2.StartIntensity );
2624 79 : aXGradient.SetEndIntens( aGradient2.EndIntensity );
2625 79 : aXGradient.SetSteps( aGradient2.StepCount );
2626 :
2627 79 : SetGradientValue( aXGradient );
2628 : }
2629 :
2630 79 : return true;
2631 : }
2632 :
2633 79 : return false;
2634 : }
2635 :
2636 : case MID_NAME:
2637 : {
2638 0 : OUString aName;
2639 0 : if (!(rVal >>= aName ))
2640 0 : return false;
2641 0 : SetName( aName );
2642 0 : break;
2643 : }
2644 :
2645 : case MID_FILLGRADIENT:
2646 : {
2647 317 : ::com::sun::star::awt::Gradient aGradient2;
2648 317 : if(!(rVal >>= aGradient2))
2649 0 : return false;
2650 :
2651 317 : XGradient aXGradient;
2652 :
2653 317 : aXGradient.SetGradientStyle( (css::awt::GradientStyle) aGradient2.Style );
2654 317 : aXGradient.SetStartColor( aGradient2.StartColor );
2655 317 : aXGradient.SetEndColor( aGradient2.EndColor );
2656 317 : aXGradient.SetAngle( aGradient2.Angle );
2657 317 : aXGradient.SetBorder( aGradient2.Border );
2658 317 : aXGradient.SetXOffset( aGradient2.XOffset );
2659 317 : aXGradient.SetYOffset( aGradient2.YOffset );
2660 317 : aXGradient.SetStartIntens( aGradient2.StartIntensity );
2661 317 : aXGradient.SetEndIntens( aGradient2.EndIntensity );
2662 317 : aXGradient.SetSteps( aGradient2.StepCount );
2663 :
2664 317 : SetGradientValue( aXGradient );
2665 317 : break;
2666 : }
2667 :
2668 : case MID_GRADIENT_STARTCOLOR:
2669 : case MID_GRADIENT_ENDCOLOR:
2670 : {
2671 0 : sal_Int32 nVal = 0;
2672 0 : if(!(rVal >>= nVal ))
2673 0 : return false;
2674 :
2675 0 : XGradient aXGradient = GetGradientValue();
2676 :
2677 0 : if ( nMemberId == MID_GRADIENT_STARTCOLOR )
2678 0 : aXGradient.SetStartColor( nVal );
2679 : else
2680 0 : aXGradient.SetEndColor( nVal );
2681 0 : SetGradientValue( aXGradient );
2682 0 : break;
2683 : }
2684 :
2685 : case MID_GRADIENT_STYLE:
2686 : case MID_GRADIENT_ANGLE:
2687 : case MID_GRADIENT_BORDER:
2688 : case MID_GRADIENT_STARTINTENSITY:
2689 : case MID_GRADIENT_ENDINTENSITY:
2690 : case MID_GRADIENT_STEPCOUNT:
2691 : case MID_GRADIENT_XOFFSET:
2692 : case MID_GRADIENT_YOFFSET:
2693 : {
2694 0 : sal_Int16 nVal = sal_Int16();
2695 0 : if(!(rVal >>= nVal ))
2696 0 : return false;
2697 :
2698 0 : XGradient aXGradient = GetGradientValue();
2699 :
2700 0 : switch ( nMemberId )
2701 : {
2702 : case MID_GRADIENT_STYLE:
2703 0 : aXGradient.SetGradientStyle( (css::awt::GradientStyle)nVal ); break;
2704 : case MID_GRADIENT_ANGLE:
2705 0 : aXGradient.SetAngle( nVal ); break;
2706 : case MID_GRADIENT_BORDER:
2707 0 : aXGradient.SetBorder( nVal ); break;
2708 : case MID_GRADIENT_STARTINTENSITY:
2709 0 : aXGradient.SetStartIntens( nVal ); break;
2710 : case MID_GRADIENT_ENDINTENSITY:
2711 0 : aXGradient.SetEndIntens( nVal ); break;
2712 : case MID_GRADIENT_STEPCOUNT:
2713 0 : aXGradient.SetSteps( nVal ); break;
2714 : case MID_GRADIENT_XOFFSET:
2715 0 : aXGradient.SetXOffset( nVal ); break;
2716 : case MID_GRADIENT_YOFFSET:
2717 0 : aXGradient.SetYOffset( nVal ); break;
2718 : }
2719 :
2720 0 : SetGradientValue( aXGradient );
2721 0 : break;
2722 : }
2723 : }
2724 :
2725 317 : return true;
2726 : }
2727 :
2728 7334 : bool XFillGradientItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
2729 : {
2730 7334 : return static_cast<const XFillGradientItem*>(p1)->GetGradientValue() == static_cast<const XFillGradientItem*>(p2)->GetGradientValue();
2731 : }
2732 :
2733 7814 : XFillGradientItem* XFillGradientItem::checkForUniqueItem( SdrModel* pModel ) const
2734 : {
2735 7814 : if( pModel )
2736 : {
2737 : const OUString aUniqueName = NameOrIndex::CheckNamedItem(
2738 7316 : this, Which(), &pModel->GetItemPool(),
2739 7527 : pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
2740 : XFillGradientItem::CompareValueFunc, RID_SVXSTR_GRADIENT,
2741 22159 : pModel->GetPropertyList( XGRADIENT_LIST ) );
2742 :
2743 : // if the given name is not valid, replace it!
2744 7316 : if( aUniqueName != GetName() )
2745 179 : return new XFillGradientItem( aUniqueName, aGradient, Which() );
2746 : }
2747 :
2748 7635 : return NULL;
2749 : }
2750 :
2751 38087 : TYPEINIT1_AUTOFACTORY( XFillFloatTransparenceItem, XFillGradientItem );
2752 :
2753 52 : XFillFloatTransparenceItem::XFillFloatTransparenceItem() :
2754 52 : bEnabled( false )
2755 : {
2756 52 : SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2757 52 : }
2758 :
2759 0 : XFillFloatTransparenceItem::XFillFloatTransparenceItem(const OUString& rName, const XGradient& rGradient, bool bEnable ) :
2760 : XFillGradientItem ( rName, rGradient ),
2761 0 : bEnabled ( bEnable )
2762 : {
2763 0 : SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2764 0 : }
2765 :
2766 615 : XFillFloatTransparenceItem::XFillFloatTransparenceItem( const XFillFloatTransparenceItem& rItem ) :
2767 : XFillGradientItem ( rItem ),
2768 615 : bEnabled ( rItem.bEnabled )
2769 : {
2770 615 : SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2771 615 : }
2772 :
2773 4814 : XFillFloatTransparenceItem::XFillFloatTransparenceItem(SfxItemPool* /*pPool*/, const XGradient& rTheGradient, bool bEnable )
2774 : : XFillGradientItem ( -1, rTheGradient ),
2775 4814 : bEnabled ( bEnable )
2776 : {
2777 4814 : SetWhich( XATTR_FILLFLOATTRANSPARENCE );
2778 4814 : }
2779 :
2780 388 : bool XFillFloatTransparenceItem::operator==( const SfxPoolItem& rItem ) const
2781 : {
2782 488 : return ( NameOrIndex::operator==(rItem) ) &&
2783 488 : ( GetGradientValue() == static_cast<const XFillGradientItem&>(rItem).GetGradientValue() ) &&
2784 488 : ( bEnabled == static_cast<const XFillFloatTransparenceItem&>(rItem).bEnabled );
2785 : }
2786 :
2787 615 : SfxPoolItem* XFillFloatTransparenceItem::Clone( SfxItemPool* /*pPool*/) const
2788 : {
2789 615 : return new XFillFloatTransparenceItem( *this );
2790 : }
2791 :
2792 0 : sal_uInt16 XFillFloatTransparenceItem::GetVersion( sal_uInt16 nFileFormatVersion ) const
2793 : {
2794 : // !!! if version number of this object must be increased, please !!!
2795 : // !!! increase version number of base class XFillGradientItem !!!
2796 0 : return XFillGradientItem::GetVersion( nFileFormatVersion );
2797 : }
2798 :
2799 569 : bool XFillFloatTransparenceItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
2800 : {
2801 569 : return XFillGradientItem::QueryValue( rVal, nMemberId );
2802 : }
2803 :
2804 49 : bool XFillFloatTransparenceItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
2805 : {
2806 49 : return XFillGradientItem::PutValue( rVal, nMemberId );
2807 : }
2808 :
2809 0 : bool XFillFloatTransparenceItem::GetPresentation( SfxItemPresentation ePres,
2810 : SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit,
2811 : OUString& rText,
2812 : const IntlWrapper * pIntlWrapper ) const
2813 : {
2814 0 : return XFillGradientItem::GetPresentation( ePres, eCoreUnit, ePresUnit, rText, pIntlWrapper );
2815 : }
2816 :
2817 2912 : bool XFillFloatTransparenceItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
2818 : {
2819 5824 : return static_cast<const XFillFloatTransparenceItem*>(p1)->IsEnabled() == static_cast<const XFillFloatTransparenceItem*>(p2)->IsEnabled() &&
2820 5824 : static_cast<const XFillFloatTransparenceItem*>(p1)->GetGradientValue() == static_cast<const XFillFloatTransparenceItem*>(p2)->GetGradientValue();
2821 : }
2822 :
2823 9358 : XFillFloatTransparenceItem* XFillFloatTransparenceItem::checkForUniqueItem( SdrModel* pModel ) const
2824 : {
2825 : // #85953# unique name only necessary when enabled
2826 9358 : if(IsEnabled())
2827 : {
2828 2942 : if( pModel )
2829 : {
2830 : const OUString aUniqueName = NameOrIndex::CheckNamedItem( this,
2831 : XATTR_FILLFLOATTRANSPARENCE,
2832 2912 : &pModel->GetItemPool(),
2833 2916 : pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
2834 : XFillFloatTransparenceItem::CompareValueFunc,
2835 : RID_SVXSTR_TRASNGR0,
2836 8740 : XPropertyListRef() );
2837 :
2838 : // if the given name is not valid, replace it!
2839 2912 : if( aUniqueName != GetName() )
2840 : {
2841 0 : return new XFillFloatTransparenceItem( aUniqueName, GetGradientValue(), true );
2842 2912 : }
2843 : }
2844 : }
2845 : else
2846 : {
2847 : // #85953# if disabled, force name to empty string
2848 6416 : if( !GetName().isEmpty() )
2849 : {
2850 0 : return new XFillFloatTransparenceItem(OUString(), GetGradientValue(), false);
2851 : }
2852 : }
2853 :
2854 9358 : return NULL;
2855 : }
2856 :
2857 5324 : XHatch::XHatch(const Color& rCol, css::drawing::HatchStyle eTheStyle, long nTheDistance,
2858 : long nTheAngle) :
2859 : eStyle(eTheStyle),
2860 : aColor(rCol),
2861 : nDistance(nTheDistance),
2862 5324 : nAngle(nTheAngle)
2863 : {
2864 5324 : }
2865 :
2866 12560 : bool XHatch::operator==(const XHatch& rHatch) const
2867 : {
2868 23532 : return ( eStyle == rHatch.eStyle &&
2869 21266 : aColor == rHatch.aColor &&
2870 32685 : nDistance == rHatch.nDistance &&
2871 22391 : nAngle == rHatch.nAngle );
2872 : }
2873 :
2874 30945 : TYPEINIT1_AUTOFACTORY(XFillHatchItem, NameOrIndex);
2875 :
2876 143 : XFillHatchItem::XFillHatchItem(const OUString& rName,
2877 : const XHatch& rTheHatch) :
2878 : NameOrIndex(XATTR_FILLHATCH, rName),
2879 143 : aHatch(rTheHatch)
2880 : {
2881 143 : }
2882 :
2883 960 : XFillHatchItem::XFillHatchItem(const XFillHatchItem& rItem) :
2884 : NameOrIndex(rItem),
2885 960 : aHatch(rItem.aHatch)
2886 : {
2887 960 : }
2888 :
2889 0 : XFillHatchItem::XFillHatchItem(SvStream& rIn) :
2890 : NameOrIndex(XATTR_FILLHATCH, rIn),
2891 0 : aHatch(COL_BLACK)
2892 : {
2893 0 : if (!IsIndex())
2894 : {
2895 : sal_uInt16 nRed;
2896 : sal_uInt16 nGreen;
2897 : sal_uInt16 nBlue;
2898 : sal_Int16 nITemp;
2899 : sal_Int32 nLTemp;
2900 :
2901 0 : rIn.ReadInt16( nITemp ); aHatch.SetHatchStyle((css::drawing::HatchStyle)nITemp);
2902 0 : rIn.ReadUInt16( nRed );
2903 0 : rIn.ReadUInt16( nGreen );
2904 0 : rIn.ReadUInt16( nBlue );
2905 :
2906 0 : Color aCol;
2907 0 : aCol = Color( (sal_uInt8)( nRed >> 8 ), (sal_uInt8)( nGreen >> 8 ), (sal_uInt8)( nBlue >> 8 ) );
2908 0 : aHatch.SetColor(aCol);
2909 0 : rIn.ReadInt32( nLTemp ); aHatch.SetDistance(nLTemp);
2910 0 : rIn.ReadInt32( nLTemp ); aHatch.SetAngle(nLTemp);
2911 : }
2912 0 : }
2913 :
2914 5069 : XFillHatchItem::XFillHatchItem(SfxItemPool* /*pPool*/, const XHatch& rTheHatch)
2915 : : NameOrIndex( XATTR_FILLHATCH, -1 ),
2916 5069 : aHatch(rTheHatch)
2917 : {
2918 5069 : }
2919 :
2920 960 : SfxPoolItem* XFillHatchItem::Clone(SfxItemPool* /*pPool*/) const
2921 : {
2922 960 : return new XFillHatchItem(*this);
2923 : }
2924 :
2925 3847 : bool XFillHatchItem::operator==(const SfxPoolItem& rItem) const
2926 : {
2927 4237 : return ( NameOrIndex::operator==(rItem) &&
2928 4237 : aHatch == static_cast<const XFillHatchItem&>(rItem).aHatch );
2929 : }
2930 :
2931 0 : SfxPoolItem* XFillHatchItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2932 : {
2933 0 : return new XFillHatchItem(rIn);
2934 : }
2935 :
2936 0 : SvStream& XFillHatchItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
2937 : {
2938 0 : NameOrIndex::Store( rOut, nItemVersion );
2939 :
2940 0 : if (!IsIndex())
2941 : {
2942 0 : rOut.WriteInt16( aHatch.GetHatchStyle() );
2943 :
2944 : sal_uInt16 nTmp;
2945 0 : nTmp = VCLTOSVCOL( aHatch.GetColor().GetRed() ); rOut.WriteUInt16( nTmp );
2946 0 : nTmp = VCLTOSVCOL( aHatch.GetColor().GetGreen() ); rOut.WriteUInt16( nTmp );
2947 0 : nTmp = VCLTOSVCOL( aHatch.GetColor().GetBlue() ); rOut.WriteUInt16( nTmp );
2948 :
2949 0 : rOut.WriteInt32( aHatch.GetDistance() );
2950 0 : rOut.WriteInt32( aHatch.GetAngle() );
2951 : }
2952 :
2953 0 : return rOut;
2954 : }
2955 :
2956 :
2957 0 : bool XFillHatchItem::GetPresentation
2958 : (
2959 : SfxItemPresentation /*ePres*/,
2960 : SfxMapUnit /*eCoreUnit*/,
2961 : SfxMapUnit /*ePresUnit*/,
2962 : OUString& rText, const IntlWrapper *
2963 : ) const
2964 : {
2965 0 : rText = GetName();
2966 0 : return true;
2967 : }
2968 :
2969 0 : bool XFillHatchItem::HasMetrics() const
2970 : {
2971 0 : return true;
2972 : }
2973 :
2974 0 : bool XFillHatchItem::ScaleMetrics(long nMul, long nDiv)
2975 : {
2976 0 : aHatch.SetDistance( ScaleMetricValue( aHatch.GetDistance(), nMul, nDiv ) );
2977 0 : return true;
2978 : }
2979 :
2980 712 : bool XFillHatchItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
2981 : {
2982 712 : nMemberId &= ~CONVERT_TWIPS;
2983 :
2984 712 : switch ( nMemberId )
2985 : {
2986 : case 0:
2987 : {
2988 79 : uno::Sequence< beans::PropertyValue > aPropSeq( 2 );
2989 :
2990 79 : ::com::sun::star::drawing::Hatch aUnoHatch;
2991 :
2992 79 : aUnoHatch.Style = (::com::sun::star::drawing::HatchStyle)aHatch.GetHatchStyle();
2993 79 : aUnoHatch.Color = aHatch.GetColor().GetColor();
2994 79 : aUnoHatch.Distance = aHatch.GetDistance();
2995 79 : aUnoHatch.Angle = aHatch.GetAngle();
2996 :
2997 158 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
2998 79 : aPropSeq[0].Name = "Name";
2999 79 : aPropSeq[0].Value = uno::makeAny( aApiName );
3000 79 : aPropSeq[1].Name = "FillHatch";
3001 79 : aPropSeq[1].Value = uno::makeAny( aUnoHatch );
3002 79 : rVal = uno::makeAny( aPropSeq );
3003 158 : break;
3004 : }
3005 :
3006 : case MID_FILLHATCH:
3007 : {
3008 335 : ::com::sun::star::drawing::Hatch aUnoHatch;
3009 :
3010 335 : aUnoHatch.Style = (::com::sun::star::drawing::HatchStyle)aHatch.GetHatchStyle();
3011 335 : aUnoHatch.Color = aHatch.GetColor().GetColor();
3012 335 : aUnoHatch.Distance = aHatch.GetDistance();
3013 335 : aUnoHatch.Angle = aHatch.GetAngle();
3014 335 : rVal <<= aUnoHatch;
3015 335 : break;
3016 : }
3017 :
3018 : case MID_NAME:
3019 : {
3020 298 : OUString aApiName = SvxUnogetApiNameForItem(Which(), GetName());
3021 298 : rVal <<= aApiName;
3022 298 : break;
3023 : }
3024 :
3025 : case MID_HATCH_STYLE:
3026 0 : rVal <<= (::com::sun::star::drawing::HatchStyle)aHatch.GetHatchStyle(); break;
3027 : case MID_HATCH_COLOR:
3028 0 : rVal <<= (sal_Int32)aHatch.GetColor().GetColor(); break;
3029 : case MID_HATCH_DISTANCE:
3030 0 : rVal <<= aHatch.GetDistance(); break;
3031 : case MID_HATCH_ANGLE:
3032 0 : rVal <<= aHatch.GetAngle(); break;
3033 :
3034 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
3035 : }
3036 :
3037 712 : return true;
3038 : }
3039 :
3040 261 : bool XFillHatchItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
3041 : {
3042 261 : nMemberId &= ~CONVERT_TWIPS;
3043 :
3044 261 : switch ( nMemberId )
3045 : {
3046 : case 0:
3047 : {
3048 79 : uno::Sequence< beans::PropertyValue > aPropSeq;
3049 79 : ::com::sun::star::drawing::Hatch aUnoHatch;
3050 158 : OUString aName;
3051 79 : bool bHatch( false );
3052 :
3053 79 : if ( rVal >>= aPropSeq )
3054 : {
3055 237 : for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
3056 : {
3057 158 : if ( aPropSeq[n].Name == "Name" )
3058 79 : aPropSeq[n].Value >>= aName;
3059 79 : else if ( aPropSeq[n].Name == "FillHatch" )
3060 : {
3061 79 : if ( aPropSeq[n].Value >>= aUnoHatch )
3062 79 : bHatch = true;
3063 : }
3064 : }
3065 :
3066 79 : SetName( aName );
3067 79 : if ( bHatch )
3068 : {
3069 79 : aHatch.SetHatchStyle( (css::drawing::HatchStyle)aUnoHatch.Style );
3070 79 : aHatch.SetColor( aUnoHatch.Color );
3071 79 : aHatch.SetDistance( aUnoHatch.Distance );
3072 79 : aHatch.SetAngle( aUnoHatch.Angle );
3073 : }
3074 :
3075 79 : return true;
3076 : }
3077 :
3078 79 : return false;
3079 : }
3080 :
3081 : case MID_FILLHATCH:
3082 : {
3083 182 : ::com::sun::star::drawing::Hatch aUnoHatch;
3084 182 : if(!(rVal >>= aUnoHatch))
3085 0 : return false;
3086 :
3087 182 : aHatch.SetHatchStyle( (css::drawing::HatchStyle)aUnoHatch.Style );
3088 182 : aHatch.SetColor( aUnoHatch.Color );
3089 182 : aHatch.SetDistance( aUnoHatch.Distance );
3090 182 : aHatch.SetAngle( aUnoHatch.Angle );
3091 182 : break;
3092 : }
3093 :
3094 : case MID_NAME:
3095 : {
3096 0 : OUString aName;
3097 0 : if (!(rVal >>= aName ))
3098 0 : return false;
3099 0 : SetName( aName );
3100 0 : break;
3101 : }
3102 :
3103 : case MID_HATCH_STYLE:
3104 : {
3105 0 : sal_Int16 nVal = sal_Int16();
3106 0 : if (!(rVal >>= nVal ))
3107 0 : return false;
3108 0 : aHatch.SetHatchStyle( (css::drawing::HatchStyle)nVal );
3109 0 : break;
3110 : }
3111 :
3112 : case MID_HATCH_COLOR:
3113 : case MID_HATCH_DISTANCE:
3114 : case MID_HATCH_ANGLE:
3115 : {
3116 0 : sal_Int32 nVal = 0;
3117 0 : if (!(rVal >>= nVal ))
3118 0 : return false;
3119 :
3120 0 : if ( nMemberId == MID_HATCH_COLOR )
3121 0 : aHatch.SetColor( nVal );
3122 0 : else if ( nMemberId == MID_HATCH_DISTANCE )
3123 0 : aHatch.SetDistance( nVal );
3124 : else
3125 0 : aHatch.SetAngle( nVal );
3126 0 : break;
3127 : }
3128 :
3129 0 : default: OSL_FAIL("Wrong MemberId!"); return false;
3130 : }
3131 :
3132 182 : return true;
3133 : }
3134 :
3135 10760 : bool XFillHatchItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
3136 : {
3137 10760 : return static_cast<const XFillHatchItem*>(p1)->GetHatchValue() == static_cast<const XFillHatchItem*>(p2)->GetHatchValue();
3138 : }
3139 :
3140 9688 : XFillHatchItem* XFillHatchItem::checkForUniqueItem( SdrModel* pModel ) const
3141 : {
3142 9688 : if( pModel )
3143 : {
3144 : const OUString aUniqueName = NameOrIndex::CheckNamedItem(
3145 9630 : this, XATTR_FILLHATCH, &pModel->GetItemPool(),
3146 9753 : pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
3147 : XFillHatchItem::CompareValueFunc, RID_SVXSTR_HATCH10,
3148 29013 : pModel->GetPropertyList( XHATCH_LIST ) );
3149 :
3150 : // if the given name is not valid, replace it!
3151 9630 : if( aUniqueName != GetName() )
3152 141 : return new XFillHatchItem( aUniqueName, aHatch );
3153 : }
3154 :
3155 9547 : return NULL;
3156 : }
3157 :
3158 : // --- form text attributes ---
3159 :
3160 14182 : TYPEINIT1_AUTOFACTORY(XFormTextStyleItem, SfxEnumItem);
3161 :
3162 4814 : XFormTextStyleItem::XFormTextStyleItem(XFormTextStyle eTheStyle) :
3163 4814 : SfxEnumItem(XATTR_FORMTXTSTYLE, sal::static_int_cast< sal_uInt16 >(eTheStyle))
3164 : {
3165 4814 : }
3166 :
3167 0 : XFormTextStyleItem::XFormTextStyleItem(SvStream& rIn) :
3168 0 : SfxEnumItem(XATTR_FORMTXTSTYLE, rIn)
3169 : {
3170 0 : }
3171 :
3172 32 : SfxPoolItem* XFormTextStyleItem::Clone(SfxItemPool* /*pPool*/) const
3173 : {
3174 32 : return new XFormTextStyleItem( *this );
3175 : }
3176 :
3177 0 : SfxPoolItem* XFormTextStyleItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3178 : {
3179 0 : return new XFormTextStyleItem(rIn);
3180 : }
3181 :
3182 0 : sal_uInt16 XFormTextStyleItem::GetValueCount() const
3183 : {
3184 0 : return 5;
3185 : }
3186 :
3187 0 : bool XFormTextStyleItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
3188 : {
3189 0 : rVal <<= (sal_Int32)GetValue();
3190 0 : return true;
3191 : }
3192 :
3193 0 : bool XFormTextStyleItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
3194 : {
3195 0 : sal_Int32 nValue = 0;
3196 0 : rVal >>= nValue;
3197 0 : SetValue(sal::static_int_cast< sal_uInt16 >(nValue));
3198 :
3199 0 : return true;
3200 : }
3201 :
3202 14182 : TYPEINIT1_AUTOFACTORY(XFormTextAdjustItem, SfxEnumItem);
3203 :
3204 4814 : XFormTextAdjustItem::XFormTextAdjustItem(XFormTextAdjust eTheAdjust) :
3205 4814 : SfxEnumItem(XATTR_FORMTXTADJUST, sal::static_int_cast< sal_uInt16 >(eTheAdjust))
3206 : {
3207 4814 : }
3208 :
3209 0 : XFormTextAdjustItem::XFormTextAdjustItem(SvStream& rIn) :
3210 0 : SfxEnumItem(XATTR_FORMTXTADJUST, rIn)
3211 : {
3212 0 : }
3213 :
3214 32 : SfxPoolItem* XFormTextAdjustItem::Clone(SfxItemPool* /*pPool*/) const
3215 : {
3216 32 : return new XFormTextAdjustItem( *this );
3217 : }
3218 :
3219 0 : SfxPoolItem* XFormTextAdjustItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3220 : {
3221 0 : return new XFormTextAdjustItem(rIn);
3222 : }
3223 :
3224 0 : sal_uInt16 XFormTextAdjustItem::GetValueCount() const
3225 : {
3226 0 : return 4;
3227 : }
3228 :
3229 0 : bool XFormTextAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
3230 : {
3231 0 : rVal <<= (sal_Int32)GetValue();
3232 0 : return true;
3233 : }
3234 :
3235 0 : bool XFormTextAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
3236 : {
3237 0 : sal_Int32 nValue = 0;
3238 0 : rVal >>= nValue;
3239 0 : SetValue(sal::static_int_cast< sal_uInt16 >(nValue));
3240 :
3241 0 : return true;
3242 : }
3243 :
3244 14182 : TYPEINIT1_AUTOFACTORY(XFormTextDistanceItem, SfxMetricItem);
3245 :
3246 4814 : XFormTextDistanceItem::XFormTextDistanceItem(long nDist) :
3247 4814 : SfxMetricItem(XATTR_FORMTXTDISTANCE, nDist)
3248 : {
3249 4814 : }
3250 :
3251 0 : XFormTextDistanceItem::XFormTextDistanceItem(SvStream& rIn) :
3252 0 : SfxMetricItem(XATTR_FORMTXTDISTANCE, rIn)
3253 : {
3254 0 : }
3255 :
3256 32 : SfxPoolItem* XFormTextDistanceItem::Clone(SfxItemPool* /*pPool*/) const
3257 : {
3258 32 : return new XFormTextDistanceItem(*this);
3259 : }
3260 :
3261 0 : SfxPoolItem* XFormTextDistanceItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3262 : {
3263 0 : return new XFormTextDistanceItem(rIn);
3264 : }
3265 :
3266 14182 : TYPEINIT1_AUTOFACTORY(XFormTextStartItem, SfxMetricItem);
3267 :
3268 4814 : XFormTextStartItem::XFormTextStartItem(long nStart) :
3269 4814 : SfxMetricItem(XATTR_FORMTXTSTART, nStart)
3270 : {
3271 4814 : }
3272 :
3273 0 : XFormTextStartItem::XFormTextStartItem(SvStream& rIn) :
3274 0 : SfxMetricItem(XATTR_FORMTXTSTART, rIn)
3275 : {
3276 0 : }
3277 :
3278 32 : SfxPoolItem* XFormTextStartItem::Clone(SfxItemPool* /*pPool*/) const
3279 : {
3280 32 : return new XFormTextStartItem(*this);
3281 : }
3282 :
3283 0 : SfxPoolItem* XFormTextStartItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3284 : {
3285 0 : return new XFormTextStartItem(rIn);
3286 : }
3287 :
3288 14182 : TYPEINIT1_AUTOFACTORY(XFormTextMirrorItem, SfxBoolItem);
3289 :
3290 4814 : XFormTextMirrorItem::XFormTextMirrorItem(bool bMirror) :
3291 4814 : SfxBoolItem(XATTR_FORMTXTMIRROR, bMirror)
3292 : {
3293 4814 : }
3294 :
3295 0 : XFormTextMirrorItem::XFormTextMirrorItem(SvStream& rIn) :
3296 0 : SfxBoolItem(XATTR_FORMTXTMIRROR, rIn)
3297 : {
3298 0 : }
3299 :
3300 32 : SfxPoolItem* XFormTextMirrorItem::Clone(SfxItemPool* /*pPool*/) const
3301 : {
3302 32 : return new XFormTextMirrorItem(*this);
3303 : }
3304 :
3305 0 : SfxPoolItem* XFormTextMirrorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3306 : {
3307 0 : return new XFormTextMirrorItem(rIn);
3308 : }
3309 :
3310 14182 : TYPEINIT1_AUTOFACTORY(XFormTextOutlineItem, SfxBoolItem);
3311 :
3312 4814 : XFormTextOutlineItem::XFormTextOutlineItem(bool bOutline) :
3313 4814 : SfxBoolItem(XATTR_FORMTXTOUTLINE, bOutline)
3314 : {
3315 4814 : }
3316 :
3317 0 : XFormTextOutlineItem::XFormTextOutlineItem(SvStream& rIn) :
3318 0 : SfxBoolItem(XATTR_FORMTXTOUTLINE, rIn)
3319 : {
3320 0 : }
3321 :
3322 32 : SfxPoolItem* XFormTextOutlineItem::Clone(SfxItemPool* /*pPool*/) const
3323 : {
3324 32 : return new XFormTextOutlineItem(*this);
3325 : }
3326 :
3327 0 : SfxPoolItem* XFormTextOutlineItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3328 : {
3329 0 : return new XFormTextOutlineItem(rIn);
3330 : }
3331 :
3332 14182 : TYPEINIT1_AUTOFACTORY(XFormTextShadowItem, SfxEnumItem);
3333 :
3334 4814 : XFormTextShadowItem::XFormTextShadowItem(XFormTextShadow eFormTextShadow) :
3335 : SfxEnumItem(
3336 4814 : XATTR_FORMTXTSHADOW, sal::static_int_cast< sal_uInt16 >(eFormTextShadow))
3337 : {
3338 4814 : }
3339 :
3340 0 : XFormTextShadowItem::XFormTextShadowItem(SvStream& rIn) :
3341 0 : SfxEnumItem(XATTR_FORMTXTSHADOW, rIn)
3342 : {
3343 0 : }
3344 :
3345 32 : SfxPoolItem* XFormTextShadowItem::Clone(SfxItemPool* /*pPool*/) const
3346 : {
3347 32 : return new XFormTextShadowItem( *this );
3348 : }
3349 :
3350 0 : SfxPoolItem* XFormTextShadowItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3351 : {
3352 0 : return new XFormTextShadowItem(rIn);
3353 : }
3354 :
3355 0 : sal_uInt16 XFormTextShadowItem::GetValueCount() const
3356 : {
3357 0 : return 3;
3358 : }
3359 :
3360 0 : bool XFormTextShadowItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
3361 : {
3362 0 : rVal <<= (sal_Int32)GetValue();
3363 0 : return true;
3364 : }
3365 :
3366 0 : bool XFormTextShadowItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
3367 : {
3368 0 : sal_Int32 nValue = 0;
3369 0 : rVal >>= nValue;
3370 0 : SetValue(sal::static_int_cast< sal_uInt16 >(nValue));
3371 :
3372 0 : return true;
3373 : }
3374 :
3375 14182 : TYPEINIT1_AUTOFACTORY(XFormTextShadowColorItem, XColorItem);
3376 :
3377 4814 : XFormTextShadowColorItem::XFormTextShadowColorItem(const OUString& rName,
3378 : const Color& rTheColor) :
3379 4814 : XColorItem(XATTR_FORMTXTSHDWCOLOR, rName, rTheColor)
3380 : {
3381 4814 : }
3382 :
3383 0 : XFormTextShadowColorItem::XFormTextShadowColorItem(SvStream& rIn) :
3384 0 : XColorItem(XATTR_FORMTXTSHDWCOLOR, rIn)
3385 : {
3386 0 : }
3387 :
3388 32 : SfxPoolItem* XFormTextShadowColorItem::Clone(SfxItemPool* /*pPool*/) const
3389 : {
3390 32 : return new XFormTextShadowColorItem(*this);
3391 : }
3392 :
3393 0 : SfxPoolItem* XFormTextShadowColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3394 : {
3395 0 : return new XFormTextShadowColorItem(rIn);
3396 : }
3397 :
3398 14182 : TYPEINIT1_AUTOFACTORY(XFormTextShadowXValItem, SfxMetricItem);
3399 :
3400 4814 : XFormTextShadowXValItem::XFormTextShadowXValItem(long nVal) :
3401 4814 : SfxMetricItem(XATTR_FORMTXTSHDWXVAL, nVal)
3402 : {
3403 4814 : }
3404 :
3405 0 : XFormTextShadowXValItem::XFormTextShadowXValItem(SvStream& rIn) :
3406 0 : SfxMetricItem(XATTR_FORMTXTSHDWXVAL, rIn)
3407 : {
3408 0 : }
3409 :
3410 32 : SfxPoolItem* XFormTextShadowXValItem::Clone(SfxItemPool* /*pPool*/) const
3411 : {
3412 32 : return new XFormTextShadowXValItem(*this);
3413 : }
3414 :
3415 0 : SfxPoolItem* XFormTextShadowXValItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3416 : {
3417 0 : return new XFormTextShadowXValItem(rIn);
3418 : }
3419 :
3420 14182 : TYPEINIT1_AUTOFACTORY(XFormTextShadowYValItem, SfxMetricItem);
3421 :
3422 4814 : XFormTextShadowYValItem::XFormTextShadowYValItem(long nVal) :
3423 4814 : SfxMetricItem(XATTR_FORMTXTSHDWYVAL, nVal)
3424 : {
3425 4814 : }
3426 :
3427 0 : XFormTextShadowYValItem::XFormTextShadowYValItem(SvStream& rIn) :
3428 0 : SfxMetricItem(XATTR_FORMTXTSHDWYVAL, rIn)
3429 : {
3430 0 : }
3431 :
3432 32 : SfxPoolItem* XFormTextShadowYValItem::Clone(SfxItemPool* /*pPool*/) const
3433 : {
3434 32 : return new XFormTextShadowYValItem(*this);
3435 : }
3436 :
3437 0 : SfxPoolItem* XFormTextShadowYValItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3438 : {
3439 0 : return new XFormTextShadowYValItem(rIn);
3440 : }
3441 :
3442 14182 : TYPEINIT1_AUTOFACTORY(XFormTextHideFormItem, SfxBoolItem);
3443 :
3444 4814 : XFormTextHideFormItem::XFormTextHideFormItem(bool bHide) :
3445 4814 : SfxBoolItem(XATTR_FORMTXTHIDEFORM, bHide)
3446 : {
3447 4814 : }
3448 :
3449 0 : XFormTextHideFormItem::XFormTextHideFormItem(SvStream& rIn) :
3450 0 : SfxBoolItem(XATTR_FORMTXTHIDEFORM, rIn)
3451 : {
3452 0 : }
3453 :
3454 32 : SfxPoolItem* XFormTextHideFormItem::Clone(SfxItemPool* /*pPool*/) const
3455 : {
3456 32 : return new XFormTextHideFormItem(*this);
3457 : }
3458 :
3459 0 : SfxPoolItem* XFormTextHideFormItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3460 : {
3461 0 : return new XFormTextHideFormItem(rIn);
3462 : }
3463 :
3464 : // --- SetItems ---
3465 :
3466 14068 : TYPEINIT1(XLineAttrSetItem, SfxSetItem);
3467 :
3468 : /// a line attribute set item
3469 4814 : XLineAttrSetItem::XLineAttrSetItem( SfxItemSet* pItemSet ) :
3470 4814 : SfxSetItem( XATTRSET_LINE, pItemSet)
3471 : {
3472 4814 : }
3473 :
3474 0 : XLineAttrSetItem::XLineAttrSetItem( SfxItemPool* pItemPool ) :
3475 : SfxSetItem( XATTRSET_LINE,
3476 0 : new SfxItemSet( *pItemPool, XATTR_LINE_FIRST, XATTR_LINE_LAST))
3477 : {
3478 0 : }
3479 :
3480 0 : XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr ) :
3481 0 : SfxSetItem( rLineAttr )
3482 : {
3483 0 : }
3484 :
3485 191 : XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr,
3486 : SfxItemPool* pItemPool) :
3487 191 : SfxSetItem( rLineAttr, pItemPool )
3488 : {
3489 191 : }
3490 :
3491 191 : SfxPoolItem* XLineAttrSetItem::Clone( SfxItemPool* pPool ) const
3492 : {
3493 191 : return new XLineAttrSetItem( *this, pPool );
3494 : }
3495 :
3496 : /// create a set item out of a stream
3497 0 : SfxPoolItem* XLineAttrSetItem::Create( SvStream& rStream, sal_uInt16 /*nVersion*/) const
3498 : {
3499 0 : SfxItemSet *pSet2 = new SfxItemSet( *GetItemSet().GetPool(),
3500 0 : XATTR_LINE_FIRST, XATTR_LINE_LAST);
3501 0 : pSet2->Load( rStream );
3502 0 : return new XLineAttrSetItem( pSet2 );
3503 : }
3504 :
3505 : /// save a set item in a stream
3506 0 : SvStream& XLineAttrSetItem::Store( SvStream& rStream, sal_uInt16 nItemVersion ) const
3507 : {
3508 0 : return SfxSetItem::Store( rStream, nItemVersion );
3509 : }
3510 :
3511 :
3512 14049 : TYPEINIT1(XFillAttrSetItem, SfxSetItem);
3513 :
3514 : /// fill attribute set item
3515 4814 : XFillAttrSetItem::XFillAttrSetItem( SfxItemSet* pItemSet ) :
3516 4814 : SfxSetItem( XATTRSET_FILL, pItemSet)
3517 : {
3518 4814 : }
3519 :
3520 0 : XFillAttrSetItem::XFillAttrSetItem( SfxItemPool* pItemPool ) :
3521 : SfxSetItem( XATTRSET_FILL,
3522 0 : new SfxItemSet( *pItemPool, XATTR_FILL_FIRST, XATTR_FILL_LAST))
3523 : {
3524 0 : }
3525 :
3526 0 : XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr ) :
3527 0 : SfxSetItem( rFillAttr )
3528 : {
3529 0 : }
3530 :
3531 191 : XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr,
3532 : SfxItemPool* pItemPool ) :
3533 191 : SfxSetItem( rFillAttr, pItemPool )
3534 : {
3535 191 : }
3536 :
3537 191 : SfxPoolItem* XFillAttrSetItem::Clone( SfxItemPool* pPool ) const
3538 : {
3539 191 : return new XFillAttrSetItem( *this, pPool );
3540 : }
3541 :
3542 : /// create a set item out of a stream
3543 0 : SfxPoolItem* XFillAttrSetItem::Create( SvStream& rStream, sal_uInt16 /*nVersion*/) const
3544 : {
3545 0 : SfxItemSet *pSet2 = new SfxItemSet( *GetItemSet().GetPool(),
3546 0 : XATTR_FILL_FIRST, XATTR_FILL_LAST);
3547 0 : pSet2->Load( rStream );
3548 0 : return new XFillAttrSetItem( pSet2 );
3549 : }
3550 :
3551 : /// save a set item in a stream
3552 0 : SvStream& XFillAttrSetItem::Store( SvStream& rStream, sal_uInt16 nItemVersion ) const
3553 : {
3554 0 : return SfxSetItem::Store( rStream, nItemVersion );
3555 435 : }
3556 :
3557 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
