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