xref: /aoo42x/main/svx/source/xoutdev/xattr.cxx (revision ae2dc0fa)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26 
27 // include ---------------------------------------------------------------
28 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
29 #include <com/sun/star/drawing/Hatch.hpp>
30 #include <com/sun/star/drawing/LineStyle.hpp>
31 #include <com/sun/star/drawing/LineDash.hpp>
32 #include <com/sun/star/drawing/DashStyle.hpp>
33 #include <com/sun/star/awt/Point.hpp>
34 #include <com/sun/star/drawing/PointSequence.hpp>
35 #include <com/sun/star/drawing/FillStyle.hpp>
36 #include <com/sun/star/awt/Gradient.hpp>
37 #include <com/sun/star/uno/Sequence.hxx>
38 #include <com/sun/star/beans/PropertyValue.hpp>
39 #include <svl/itempool.hxx>
40 #include <editeng/memberids.hrc>
41 #include <tools/stream.hxx>
42 
43 #include "svx/unoapi.hxx"
44 #include <svl/style.hxx>
45 #include "unopolyhelper.hxx"
46 
47 #include <tools/bigint.hxx>
48 #include <svl/itemset.hxx>
49 #include <svx/dialogs.hrc>
50 #include "svx/svdstr.hrc"
51 #include "svx/xattr.hxx"
52 #include <svx/xtable.hxx>
53 #include <svx/dialmgr.hxx>
54 #include <editeng/itemtype.hxx>
55 #include <svx/xdef.hxx>
56 #include <svx/unomid.hxx>
57 #include <svx/svdmodel.hxx>
58 #include <basegfx/polygon/b2dpolygon.hxx>
59 #include <basegfx/point/b2dpoint.hxx>
60 #include <basegfx/vector/b2dvector.hxx>
61 
62 #include <stdio.h>
63 
64 using namespace ::rtl;
65 using namespace ::com::sun::star;
66 
67 #define GLOBALOVERFLOW
68 
69 #define TWIP_TO_MM100(TWIP)     ((TWIP) >= 0 ? (((TWIP)*127L+36L)/72L) : (((TWIP)*127L-36L)/72L))
70 #define MM100_TO_TWIP(MM100)    ((MM100) >= 0 ? (((MM100)*72L+63L)/127L) : (((MM100)*72L-63L)/127L))
71 
72 /************************************************************************/
73 
74 #define VCLTOSVCOL( rCol ) (sal_uInt16)((((sal_uInt16)(rCol))<<8)|(rCol))
75 
76 /************************************************************************/
77 
78 XubString aNameOrIndexEmptyString;
79 
80 TYPEINIT1_AUTOFACTORY(NameOrIndex, SfxStringItem);
81 
82 /*************************************************************************
83 |*
84 |*
85 |*
86 \*************************************************************************/
87 
88 long ScaleMetricValue( long nVal, long nMul, long nDiv )
89 {
90 	BigInt aVal( nVal );
91 
92 	aVal *= nMul;
93 
94 	if ( aVal.IsNeg() != ( nDiv < 0 ) )
95 		aVal-=nDiv/2; // fuer korrektes Runden
96 	else
97 		aVal+=nDiv/2; // fuer korrektes Runden
98 
99 	aVal/=nDiv;
100 
101 	return long( aVal );
102 }
103 
104 /*************************************************************************
105 |*
106 |*	  NameOrIndex::NameOrIndex(sal_uInt16 nWhich, sal_Int32 nIndex)
107 |*
108 |*	  Beschreibung
109 |*	  Ersterstellung	14.11.94
110 |*	  Letzte Aenderung	14.11.94
111 |*
112 *************************************************************************/
113 
114 NameOrIndex::NameOrIndex(sal_uInt16 _nWhich, sal_Int32 nIndex) :
115 	SfxStringItem(_nWhich, aNameOrIndexEmptyString),
116 	nPalIndex(nIndex)
117 {
118 }
119 
120 /*************************************************************************
121 |*
122 |*	  NameOrIndex::NameOrIndex(sal_uInt16 nWhich, const String& rName)
123 |*
124 |*	  Beschreibung
125 |*	  Ersterstellung	14.11.94
126 |*	  Letzte Aenderung	14.11.94
127 |*
128 *************************************************************************/
129 
130 NameOrIndex::NameOrIndex(sal_uInt16 _nWhich, const XubString& rName) :
131 	SfxStringItem(_nWhich, rName),
132 	nPalIndex(-1)
133 {
134 }
135 
136 /*************************************************************************
137 |*
138 |*	  NameOrIndex::NameOrIndex(sal_uInt16 nWhich, SvStream& rIn)
139 |*
140 |*	  Beschreibung
141 |*	  Ersterstellung	14.11.94
142 |*	  Letzte Aenderung	14.11.94
143 |*
144 *************************************************************************/
145 
146 NameOrIndex::NameOrIndex(sal_uInt16 _nWhich, SvStream& rIn) :
147 	SfxStringItem(_nWhich, rIn)
148 {
149 	rIn >> nPalIndex;
150 }
151 
152 /*************************************************************************
153 |*
154 |*	  NameOrIndex::NameOrIndex(const NameOrIndex& rNameOrIndex)
155 |*
156 |*	  Beschreibung
157 |*	  Ersterstellung	14.11.94
158 |*	  Letzte Aenderung	14.11.94
159 |*
160 *************************************************************************/
161 
162 NameOrIndex::NameOrIndex(const NameOrIndex& rNameOrIndex) :
163 	SfxStringItem(rNameOrIndex),
164 	nPalIndex(rNameOrIndex.nPalIndex)
165 {
166 }
167 
168 /*************************************************************************
169 |*
170 |*	  int NameOrIndex::operator==(const SfxPoolItem& rItem) const
171 |*
172 |*	  Beschreibung
173 |*	  Ersterstellung	14.11.94
174 |*	  Letzte Aenderung	14.11.94
175 |*
176 *************************************************************************/
177 
178 int NameOrIndex::operator==(const SfxPoolItem& rItem) const
179 {
180 	return ( SfxStringItem::operator==(rItem) &&
181 			((const NameOrIndex&) rItem).nPalIndex == nPalIndex );
182 }
183 
184 /*************************************************************************
185 |*
186 |*	  SfxPoolItem* NameOrIndex::Clone(SfxItemPool* pPool) const
187 |*
188 |*	  Beschreibung
189 |*	  Ersterstellung	14.11.94
190 |*	  Letzte Aenderung	14.11.94
191 |*
192 *************************************************************************/
193 
194 SfxPoolItem* NameOrIndex::Clone(SfxItemPool* /*pPool*/) const
195 {
196 
197 	return new NameOrIndex(*this);
198 }
199 
200 /*************************************************************************
201 |*
202 |*	  SfxPoolItem* NameOrIndex::Create(SvStream& rIn, sal_uInt16 nVer) const
203 |*
204 |*	  Beschreibung
205 |*	  Ersterstellung	14.11.94
206 |*	  Letzte Aenderung	14.11.94
207 |*
208 *************************************************************************/
209 
210 SfxPoolItem* NameOrIndex::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
211 {
212 	return new NameOrIndex(Which(), rIn);
213 }
214 
215 /*************************************************************************
216 |*
217 |*	  SvStream* NameOrIndex::Store(SvStream& rIn) const
218 |*
219 |*	  Beschreibung
220 |*	  Ersterstellung	14.11.94
221 |*	  Letzte Aenderung	14.11.94
222 |*
223 *************************************************************************/
224 
225 SvStream& NameOrIndex::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
226 {
227 	SfxStringItem::Store( rOut, nItemVersion );
228 	rOut << nPalIndex;
229 	return rOut;
230 }
231 
232 /** this static checks if the given NameOrIndex item has a unique name for its value.
233 	The returned String is a unique name for an item with this value in both given pools.
234 	Argument pPool2 can be null.
235 	If returned string equals NameOrIndex->GetName(), the name was already unique.
236 */
237 String NameOrIndex::CheckNamedItem( const NameOrIndex* pCheckItem, const sal_uInt16 nWhich, const SfxItemPool* pPool1, const SfxItemPool* /*pPool2*/, SvxCompareValueFunc pCompareValueFunc, sal_uInt16 nPrefixResId, XPropertyList* pDefaults )
238 {
239 	sal_Bool bForceNew = sal_False;
240 
241 	String aUniqueName;
242 	SvxUnogetInternalNameForItem( nWhich, pCheckItem->GetName(), aUniqueName );
243 
244 	// 2. if we have a name check if there is already an item with the
245 	// same name in the documents pool with a different line end or start
246 
247 	if( aUniqueName.Len() && pPool1 )
248 	{
249 		const sal_uInt32 nCount = pPool1->GetItemCount2( nWhich );
250 
251 		const NameOrIndex *pItem;
252 		for( sal_uInt32 nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
253 		{
254 			pItem = (NameOrIndex*)pPool1->GetItem2( nWhich, nSurrogate );
255 
256 			if( pItem && ( pItem->GetName() == pCheckItem->GetName() ) )
257 			{
258 				// if there is already an item with the same name and the same
259 				// value its ok to set it
260 				if( !pCompareValueFunc( pItem, pCheckItem ) )
261 				{
262 					// same name but different value, we need a new name for this item
263 					aUniqueName = String();
264 					bForceNew = sal_True;
265 				}
266 				break;
267 			}
268 		}
269 	}
270 
271 	// if we have no name yet, find existing item with same conent or
272 	// create a unique name
273 	if( aUniqueName.Len() == 0 )
274 	{
275 		sal_Int32 nUserIndex = 1;
276 		const ResId aRes(SVX_RES(nPrefixResId));
277 		String aUser( aRes );
278 		aUser += sal_Unicode( ' ' );
279 
280 		if( pDefaults )
281 		{
282 			const int nCount = pDefaults->Count();
283 			int nIndex;
284 			for( nIndex = 0; nIndex < nCount; nIndex++ )
285 			{
286 				XPropertyEntry* pEntry = pDefaults->Get( nIndex );
287 				if( pEntry )
288 				{
289 					bool bFound = false;
290 
291 					switch( nWhich )
292 					{
293 					case XATTR_FILLBITMAP:
294                     {
295                         const GraphicObject& rGraphicObjectA(((XFillBitmapItem*)pCheckItem)->GetGraphicObject());
296                         const GraphicObject& rGraphicObjectB(((XBitmapEntry*)pEntry)->GetGraphicObject());
297 
298                         bFound = (rGraphicObjectA == rGraphicObjectB);
299 						break;
300                     }
301 					case XATTR_LINEDASH:
302 						bFound = (((XLineDashItem*)pCheckItem)->GetDashValue() == ((XDashEntry*)pEntry) ->GetDash());
303 						break;
304 					case XATTR_LINESTART:
305 						bFound = (((XLineStartItem*)pCheckItem)->GetLineStartValue() == ((XLineEndEntry*)pEntry)->GetLineEnd());
306 						break;
307 					case XATTR_LINEEND:
308 						bFound = (((XLineEndItem*)pCheckItem)->GetLineEndValue() == ((XLineEndEntry*)pEntry)->GetLineEnd());
309 						break;
310 					case XATTR_FILLGRADIENT:
311 						bFound = (((XFillGradientItem*)pCheckItem)->GetGradientValue() == ((XGradientEntry*)pEntry)->GetGradient());
312 						break;
313 					case XATTR_FILLHATCH:
314 						bFound = (((XFillHatchItem*)pCheckItem)->GetHatchValue() == ((XHatchEntry*)pEntry)->GetHatch());
315 						break;
316 					}
317 
318 					if( bFound )
319 					{
320 						aUniqueName = pEntry->GetName();
321 						break;
322 					}
323 					else
324 					{
325 						sal_Int32 nThisIndex = pEntry->GetName().Copy( aUser.Len() ).ToInt32();
326 						if( nThisIndex >= nUserIndex )
327 							nUserIndex = nThisIndex + 1;
328 					}
329 				}
330 			}
331 		}
332 
333 		if( (aUniqueName.Len() == 0) && pPool1 )
334 		{
335 			const sal_uInt32 nCount = pPool1->GetItemCount2( nWhich );
336 			const NameOrIndex *pItem;
337 			for( sal_uInt32 nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
338 			{
339 				pItem = (NameOrIndex*)pPool1->GetItem2( nWhich, nSurrogate );
340 
341 				if( pItem && pItem->GetName().Len() )
342 				{
343 					if( !bForceNew && pCompareValueFunc( pItem, pCheckItem ) )
344 						return pItem->GetName();
345 
346 					if( pItem->GetName().CompareTo( aUser, aUser.Len() ) == 0 )
347 					{
348 						sal_Int32 nThisIndex = pItem->GetName().Copy( aUser.Len() ).ToInt32();
349 						if( nThisIndex >= nUserIndex )
350 							nUserIndex = nThisIndex + 1;
351 					}
352 				}
353 			}
354             aUniqueName = aUser;
355             aUniqueName += String::CreateFromInt32( nUserIndex );
356 		}
357 	}
358 
359 	return aUniqueName;
360 }
361 
362 //*************************************************************************
363 
364 // -------------------
365 // class XColorItem
366 // -------------------
367 TYPEINIT1_AUTOFACTORY(XColorItem, NameOrIndex);
368 
369 /*************************************************************************
370 |*
371 |*	  XColorItem::XColorItem(sal_uInt16 nWhich, sal_Int32 nIndex, const Color& rTheColor)
372 |*
373 \************************************************************************/
374 
375 XColorItem::XColorItem(sal_uInt16 _nWhich, sal_Int32 nIndex, const Color& rTheColor) :
376 	NameOrIndex(_nWhich, nIndex),
377 	aColor(rTheColor)
378 {
379 }
380 
381 /*************************************************************************
382 |*
383 |*	  XColorItem::XColorItem(sal_uInt16 nWhich, const String& rName, const Color& rTheColor)
384 |*
385 \************************************************************************/
386 
387 XColorItem::XColorItem(sal_uInt16 _nWhich, const XubString& rName, const Color& rTheColor) :
388 	NameOrIndex(_nWhich, rName),
389 	aColor(rTheColor)
390 {
391 }
392 
393 /*************************************************************************
394 |*
395 |*	  XColorItem::XColorItem(const XColorItem& rItem)
396 |*
397 \************************************************************************/
398 
399 XColorItem::XColorItem(const XColorItem& rItem) :
400 	NameOrIndex(rItem),
401 	aColor(rItem.aColor)
402 {
403 }
404 
405 /*************************************************************************
406 |*
407 |*	  XColorItem::XColorItem(sal_uInt16 nWhich, SvStream& rIn)
408 |*
409 \************************************************************************/
410 
411 XColorItem::XColorItem(sal_uInt16 _nWhich, SvStream& rIn) :
412 	NameOrIndex(_nWhich, rIn)
413 {
414 	if (!IsIndex())
415 	{
416 		rIn >> aColor;
417 	}
418 }
419 
420 /*************************************************************************
421 |*
422 |*	  XColorItem::Clone(SfxItemPool* pPool) const
423 |*
424 \************************************************************************/
425 
426 SfxPoolItem* XColorItem::Clone(SfxItemPool* /*pPool*/) const
427 {
428 	return new XColorItem(*this);
429 }
430 
431 /*************************************************************************
432 |*
433 |*	  int XColorItem::operator==(const SfxPoolItem& rItem) const
434 |*
435 \************************************************************************/
436 
437 int XColorItem::operator==(const SfxPoolItem& rItem) const
438 {
439 	return ( NameOrIndex::operator==(rItem) &&
440 			((const XColorItem&) rItem).aColor == aColor );
441 }
442 
443 /*************************************************************************
444 |*
445 |*	  SfxPoolItem* XColorItem::Create(SvStream& rIn, sal_uInt16 nVer) const
446 |*
447 \************************************************************************/
448 
449 SfxPoolItem* XColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
450 {
451 	return new XColorItem(Which(), rIn);
452 }
453 
454 /*************************************************************************
455 |*
456 |*	  SfxPoolItem* XColorItem::Store(SvStream& rOut) const
457 |*
458 \************************************************************************/
459 
460 SvStream& XColorItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
461 {
462 	NameOrIndex::Store( rOut, nItemVersion );
463 
464 	if ( !IsIndex() )
465 	{
466 		rOut << aColor;
467 	}
468 
469 	return rOut;
470 }
471 
472 /*************************************************************************
473 |*
474 |*	  const XColor& XColorItem::GetColorValue(const XColorList* pTable) const
475 |*
476 \************************************************************************/
477 
478 const Color& XColorItem::GetColorValue() const
479 {
480     if(!IsIndex())
481     {
482         return aColor;
483     }
484 
485     OSL_ENSURE(false, "Acces to Indexed XColorItem needs to use the call which hands over a XColorListSharedPtr (!)");
486 
487     return aColor;
488 }
489 
490 const Color& XColorItem::GetColorValue(const XColorListSharedPtr aTable) const
491 {
492     if(!IsIndex())
493     {
494         return aColor;
495     }
496 
497     return aTable->GetColor(GetIndex())->GetColor();
498 }
499 
500 sal_Bool XColorItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
501 {
502     rVal <<= (sal_Int32)GetColorValue().GetRGBColor();
503 	return sal_True;
504 }
505 
506 sal_Bool XColorItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
507 {
508 	sal_Int32 nValue = 0;
509 	rVal >>= nValue;
510 	SetColorValue( nValue );
511 
512 	return sal_True;
513 }
514 
515 
516 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
517 //							 Linienattribute
518 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
519 
520 //---------------------
521 // class XLineStyleItem
522 //---------------------
523 TYPEINIT1_AUTOFACTORY(XLineStyleItem, SfxEnumItem);
524 
525 /*************************************************************************
526 |*
527 |*	  XLineStyleItem::XLineStyleItem(XLineStyle eTheLineStyle)
528 |*
529 |*	  Beschreibung
530 |*	  Ersterstellung	15.11.94
531 |*	  Letzte Aenderung	18.11.94
532 |*
533 *************************************************************************/
534 
535 XLineStyleItem::XLineStyleItem(XLineStyle eTheLineStyle) :
536 	SfxEnumItem(XATTR_LINESTYLE, sal::static_int_cast< sal_uInt16 >(eTheLineStyle))
537 {
538 }
539 
540 /*************************************************************************
541 |*
542 |*	  XLineStyleItem::XLineStyleItem(SvStream& rIn)
543 |*
544 |*	  Beschreibung
545 |*	  Ersterstellung	15.11.94
546 |*	  Letzte Aenderung	15.11.94
547 |*
548 *************************************************************************/
549 
550 XLineStyleItem::XLineStyleItem(SvStream& rIn) :
551 	SfxEnumItem(XATTR_LINESTYLE, rIn)
552 {
553 }
554 
555 /*************************************************************************
556 |*
557 |*	  XLineStyleItem::Clone(SfxItemPool* pPool) const
558 |*
559 |*	  Beschreibung
560 |*	  Ersterstellung	09.11.94
561 |*	  Letzte Aenderung	09.11.94
562 |*
563 *************************************************************************/
564 
565 SfxPoolItem* XLineStyleItem::Clone(SfxItemPool* /*pPool*/) const
566 {
567 	return new XLineStyleItem( *this );
568 }
569 
570 /*************************************************************************
571 |*
572 |*	  SfxPoolItem* XLineStyleItem::Create(SvStream& rIn, sal_uInt16 nVer) const
573 |*
574 |*	  Beschreibung
575 |*	  Ersterstellung	15.11.94
576 |*	  Letzte Aenderung	15.11.94
577 |*
578 *************************************************************************/
579 
580 SfxPoolItem* XLineStyleItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
581 {
582 	return new XLineStyleItem(rIn);
583 }
584 
585 //------------------------------------------------------------------------
586 
587 SfxItemPresentation XLineStyleItem::GetPresentation
588 (
589 	SfxItemPresentation ePres,
590 	SfxMapUnit			/*eCoreUnit*/,
591 	SfxMapUnit			/*ePresUnit*/,
592     XubString&          rText, const IntlWrapper *
593 )	const
594 {
595 	rText.Erase();
596 
597 	switch ( ePres )
598 	{
599 		case SFX_ITEM_PRESENTATION_NONE:
600 			return ePres;
601 		case SFX_ITEM_PRESENTATION_COMPLETE:
602 		case SFX_ITEM_PRESENTATION_NAMELESS:
603 		{
604 			sal_uInt16 nId = 0;
605 
606 			switch( (sal_uInt16)GetValue() )
607 			{
608 				case XLINE_NONE:
609 					nId = RID_SVXSTR_INVISIBLE;
610 					break;
611 				case XLINE_SOLID:
612 					nId = RID_SVXSTR_SOLID;
613 					break;
614 			}
615 
616 			if ( nId )
617 				rText = SVX_RESSTR( nId );
618 			return ePres;
619 		}
620 		default:
621 			return SFX_ITEM_PRESENTATION_NONE;
622 	}
623 }
624 
625 sal_Bool XLineStyleItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
626 {
627 	::com::sun::star::drawing::LineStyle eLS = (::com::sun::star::drawing::LineStyle)GetValue();
628 	rVal <<= eLS;
629 	return sal_True;
630 }
631 
632 sal_Bool XLineStyleItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
633 {
634 	::com::sun::star::drawing::LineStyle eLS;
635 	if(!(rVal >>= eLS ))
636     {
637         // also try an int (for Basic)
638         sal_Int32 nLS = 0;
639         if(!(rVal >>= nLS))
640             return sal_False;
641         eLS = (::com::sun::star::drawing::LineStyle)nLS;
642     }
643 
644 	SetValue( sal::static_int_cast< sal_uInt16 >( eLS ) );
645 	return sal_True;
646 }
647 
648 //------------------------------------------------------------------------
649 
650 sal_uInt16 XLineStyleItem::GetValueCount() const
651 {
652 	return 3;
653 }
654 
655 
656 // ------------
657 // class XDash
658 // ------------
659 /*************************************************************************
660 |*
661 |*	  XDash::XDash(XDashStyle, sal_uInt16, sal_uIntPtr, sal_uInt16, sal_uIntPtr, sal_uIntPtr)
662 |*
663 |*	  Beschreibung
664 |*	  Ersterstellung	21.11.94
665 |*	  Letzte Aenderung	21.11.94
666 |*
667 *************************************************************************/
668 
669 XDash::XDash(XDashStyle eTheDash, sal_uInt16 nTheDots, sal_uIntPtr nTheDotLen,
670 			 sal_uInt16 nTheDashes, sal_uIntPtr nTheDashLen, sal_uIntPtr nTheDistance) :
671 	eDash(eTheDash),
672 	nDots(nTheDots),
673 	nDotLen(nTheDotLen),
674 	nDashes(nTheDashes),
675 	nDashLen(nTheDashLen),
676 	nDistance(nTheDistance)
677 {
678 }
679 
680 /*************************************************************************
681 |*
682 |*	  int XDash::operator==(const SfxPoolItem& rItem) const
683 |*
684 |*	  Beschreibung
685 |*	  Ersterstellung	29.11.94
686 |*	  Letzte Aenderung	29.11.94
687 |*
688 *************************************************************************/
689 
690 bool XDash::operator==(const XDash& rDash) const
691 {
692 	return ( eDash		== rDash.eDash		&&
693 			 nDots		== rDash.nDots		&&
694 			 nDotLen	== rDash.nDotLen	&&
695 			 nDashes	== rDash.nDashes	&&
696 			 nDashLen	== rDash.nDashLen	&&
697 			 nDistance	== rDash.nDistance );
698 }
699 
700 // XDash is translated into an array of doubles which describe the lengths of the
701 // dashes, dots and empty passages. It returns the complete length of the full DashDot
702 // sequence and fills the given vetor of doubles accordingly (also resizing, so deleting it).
703 static double SMALLEST_DASH_WIDTH(26.95);
704 double XDash::CreateDotDashArray(::std::vector< double >& rDotDashArray, double fLineWidth) const
705 {
706 	double fFullDotDashLen(0.0);
707 	const sal_uInt16 nNumDotDashArray = (GetDots() + GetDashes()) * 2;
708 	rDotDashArray.resize( nNumDotDashArray, 0.0 );
709 	sal_uInt16 a;
710 	sal_uInt16 nIns(0);
711 	double fDashDotDistance = (double)GetDistance();
712 	double fSingleDashLen = (double)GetDashLen();
713 	double fSingleDotLen = (double)GetDotLen();
714 
715 	if(GetDashStyle() == XDASH_RECTRELATIVE || GetDashStyle() == XDASH_ROUNDRELATIVE)
716 	{
717 		if(fLineWidth != 0.0)
718 		{
719 			double fFactor = fLineWidth / 100.0;
720 
721 			if(GetDashes())
722 			{
723 				if(GetDashLen())
724 				{
725 					// is a dash
726 					fSingleDashLen *= fFactor;
727 				}
728 				else
729 				{
730 					// is a dot
731 					fSingleDashLen = fLineWidth;
732 				}
733 			}
734 
735 			if(GetDots())
736 			{
737 				if(GetDotLen())
738 				{
739 					// is a dash
740 					fSingleDotLen *= fFactor;
741 				}
742 				else
743 				{
744 					// is a dot
745 					fSingleDotLen = fLineWidth;
746 				}
747 			}
748 
749 			if(GetDashes() || GetDots())
750 			{
751 				if(GetDistance())
752 				{
753 					fDashDotDistance *= fFactor;
754 				}
755 				else
756 				{
757 					fDashDotDistance = fLineWidth;
758 				}
759 			}
760 		}
761 		else
762 		{
763 			if(GetDashes())
764 			{
765 				if(GetDashLen())
766 				{
767 					// is a dash
768 					fSingleDashLen = (SMALLEST_DASH_WIDTH * fSingleDashLen) / 100.0;
769 				}
770 				else
771 				{
772 					// is a dot
773 					fSingleDashLen = SMALLEST_DASH_WIDTH;
774 				}
775 			}
776 
777 			if(GetDots())
778 			{
779 				if(GetDotLen())
780 				{
781 					// is a dash
782 					fSingleDotLen = (SMALLEST_DASH_WIDTH * fSingleDotLen) / 100.0;
783 				}
784 				else
785 				{
786 					// is a dot
787 					fSingleDotLen = SMALLEST_DASH_WIDTH;
788 				}
789 			}
790 
791 			if(GetDashes() || GetDots())
792 			{
793 				if(GetDistance())
794 				{
795 					// dash as distance
796 					fDashDotDistance = (SMALLEST_DASH_WIDTH * fDashDotDistance) / 100.0;
797 				}
798 				else
799 				{
800 					// dot as distance
801 					fDashDotDistance = SMALLEST_DASH_WIDTH;
802 				}
803 			}
804 		}
805 	}
806 	else
807 	{
808 		// smallest dot size compare value
809 		double fDotCompVal(fLineWidth != 0.0 ? fLineWidth : SMALLEST_DASH_WIDTH);
810 
811 		// absolute values
812 		if(GetDashes())
813 		{
814 			if(GetDashLen())
815 			{
816 				// is a dash
817 				if(fSingleDashLen < SMALLEST_DASH_WIDTH)
818 				{
819 					fSingleDashLen = SMALLEST_DASH_WIDTH;
820 				}
821 			}
822 			else
823 			{
824 				// is a dot
825 				if(fSingleDashLen < fDotCompVal)
826 				{
827 					fSingleDashLen = fDotCompVal;
828 				}
829 			}
830 		}
831 
832 		if(GetDots())
833 		{
834 			if(GetDotLen())
835 			{
836 				// is a dash
837 				if(fSingleDotLen < SMALLEST_DASH_WIDTH)
838 				{
839 					fSingleDotLen = SMALLEST_DASH_WIDTH;
840 				}
841 			}
842 			else
843 			{
844 				// is a dot
845 				if(fSingleDotLen < fDotCompVal)
846 				{
847 					fSingleDotLen = fDotCompVal;
848 				}
849 			}
850 		}
851 
852 		if(GetDashes() || GetDots())
853 		{
854 			if(GetDistance())
855 			{
856 				// dash as distance
857 				if(fDashDotDistance < SMALLEST_DASH_WIDTH)
858 				{
859 					fDashDotDistance = SMALLEST_DASH_WIDTH;
860 				}
861 			}
862 			else
863 			{
864 				// dot as distance
865 				if(fDashDotDistance < fDotCompVal)
866 				{
867 					fDashDotDistance = fDotCompVal;
868 				}
869 			}
870 		}
871 	}
872 
873 	for(a=0;a<GetDots();a++)
874 	{
875 		rDotDashArray[nIns++] = fSingleDotLen;
876 		fFullDotDashLen += fSingleDotLen;
877 		rDotDashArray[nIns++] = fDashDotDistance;
878 		fFullDotDashLen += fDashDotDistance;
879 	}
880 
881 	for(a=0;a<GetDashes();a++)
882 	{
883 		rDotDashArray[nIns++] = fSingleDashLen;
884 		fFullDotDashLen += fSingleDashLen;
885 		rDotDashArray[nIns++] = fDashDotDistance;
886 		fFullDotDashLen += fDashDotDistance;
887 	}
888 
889 	return fFullDotDashLen;
890 }
891 
892 // -------------------
893 // class XLineDashItem
894 // -------------------
895 TYPEINIT1_AUTOFACTORY(XLineDashItem, NameOrIndex);
896 
897 /*************************************************************************
898 |*
899 |*	  XLineDashItem::XLineDashItem(sal_Int32 nIndex, const XDash& rTheDash)
900 |*
901 |*	  Beschreibung
902 |*	  Ersterstellung	15.11.94
903 |*	  Letzte Aenderung	15.11.94
904 |*
905 *************************************************************************/
906 
907 XLineDashItem::XLineDashItem(sal_Int32 nIndex, const XDash& rTheDash) :
908 	NameOrIndex(XATTR_LINEDASH, nIndex),
909 	aDash(rTheDash)
910 {
911 }
912 
913 /*************************************************************************
914 |*
915 |*	  XLineDashItem::XLineDashItem(const String& rName, const XDash& rTheDash)
916 |*
917 |*	  Beschreibung
918 |*	  Ersterstellung	15.11.94
919 |*	  Letzte Aenderung	15.11.94
920 |*
921 *************************************************************************/
922 
923 XLineDashItem::XLineDashItem(const XubString& rName, const XDash& rTheDash) :
924 	NameOrIndex(XATTR_LINEDASH, rName),
925 	aDash(rTheDash)
926 {
927 }
928 
929 /*************************************************************************
930 |*
931 |*	  XLineDashItem::XLineDashItem(const XLineDashItem& rItem)
932 |*
933 |*	  Beschreibung
934 |*	  Ersterstellung	15.11.94
935 |*	  Letzte Aenderung	15.11.94
936 |*
937 *************************************************************************/
938 
939 XLineDashItem::XLineDashItem(const XLineDashItem& rItem) :
940 	NameOrIndex(rItem),
941 	aDash(rItem.aDash)
942 {
943 }
944 
945 /*************************************************************************
946 |*
947 |*	  XLineDashItem::XLineDashItem(SvStream& rIn)
948 |*
949 |*	  Beschreibung
950 |*	  Ersterstellung	15.11.94
951 |*	  Letzte Aenderung	15.11.94
952 |*
953 *************************************************************************/
954 
955 XLineDashItem::XLineDashItem(SvStream& rIn) :
956 	NameOrIndex(XATTR_LINEDASH, rIn)
957 {
958 	if (!IsIndex())
959 	{
960 		sal_uInt16	nSTemp;
961 		sal_uInt32	nLTemp;
962 		sal_Int32   nITemp;
963 
964 		rIn >> nITemp; aDash.SetDashStyle((XDashStyle)nITemp);
965 		rIn >> nSTemp; aDash.SetDots(nSTemp);
966 		rIn >> nLTemp; aDash.SetDotLen(nLTemp);
967 		rIn >> nSTemp; aDash.SetDashes(nSTemp);
968 		rIn >> nLTemp; aDash.SetDashLen(nLTemp);
969 		rIn >> nLTemp; aDash.SetDistance(nLTemp);
970 	}
971 }
972 
973 //*************************************************************************
974 
975 XLineDashItem::XLineDashItem(SfxItemPool* /*pPool*/, const XDash& rTheDash)
976 : 	NameOrIndex( XATTR_LINEDASH, -1 ),
977 	aDash(rTheDash)
978 {
979 }
980 
981 //*************************************************************************
982 
983 XLineDashItem::XLineDashItem(SfxItemPool* /*pPool*/)
984 : NameOrIndex(XATTR_LINEDASH, -1 )
985 {
986 }
987 
988 /*************************************************************************
989 |*
990 |*	  XLineDashItem::Clone(SfxItemPool* pPool) const
991 |*
992 |*	  Beschreibung
993 |*	  Ersterstellung	15.11.94
994 |*	  Letzte Aenderung	15.11.94
995 |*
996 *************************************************************************/
997 
998 SfxPoolItem* XLineDashItem::Clone(SfxItemPool* /*pPool*/) const
999 {
1000 	return new XLineDashItem(*this);
1001 }
1002 
1003 /*************************************************************************
1004 |*
1005 |*	  int XLineDashItem::operator==(const SfxPoolItem& rItem) const
1006 |*
1007 |*	  Beschreibung
1008 |*	  Ersterstellung	15.11.94
1009 |*	  Letzte Aenderung	15.11.94
1010 |*
1011 *************************************************************************/
1012 
1013 int XLineDashItem::operator==(const SfxPoolItem& rItem) const
1014 {
1015 	return ( NameOrIndex::operator==(rItem) &&
1016 			 aDash == ((const XLineDashItem&) rItem).aDash );
1017 }
1018 
1019 /*************************************************************************
1020 |*
1021 |*	  SfxPoolItem* XLineDashItem::Create(SvStream& rIn, sal_uInt16 nVer) const
1022 |*
1023 |*	  Beschreibung
1024 |*	  Ersterstellung	15.11.94
1025 |*	  Letzte Aenderung	15.11.94
1026 |*
1027 *************************************************************************/
1028 
1029 SfxPoolItem* XLineDashItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1030 {
1031 	return new XLineDashItem(rIn);
1032 }
1033 
1034 /*************************************************************************
1035 |*
1036 |*	  SfxPoolItem* XLineDashItem::Store(SvStream& rOut) const
1037 |*
1038 |*	  Beschreibung
1039 |*	  Ersterstellung	15.11.94
1040 |*	  Letzte Aenderung	15.11.94
1041 |*
1042 *************************************************************************/
1043 
1044 SvStream& XLineDashItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
1045 {
1046 	NameOrIndex::Store( rOut, nItemVersion );
1047 
1048 	if (!IsIndex())
1049 	{
1050 		rOut << (sal_Int32) aDash.GetDashStyle();
1051 		rOut << aDash.GetDots();
1052 		rOut << (sal_uInt32) aDash.GetDotLen();
1053 		rOut << aDash.GetDashes();
1054 		rOut << (sal_uInt32) aDash.GetDashLen();
1055 		rOut << (sal_uInt32) aDash.GetDistance();
1056 	}
1057 
1058 	return rOut;
1059 }
1060 
1061 /*************************************************************************
1062 |*
1063 |*	  const XDash& XLineDashItem::GetValue(const XDashList* pTable) const
1064 |*
1065 |*	  Beschreibung
1066 |*	  Ersterstellung	15.11.94
1067 |*	  Letzte Aenderung	18.11.94
1068 |*
1069 *************************************************************************/
1070 
1071 const XDash& XLineDashItem::GetDashValue(const XDashList* pTable) const // GetValue -> GetDashValue
1072 {
1073 	if (!IsIndex())
1074 		return aDash;
1075 	else
1076 		return pTable->GetDash(GetIndex())->GetDash();
1077 }
1078 
1079 //------------------------------------------------------------------------
1080 
1081 SfxItemPresentation XLineDashItem::GetPresentation
1082 (
1083 	SfxItemPresentation ePres,
1084 	SfxMapUnit			/*eCoreUnit*/,
1085 	SfxMapUnit			/*ePresUnit*/,
1086     XubString&          rText, const IntlWrapper *
1087 )	const
1088 {
1089 	switch ( ePres )
1090 	{
1091 		case SFX_ITEM_PRESENTATION_NONE:
1092 			rText.Erase();
1093 			return ePres;
1094 		case SFX_ITEM_PRESENTATION_NAMELESS:
1095 		case SFX_ITEM_PRESENTATION_COMPLETE:
1096 			rText = GetName();
1097 			return ePres;
1098 		default:
1099 			return SFX_ITEM_PRESENTATION_NONE;
1100 	}
1101 }
1102 
1103 //------------------------------------------------------------------------
1104 
1105 FASTBOOL XLineDashItem::HasMetrics() const
1106 {
1107 	return sal_True;
1108 }
1109 
1110 //------------------------------------------------------------------------
1111 
1112 FASTBOOL XLineDashItem::ScaleMetrics(long nMul, long nDiv)
1113 {
1114 	aDash.SetDotLen( ScaleMetricValue( aDash.GetDotLen(), nMul, nDiv ) );
1115 	aDash.SetDashLen( ScaleMetricValue( aDash.GetDashLen(), nMul, nDiv ) );
1116 	aDash.SetDistance( ScaleMetricValue( aDash.GetDistance(), nMul, nDiv ) );
1117 	return sal_True;
1118 }
1119 
1120 sal_Bool XLineDashItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
1121 {
1122 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1123     nMemberId &= ~CONVERT_TWIPS;
1124 
1125 	switch ( nMemberId )
1126 	{
1127         case 0:
1128         {
1129             uno::Sequence< beans::PropertyValue > aPropSeq( 2 );
1130 
1131             ::com::sun::star::drawing::LineDash aLineDash;
1132 
1133 			const XDash& rXD = GetDashValue();
1134 			aLineDash.Style = (::com::sun::star::drawing::DashStyle)((sal_uInt16)rXD.GetDashStyle());
1135 			aLineDash.Dots = rXD.GetDots();
1136 			aLineDash.DotLen = rXD.GetDotLen();
1137 			aLineDash.Dashes = rXD.GetDashes();
1138 			aLineDash.DashLen = rXD.GetDashLen();
1139 			aLineDash.Distance = rXD.GetDistance();
1140 
1141 			rtl::OUString aApiName;
1142 			SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
1143             aPropSeq[0].Name    = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Name" ));
1144             aPropSeq[0].Value   = uno::makeAny( aApiName );
1145             aPropSeq[1].Name    = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LineDash" ));
1146             aPropSeq[1].Value   = uno::makeAny( aLineDash );
1147             rVal = uno::makeAny( aPropSeq );
1148             break;
1149         }
1150 
1151         case MID_NAME:
1152 		{
1153 			rtl::OUString aApiName;
1154 			SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
1155 			rVal <<= aApiName;
1156 			break;
1157 		}
1158 
1159 		case MID_LINEDASH:
1160 		{
1161 			const XDash& rXD = GetDashValue();
1162 
1163 			::com::sun::star::drawing::LineDash aLineDash;
1164 
1165 			aLineDash.Style = (::com::sun::star::drawing::DashStyle)((sal_uInt16)rXD.GetDashStyle());
1166 			aLineDash.Dots = rXD.GetDots();
1167 			aLineDash.DotLen = rXD.GetDotLen();
1168 			aLineDash.Dashes = rXD.GetDashes();
1169 			aLineDash.DashLen = rXD.GetDashLen();
1170 			aLineDash.Distance = rXD.GetDistance();
1171 
1172 			rVal <<= aLineDash;
1173 			break;
1174 		}
1175 
1176 		case MID_LINEDASH_STYLE:
1177 		{
1178 			const XDash& rXD = GetDashValue();
1179 			rVal <<= (::com::sun::star::drawing::DashStyle)((sal_Int16)rXD.GetDashStyle());
1180 			break;
1181 		}
1182 
1183 		case MID_LINEDASH_DOTS:
1184 		{
1185 			const XDash& rXD = GetDashValue();
1186 			rVal <<= rXD.GetDots();
1187 			break;
1188 		}
1189 
1190 		case MID_LINEDASH_DOTLEN:
1191 		{
1192 			const XDash& rXD = GetDashValue();
1193 			rVal <<= rXD.GetDotLen();
1194 			break;
1195 		}
1196 
1197 		case MID_LINEDASH_DASHES:
1198 		{
1199 			const XDash& rXD = GetDashValue();
1200 			rVal <<= rXD.GetDashes();
1201 			break;
1202 		}
1203 
1204 		case MID_LINEDASH_DASHLEN:
1205 		{
1206 			const XDash& rXD = GetDashValue();
1207 			rVal <<= rXD.GetDashLen();
1208 			break;
1209 		}
1210 
1211 		case MID_LINEDASH_DISTANCE:
1212 		{
1213 			const XDash& rXD = GetDashValue();
1214 			rVal <<= rXD.GetDistance();
1215 			break;
1216 		}
1217 
1218 		default: DBG_ERROR("Wrong MemberId!"); return sal_False;
1219 	}
1220 
1221 	return sal_True;
1222 }
1223 
1224 sal_Bool XLineDashItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
1225 {
1226 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1227     nMemberId &= ~CONVERT_TWIPS;
1228 
1229 	switch ( nMemberId )
1230 	{
1231         case 0:
1232         {
1233             uno::Sequence< beans::PropertyValue >   aPropSeq;
1234             ::com::sun::star::drawing::LineDash     aLineDash;
1235             rtl::OUString                           aName;
1236             sal_Bool                                bLineDash( sal_False );
1237 
1238             if ( rVal >>= aPropSeq )
1239             {
1240                 for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
1241                 {
1242                     if ( aPropSeq[n].Name.equalsAsciiL( "Name", 4  ))
1243                         aPropSeq[n].Value >>= aName;
1244                     else if ( aPropSeq[n].Name.equalsAsciiL( "LineDash", 8 ))
1245                     {
1246                         if ( aPropSeq[n].Value >>= aLineDash )
1247                             bLineDash = sal_True;
1248                     }
1249                 }
1250 
1251                 SetName( aName );
1252                 if ( bLineDash )
1253                 {
1254 			        XDash aXDash;
1255 
1256 			        aXDash.SetDashStyle((XDashStyle)((sal_uInt16)(aLineDash.Style)));
1257 			        aXDash.SetDots(aLineDash.Dots);
1258 			        aXDash.SetDotLen(aLineDash.DotLen);
1259 			        aXDash.SetDashes(aLineDash.Dashes);
1260 			        aXDash.SetDashLen(aLineDash.DashLen);
1261 			        aXDash.SetDistance(aLineDash.Distance);
1262 
1263 			        if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
1264 				        aXDash.SetDots(1);
1265 
1266 			        SetDashValue( aXDash );
1267                 }
1268 
1269                 return sal_True;
1270             }
1271 
1272             return sal_False;
1273         }
1274 
1275         case MID_NAME:
1276 		{
1277 			rtl::OUString aName;
1278 			if (!(rVal >>= aName))
1279 				return sal_False;
1280 			SetName( aName );
1281 			break;
1282 		}
1283 
1284 		case MID_LINEDASH:
1285 		{
1286 			::com::sun::star::drawing::LineDash aLineDash;
1287 			if(!(rVal >>= aLineDash))
1288 				return sal_False;
1289 
1290 			XDash aXDash;
1291 
1292 			aXDash.SetDashStyle((XDashStyle)((sal_uInt16)(aLineDash.Style)));
1293 			aXDash.SetDots(aLineDash.Dots);
1294 			aXDash.SetDotLen(aLineDash.DotLen);
1295 			aXDash.SetDashes(aLineDash.Dashes);
1296 			aXDash.SetDashLen(aLineDash.DashLen);
1297 			aXDash.SetDistance(aLineDash.Distance);
1298 
1299 			if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
1300 				aXDash.SetDots(1);
1301 
1302 			SetDashValue( aXDash );
1303 			break;
1304 		}
1305 
1306 		case MID_LINEDASH_STYLE:
1307 		{
1308 			sal_Int16 nVal = sal_Int16();
1309 			if(!(rVal >>= nVal))
1310 				return sal_False;
1311 
1312 			XDash aXDash = GetDashValue();
1313 			aXDash.SetDashStyle((XDashStyle)((sal_uInt16)(nVal)));
1314 
1315 			if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
1316 				aXDash.SetDots(1);
1317 
1318 			SetDashValue( aXDash );
1319 
1320 			break;
1321 		}
1322 
1323 		case MID_LINEDASH_DOTS:
1324 		case MID_LINEDASH_DASHES:
1325 		{
1326 			sal_Int16 nVal = sal_Int16();
1327 			if(!(rVal >>= nVal))
1328 				return sal_False;
1329 
1330 			XDash aXDash = GetDashValue();
1331 			if ( nMemberId == MID_LINEDASH_DOTS )
1332 				aXDash.SetDots( nVal );
1333 			else
1334 				aXDash.SetDashes( nVal );
1335 
1336 			if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
1337 				aXDash.SetDots(1);
1338 
1339 			SetDashValue( aXDash );
1340 			break;
1341 		}
1342 
1343 		case MID_LINEDASH_DOTLEN:
1344 		case MID_LINEDASH_DASHLEN:
1345 		case MID_LINEDASH_DISTANCE:
1346 		{
1347 			sal_Int32 nVal = 0;
1348 			if(!(rVal >>= nVal))
1349 				return sal_False;
1350 
1351 			XDash aXDash = GetDashValue();
1352 			if ( nMemberId == MID_LINEDASH_DOTLEN )
1353 				aXDash.SetDotLen( nVal );
1354 			else if ( nMemberId == MID_LINEDASH_DASHLEN )
1355 				aXDash.SetDashLen( nVal );
1356 			else
1357 				aXDash.SetDistance( nVal );
1358 
1359 			if((0 == aXDash.GetDots()) && (0 == aXDash.GetDashes()))
1360 				aXDash.SetDots(1);
1361 
1362 			SetDashValue( aXDash );
1363 			break;
1364 		}
1365 	}
1366 
1367 	return sal_True;
1368 }
1369 
1370 sal_Bool XLineDashItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
1371 {
1372 	return ((XLineDashItem*)p1)->GetDashValue() == ((XLineDashItem*)p2)->GetDashValue();
1373 }
1374 
1375 XLineDashItem* XLineDashItem::checkForUniqueItem( SdrModel* pModel ) const
1376 {
1377 	if( pModel )
1378 	{
1379 		const String aUniqueName = NameOrIndex::CheckNamedItem(	this,
1380 																XATTR_LINEDASH,
1381 																&pModel->GetItemPool(),
1382 																pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
1383 																XLineDashItem::CompareValueFunc,
1384 																RID_SVXSTR_DASH11,
1385 																pModel->GetDashListFromSdrModel().get() );
1386 
1387 		// if the given name is not valid, replace it!
1388 		if( aUniqueName != GetName() )
1389 		{
1390 			return new XLineDashItem( aUniqueName, aDash );
1391 		}
1392 	}
1393 
1394 	return (XLineDashItem*)this;
1395 }
1396 
1397 // -------------------
1398 // class XLineWidthItem
1399 // -------------------
1400 TYPEINIT1_AUTOFACTORY(XLineWidthItem, SfxMetricItem);
1401 
1402 /*************************************************************************
1403 |*
1404 |*	  XLineWidthItem::XLineWidthItem(long nWidth)
1405 |*
1406 |*	  Beschreibung
1407 |*	  Ersterstellung	15.11.94
1408 |*	  Letzte Aenderung	18.11.94
1409 |*
1410 *************************************************************************/
1411 
1412 XLineWidthItem::XLineWidthItem(long nWidth) :
1413 	SfxMetricItem(XATTR_LINEWIDTH, nWidth)
1414 {
1415 }
1416 
1417 /*************************************************************************
1418 |*
1419 |*	  XLineWidthItem::XLineWidthItem(SvStream& rIn)
1420 |*
1421 |*	  Beschreibung
1422 |*	  Ersterstellung	15.11.94
1423 |*	  Letzte Aenderung	15.11.94
1424 |*
1425 *************************************************************************/
1426 
1427 XLineWidthItem::XLineWidthItem(SvStream& rIn) :
1428 	SfxMetricItem(XATTR_LINEWIDTH, rIn)
1429 {
1430 }
1431 
1432 /*************************************************************************
1433 |*
1434 |*	  XLineWidthItem::Clone(SfxItemPool* pPool) const
1435 |*
1436 |*	  Beschreibung
1437 |*	  Ersterstellung	15.11.94
1438 |*	  Letzte Aenderung	15.11.94
1439 |*
1440 *************************************************************************/
1441 
1442 SfxPoolItem* XLineWidthItem::Clone(SfxItemPool* /*pPool*/) const
1443 {
1444 	return new XLineWidthItem(*this);
1445 }
1446 
1447 /*************************************************************************
1448 |*
1449 |*	  SfxPoolItem* XLineWidthItem::Create(SvStream& rIn, sal_uInt16 nVer) const
1450 |*
1451 |*	  Beschreibung
1452 |*	  Ersterstellung	15.11.94
1453 |*	  Letzte Aenderung	15.11.94
1454 |*
1455 *************************************************************************/
1456 
1457 SfxPoolItem* XLineWidthItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1458 {
1459 	return new XLineWidthItem(rIn);
1460 }
1461 
1462 //------------------------------------------------------------------------
1463 
1464 SfxItemPresentation XLineWidthItem::GetPresentation
1465 (
1466 	SfxItemPresentation ePres,
1467 	SfxMapUnit			eCoreUnit,
1468 	SfxMapUnit			ePresUnit,
1469     XubString&          rText, const IntlWrapper * pIntl
1470 )	const
1471 {
1472 	switch ( ePres )
1473 	{
1474 		case SFX_ITEM_PRESENTATION_NONE:
1475 			rText.Erase();
1476 			return ePres;
1477 		case SFX_ITEM_PRESENTATION_NAMELESS:
1478 		case SFX_ITEM_PRESENTATION_COMPLETE:
1479 			rText = GetMetricText( (long) GetValue(),
1480                                     eCoreUnit, ePresUnit, pIntl);
1481 			rText += sal_Unicode(' ');
1482 			rText += SVX_RESSTR( GetMetricId( ePresUnit) );
1483 			return ePres;
1484 		default:
1485 			return SFX_ITEM_PRESENTATION_NONE;
1486 	}
1487 }
1488 
1489 sal_Bool XLineWidthItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
1490 {
1491     sal_Int32 nValue = GetValue();
1492     if( 0 != (nMemberId&CONVERT_TWIPS) )
1493         nValue = TWIP_TO_MM100(nValue);
1494 
1495     rVal <<= nValue;
1496 	return sal_True;
1497 }
1498 
1499 sal_Bool XLineWidthItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
1500 {
1501 	sal_Int32 nValue = 0;
1502 	rVal >>= nValue;
1503     if( 0 != (nMemberId&CONVERT_TWIPS) )
1504         nValue = MM100_TO_TWIP(nValue);
1505 
1506 	SetValue( nValue );
1507 	return sal_True;
1508 }
1509 
1510 // -------------------
1511 // class XLineColorItem
1512 // -------------------
1513 TYPEINIT1_AUTOFACTORY(XLineColorItem, XColorItem);
1514 
1515 /*************************************************************************
1516 |*
1517 |*	  XLineColorItem::XLineColorItem(sal_Int32 nIndex, const Color& rTheColor)
1518 |*
1519 |*	  Beschreibung
1520 |*	  Ersterstellung	15.11.94
1521 |*	  Letzte Aenderung	15.11.94
1522 |*
1523 *************************************************************************/
1524 
1525 XLineColorItem::XLineColorItem(sal_Int32 nIndex, const Color& rTheColor) :
1526 	XColorItem(XATTR_LINECOLOR, nIndex, rTheColor)
1527 {
1528 }
1529 
1530 /*************************************************************************
1531 |*
1532 |*	  XLineColorItem::XLineColorItem(const XubString& rName, const Color& rTheColor)
1533 |*
1534 |*	  Beschreibung
1535 |*	  Ersterstellung	15.11.94
1536 |*	  Letzte Aenderung	15.11.94
1537 |*
1538 *************************************************************************/
1539 
1540 XLineColorItem::XLineColorItem(const XubString& rName, const Color& rTheColor) :
1541 	XColorItem(XATTR_LINECOLOR, rName, rTheColor)
1542 {
1543 }
1544 
1545 /*************************************************************************
1546 |*
1547 |*	  XLineColorItem::XLineColorItem(SvStream& rIn)
1548 |*
1549 |*	  Beschreibung
1550 |*	  Ersterstellung	15.11.94
1551 |*	  Letzte Aenderung	15.11.94
1552 |*
1553 *************************************************************************/
1554 
1555 XLineColorItem::XLineColorItem(SvStream& rIn) :
1556 	XColorItem(XATTR_LINECOLOR, rIn)
1557 {
1558 }
1559 
1560 /*************************************************************************
1561 |*
1562 |*	  XLineColorItem::Clone(SfxItemPool* pPool) const
1563 |*
1564 |*	  Beschreibung
1565 |*	  Ersterstellung	15.11.94
1566 |*	  Letzte Aenderung	15.11.94
1567 |*
1568 *************************************************************************/
1569 
1570 SfxPoolItem* XLineColorItem::Clone(SfxItemPool* /*pPool*/) const
1571 {
1572 	return new XLineColorItem(*this);
1573 }
1574 
1575 /*************************************************************************
1576 |*
1577 |*	  SfxPoolItem* XLineColorItem::Create(SvStream& rIn, sal_uInt16 nVer) const
1578 |*
1579 |*	  Beschreibung
1580 |*	  Ersterstellung	15.11.94
1581 |*	  Letzte Aenderung	15.11.94
1582 |*
1583 *************************************************************************/
1584 
1585 SfxPoolItem* XLineColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1586 {
1587 	return new XLineColorItem(rIn);
1588 }
1589 
1590 //------------------------------------------------------------------------
1591 
1592 SfxItemPresentation XLineColorItem::GetPresentation
1593 (
1594 	SfxItemPresentation ePres,
1595 	SfxMapUnit			/*eCoreUnit*/,
1596 	SfxMapUnit			/*ePresUnit*/,
1597     XubString&          rText, const IntlWrapper *
1598 )	const
1599 {
1600 	switch ( ePres )
1601 	{
1602 		case SFX_ITEM_PRESENTATION_NONE:
1603 			rText.Erase();
1604 			return ePres;
1605 		case SFX_ITEM_PRESENTATION_NAMELESS:
1606 		case SFX_ITEM_PRESENTATION_COMPLETE:
1607 			rText = GetName();
1608 			return ePres;
1609 		default:
1610 			return SFX_ITEM_PRESENTATION_NONE;
1611 	}
1612 }
1613 
1614 sal_Bool XLineColorItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
1615 {
1616     rVal <<= (sal_Int32)GetColorValue().GetRGBColor();
1617 	return sal_True;
1618 }
1619 
1620 sal_Bool XLineColorItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
1621 {
1622 	sal_Int32 nValue = 0;
1623 	if(!(rVal >>= nValue))
1624 		return sal_False;
1625 
1626 	SetColorValue( nValue );
1627 	return sal_True;
1628 }
1629 
1630 //////////////////////////////////////////////////////////////////////////////
1631 // tooling for simple spooling B2DPolygon to file and back
1632 
1633 namespace
1634 {
1635 	void streamOutB2DPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon, SvStream& rOut)
1636 	{
1637 		const sal_uInt32 nPolygonCount(rPolyPolygon.count());
1638 		rOut << nPolygonCount;
1639 
1640 		for(sal_uInt32 a(0L); a < nPolygonCount; a++)
1641 		{
1642 			const basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(a));
1643 			const sal_uInt32 nPointCount(aCandidate.count());
1644 			const sal_uInt8 bClosed(aCandidate.isClosed() ? 1 : 0);
1645 			const sal_uInt8 bControlPoints(aCandidate.areControlPointsUsed() ? 1 : 0);
1646 			rOut << nPointCount;
1647 			rOut << bClosed;
1648 			rOut << bControlPoints;
1649 
1650 			for(sal_uInt32 b(0L); b < nPointCount; b++)
1651 			{
1652 				const basegfx::B2DPoint aPoint(aCandidate.getB2DPoint(b));
1653 				rOut << aPoint.getX();
1654 				rOut << aPoint.getY();
1655 
1656 				if(bControlPoints)
1657 				{
1658 					const sal_uInt8 bEdgeIsCurve(aCandidate.isPrevControlPointUsed(b) || aCandidate.isNextControlPointUsed(b) ? 1 : 0);
1659 					rOut << bEdgeIsCurve;
1660 
1661 					if(bEdgeIsCurve)
1662 					{
1663 						const basegfx::B2DVector aControlVectorA(aCandidate.getPrevControlPoint(b));
1664 						rOut << aControlVectorA.getX();
1665 						rOut << aControlVectorA.getY();
1666 
1667 						const basegfx::B2DVector aControlVectorB(aCandidate.getNextControlPoint(b));
1668 						rOut << aControlVectorB.getX();
1669 						rOut << aControlVectorB.getY();
1670 					}
1671 				}
1672 			}
1673 		}
1674 	}
1675 
1676 	basegfx::B2DPolyPolygon streamInB2DPolyPolygon(SvStream& rIn)
1677 	{
1678 		basegfx::B2DPolyPolygon aRetval;
1679 		sal_uInt32 nPolygonCount;
1680 		rIn >> nPolygonCount;
1681 
1682 		for(sal_uInt32 a(0L); a < nPolygonCount; a++)
1683 		{
1684 			sal_uInt32 nPointCount;
1685 			sal_uInt8 bClosed;
1686 			sal_uInt8 bControlPoints;
1687 
1688 			rIn >> nPointCount;
1689 			rIn >> bClosed;
1690 			rIn >> bControlPoints;
1691 
1692 			basegfx::B2DPolygon aCandidate;
1693 			aCandidate.setClosed(0 != bClosed);
1694 
1695 			for(sal_uInt32 b(0L); b < nPointCount; b++)
1696 			{
1697 				double fX, fY;
1698 				rIn >> fX;
1699 				rIn >> fY;
1700 				aCandidate.append(basegfx::B2DPoint(fX, fY));
1701 
1702 				if(0 != bControlPoints)
1703 				{
1704 					sal_uInt8 bEdgeIsCurve;
1705 					rIn >> bEdgeIsCurve;
1706 
1707 					if(0 != bEdgeIsCurve)
1708 					{
1709 						rIn >> fX;
1710 						rIn >> fY;
1711 						aCandidate.setPrevControlPoint(b, basegfx::B2DVector(fX, fY));
1712 
1713 						rIn >> fX;
1714 						rIn >> fY;
1715 						aCandidate.setNextControlPoint(b, basegfx::B2DVector(fX, fY));
1716 					}
1717 				}
1718 			}
1719 
1720 			aRetval.append(aCandidate);
1721 		}
1722 
1723 		return aRetval;
1724 	}
1725 }
1726 
1727 //////////////////////////////////////////////////////////////////////////////
1728 
1729 // -----------------------
1730 // class XLineStartItem
1731 // -----------------------
1732 TYPEINIT1_AUTOFACTORY(XLineStartItem, NameOrIndex);
1733 
1734 /*************************************************************************
1735 |*
1736 |*	  XLineStartItem::XLineStartItem(sal_Int32 nIndex)
1737 |*
1738 |*	  Beschreibung
1739 |*	  Ersterstellung	15.11.94
1740 |*	  Letzte Aenderung	18.11.94
1741 |*
1742 *************************************************************************/
1743 
1744 XLineStartItem::XLineStartItem(sal_Int32 nIndex)
1745 :	NameOrIndex(XATTR_LINESTART, nIndex)
1746 {
1747 }
1748 
1749 /*************************************************************************
1750 |*
1751 |*	  XLineStartItem::XLineStartItem(const XubString& rName,
1752 |*									 const basegfx::B2DPolyPolygon& rXPolygon)
1753 |*
1754 |*	  Beschreibung
1755 |*	  Ersterstellung	15.11.94
1756 |*	  Letzte Aenderung	18.11.94
1757 |*
1758 *************************************************************************/
1759 
1760 XLineStartItem::XLineStartItem(const XubString& rName, const basegfx::B2DPolyPolygon& rPolyPolygon)
1761 :	NameOrIndex(XATTR_LINESTART, rName),
1762 	maPolyPolygon(rPolyPolygon)
1763 {
1764 }
1765 
1766 /*************************************************************************
1767 |*
1768 |*	  XLineStartItem::XLineStartItem(const XLineStartItem& rItem)
1769 |*
1770 |*	  Beschreibung
1771 |*	  Ersterstellung	15.11.94
1772 |*	  Letzte Aenderung	17.11.94
1773 |*
1774 *************************************************************************/
1775 
1776 XLineStartItem::XLineStartItem(const XLineStartItem& rItem)
1777 :	NameOrIndex(rItem),
1778 	maPolyPolygon(rItem.maPolyPolygon)
1779 {
1780 }
1781 
1782 /*************************************************************************
1783 |*
1784 |*	  XLineStartItem::XLineStartItem(SvStream& rIn)
1785 |*
1786 |*	  Beschreibung
1787 |*	  Ersterstellung	15.11.94
1788 |*	  Letzte Aenderung	17.11.94
1789 |*
1790 *************************************************************************/
1791 
1792 XLineStartItem::XLineStartItem(SvStream& rIn) :
1793 	NameOrIndex(XATTR_LINESTART, rIn)
1794 {
1795 	if (!IsIndex())
1796 	{
1797 		maPolyPolygon = streamInB2DPolyPolygon(rIn);
1798 	}
1799 }
1800 
1801 //*************************************************************************
1802 
1803 XLineStartItem::XLineStartItem(SfxItemPool* /*pPool*/, const basegfx::B2DPolyPolygon& rPolyPolygon)
1804 : 	NameOrIndex( XATTR_LINESTART, -1 ),
1805 	maPolyPolygon(rPolyPolygon)
1806 {
1807 }
1808 
1809 //*************************************************************************
1810 
1811 XLineStartItem::XLineStartItem(SfxItemPool* /*pPool*/)
1812 :	NameOrIndex(XATTR_LINESTART, -1 )
1813 {
1814 }
1815 
1816 /*************************************************************************
1817 |*
1818 |*	  XLineStartItem::Clone(SfxItemPool* pPool) const
1819 |*
1820 |*	  Beschreibung
1821 |*	  Ersterstellung	15.11.94
1822 |*	  Letzte Aenderung	15.11.94
1823 |*
1824 *************************************************************************/
1825 
1826 SfxPoolItem* XLineStartItem::Clone(SfxItemPool* /*pPool*/) const
1827 {
1828 	return new XLineStartItem(*this);
1829 }
1830 
1831 /*************************************************************************
1832 |*
1833 |*	  int XLineStartItem::operator==(const SfxPoolItem& rItem) const
1834 |*
1835 |*	  Beschreibung
1836 |*	  Ersterstellung	15.11.94
1837 |*	  Letzte Aenderung	18.11.94
1838 |*
1839 *************************************************************************/
1840 
1841 int XLineStartItem::operator==(const SfxPoolItem& rItem) const
1842 {
1843 	return ( NameOrIndex::operator==(rItem) && ((const XLineStartItem&) rItem).maPolyPolygon == maPolyPolygon );
1844 }
1845 
1846 /*************************************************************************
1847 |*
1848 |*	  SfxPoolItem* XLineStartItem::Create(SvStream& rIn, sal_uInt16 nVer) const
1849 |*
1850 |*	  Beschreibung
1851 |*	  Ersterstellung	15.11.94
1852 |*	  Letzte Aenderung	15.11.94
1853 |*
1854 *************************************************************************/
1855 
1856 SfxPoolItem* XLineStartItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
1857 {
1858 	return new XLineStartItem(rIn);
1859 }
1860 
1861 /*************************************************************************
1862 |*
1863 |*	  SfxPoolItem* XLineStartItem::Store(SvStream& rOut) const
1864 |*
1865 |*	  Beschreibung
1866 |*	  Ersterstellung	15.11.94
1867 |*	  Letzte Aenderung	18.11.94
1868 |*
1869 *************************************************************************/
1870 
1871 SvStream& XLineStartItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
1872 {
1873 	NameOrIndex::Store( rOut, nItemVersion );
1874 
1875 	if (!IsIndex())
1876 	{
1877 		streamOutB2DPolyPolygon(maPolyPolygon, rOut);
1878 	}
1879 
1880 	return rOut;
1881 }
1882 
1883 /*************************************************************************
1884 |*
1885 |*	  const basegfx::B2DPolyPolygon& XLineStartItem::GetValue(const XLineEndList* pTable)
1886 |*											   const
1887 |*
1888 |*	  Beschreibung
1889 |*	  Ersterstellung	15.11.94
1890 |*	  Letzte Aenderung	18.11.94
1891 |*
1892 *************************************************************************/
1893 
1894 basegfx::B2DPolyPolygon XLineStartItem::GetLineStartValue(const XLineEndList* pTable) const
1895 {
1896 	if (!IsIndex())
1897 	{
1898 		return maPolyPolygon;
1899 	}
1900 	else
1901 	{
1902 		return pTable->GetLineEnd(GetIndex())->GetLineEnd();
1903 	}
1904 }
1905 
1906 //------------------------------------------------------------------------
1907 
1908 SfxItemPresentation XLineStartItem::GetPresentation
1909 (
1910 	SfxItemPresentation ePres,
1911 	SfxMapUnit			/*eCoreUnit*/,
1912 	SfxMapUnit			/*ePresUnit*/,
1913     XubString&          rText, const IntlWrapper *
1914 )	const
1915 {
1916 	switch ( ePres )
1917 	{
1918 		case SFX_ITEM_PRESENTATION_NONE:
1919 			rText.Erase();
1920 			return ePres;
1921 		case SFX_ITEM_PRESENTATION_NAMELESS:
1922 		case SFX_ITEM_PRESENTATION_COMPLETE:
1923 			rText = GetName();
1924 			return ePres;
1925 		default:
1926 		return SFX_ITEM_PRESENTATION_NONE;
1927 	}
1928 }
1929 
1930 sal_Bool XLineStartItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
1931 {
1932 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1933     nMemberId &= ~CONVERT_TWIPS;
1934 	if( nMemberId == MID_NAME )
1935 	{
1936 		rtl::OUString aApiName;
1937 		SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
1938 		rVal <<= aApiName;
1939 	}
1940 	else
1941 	{
1942 		com::sun::star::drawing::PolyPolygonBezierCoords aBezier;
1943 		SvxConvertB2DPolyPolygonToPolyPolygonBezier( maPolyPolygon, aBezier );
1944 		rVal <<= aBezier;
1945 	}
1946 
1947 	return sal_True;
1948 }
1949 
1950 sal_Bool XLineStartItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
1951 {
1952 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
1953     nMemberId &= ~CONVERT_TWIPS;
1954 	if( nMemberId == MID_NAME )
1955 	{
1956 		return sal_False;
1957 	}
1958 	else
1959 	{
1960 		maPolyPolygon.clear();
1961 
1962 		if( rVal.hasValue() && rVal.getValue() )
1963 		{
1964 			if( rVal.getValueType() != ::getCppuType((const com::sun::star::drawing::PolyPolygonBezierCoords*)0) )
1965 				return sal_False;
1966 
1967 			com::sun::star::drawing::PolyPolygonBezierCoords* pCoords = (com::sun::star::drawing::PolyPolygonBezierCoords*)rVal.getValue();
1968 			if( pCoords->Coordinates.getLength() > 0 )
1969 			{
1970 				maPolyPolygon = SvxConvertPolyPolygonBezierToB2DPolyPolygon( pCoords );
1971 				// #i72807# close line start/end polygons hard
1972 				// maPolyPolygon.setClosed(true);
1973 			}
1974 		}
1975 	}
1976 
1977 	return sal_True;
1978 }
1979 
1980 /** this function searches in both the models pool and the styles pool for XLineStartItem
1981 	and XLineEndItem with the same value or name and returns an item with the value of
1982 	this item and a unique name for an item with this value. */
1983 XLineStartItem* XLineStartItem::checkForUniqueItem( SdrModel* pModel ) const
1984 {
1985 	if( pModel )
1986 	{
1987 		XLineStartItem* pTempItem = NULL;
1988 		const XLineStartItem* pLineStartItem = this;
1989 
1990 		String aUniqueName( GetName() );
1991 
1992 		if( !maPolyPolygon.count() )
1993 		{
1994 			// if the polygon is empty, check if the name is empty
1995 			if( aUniqueName.Len() == 0 )
1996 				return (XLineStartItem*)this;
1997 
1998 			// force empty name for empty polygons
1999 			return new XLineStartItem( String(), maPolyPolygon );
2000 		}
2001 
2002 		if( maPolyPolygon.count() > 1L )
2003 		{
2004 			// check if the polygon is closed
2005 			if(!maPolyPolygon.isClosed())
2006 			{
2007 				// force a closed polygon
2008 				basegfx::B2DPolyPolygon aNew(maPolyPolygon);
2009 				aNew.setClosed(true);
2010 				pTempItem = new XLineStartItem( aUniqueName, aNew );
2011 				pLineStartItem = pTempItem;
2012 			}
2013 		}
2014 
2015 		sal_Bool bForceNew = sal_False;
2016 
2017 		// 2. if we have a name check if there is already an item with the
2018 		// same name in the documents pool with a different line end or start
2019 
2020 		sal_uInt32 nCount, nSurrogate;
2021 
2022 		const SfxItemPool* pPool1 = &pModel->GetItemPool();
2023 		if( aUniqueName.Len() && pPool1 )
2024 		{
2025 			nCount = pPool1->GetItemCount2( XATTR_LINESTART );
2026 
2027 			for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2028 			{
2029 				const XLineStartItem* pItem = (const XLineStartItem*)pPool1->GetItem2( XATTR_LINESTART, nSurrogate );
2030 
2031 				if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
2032 				{
2033 					// if there is already an item with the same name and the same
2034 					// value its ok to set it
2035 					if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() )
2036 					{
2037 						// same name but different value, we need a new name for this item
2038 						aUniqueName = String();
2039 						bForceNew = sal_True;
2040 					}
2041 					break;
2042 				}
2043 			}
2044 
2045 			if( !bForceNew )
2046 			{
2047 				nCount = pPool1->GetItemCount2( XATTR_LINEEND );
2048 
2049 				for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2050 				{
2051 					const XLineEndItem* pItem = (const XLineEndItem*)pPool1->GetItem2( XATTR_LINEEND, nSurrogate );
2052 
2053 					if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
2054 					{
2055 						// if there is already an item with the same name and the same
2056 						// value its ok to set it
2057 						if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() )
2058 						{
2059 							// same name but different value, we need a new name for this item
2060 							aUniqueName = String();
2061 							bForceNew = sal_True;
2062 						}
2063 						break;
2064 					}
2065 				}
2066 			}
2067 		}
2068 
2069 		const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL;
2070 		if( aUniqueName.Len() && pPool2)
2071 		{
2072 			nCount = pPool2->GetItemCount2( XATTR_LINESTART );
2073 			for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2074 			{
2075 				const XLineStartItem* pItem = (const XLineStartItem*)pPool2->GetItem2( XATTR_LINESTART, nSurrogate );
2076 
2077 				if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
2078 				{
2079 					// if there is already an item with the same name and the same
2080 					// value its ok to set it
2081 					if( pItem->GetLineStartValue() != pLineStartItem->GetLineStartValue() )
2082 					{
2083 						// same name but different value, we need a new name for this item
2084 						aUniqueName = String();
2085 						bForceNew = sal_True;
2086 					}
2087 					break;
2088 				}
2089 			}
2090 
2091 			if( !bForceNew )
2092 			{
2093 				nCount = pPool2->GetItemCount2( XATTR_LINEEND );
2094 				for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2095 				{
2096 					const XLineEndItem* pItem = (const XLineEndItem*)pPool2->GetItem2( XATTR_LINEEND, nSurrogate );
2097 
2098 					if( pItem && ( pItem->GetName() == pLineStartItem->GetName() ) )
2099 					{
2100 						// if there is already an item with the same name and the same
2101 						// value its ok to set it
2102 						if( pItem->GetLineEndValue() != pLineStartItem->GetLineStartValue() )
2103 						{
2104 							// same name but different value, we need a new name for this item
2105 							aUniqueName = String();
2106 							bForceNew = sal_True;
2107 						}
2108 						break;
2109 					}
2110 				}
2111 			}
2112 		}
2113 
2114 		// if we have no name yet, find existing item with same conent or
2115 		// create a unique name
2116 		if( aUniqueName.Len() == 0 )
2117 		{
2118 			sal_Bool bFoundExisting = sal_False;
2119 
2120 			sal_Int32 nUserIndex = 1;
2121 			const ResId aRes(SVX_RES(RID_SVXSTR_LINEEND));
2122 			const String aUser( aRes );
2123 
2124 			if( pPool1 )
2125 			{
2126 				nCount = pPool1->GetItemCount2( XATTR_LINESTART );
2127 				sal_uInt32 nSurrogate2;
2128 
2129 				for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
2130 				{
2131 					const XLineStartItem* pItem = (const XLineStartItem*)pPool1->GetItem2( XATTR_LINESTART, nSurrogate2 );
2132 
2133 					if( pItem && pItem->GetName().Len() )
2134 					{
2135 						if( !bForceNew && pItem->GetLineStartValue() == pLineStartItem->GetLineStartValue() )
2136 						{
2137 							aUniqueName = pItem->GetName();
2138 							bFoundExisting = sal_True;
2139 							break;
2140 						}
2141 
2142 						if( pItem->GetName().CompareTo( aUser, aUser.Len() ) == 0 )
2143 						{
2144 							sal_Int32 nThisIndex = pItem->GetName().Copy( aUser.Len() ).ToInt32();
2145 							if( nThisIndex >= nUserIndex )
2146 								nUserIndex = nThisIndex + 1;
2147 						}
2148 					}
2149 				}
2150 
2151 				nCount = pPool1->GetItemCount2( XATTR_LINEEND );
2152 				for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
2153 				{
2154 					const XLineEndItem* pItem = (const XLineEndItem*)pPool1->GetItem2( XATTR_LINEEND, nSurrogate2 );
2155 
2156 					if( pItem && pItem->GetName().Len() )
2157 					{
2158 						if( !bForceNew && pItem->GetLineEndValue() == pLineStartItem->GetLineStartValue() )
2159 						{
2160 							aUniqueName = pItem->GetName();
2161 							bFoundExisting = sal_True;
2162 							break;
2163 						}
2164 
2165 						if( pItem->GetName().CompareTo( aUser, aUser.Len() ) == 0 )
2166 						{
2167 							sal_Int32 nThisIndex = pItem->GetName().Copy( aUser.Len() ).ToInt32();
2168 							if( nThisIndex >= nUserIndex )
2169 								nUserIndex = nThisIndex + 1;
2170 						}
2171 					}
2172 				}
2173 			}
2174 
2175 			if( !bFoundExisting )
2176 			{
2177 				aUniqueName = aUser;
2178 				aUniqueName += sal_Unicode(' ');
2179 				aUniqueName += String::CreateFromInt32( nUserIndex );
2180 			}
2181 		}
2182 
2183 		// if the given name is not valid, replace it!
2184 		if( aUniqueName != GetName() || pTempItem )
2185 		{
2186 			if( pTempItem )
2187 			{
2188 				pTempItem->SetName( aUniqueName );
2189 				return pTempItem;
2190 			}
2191 			else
2192 			{
2193 				return new XLineStartItem( aUniqueName, maPolyPolygon );
2194 			}
2195 		}
2196 	}
2197 
2198 	return (XLineStartItem*)this;
2199 }
2200 
2201 // ---------------------
2202 // class XLineEndItem
2203 // ---------------------
2204 TYPEINIT1_AUTOFACTORY(XLineEndItem, NameOrIndex);
2205 
2206 /*************************************************************************
2207 |*
2208 |*	  XLineEndItem::XLineEndItem(sal_Int32 nIndex)
2209 |*
2210 |*	  Beschreibung
2211 |*	  Ersterstellung	15.11.94
2212 |*	  Letzte Aenderung	18.11.94
2213 |*
2214 *************************************************************************/
2215 
2216 XLineEndItem::XLineEndItem(sal_Int32 nIndex)
2217 :	NameOrIndex(XATTR_LINEEND, nIndex)
2218 {
2219 }
2220 
2221 /*************************************************************************
2222 |*
2223 |*	  XLineEndItem::XLineEndItem(const XubString& rName,
2224 |*								 const basegfx::B2DPolyPolygon& rXPolygon)
2225 |*
2226 |*	  Beschreibung
2227 |*	  Ersterstellung	15.11.94
2228 |*	  Letzte Aenderung	18.11.94
2229 |*
2230 *************************************************************************/
2231 
2232 XLineEndItem::XLineEndItem(const XubString& rName, const basegfx::B2DPolyPolygon& rPolyPolygon)
2233 :	NameOrIndex(XATTR_LINEEND, rName),
2234 	maPolyPolygon(rPolyPolygon)
2235 {
2236 }
2237 
2238 /*************************************************************************
2239 |*
2240 |*	  XLineEndItem::XLineEndItem(const XLineEndItem& rItem)
2241 |*
2242 |*	  Beschreibung
2243 |*	  Ersterstellung	15.11.94
2244 |*	  Letzte Aenderung	18.11.94
2245 |*
2246 *************************************************************************/
2247 
2248 XLineEndItem::XLineEndItem(const XLineEndItem& rItem)
2249 :	NameOrIndex(rItem),
2250 	maPolyPolygon(rItem.maPolyPolygon)
2251 {
2252 }
2253 
2254 /*************************************************************************
2255 |*
2256 |*	  XLineEndItem::XLineEndItem(SvStream& rIn)
2257 |*
2258 |*	  Beschreibung
2259 |*	  Ersterstellung	15.11.94
2260 |*	  Letzte Aenderung	17.11.94
2261 |*
2262 *************************************************************************/
2263 
2264 XLineEndItem::XLineEndItem(SvStream& rIn) :
2265 	NameOrIndex(XATTR_LINEEND, rIn)
2266 {
2267 	if (!IsIndex())
2268 	{
2269 		maPolyPolygon = streamInB2DPolyPolygon(rIn);
2270 	}
2271 }
2272 
2273 //*************************************************************************
2274 
2275 XLineEndItem::XLineEndItem(SfxItemPool* /*pPool*/, const basegfx::B2DPolyPolygon& rPolyPolygon)
2276 : 	NameOrIndex( XATTR_LINEEND, -1 ),
2277 	maPolyPolygon(rPolyPolygon)
2278 {
2279 }
2280 
2281 //*************************************************************************
2282 
2283 XLineEndItem::XLineEndItem(SfxItemPool* /*pPool*/)
2284 :	NameOrIndex(XATTR_LINEEND, -1 )
2285 {
2286 }
2287 
2288 /*************************************************************************
2289 |*
2290 |*	  XLineEndItem::Clone(SfxItemPool* pPool) const
2291 |*
2292 |*	  Beschreibung
2293 |*	  Ersterstellung	15.11.94
2294 |*	  Letzte Aenderung	15.11.94
2295 |*
2296 *************************************************************************/
2297 
2298 SfxPoolItem* XLineEndItem::Clone(SfxItemPool* /*pPool*/) const
2299 {
2300 	return new XLineEndItem(*this);
2301 }
2302 
2303 /*************************************************************************
2304 |*
2305 |*	  int XLineEndItem::operator==(const SfxPoolItem& rItem) const
2306 |*
2307 |*	  Beschreibung
2308 |*	  Ersterstellung	15.11.94
2309 |*	  Letzte Aenderung	17.11.94
2310 |*
2311 *************************************************************************/
2312 
2313 int XLineEndItem::operator==(const SfxPoolItem& rItem) const
2314 {
2315 	return ( NameOrIndex::operator==(rItem) && ((const XLineEndItem&) rItem).maPolyPolygon == maPolyPolygon );
2316 }
2317 
2318 /*************************************************************************
2319 |*
2320 |*	  SfxPoolItem* XLineEndItem::Create(SvStream& rIn, sal_uInt16 nVer) const
2321 |*
2322 |*	  Beschreibung
2323 |*	  Ersterstellung	15.11.94
2324 |*	  Letzte Aenderung	15.11.94
2325 |*
2326 *************************************************************************/
2327 
2328 SfxPoolItem* XLineEndItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2329 {
2330 	return new XLineEndItem(rIn);
2331 }
2332 
2333 /*************************************************************************
2334 |*
2335 |*	  SfxPoolItem* XLineEndItem::Store(SvStream& rOut) const
2336 |*
2337 |*	  Beschreibung
2338 |*	  Ersterstellung	15.11.94
2339 |*	  Letzte Aenderung	17.11.94
2340 |*
2341 *************************************************************************/
2342 
2343 SvStream& XLineEndItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
2344 {
2345 	NameOrIndex::Store( rOut, nItemVersion );
2346 
2347 	if (!IsIndex())
2348 	{
2349 		streamOutB2DPolyPolygon(maPolyPolygon, rOut);
2350 	}
2351 
2352 	return rOut;
2353 }
2354 
2355 /*************************************************************************
2356 |*
2357 |*	  const basegfx::B2DPolyPolygon& XLineEndItem::GetValue(const XLineEndList* pTable) const
2358 |*
2359 |*	  Beschreibung
2360 |*	  Ersterstellung	15.11.94
2361 |*	  Letzte Aenderung	18.11.94
2362 |*
2363 *************************************************************************/
2364 
2365 basegfx::B2DPolyPolygon XLineEndItem::GetLineEndValue(const XLineEndList* pTable) const
2366 {
2367 	if (!IsIndex())
2368 	{
2369 		return maPolyPolygon;
2370 	}
2371 	else
2372 	{
2373 		return pTable->GetLineEnd(GetIndex())->GetLineEnd();
2374 	}
2375 }
2376 
2377 
2378 /** this function searches in both the models pool and the styles pool for XLineStartItem
2379 	and XLineEndItem with the same value or name and returns an item with the value of
2380 	this item and a unique name for an item with this value. */
2381 XLineEndItem* XLineEndItem::checkForUniqueItem( SdrModel* pModel ) const
2382 {
2383 	if( pModel )
2384 	{
2385 		XLineEndItem* pTempItem = NULL;
2386 		const XLineEndItem* pLineEndItem = this;
2387 
2388 		String aUniqueName( GetName() );
2389 
2390 		if( !maPolyPolygon.count() )
2391 		{
2392 			// if the polygon is empty, check if the name is empty
2393 			if( aUniqueName.Len() == 0 )
2394 				return (XLineEndItem*)this;
2395 
2396 			// force empty name for empty polygons
2397 			return new XLineEndItem( String(), maPolyPolygon );
2398 		}
2399 
2400 		if( maPolyPolygon.count() > 1L )
2401 		{
2402 			// check if the polygon is closed
2403 			if(!maPolyPolygon.isClosed())
2404 			{
2405 				// force a closed polygon
2406 				basegfx::B2DPolyPolygon aNew(maPolyPolygon);
2407 				aNew.setClosed(true);
2408 				pTempItem = new XLineEndItem( aUniqueName, aNew );
2409 				pLineEndItem = pTempItem;
2410 			}
2411 		}
2412 
2413 		sal_Bool bForceNew = sal_False;
2414 
2415 		// 2. if we have a name check if there is already an item with the
2416 		// same name in the documents pool with a different line end or start
2417 
2418 		sal_uInt16 nCount, nSurrogate;
2419 
2420 		const SfxItemPool* pPool1 = &pModel->GetItemPool();
2421 		if( aUniqueName.Len() && pPool1 )
2422 		{
2423 			nCount = pPool1->GetItemCount2( XATTR_LINESTART );
2424 
2425 			for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2426 			{
2427 				const XLineStartItem* pItem = (const XLineStartItem*)pPool1->GetItem2( XATTR_LINESTART, nSurrogate );
2428 
2429 				if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
2430 				{
2431 					// if there is already an item with the same name and the same
2432 					// value its ok to set it
2433 					if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() )
2434 					{
2435 						// same name but different value, we need a new name for this item
2436 						aUniqueName = String();
2437 						bForceNew = sal_True;
2438 					}
2439 					break;
2440 				}
2441 			}
2442 
2443 			if( !bForceNew )
2444 			{
2445 				nCount = pPool1->GetItemCount2( XATTR_LINEEND );
2446 
2447 				for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2448 				{
2449 					const XLineEndItem* pItem = (const XLineEndItem*)pPool1->GetItem2( XATTR_LINEEND, nSurrogate );
2450 
2451 					if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
2452 					{
2453 						// if there is already an item with the same name and the same
2454 						// value its ok to set it
2455 						if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() )
2456 						{
2457 							// same name but different value, we need a new name for this item
2458 							aUniqueName = String();
2459 							bForceNew = sal_True;
2460 						}
2461 						break;
2462 					}
2463 				}
2464 			}
2465 		}
2466 
2467 		const SfxItemPool* pPool2 = pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL;
2468 		if( aUniqueName.Len() && pPool2)
2469 		{
2470 			nCount = pPool2->GetItemCount2( XATTR_LINESTART );
2471 			for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2472 			{
2473 				const XLineStartItem* pItem = (const XLineStartItem*)pPool2->GetItem2( XATTR_LINESTART, nSurrogate );
2474 
2475 				if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
2476 				{
2477 					// if there is already an item with the same name and the same
2478 					// value its ok to set it
2479 					if( pItem->GetLineStartValue() != pLineEndItem->GetLineEndValue() )
2480 					{
2481 						// same name but different value, we need a new name for this item
2482 						aUniqueName = String();
2483 						bForceNew = sal_True;
2484 					}
2485 					break;
2486 				}
2487 			}
2488 
2489 			if( !bForceNew )
2490 			{
2491 				nCount = pPool2->GetItemCount2( XATTR_LINEEND );
2492 				for( nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
2493 				{
2494 					const XLineEndItem* pItem = (const XLineEndItem*)pPool2->GetItem2( XATTR_LINEEND, nSurrogate );
2495 
2496 					if( pItem && ( pItem->GetName() == pLineEndItem->GetName() ) )
2497 					{
2498 						// if there is already an item with the same name and the same
2499 						// value its ok to set it
2500 						if( pItem->GetLineEndValue() != pLineEndItem->GetLineEndValue() )
2501 						{
2502 							// same name but different value, we need a new name for this item
2503 							aUniqueName = String();
2504 							bForceNew = sal_True;
2505 						}
2506 						break;
2507 					}
2508 				}
2509 			}
2510 		}
2511 
2512 		// if we have no name yet, find existing item with same conent or
2513 		// create a unique name
2514 		if( aUniqueName.Len() == 0 )
2515 		{
2516 			sal_Bool bFoundExisting = sal_False;
2517 
2518 			sal_Int32 nUserIndex = 1;
2519 			const ResId aRes(SVX_RES(RID_SVXSTR_LINEEND));
2520 			const String aUser( aRes );
2521 
2522 			if( pPool1 )
2523 			{
2524 				nCount = pPool1->GetItemCount2( XATTR_LINESTART );
2525 				sal_uInt32 nSurrogate2;
2526 
2527 				for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
2528 				{
2529 					const XLineStartItem* pItem = (const XLineStartItem*)pPool1->GetItem2( XATTR_LINESTART, nSurrogate2 );
2530 
2531 					if( pItem && pItem->GetName().Len() )
2532 					{
2533 						if( !bForceNew && pItem->GetLineStartValue() == pLineEndItem->GetLineEndValue() )
2534 						{
2535 							aUniqueName = pItem->GetName();
2536 							bFoundExisting = sal_True;
2537 							break;
2538 						}
2539 
2540 						if( pItem->GetName().CompareTo( aUser, aUser.Len() ) == 0 )
2541 						{
2542 							sal_Int32 nThisIndex = pItem->GetName().Copy( aUser.Len() ).ToInt32();
2543 							if( nThisIndex >= nUserIndex )
2544 								nUserIndex = nThisIndex + 1;
2545 						}
2546 					}
2547 				}
2548 
2549 				nCount = pPool1->GetItemCount2( XATTR_LINEEND );
2550 				for( nSurrogate2 = 0; nSurrogate2 < nCount; nSurrogate2++ )
2551 				{
2552 					const XLineEndItem* pItem = (const XLineEndItem*)pPool1->GetItem2( XATTR_LINEEND, nSurrogate2 );
2553 
2554 					if( pItem && pItem->GetName().Len() )
2555 					{
2556 						if( !bForceNew && pItem->GetLineEndValue() == pLineEndItem->GetLineEndValue() )
2557 						{
2558 							aUniqueName = pItem->GetName();
2559 							bFoundExisting = sal_True;
2560 							break;
2561 						}
2562 
2563 						if( pItem->GetName().CompareTo( aUser, aUser.Len() ) == 0 )
2564 						{
2565 							sal_Int32 nThisIndex = pItem->GetName().Copy( aUser.Len() ).ToInt32();
2566 							if( nThisIndex >= nUserIndex )
2567 								nUserIndex = nThisIndex + 1;
2568 						}
2569 					}
2570 				}
2571 			}
2572 
2573 			if( !bFoundExisting )
2574 			{
2575 				aUniqueName = aUser;
2576 				aUniqueName += sal_Unicode(' ');
2577 				aUniqueName += String::CreateFromInt32( nUserIndex );
2578 			}
2579 		}
2580 
2581 		// if the given name is not valid, replace it!
2582 		if( aUniqueName != GetName() || pTempItem )
2583 		{
2584 			if( pTempItem )
2585 			{
2586 				pTempItem->SetName( aUniqueName );
2587 				return pTempItem;
2588 			}
2589 			else
2590 			{
2591 				return new XLineEndItem( aUniqueName, maPolyPolygon );
2592 			}
2593 		}
2594 	}
2595 
2596 	return (XLineEndItem*)this;
2597 }
2598 
2599 
2600 //------------------------------------------------------------------------
2601 
2602 SfxItemPresentation XLineEndItem::GetPresentation
2603 (
2604 	SfxItemPresentation ePres,
2605 	SfxMapUnit			/*eCoreUnit*/,
2606 	SfxMapUnit			/*ePresUnit*/,
2607     XubString&          rText, const IntlWrapper *
2608 )	const
2609 {
2610 	switch ( ePres )
2611 	{
2612 		case SFX_ITEM_PRESENTATION_NONE:
2613 			rText.Erase();
2614 			return ePres;
2615 		case SFX_ITEM_PRESENTATION_NAMELESS:
2616 		case SFX_ITEM_PRESENTATION_COMPLETE:
2617 			rText = GetName();
2618 			return ePres;
2619 		default:
2620 			return SFX_ITEM_PRESENTATION_NONE;
2621 	}
2622 }
2623 
2624 sal_Bool XLineEndItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
2625 {
2626 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
2627     nMemberId &= ~CONVERT_TWIPS;
2628 	if( nMemberId == MID_NAME )
2629 	{
2630 		rtl::OUString aApiName;
2631 		SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
2632 		rVal <<= aApiName;
2633 	}
2634 	else
2635 	{
2636 		com::sun::star::drawing::PolyPolygonBezierCoords aBezier;
2637 		SvxConvertB2DPolyPolygonToPolyPolygonBezier( maPolyPolygon, aBezier );
2638 		rVal <<= aBezier;
2639 	}
2640 	return sal_True;
2641 }
2642 
2643 sal_Bool XLineEndItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
2644 {
2645 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
2646     nMemberId &= ~CONVERT_TWIPS;
2647 	if( nMemberId == MID_NAME )
2648 	{
2649 		return sal_False;
2650 	}
2651 	else
2652 	{
2653 		maPolyPolygon.clear();
2654 
2655 		if( rVal.hasValue() && rVal.getValue() )
2656 		{
2657 			if( rVal.getValueType() != ::getCppuType((const com::sun::star::drawing::PolyPolygonBezierCoords*)0) )
2658 				return sal_False;
2659 
2660 			com::sun::star::drawing::PolyPolygonBezierCoords* pCoords = (com::sun::star::drawing::PolyPolygonBezierCoords*)rVal.getValue();
2661 			if( pCoords->Coordinates.getLength() > 0 )
2662 			{
2663 				maPolyPolygon = SvxConvertPolyPolygonBezierToB2DPolyPolygon( pCoords );
2664 				// #i72807# close line start/end polygons hard
2665 				// maPolyPolygon.setClosed(true);
2666 			}
2667 		}
2668 	}
2669 
2670 	return sal_True;
2671 }
2672 
2673 // ----------------------------
2674 // class XLineStartWidthItem
2675 // ----------------------------
2676 TYPEINIT1_AUTOFACTORY(XLineStartWidthItem, SfxMetricItem);
2677 
2678 /*************************************************************************
2679 |*
2680 |*	  XLineStartWidthItem::XLineStartWidthItem(sal_Int32 nWidth)
2681 |*
2682 |*	  Beschreibung
2683 |*	  Ersterstellung	15.11.94
2684 |*	  Letzte Aenderung	18.11.94
2685 |*
2686 *************************************************************************/
2687 
2688 XLineStartWidthItem::XLineStartWidthItem(long nWidth) :
2689 	SfxMetricItem(XATTR_LINESTARTWIDTH, nWidth)
2690 {
2691 }
2692 
2693 /*************************************************************************
2694 |*
2695 |*	  XLineStartWidthItem::XLineStartWidthItem(SvStream& rIn)
2696 |*
2697 |*	  Beschreibung
2698 |*	  Ersterstellung	15.11.94
2699 |*	  Letzte Aenderung	15.11.94
2700 |*
2701 *************************************************************************/
2702 
2703 XLineStartWidthItem::XLineStartWidthItem(SvStream& rIn) :
2704 	SfxMetricItem(XATTR_LINESTARTWIDTH, rIn)
2705 {
2706 }
2707 
2708 /*************************************************************************
2709 |*
2710 |*	  XLineStartWidthItem::Clone(SfxItemPool* pPool) const
2711 |*
2712 |*	  Beschreibung
2713 |*	  Ersterstellung	15.11.94
2714 |*	  Letzte Aenderung	15.11.94
2715 |*
2716 *************************************************************************/
2717 
2718 SfxPoolItem* XLineStartWidthItem::Clone(SfxItemPool* /*pPool*/) const
2719 {
2720 	return new XLineStartWidthItem(*this);
2721 }
2722 
2723 /*************************************************************************
2724 |*
2725 |*	  SfxPoolItem* XLineStartWidthItem::Create(SvStream& rIn, sal_uInt16 nVer)
2726 |*												const
2727 |*
2728 |*	  Beschreibung
2729 |*	  Ersterstellung	15.11.94
2730 |*	  Letzte Aenderung	15.11.94
2731 |*
2732 *************************************************************************/
2733 
2734 SfxPoolItem* XLineStartWidthItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2735 {
2736 	return new XLineStartWidthItem(rIn);
2737 }
2738 
2739 //------------------------------------------------------------------------
2740 
2741 SfxItemPresentation XLineStartWidthItem::GetPresentation
2742 (
2743 	SfxItemPresentation ePres,
2744 	SfxMapUnit			eCoreUnit,
2745 	SfxMapUnit			ePresUnit,
2746     XubString&          rText, const IntlWrapper * pIntl
2747 )	const
2748 {
2749 	switch ( ePres )
2750 	{
2751 		case SFX_ITEM_PRESENTATION_NONE:
2752 			rText.Erase();
2753 			return ePres;
2754 		case SFX_ITEM_PRESENTATION_NAMELESS:
2755 		case SFX_ITEM_PRESENTATION_COMPLETE:
2756 			rText = GetMetricText( (long) GetValue(),
2757                                     eCoreUnit, ePresUnit, pIntl);
2758 			rText += sal_Unicode(' ');
2759 			rText += SVX_RESSTR( GetMetricId( ePresUnit) );
2760 			return ePres;
2761 		default:
2762 			return SFX_ITEM_PRESENTATION_NONE;
2763 	}
2764 }
2765 
2766 sal_Bool XLineStartWidthItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2767 {
2768 	rVal <<= (sal_Int32)GetValue();
2769 	return sal_True;
2770 }
2771 
2772 sal_Bool XLineStartWidthItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2773 {
2774 	sal_Int32 nValue = 0;
2775 	rVal >>= nValue;
2776 	SetValue( nValue );
2777 	return sal_True;
2778 }
2779 
2780 
2781 
2782 // --------------------------
2783 // class XLineEndWidthItem
2784 // --------------------------
2785 TYPEINIT1_AUTOFACTORY(XLineEndWidthItem, SfxMetricItem);
2786 
2787 /*************************************************************************
2788 |*
2789 |*	  XLineEndWidthItem::XLineEndWidthItem(long nWidth)
2790 |*
2791 |*	  Beschreibung
2792 |*	  Ersterstellung	15.11.94
2793 |*	  Letzte Aenderung	15.11.94
2794 |*
2795 *************************************************************************/
2796 
2797 XLineEndWidthItem::XLineEndWidthItem(long nWidth) :
2798    SfxMetricItem(XATTR_LINEENDWIDTH, nWidth)
2799 {
2800 }
2801 
2802 /*************************************************************************
2803 |*
2804 |*	  XLineEndWidthItem::XLineEndWidthItem(SvStream& rIn)
2805 |*
2806 |*	  Beschreibung
2807 |*	  Ersterstellung	15.11.94
2808 |*	  Letzte Aenderung	15.11.94
2809 |*
2810 *************************************************************************/
2811 
2812 XLineEndWidthItem::XLineEndWidthItem(SvStream& rIn) :
2813 	SfxMetricItem(XATTR_LINEENDWIDTH, rIn)
2814 {
2815 }
2816 
2817 /*************************************************************************
2818 |*
2819 |*	  XLineEndWidthItem::Clone(SfxItemPool* pPool) const
2820 |*
2821 |*	  Beschreibung
2822 |*	  Ersterstellung	15.11.94
2823 |*	  Letzte Aenderung	15.11.94
2824 |*
2825 *************************************************************************/
2826 
2827 SfxPoolItem* XLineEndWidthItem::Clone(SfxItemPool* /*pPool*/) const
2828 {
2829 	return new XLineEndWidthItem(*this);
2830 }
2831 
2832 /*************************************************************************
2833 |*
2834 |*	  SfxPoolItem* XLineEndWidthItem::Create(SvStream& rIn, sal_uInt16 nVer) const
2835 |*
2836 |*	  Beschreibung
2837 |*	  Ersterstellung	15.11.94
2838 |*	  Letzte Aenderung	15.11.94
2839 |*
2840 *************************************************************************/
2841 
2842 SfxPoolItem* XLineEndWidthItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2843 {
2844 	return new XLineEndWidthItem(rIn);
2845 }
2846 
2847 //------------------------------------------------------------------------
2848 
2849 SfxItemPresentation XLineEndWidthItem::GetPresentation
2850 (
2851 	SfxItemPresentation ePres,
2852 	SfxMapUnit			eCoreUnit,
2853 	SfxMapUnit			ePresUnit,
2854     XubString&          rText, const IntlWrapper *pIntl
2855 )	const
2856 {
2857 	switch ( ePres )
2858 	{
2859 		case SFX_ITEM_PRESENTATION_NONE:
2860 			rText.Erase();
2861 			return ePres;
2862 		case SFX_ITEM_PRESENTATION_NAMELESS:
2863 		case SFX_ITEM_PRESENTATION_COMPLETE:
2864 			rText = GetMetricText( (long) GetValue(),
2865                                     eCoreUnit, ePresUnit, pIntl);
2866 			rText += sal_Unicode(' ');
2867 			rText += SVX_RESSTR( GetMetricId( ePresUnit) );
2868 			return ePres;
2869 		default:
2870 			return SFX_ITEM_PRESENTATION_NONE;
2871 	}
2872 }
2873 
2874 sal_Bool XLineEndWidthItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2875 {
2876 	rVal <<= (sal_Int32)GetValue();
2877 	return sal_True;
2878 }
2879 
2880 sal_Bool XLineEndWidthItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2881 {
2882 	sal_Int32 nValue = 0;
2883 	rVal >>= nValue;
2884 	SetValue( nValue );
2885 	return sal_True;
2886 }
2887 
2888 
2889 // -----------------------------
2890 // class XLineStartCenterItem
2891 // -----------------------------
2892 TYPEINIT1_AUTOFACTORY(XLineStartCenterItem, SfxBoolItem);
2893 
2894 /*************************************************************************
2895 |*
2896 |*	  XLineStartCenterItem::XLineStartCenterItem(sal_Bool bStartCenter)
2897 |*
2898 |*	  Beschreibung
2899 |*	  Ersterstellung	15.11.94
2900 |*	  Letzte Aenderung	15.11.94
2901 |*
2902 *************************************************************************/
2903 
2904 XLineStartCenterItem::XLineStartCenterItem(sal_Bool bStartCenter) :
2905 	SfxBoolItem(XATTR_LINESTARTCENTER, bStartCenter)
2906 {
2907 }
2908 
2909 /*************************************************************************
2910 |*
2911 |*	  XLineStartCenterItem::XLineStartCenterItem(SvStream& rIn)
2912 |*
2913 |*	  Beschreibung
2914 |*	  Ersterstellung	15.11.94
2915 |*	  Letzte Aenderung	15.11.94
2916 |*
2917 *************************************************************************/
2918 
2919 XLineStartCenterItem::XLineStartCenterItem(SvStream& rIn) :
2920 	SfxBoolItem(XATTR_LINESTARTCENTER, rIn)
2921 {
2922 }
2923 
2924 /*************************************************************************
2925 |*
2926 |*	  XLineStartCenterItem::Clone(SfxItemPool* pPool) const
2927 |*
2928 |*	  Beschreibung
2929 |*	  Ersterstellung	15.11.94
2930 |*	  Letzte Aenderung	15.11.94
2931 |*
2932 *************************************************************************/
2933 
2934 SfxPoolItem* XLineStartCenterItem::Clone(SfxItemPool* /*pPool*/) const
2935 {
2936 	return new XLineStartCenterItem(*this);
2937 }
2938 
2939 /*************************************************************************
2940 |*
2941 |*	  SfxPoolItem* XLineStartCenterItem::Create(SvStream& rIn, sal_uInt16 nVer)
2942 |*												const
2943 |*
2944 |*	  Beschreibung
2945 |*	  Ersterstellung	15.11.94
2946 |*	  Letzte Aenderung	15.11.94
2947 |*
2948 *************************************************************************/
2949 
2950 SfxPoolItem* XLineStartCenterItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
2951 {
2952 	return new XLineStartCenterItem(rIn);
2953 }
2954 
2955 //------------------------------------------------------------------------
2956 
2957 SfxItemPresentation XLineStartCenterItem::GetPresentation
2958 (
2959 	SfxItemPresentation ePres,
2960 	SfxMapUnit			/*eCoreUnit*/,
2961 	SfxMapUnit			/*ePresUnit*/,
2962     XubString&          rText, const IntlWrapper *
2963 )	const
2964 {
2965 	switch ( ePres )
2966 	{
2967 		case SFX_ITEM_PRESENTATION_NONE:
2968 			rText.Erase();
2969 			return ePres;
2970 		case SFX_ITEM_PRESENTATION_NAMELESS:
2971 		case SFX_ITEM_PRESENTATION_COMPLETE:
2972 			rText = XubString( ResId( GetValue() ? RID_SVXSTR_CENTERED :
2973 							RID_SVXSTR_NOTCENTERED, DIALOG_MGR() ) );
2974 			return ePres;
2975 		default:
2976 			return SFX_ITEM_PRESENTATION_NONE;
2977 	}
2978 }
2979 
2980 sal_Bool XLineStartCenterItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
2981 {
2982 	sal_Bool bValue = GetValue();
2983 	rVal.setValue( &bValue, ::getCppuBooleanType()  );
2984 	return sal_True;
2985 }
2986 
2987 sal_Bool XLineStartCenterItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
2988 {
2989 	if( !rVal.hasValue() || rVal.getValueType() != ::getCppuBooleanType() )
2990 		return sal_False;
2991 
2992 	SetValue( *(sal_Bool*)rVal.getValue() );
2993 	return sal_True;
2994 }
2995 
2996 
2997 // ---------------------------
2998 // class XLineEndCenterItem
2999 // ---------------------------
3000 TYPEINIT1_AUTOFACTORY(XLineEndCenterItem, SfxBoolItem);
3001 
3002 /*************************************************************************
3003 |*
3004 |*	  XLineEndCenterItem::XLineEndCenterItem(sal_Bool bEndCenter)
3005 |*
3006 |*	  Beschreibung
3007 |*	  Ersterstellung	15.11.94
3008 |*	  Letzte Aenderung	15.11.94
3009 |*
3010 *************************************************************************/
3011 
3012 XLineEndCenterItem::XLineEndCenterItem(sal_Bool bEndCenter) :
3013 	SfxBoolItem(XATTR_LINEENDCENTER, bEndCenter)
3014 {
3015 }
3016 
3017 /*************************************************************************
3018 |*
3019 |*	  XLineEndCenterItem::XLineEndCenterItem(SvStream& rIn)
3020 |*
3021 |*	  Beschreibung
3022 |*	  Ersterstellung	15.11.94
3023 |*	  Letzte Aenderung	15.11.94
3024 |*
3025 *************************************************************************/
3026 
3027 XLineEndCenterItem::XLineEndCenterItem(SvStream& rIn) :
3028 	SfxBoolItem(XATTR_LINEENDCENTER, rIn)
3029 {
3030 }
3031 
3032 /*************************************************************************
3033 |*
3034 |*	  XLineEndCenterItem::Clone(SfxItemPool* pPool) const
3035 |*
3036 |*	  Beschreibung
3037 |*	  Ersterstellung	15.11.94
3038 |*	  Letzte Aenderung	15.11.94
3039 |*
3040 *************************************************************************/
3041 
3042 SfxPoolItem* XLineEndCenterItem::Clone(SfxItemPool* /*pPool*/) const
3043 {
3044 	return new XLineEndCenterItem(*this);
3045 }
3046 
3047 /*************************************************************************
3048 |*
3049 |*	  SfxPoolItem* XLineEndCenterItem::Create(SvStream& rIn, sal_uInt16 nVer)
3050 |*												const
3051 |*
3052 |*	  Beschreibung
3053 |*	  Ersterstellung	15.11.94
3054 |*	  Letzte Aenderung	15.11.94
3055 |*
3056 *************************************************************************/
3057 
3058 SfxPoolItem* XLineEndCenterItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3059 {
3060 	return new XLineEndCenterItem(rIn);
3061 }
3062 
3063 //------------------------------------------------------------------------
3064 
3065 SfxItemPresentation XLineEndCenterItem::GetPresentation
3066 (
3067 	SfxItemPresentation ePres,
3068 	SfxMapUnit			/*eCoreUnit*/,
3069 	SfxMapUnit			/*ePresUnit*/,
3070     XubString&          rText, const IntlWrapper *
3071 )	const
3072 {
3073 	switch ( ePres )
3074 	{
3075 		case SFX_ITEM_PRESENTATION_NONE:
3076 			rText.Erase();
3077 			return ePres;
3078 		case SFX_ITEM_PRESENTATION_NAMELESS:
3079 		case SFX_ITEM_PRESENTATION_COMPLETE:
3080 			rText = XubString( ResId( GetValue() ? RID_SVXSTR_CENTERED :
3081 							RID_SVXSTR_NOTCENTERED, DIALOG_MGR() ) );
3082 			return ePres;
3083 		default:
3084 			return SFX_ITEM_PRESENTATION_NONE;
3085 	}
3086 }
3087 
3088 sal_Bool XLineEndCenterItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
3089 {
3090 	sal_Bool bValue = GetValue();
3091 	rVal.setValue( &bValue, ::getCppuBooleanType()  );
3092 	return sal_True;
3093 }
3094 
3095 sal_Bool XLineEndCenterItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
3096 {
3097 	if( !rVal.hasValue() || rVal.getValueType() != ::getCppuBooleanType() )
3098 		return sal_False;
3099 
3100 	SetValue( *(sal_Bool*)rVal.getValue() );
3101 	return sal_True;
3102 }
3103 
3104 
3105 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3106 //							 Fuellattribute
3107 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3108 
3109 // --------------------
3110 // class XFillStyleItem
3111 // --------------------
3112 TYPEINIT1_AUTOFACTORY(XFillStyleItem, SfxEnumItem);
3113 
3114 /*************************************************************************
3115 |*
3116 |*	  XFillStyleItem::XFillStyleItem(XFillStyle eFillStyle)
3117 |*
3118 |*	  Beschreibung
3119 |*	  Ersterstellung	15.11.94
3120 |*	  Letzte Aenderung	15.11.94
3121 |*
3122 *************************************************************************/
3123 
3124 XFillStyleItem::XFillStyleItem(XFillStyle eFillStyle) :
3125 	SfxEnumItem(XATTR_FILLSTYLE, sal::static_int_cast< sal_uInt16 >(eFillStyle))
3126 {
3127 }
3128 
3129 /*************************************************************************
3130 |*
3131 |*	  XFillStyleItem::XFillStyleItem(SvStream& rIn)
3132 |*
3133 |*	  Beschreibung
3134 |*	  Ersterstellung	15.11.94
3135 |*	  Letzte Aenderung	15.11.94
3136 |*
3137 *************************************************************************/
3138 
3139 XFillStyleItem::XFillStyleItem(SvStream& rIn) :
3140 	SfxEnumItem(XATTR_FILLSTYLE, rIn)
3141 {
3142 }
3143 
3144 /*************************************************************************
3145 |*
3146 |*	  XFillStyleItem::Clone(SfxItemPool* pPool) const
3147 |*
3148 |*	  Beschreibung
3149 |*	  Ersterstellung	09.11.94
3150 |*	  Letzte Aenderung	09.11.94
3151 |*
3152 *************************************************************************/
3153 
3154 SfxPoolItem* XFillStyleItem::Clone(SfxItemPool* /*pPool*/) const
3155 {
3156 	return new XFillStyleItem( *this );
3157 }
3158 
3159 /*************************************************************************
3160 |*
3161 |*	  SfxPoolItem* XFillStyleItem::Create(SvStream& rIn, sal_uInt16 nVer) const
3162 |*
3163 |*	  Beschreibung
3164 |*	  Ersterstellung	15.11.94
3165 |*	  Letzte Aenderung	15.11.94
3166 |*
3167 *************************************************************************/
3168 
3169 SfxPoolItem* XFillStyleItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3170 {
3171 	return new XFillStyleItem(rIn);
3172 }
3173 
3174 //------------------------------------------------------------------------
3175 
3176 SfxItemPresentation XFillStyleItem::GetPresentation
3177 (
3178 	SfxItemPresentation ePres,
3179 	SfxMapUnit			/*eCoreUnit*/,
3180 	SfxMapUnit			/*ePresUnit*/,
3181     XubString&          rText, const IntlWrapper *
3182 )	const
3183 {
3184 	rText.Erase();
3185 
3186 	switch ( ePres )
3187 	{
3188 		case SFX_ITEM_PRESENTATION_NONE:
3189 			return ePres;
3190 
3191 		case SFX_ITEM_PRESENTATION_NAMELESS:
3192 		case SFX_ITEM_PRESENTATION_COMPLETE:
3193 		{
3194 			sal_uInt16 nId = 0;
3195 
3196 			switch( (sal_uInt16)GetValue() )
3197 			{
3198 				case XFILL_NONE:
3199 					nId = RID_SVXSTR_INVISIBLE;
3200 					break;
3201 				case XFILL_SOLID:
3202 					nId = RID_SVXSTR_SOLID;
3203 					break;
3204 				case XFILL_GRADIENT:
3205 					nId = RID_SVXSTR_GRADIENT;
3206 					break;
3207 				case XFILL_HATCH:
3208 					nId = RID_SVXSTR_HATCH;
3209 					break;
3210 				case XFILL_BITMAP:
3211 					nId = RID_SVXSTR_BITMAP;
3212 					break;
3213 			}
3214 
3215 			if ( nId )
3216 				rText = SVX_RESSTR( nId );
3217 			return ePres;
3218 		}
3219 		default:
3220 			return SFX_ITEM_PRESENTATION_NONE;
3221 	}
3222 }
3223 
3224 //------------------------------------------------------------------------
3225 
3226 sal_uInt16 XFillStyleItem::GetValueCount() const
3227 {
3228 	return 5;
3229 }
3230 
3231 // -----------------------------------------------------------------------
3232 sal_Bool XFillStyleItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
3233 {
3234 	::com::sun::star::drawing::FillStyle eFS = (::com::sun::star::drawing::FillStyle)GetValue();
3235 
3236 	rVal <<= eFS;
3237 
3238 	return sal_True;
3239 }
3240 
3241 // -----------------------------------------------------------------------
3242 sal_Bool XFillStyleItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
3243 {
3244     ::com::sun::star::drawing::FillStyle eFS;
3245 	if(!(rVal >>= eFS))
3246     {
3247         // also try an int (for Basic)
3248         sal_Int32 nFS = 0;
3249         if(!(rVal >>= nFS))
3250             return sal_False;
3251         eFS = (::com::sun::star::drawing::FillStyle)nFS;
3252     }
3253 
3254 	SetValue( sal::static_int_cast< sal_uInt16 >( eFS ) );
3255 
3256 	return sal_True;
3257 }
3258 
3259 
3260 // -------------------
3261 // class XFillColorItem
3262 // -------------------
3263 TYPEINIT1_AUTOFACTORY(XFillColorItem, XColorItem);
3264 
3265 /*************************************************************************
3266 |*
3267 |*	  XFillColorItem::XFillColorItem(sal_Int32 nIndex, const Color& rTheColor)
3268 |*
3269 |*	  Beschreibung
3270 |*	  Ersterstellung	15.11.94
3271 |*	  Letzte Aenderung	15.11.94
3272 |*
3273 *************************************************************************/
3274 
3275 XFillColorItem::XFillColorItem(sal_Int32 nIndex, const Color& rTheColor) :
3276 	XColorItem(XATTR_FILLCOLOR, nIndex, rTheColor)
3277 {
3278 }
3279 
3280 /*************************************************************************
3281 |*
3282 |*	  XFillColorItem::XFillColorItem(const XubString& rName, const Color& rTheColor)
3283 |*
3284 |*	  Beschreibung
3285 |*	  Ersterstellung	15.11.94
3286 |*	  Letzte Aenderung	15.11.94
3287 |*
3288 *************************************************************************/
3289 
3290 XFillColorItem::XFillColorItem(const XubString& rName, const Color& rTheColor) :
3291 	XColorItem(XATTR_FILLCOLOR, rName, rTheColor)
3292 {
3293 }
3294 
3295 /*************************************************************************
3296 |*
3297 |*	  XFillColorItem::XFillColorItem(SvStream& rIn)
3298 |*
3299 |*	  Beschreibung
3300 |*	  Ersterstellung	15.11.94
3301 |*	  Letzte Aenderung	15.11.94
3302 |*
3303 *************************************************************************/
3304 
3305 XFillColorItem::XFillColorItem(SvStream& rIn) :
3306 	XColorItem(XATTR_FILLCOLOR, rIn)
3307 {
3308 }
3309 
3310 /*************************************************************************
3311 |*
3312 |*	  XFillColorItem::Clone(SfxItemPool* pPool) const
3313 |*
3314 |*	  Beschreibung
3315 |*	  Ersterstellung	15.11.94
3316 |*	  Letzte Aenderung	15.11.94
3317 |*
3318 *************************************************************************/
3319 
3320 SfxPoolItem* XFillColorItem::Clone(SfxItemPool* /*pPool*/) const
3321 {
3322 	return new XFillColorItem(*this);
3323 }
3324 
3325 /*************************************************************************
3326 |*
3327 |*	  SfxPoolItem* XFillColorItem::Create(SvStream& rIn, sal_uInt16 nVer) const
3328 |*
3329 |*	  Beschreibung
3330 |*	  Ersterstellung	15.11.94
3331 |*	  Letzte Aenderung	15.11.94
3332 |*
3333 *************************************************************************/
3334 
3335 SfxPoolItem* XFillColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
3336 {
3337 	return new XFillColorItem(rIn);
3338 }
3339 
3340 //------------------------------------------------------------------------
3341 
3342 SfxItemPresentation XFillColorItem::GetPresentation
3343 (
3344 	SfxItemPresentation ePres,
3345 	SfxMapUnit			/*eCoreUnit*/,
3346 	SfxMapUnit			/*ePresUnit*/,
3347     XubString&          rText, const IntlWrapper *
3348 )	const
3349 {
3350 	switch ( ePres )
3351 	{
3352 		case SFX_ITEM_PRESENTATION_NONE:
3353 			rText.Erase();
3354 			return ePres;
3355 		case SFX_ITEM_PRESENTATION_NAMELESS:
3356 		case SFX_ITEM_PRESENTATION_COMPLETE:
3357 			rText = GetName();
3358 			return ePres;
3359 		default:
3360 			return SFX_ITEM_PRESENTATION_NONE;
3361 	}
3362 }
3363 
3364 // -----------------------------------------------------------------------
3365 
3366 sal_Bool XFillColorItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
3367 {
3368     rVal <<= (sal_Int32)GetColorValue().GetRGBColor();
3369 
3370 	return sal_True;
3371 }
3372 
3373 // -----------------------------------------------------------------------
3374 
3375 sal_Bool XFillColorItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 /*nMemberId*/)
3376 {
3377 	sal_Int32 nValue = 0;
3378 	if(!(rVal >>= nValue ))
3379 		return sal_False;
3380 
3381 	SetColorValue( nValue );
3382 	return sal_True;
3383 }
3384 
3385 // -----------------------------
3386 // class XSecondaryFillColorItem
3387 // -----------------------------
3388 TYPEINIT1_AUTOFACTORY(XSecondaryFillColorItem, XColorItem);
3389 
3390 XSecondaryFillColorItem::XSecondaryFillColorItem(sal_Int32 nIndex, const Color& rTheColor) :
3391 	XColorItem(XATTR_SECONDARYFILLCOLOR, nIndex, rTheColor)
3392 {
3393 }
3394 
3395 XSecondaryFillColorItem::XSecondaryFillColorItem(const XubString& rName, const Color& rTheColor) :
3396 	XColorItem(XATTR_SECONDARYFILLCOLOR, rName, rTheColor)
3397 {
3398 }
3399 
3400 XSecondaryFillColorItem::XSecondaryFillColorItem( SvStream& rIn ) :
3401 	XColorItem(XATTR_SECONDARYFILLCOLOR, rIn)
3402 {
3403 }
3404 
3405 SfxPoolItem* XSecondaryFillColorItem::Clone(SfxItemPool* /*pPool*/) const
3406 {
3407 	return new XSecondaryFillColorItem(*this);
3408 }
3409 
3410 SfxPoolItem* XSecondaryFillColorItem::Create( SvStream& rIn, sal_uInt16 nVer ) const
3411 {
3412 	if ( nVer >= 2 )
3413 		return new XSecondaryFillColorItem( rIn );
3414 	else
3415 		return new XSecondaryFillColorItem( String(), Color(0,184,255) );
3416 }
3417 sal_uInt16 XSecondaryFillColorItem::GetVersion( sal_uInt16 /*nFileFormatVersion*/ ) const
3418 {
3419 	return 2;
3420 }
3421 SfxItemPresentation XSecondaryFillColorItem::GetPresentation
3422 (
3423 	SfxItemPresentation ePres,
3424 	SfxMapUnit			/*eCoreUnit*/,
3425 	SfxMapUnit			/*ePresUnit*/,
3426     XubString&          rText, const IntlWrapper *
3427 )	const
3428 {
3429 	switch ( ePres )
3430 	{
3431 		case SFX_ITEM_PRESENTATION_NONE:
3432 			rText.Erase();
3433 			return ePres;
3434 		case SFX_ITEM_PRESENTATION_NAMELESS:
3435 		case SFX_ITEM_PRESENTATION_COMPLETE:
3436 			rText = GetName();
3437 			return ePres;
3438 		default:
3439 			return SFX_ITEM_PRESENTATION_NONE;
3440 	}
3441 }
3442 
3443 // ----------------
3444 // class XGradient
3445 // ----------------
3446 
3447 /*************************************************************************
3448 |*
3449 |*    XGradient::XGradient()
3450 |*
3451 *************************************************************************/
3452 
3453 XGradient::XGradient() :
3454     eStyle( XGRAD_LINEAR ),
3455     aStartColor( Color( COL_BLACK ) ),
3456     aEndColor( Color( COL_WHITE ) ),
3457     nAngle( 0 ),
3458     nBorder( 0 ),
3459     nOfsX( 50 ),
3460     nOfsY( 50 ),
3461     nIntensStart( 100 ),
3462     nIntensEnd( 100 ),
3463     nStepCount( 0 )
3464 {
3465 }
3466 
3467 /*************************************************************************
3468 |*
3469 |*    XGradient::XGradient(XGradientStyle, const Color&, const Color&,
3470 |*                         long, sal_uInt16, sal_uInt16, sal_uInt16)
3471 |*
3472 |*    Beschreibung
3473 |*    Ersterstellung    21.11.94
3474 |*    Letzte Aenderung  21.11.94
3475 |*
3476 *************************************************************************/
3477 
3478 XGradient::XGradient(const Color& rStart, const Color& rEnd,
3479 					 XGradientStyle eTheStyle, long nTheAngle, sal_uInt16 nXOfs,
3480 					 sal_uInt16 nYOfs, sal_uInt16 nTheBorder,
3481 					 sal_uInt16 nStartIntens, sal_uInt16 nEndIntens,
3482 					 sal_uInt16 nSteps) :
3483 	eStyle(eTheStyle),
3484 	aStartColor(rStart),
3485 	aEndColor(rEnd),
3486 	nAngle(nTheAngle),
3487 	nBorder(nTheBorder),
3488 	nOfsX(nXOfs),
3489 	nOfsY(nYOfs),
3490 	nIntensStart(nStartIntens),
3491 	nIntensEnd(nEndIntens),
3492 	nStepCount(nSteps)
3493 {
3494 }
3495 
3496 /*************************************************************************
3497 |*
3498 |*	  int XGradient::operator==(const SfxPoolItem& rItem) const
3499 |*
3500 |*	  Beschreibung
3501 |*	  Ersterstellung	29.11.94
3502 |*	  Letzte Aenderung	29.11.94
3503 |*
3504 *************************************************************************/
3505 
3506 bool XGradient::operator==(const XGradient& rGradient) const
3507 {
3508 	return ( eStyle 		== rGradient.eStyle 		&&
3509 			 aStartColor	== rGradient.aStartColor	&&
3510 			 aEndColor		== rGradient.aEndColor		&&
3511 			 nAngle 		== rGradient.nAngle 		&&
3512 			 nBorder		== rGradient.nBorder		&&
3513 			 nOfsX			== rGradient.nOfsX			&&
3514 			 nOfsY			== rGradient.nOfsY			&&
3515 			 nIntensStart	== rGradient.nIntensStart	&&
3516 			 nIntensEnd		== rGradient.nIntensEnd		&&
3517 			 nStepCount		== rGradient.nStepCount );
3518 }
3519 
3520 
3521 // -----------------------
3522 // class XFillGradientItem
3523 // -----------------------
3524 TYPEINIT1_AUTOFACTORY(XFillGradientItem, NameOrIndex);
3525 
3526 /*************************************************************************
3527 |*
3528 |*	  XFillGradientItem::XFillGradientItem(sal_Int32 nIndex,
3529 |*										 const XGradient& rTheGradient)
3530 |*
3531 |*	  Beschreibung
3532 |*	  Ersterstellung	15.11.94
3533 |*	  Letzte Aenderung	15.11.94
3534 |*
3535 *************************************************************************/
3536 
3537 XFillGradientItem::XFillGradientItem(sal_Int32 nIndex,
3538 								   const XGradient& rTheGradient) :
3539 	NameOrIndex(XATTR_FILLGRADIENT, nIndex),
3540 	aGradient(rTheGradient)
3541 {
3542 }
3543 
3544 /*************************************************************************
3545 |*
3546 |*	  XFillGradientItem::XFillGradientItem(const XubString& rName,
3547 |*										 const XGradient& rTheGradient)
3548 |*
3549 |*	  Beschreibung
3550 |*	  Ersterstellung	15.11.94
3551 |*	  Letzte Aenderung	15.11.94
3552 |*
3553 *************************************************************************/
3554 
3555 XFillGradientItem::XFillGradientItem(const XubString& rName,
3556 								   const XGradient& rTheGradient) :
3557 	NameOrIndex(XATTR_FILLGRADIENT, rName),
3558 	aGradient(rTheGradient)
3559 {
3560 }
3561 
3562 /*************************************************************************
3563 |*
3564 |*	  XFillGradientItem::XFillGradientItem(const XFillGradientItem& rItem)
3565 |*
3566 |*	  Beschreibung
3567 |*	  Ersterstellung	15.11.94
3568 |*	  Letzte Aenderung	15.11.94
3569 |*
3570 *************************************************************************/
3571 
3572 XFillGradientItem::XFillGradientItem(const XFillGradientItem& rItem) :
3573 	NameOrIndex(rItem),
3574 	aGradient(rItem.aGradient)
3575 {
3576 }
3577 
3578 /*************************************************************************
3579 |*
3580 |*	  XFillGradientItem::XFillGradientItem(SvStream& rIn)
3581 |*
3582 |*	  Beschreibung
3583 |*	  Ersterstellung	15.11.94
3584 |*	  Letzte Aenderung	15.11.94
3585 |*
3586 *************************************************************************/
3587 
3588 XFillGradientItem::XFillGradientItem(SvStream& rIn, sal_uInt16 nVer) :
3589 	NameOrIndex(XATTR_FILLGRADIENT, rIn),
3590 	aGradient(COL_BLACK, COL_WHITE)
3591 {
3592 	if (!IsIndex())
3593 	{
3594 		sal_uInt16 nUSTemp;
3595 		sal_uInt16 nRed;
3596 		sal_uInt16 nGreen;
3597 		sal_uInt16 nBlue;
3598 		sal_Int16  nITemp;
3599 		sal_Int32  nLTemp;
3600 
3601 		rIn >> nITemp; aGradient.SetGradientStyle((XGradientStyle)nITemp);
3602 		rIn >> nRed;
3603 		rIn >> nGreen;
3604 		rIn >> nBlue;
3605 		Color aCol;
3606 		aCol = Color( (sal_uInt8)( nRed >> 8 ), (sal_uInt8)( nGreen >> 8 ), (sal_uInt8)( nBlue >> 8 ) );
3607 		aGradient.SetStartColor( aCol );
3608 
3609 		rIn >> nRed;
3610 		rIn >> nGreen;
3611 		rIn >> nBlue;
3612 		aCol = Color( (sal_uInt8)( nRed >> 8 ), (sal_uInt8)( nGreen >> 8 ), (sal_uInt8)( nBlue >> 8 ) );
3613 		aGradient.SetEndColor(aCol);
3614 		rIn >> nLTemp; aGradient.SetAngle(nLTemp);
3615 		rIn >> nUSTemp; aGradient.SetBorder(nUSTemp);
3616 		rIn >> nUSTemp; aGradient.SetXOffset(nUSTemp);
3617 		rIn >> nUSTemp; aGradient.SetYOffset(nUSTemp);
3618 		rIn >> nUSTemp; aGradient.SetStartIntens(nUSTemp);
3619 		rIn >> nUSTemp; aGradient.SetEndIntens(nUSTemp);
3620 
3621 		// bei neueren Versionen wird zusaetzlich
3622 		// die Schrittweite mit eingelesen
3623 		if (nVer >= 1)
3624 		{
3625 			rIn >> nUSTemp; aGradient.SetSteps(nUSTemp);
3626 		}
3627 	}
3628 }
3629 
3630 //*************************************************************************
3631 
3632 XFillGradientItem::XFillGradientItem(SfxItemPool* /*pPool*/, const XGradient& rTheGradient)
3633 : 	NameOrIndex( XATTR_FILLGRADIENT, -1 ),
3634 	aGradient(rTheGradient)
3635 {
3636 }
3637 
3638 //*************************************************************************
3639 
3640 XFillGradientItem::XFillGradientItem(SfxItemPool* /*pPool*/)
3641 : NameOrIndex(XATTR_FILLGRADIENT, -1 )
3642 {
3643 }
3644 
3645 /*************************************************************************
3646 |*
3647 |*	  XFillGradientItem::Clone(SfxItemPool* pPool) const
3648 |*
3649 |*	  Beschreibung
3650 |*	  Ersterstellung	15.11.94
3651 |*	  Letzte Aenderung	15.11.94
3652 |*
3653 *************************************************************************/
3654 
3655 SfxPoolItem* XFillGradientItem::Clone(SfxItemPool* /*pPool*/) const
3656 {
3657 	return new XFillGradientItem(*this);
3658 }
3659 
3660 /*************************************************************************
3661 |*
3662 |*	  int XFillGradientItem::operator==(const SfxPoolItem& rItem) const
3663 |*
3664 |*	  Beschreibung
3665 |*	  Ersterstellung	15.11.94
3666 |*	  Letzte Aenderung	15.11.94
3667 |*
3668 *************************************************************************/
3669 
3670 int XFillGradientItem::operator==(const SfxPoolItem& rItem) const
3671 {
3672 	return ( NameOrIndex::operator==(rItem) &&
3673 			 aGradient == ((const XFillGradientItem&) rItem).aGradient );
3674 }
3675 
3676 /*************************************************************************
3677 |*
3678 |*	  SfxPoolItem* XFillGradientItem::Create(SvStream& rIn, sal_uInt16 nVer) const
3679 |*
3680 |*	  Beschreibung
3681 |*	  Ersterstellung	15.11.94
3682 |*	  Letzte Aenderung	15.11.94
3683 |*
3684 *************************************************************************/
3685 
3686 SfxPoolItem* XFillGradientItem::Create(SvStream& rIn, sal_uInt16 nVer) const
3687 {
3688 	return new XFillGradientItem(rIn, nVer);
3689 }
3690 
3691 /*************************************************************************
3692 |*
3693 |*	  SfxPoolItem* XFillGradientItem::Store(SvStream& rOut) const
3694 |*
3695 |*	  Beschreibung
3696 |*	  Ersterstellung	15.11.94
3697 |*	  Letzte Aenderung	15.11.94
3698 |*
3699 *************************************************************************/
3700 
3701 SvStream& XFillGradientItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
3702 {
3703 	NameOrIndex::Store( rOut, nItemVersion );
3704 
3705 	if (!IsIndex())
3706 	{
3707 		rOut << (sal_Int16)aGradient.GetGradientStyle();
3708 
3709 		sal_uInt16 nTmp;
3710 
3711 		nTmp = VCLTOSVCOL( aGradient.GetStartColor().GetRed() ); rOut << nTmp;
3712 		nTmp = VCLTOSVCOL( aGradient.GetStartColor().GetGreen() ); rOut << nTmp;
3713 		nTmp = VCLTOSVCOL( aGradient.GetStartColor().GetBlue() ); rOut << nTmp;
3714 		nTmp = VCLTOSVCOL( aGradient.GetEndColor().GetRed() ); rOut << nTmp;
3715 		nTmp = VCLTOSVCOL( aGradient.GetEndColor().GetGreen() ); rOut << nTmp;
3716 		nTmp = VCLTOSVCOL( aGradient.GetEndColor().GetBlue() ); rOut << nTmp;
3717 
3718 		rOut << (sal_Int32) aGradient.GetAngle();
3719 		rOut << aGradient.GetBorder();
3720 		rOut << aGradient.GetXOffset();
3721 		rOut << aGradient.GetYOffset();
3722 		rOut << aGradient.GetStartIntens();
3723 		rOut << aGradient.GetEndIntens();
3724 		rOut << aGradient.GetSteps();
3725 	}
3726 
3727 	return rOut;
3728 }
3729 
3730 /*************************************************************************
3731 |*
3732 |*	  const XGradient& XFillGradientItem::GetValue(const XGradientList* pTable)
3733 |*																   const
3734 |*
3735 |*	  Beschreibung
3736 |*	  Ersterstellung	15.11.94
3737 |*	  Letzte Aenderung	18.11.94
3738 |*
3739 *************************************************************************/
3740 
3741 const XGradient& XFillGradientItem::GetGradientValue(const XGradientList* pTable) const // GetValue -> GetGradientValue
3742 {
3743 	if (!IsIndex())
3744 		return aGradient;
3745 	else
3746 		return pTable->GetGradient(GetIndex())->GetGradient();
3747 }
3748 
3749 
3750 /*************************************************************************
3751 |*
3752 |*	  sal_uInt16 XFillGradientItem::GetVersion() const
3753 |*
3754 |*	  Beschreibung
3755 |*	  Ersterstellung	01.11.95
3756 |*	  Letzte Aenderung	01.11.95
3757 |*
3758 *************************************************************************/
3759 
3760 sal_uInt16 XFillGradientItem::GetVersion( sal_uInt16 /*nFileFormatVersion*/) const
3761 {
3762 	// !!! this version number also represents the version number of superclasses
3763 	// !!! (e.g. XFillFloatTransparenceItem); if you make any changes here,
3764 	// !!! the superclass is also affected
3765 	return 1;
3766 }
3767 
3768 //------------------------------------------------------------------------
3769 
3770 SfxItemPresentation XFillGradientItem::GetPresentation
3771 (
3772 	SfxItemPresentation ePres,
3773 	SfxMapUnit			/*eCoreUnit*/,
3774 	SfxMapUnit			/*ePresUnit*/,
3775     XubString&          rText, const IntlWrapper *
3776 )	const
3777 {
3778 	switch ( ePres )
3779 	{
3780 		case SFX_ITEM_PRESENTATION_NONE:
3781 			rText.Erase();
3782 			return ePres;
3783 		case SFX_ITEM_PRESENTATION_NAMELESS:
3784 		case SFX_ITEM_PRESENTATION_COMPLETE:
3785 			rText = GetName();
3786 			return ePres;
3787 		default:
3788 			return SFX_ITEM_PRESENTATION_NONE;
3789 	}
3790 }
3791 
3792 // -----------------------------------------------------------------------
3793 sal_Bool XFillGradientItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
3794 {
3795     //sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3796     nMemberId &= ~CONVERT_TWIPS;
3797 	switch ( nMemberId )
3798 	{
3799         case 0:
3800         {
3801             uno::Sequence< beans::PropertyValue > aPropSeq( 2 );
3802 
3803             ::com::sun::star::awt::Gradient aGradient2;
3804 
3805 			const XGradient& aXGradient = GetGradientValue();
3806 			aGradient2.Style = (::com::sun::star::awt::GradientStyle) aXGradient.GetGradientStyle();
3807 			aGradient2.StartColor = (sal_Int32)aXGradient.GetStartColor().GetColor();
3808 			aGradient2.EndColor = (sal_Int32)aXGradient.GetEndColor().GetColor();
3809 			aGradient2.Angle = (short)aXGradient.GetAngle();
3810 			aGradient2.Border = aXGradient.GetBorder();
3811 			aGradient2.XOffset = aXGradient.GetXOffset();
3812 			aGradient2.YOffset = aXGradient.GetYOffset();
3813 			aGradient2.StartIntensity = aXGradient.GetStartIntens();
3814 			aGradient2.EndIntensity = aXGradient.GetEndIntens();
3815 			aGradient2.StepCount = aXGradient.GetSteps();
3816 
3817 			rtl::OUString aApiName;
3818 			SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
3819             aPropSeq[0].Name    = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Name" ));
3820             aPropSeq[0].Value   = uno::makeAny( aApiName );
3821             aPropSeq[1].Name    = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FillGradient" ));
3822             aPropSeq[1].Value   = uno::makeAny( aGradient2 );
3823             rVal = uno::makeAny( aPropSeq );
3824             break;
3825         }
3826 
3827         case MID_FILLGRADIENT:
3828 		{
3829 			const XGradient& aXGradient = GetGradientValue();
3830 			::com::sun::star::awt::Gradient aGradient2;
3831 
3832 			aGradient2.Style = (::com::sun::star::awt::GradientStyle) aXGradient.GetGradientStyle();
3833 			aGradient2.StartColor = (sal_Int32)aXGradient.GetStartColor().GetColor();
3834 			aGradient2.EndColor = (sal_Int32)aXGradient.GetEndColor().GetColor();
3835 			aGradient2.Angle = (short)aXGradient.GetAngle();
3836 			aGradient2.Border = aXGradient.GetBorder();
3837 			aGradient2.XOffset = aXGradient.GetXOffset();
3838 			aGradient2.YOffset = aXGradient.GetYOffset();
3839 			aGradient2.StartIntensity = aXGradient.GetStartIntens();
3840 			aGradient2.EndIntensity = aXGradient.GetEndIntens();
3841 			aGradient2.StepCount = aXGradient.GetSteps();
3842 
3843 			rVal <<= aGradient2;
3844 			break;
3845 		}
3846 
3847 		case MID_NAME:
3848 		{
3849 			rtl::OUString aApiName;
3850 			SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
3851 			rVal <<= aApiName;
3852 			break;
3853 		}
3854 
3855 		case MID_GRADIENT_STYLE: rVal <<= (sal_Int16)GetGradientValue().GetGradientStyle(); break;
3856 		case MID_GRADIENT_STARTCOLOR: rVal <<= (sal_Int32)GetGradientValue().GetStartColor().GetColor(); break;
3857 		case MID_GRADIENT_ENDCOLOR: rVal <<= (sal_Int32)GetGradientValue().GetEndColor().GetColor(); break;
3858 		case MID_GRADIENT_ANGLE: rVal <<= (sal_Int16)GetGradientValue().GetAngle(); break;
3859 		case MID_GRADIENT_BORDER: rVal <<= GetGradientValue().GetBorder(); break;
3860 		case MID_GRADIENT_XOFFSET: rVal <<= GetGradientValue().GetXOffset(); break;
3861 		case MID_GRADIENT_YOFFSET: rVal <<= GetGradientValue().GetYOffset(); break;
3862 		case MID_GRADIENT_STARTINTENSITY: rVal <<= GetGradientValue().GetStartIntens(); break;
3863 		case MID_GRADIENT_ENDINTENSITY: rVal <<= GetGradientValue().GetEndIntens(); break;
3864 		case MID_GRADIENT_STEPCOUNT: rVal <<= GetGradientValue().GetSteps(); break;
3865 
3866 		default: DBG_ERROR("Wrong MemberId!"); return sal_False;
3867 	}
3868 
3869 	return sal_True;
3870 }
3871 
3872 // -----------------------------------------------------------------------
3873 sal_Bool XFillGradientItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
3874 {
3875 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
3876     nMemberId &= ~CONVERT_TWIPS;
3877 
3878 	switch ( nMemberId )
3879 	{
3880         case 0:
3881         {
3882             uno::Sequence< beans::PropertyValue >   aPropSeq;
3883             ::com::sun::star::awt::Gradient         aGradient2;
3884             rtl::OUString                           aName;
3885             bool                                    bGradient( false );
3886 
3887             if ( rVal >>= aPropSeq )
3888             {
3889                 for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
3890                 {
3891                     if ( aPropSeq[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Name" )))
3892                         aPropSeq[n].Value >>= aName;
3893                     else if ( aPropSeq[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FillGradient" )))
3894                     {
3895                         if ( aPropSeq[n].Value >>= aGradient2 )
3896                             bGradient = true;
3897                     }
3898                 }
3899 
3900                 SetName( aName );
3901                 if ( bGradient )
3902                 {
3903 			        XGradient aXGradient;
3904 
3905                     aXGradient.SetGradientStyle( (XGradientStyle) aGradient2.Style );
3906                     aXGradient.SetStartColor( aGradient2.StartColor );
3907                     aXGradient.SetEndColor( aGradient2.EndColor );
3908                     aXGradient.SetAngle( aGradient2.Angle );
3909                     aXGradient.SetBorder( aGradient2.Border );
3910                     aXGradient.SetXOffset( aGradient2.XOffset );
3911                     aXGradient.SetYOffset( aGradient2.YOffset );
3912                     aXGradient.SetStartIntens( aGradient2.StartIntensity );
3913                     aXGradient.SetEndIntens( aGradient2.EndIntensity );
3914                     aXGradient.SetSteps( aGradient2.StepCount );
3915 
3916                     SetGradientValue( aXGradient );
3917                 }
3918 
3919                 return sal_True;
3920             }
3921 
3922             return sal_False;
3923         }
3924 
3925 		case MID_NAME:
3926 		{
3927 			rtl::OUString aName;
3928 			if (!(rVal >>= aName ))
3929 				return sal_False;
3930 			SetName( aName );
3931 			break;
3932 		}
3933 
3934 		case MID_FILLGRADIENT:
3935 		{
3936 			::com::sun::star::awt::Gradient aGradient2;
3937 			if(!(rVal >>= aGradient2))
3938 				return sal_False;
3939 
3940 			XGradient aXGradient;
3941 
3942 			aXGradient.SetGradientStyle( (XGradientStyle) aGradient2.Style );
3943 			aXGradient.SetStartColor( aGradient2.StartColor );
3944 			aXGradient.SetEndColor( aGradient2.EndColor );
3945 			aXGradient.SetAngle( aGradient2.Angle );
3946 			aXGradient.SetBorder( aGradient2.Border );
3947 			aXGradient.SetXOffset( aGradient2.XOffset );
3948 			aXGradient.SetYOffset( aGradient2.YOffset );
3949 			aXGradient.SetStartIntens( aGradient2.StartIntensity );
3950 			aXGradient.SetEndIntens( aGradient2.EndIntensity );
3951 			aXGradient.SetSteps( aGradient2.StepCount );
3952 
3953 			SetGradientValue( aXGradient );
3954 			break;
3955 		}
3956 
3957 		case MID_GRADIENT_STARTCOLOR:
3958 		case MID_GRADIENT_ENDCOLOR:
3959 		{
3960 			sal_Int32 nVal = 0;
3961 			if(!(rVal >>= nVal ))
3962 				return sal_False;
3963 
3964 			XGradient aXGradient = GetGradientValue();
3965 
3966 			if ( nMemberId == MID_GRADIENT_STARTCOLOR )
3967 				aXGradient.SetStartColor( nVal );
3968 			else
3969 				aXGradient.SetEndColor( nVal );
3970 			SetGradientValue( aXGradient );
3971 			break;
3972 		}
3973 
3974 		case MID_GRADIENT_STYLE:
3975 		case MID_GRADIENT_ANGLE:
3976 		case MID_GRADIENT_BORDER:
3977 		case MID_GRADIENT_STARTINTENSITY:
3978 		case MID_GRADIENT_ENDINTENSITY:
3979 		case MID_GRADIENT_STEPCOUNT:
3980 		case MID_GRADIENT_XOFFSET:
3981 		case MID_GRADIENT_YOFFSET:
3982 		{
3983 			sal_Int16 nVal = sal_Int16();
3984 			if(!(rVal >>= nVal ))
3985 				return sal_False;
3986 
3987 			XGradient aXGradient = GetGradientValue();
3988 
3989 			switch ( nMemberId )
3990 			{
3991 				case MID_GRADIENT_STYLE:
3992 					aXGradient.SetGradientStyle( (XGradientStyle)nVal ); break;
3993 				case MID_GRADIENT_ANGLE:
3994 					aXGradient.SetAngle( nVal ); break;
3995 				case MID_GRADIENT_BORDER:
3996 					aXGradient.SetBorder( nVal ); break;
3997 				case MID_GRADIENT_STARTINTENSITY:
3998 					aXGradient.SetStartIntens( nVal ); break;
3999 				case MID_GRADIENT_ENDINTENSITY:
4000 					aXGradient.SetEndIntens( nVal ); break;
4001 				case MID_GRADIENT_STEPCOUNT:
4002 					aXGradient.SetSteps( nVal ); break;
4003 				case MID_GRADIENT_XOFFSET:
4004 					aXGradient.SetXOffset( nVal ); break;
4005 				case MID_GRADIENT_YOFFSET:
4006 					aXGradient.SetYOffset( nVal ); break;
4007 			}
4008 
4009 			SetGradientValue( aXGradient );
4010 			break;
4011 		}
4012 	}
4013 
4014 	return sal_True;
4015 }
4016 
4017 sal_Bool XFillGradientItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
4018 {
4019 	return ((XFillGradientItem*)p1)->GetGradientValue() == ((XFillGradientItem*)p2)->GetGradientValue();
4020 }
4021 
4022 XFillGradientItem* XFillGradientItem::checkForUniqueItem( SdrModel* pModel ) const
4023 {
4024 	if( pModel )
4025 	{
4026 		const String aUniqueName = NameOrIndex::CheckNamedItem(	this,
4027 																XATTR_FILLGRADIENT,
4028 																&pModel->GetItemPool(),
4029 																pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
4030 																XFillGradientItem::CompareValueFunc,
4031 																RID_SVXSTR_GRADIENT,
4032 																pModel->GetGradientListFromSdrModel().get() );
4033 
4034 		// if the given name is not valid, replace it!
4035 		if( aUniqueName != GetName() )
4036 		{
4037 			return new XFillGradientItem( aUniqueName, aGradient );
4038 		}
4039 	}
4040 
4041 	return (XFillGradientItem*)this;
4042 }
4043 
4044 // ----------------------------------
4045 // class XFillFloatTransparenceItem -
4046 // ----------------------------------
4047 
4048 TYPEINIT1_AUTOFACTORY( XFillFloatTransparenceItem, XFillGradientItem );
4049 
4050 // -----------------------------------------------------------------------------
4051 
4052 XFillFloatTransparenceItem::XFillFloatTransparenceItem() :
4053 	bEnabled( sal_False )
4054 {
4055 	SetWhich( XATTR_FILLFLOATTRANSPARENCE );
4056 }
4057 
4058 //------------------------------------------------------------------------
4059 
4060 XFillFloatTransparenceItem::XFillFloatTransparenceItem( sal_Int32 nIndex, const XGradient& rGradient, sal_Bool bEnable ) :
4061 	XFillGradientItem	( nIndex, rGradient ),
4062 	bEnabled			( bEnable )
4063 {
4064 	SetWhich( XATTR_FILLFLOATTRANSPARENCE );
4065 }
4066 
4067 //------------------------------------------------------------------------
4068 
4069 XFillFloatTransparenceItem::XFillFloatTransparenceItem(const XubString& rName, const XGradient& rGradient, sal_Bool bEnable ) :
4070 	XFillGradientItem	( rName, rGradient ),
4071 	bEnabled			( bEnable )
4072 {
4073 	SetWhich( XATTR_FILLFLOATTRANSPARENCE );
4074 }
4075 
4076 //------------------------------------------------------------------------
4077 
4078 XFillFloatTransparenceItem::XFillFloatTransparenceItem( const XFillFloatTransparenceItem& rItem ) :
4079 	XFillGradientItem	( rItem ),
4080 	bEnabled			( rItem.bEnabled )
4081 {
4082 	SetWhich( XATTR_FILLFLOATTRANSPARENCE );
4083 }
4084 
4085 //------------------------------------------------------------------------
4086 
4087 //XFillFloatTransparenceItem::XFillFloatTransparenceItem( SvStream& rIn, sal_uInt16 nVer ) :
4088 //	XFillGradientItem	( rIn, nVer )
4089 //{
4090 //	SetWhich( XATTR_FILLFLOATTRANSPARENCE );
4091 //	rIn >> bEnabled;
4092 //}
4093 
4094 //*************************************************************************
4095 
4096 XFillFloatTransparenceItem::XFillFloatTransparenceItem(SfxItemPool* /*pPool*/, const XGradient& rTheGradient, sal_Bool bEnable )
4097 : 	XFillGradientItem	( -1, rTheGradient ),
4098 	bEnabled			( bEnable )
4099 {
4100 	SetWhich( XATTR_FILLFLOATTRANSPARENCE );
4101 }
4102 
4103 //*************************************************************************
4104 
4105 XFillFloatTransparenceItem::XFillFloatTransparenceItem(SfxItemPool* /*pPool*/)
4106 {
4107 	SetWhich( XATTR_FILLFLOATTRANSPARENCE );
4108 }
4109 
4110 //------------------------------------------------------------------------
4111 
4112 int XFillFloatTransparenceItem::operator==( const SfxPoolItem& rItem ) const
4113 {
4114 	return ( NameOrIndex::operator==(rItem) ) &&
4115 			( GetGradientValue() == ((const XFillGradientItem&)rItem).GetGradientValue() ) &&
4116 		     ( bEnabled == ( (XFillFloatTransparenceItem&) rItem ).bEnabled );
4117 }
4118 
4119 //------------------------------------------------------------------------
4120 
4121 SfxPoolItem* XFillFloatTransparenceItem::Clone( SfxItemPool* /*pPool*/) const
4122 {
4123 	return new XFillFloatTransparenceItem( *this );
4124 }
4125 
4126 //------------------------------------------------------------------------
4127 
4128 //SfxPoolItem* XFillFloatTransparenceItem::Create( SvStream& rIn, sal_uInt16 nVer ) const
4129 //{
4130 //	return( ( 0 == nVer ) ? Clone( NULL ) : new XFillFloatTransparenceItem( rIn, nVer ) );
4131 //}
4132 
4133 //------------------------------------------------------------------------
4134 
4135 //SvStream& XFillFloatTransparenceItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
4136 //{
4137 //	XFillGradientItem::Store( rOut, nItemVersion );
4138 //	rOut << bEnabled;
4139 //	return rOut;
4140 //}
4141 
4142 //------------------------------------------------------------------------
4143 
4144 sal_uInt16 XFillFloatTransparenceItem::GetVersion( sal_uInt16 nFileFormatVersion ) const
4145 {
4146 	// !!! if version number of this object must be increased, please	!!!
4147 	// !!! increase version number of base class XFillGradientItem		!!!
4148 	return XFillGradientItem::GetVersion( nFileFormatVersion );
4149 }
4150 
4151 //------------------------------------------------------------------------
4152 
4153 sal_Bool XFillFloatTransparenceItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
4154 {
4155 	return XFillGradientItem::QueryValue( rVal, nMemberId );
4156 }
4157 
4158 //------------------------------------------------------------------------
4159 
4160 sal_Bool XFillFloatTransparenceItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
4161 {
4162 	return XFillGradientItem::PutValue( rVal, nMemberId );
4163 }
4164 
4165 //------------------------------------------------------------------------
4166 
4167 SfxItemPresentation XFillFloatTransparenceItem::GetPresentation(	SfxItemPresentation ePres,
4168 																	SfxMapUnit eCoreUnit, SfxMapUnit ePresUnit,
4169 																	XubString& rText,
4170                                                                     const IntlWrapper * pIntlWrapper ) const
4171 {
4172     return XFillGradientItem::GetPresentation( ePres, eCoreUnit, ePresUnit, rText, pIntlWrapper );
4173 }
4174 
4175 sal_Bool XFillFloatTransparenceItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
4176 {
4177 	return	((XFillFloatTransparenceItem*)p1)->IsEnabled() == ((XFillFloatTransparenceItem*)p2)->IsEnabled() &&
4178 			((XFillFloatTransparenceItem*)p1)->GetGradientValue()  == ((XFillFloatTransparenceItem*)p2)->GetGradientValue();
4179 }
4180 
4181 XFillFloatTransparenceItem* XFillFloatTransparenceItem::checkForUniqueItem( SdrModel* pModel ) const
4182 {
4183 	// #85953# unique name only necessary when enabled
4184 	if(IsEnabled())
4185 	{
4186 		if( pModel )
4187 		{
4188 			const String aUniqueName = NameOrIndex::CheckNamedItem(	this,
4189 																	XATTR_FILLFLOATTRANSPARENCE,
4190 																	&pModel->GetItemPool(),
4191 																	pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
4192 																	XFillFloatTransparenceItem::CompareValueFunc,
4193 																	RID_SVXSTR_TRASNGR0,
4194 																	NULL );
4195 
4196 			// if the given name is not valid, replace it!
4197 			if( aUniqueName != GetName() )
4198 			{
4199 				return new XFillFloatTransparenceItem( aUniqueName, GetGradientValue(), sal_True );
4200 			}
4201 		}
4202 	}
4203 	else
4204 	{
4205 		// #85953# if disabled, force name to empty string
4206 		if(GetName().Len())
4207 		{
4208 			return new XFillFloatTransparenceItem(String(), GetGradientValue(), sal_False);
4209 		}
4210 	}
4211 
4212 	return (XFillFloatTransparenceItem*)this;
4213 }
4214 
4215 // -------------
4216 // class XHatch
4217 // -------------
4218 
4219 /*************************************************************************
4220 |*
4221 |*	  XHatch::XHatch(XHatchStyle, const Color&, long, long)
4222 |*
4223 |*	  Beschreibung
4224 |*	  Ersterstellung	21.11.94
4225 |*	  Letzte Aenderung	21.11.94
4226 |*
4227 *************************************************************************/
4228 
4229 XHatch::XHatch(const Color& rCol, XHatchStyle eTheStyle, long nTheDistance,
4230 			   long nTheAngle) :
4231 	eStyle(eTheStyle),
4232 	aColor(rCol),
4233 	nDistance(nTheDistance),
4234 	nAngle(nTheAngle)
4235 {
4236 }
4237 
4238 /*************************************************************************
4239 |*
4240 |*	  int XHatch::operator==(const SfxPoolItem& rItem) const
4241 |*
4242 |*	  Beschreibung
4243 |*	  Ersterstellung	29.11.94
4244 |*	  Letzte Aenderung	29.11.94
4245 |*
4246 *************************************************************************/
4247 
4248 bool XHatch::operator==(const XHatch& rHatch) const
4249 {
4250 	return ( eStyle 	== rHatch.eStyle	&&
4251 			 aColor 	== rHatch.aColor	&&
4252 			 nDistance	== rHatch.nDistance &&
4253 			 nAngle 	== rHatch.nAngle );
4254 }
4255 
4256 
4257 // -----------------------
4258 // class XFillHatchItem
4259 // -----------------------
4260 TYPEINIT1_AUTOFACTORY(XFillHatchItem, NameOrIndex);
4261 
4262 /*************************************************************************
4263 |*
4264 |*	  XFillHatchItem::XFillHatchItem(sal_Int32 nIndex,
4265 |*								   const XHatch& rTheHatch)
4266 |*
4267 |*	  Beschreibung
4268 |*	  Ersterstellung	15.11.94
4269 |*	  Letzte Aenderung	15.11.94
4270 |*
4271 *************************************************************************/
4272 
4273 XFillHatchItem::XFillHatchItem(sal_Int32 nIndex,
4274 							 const XHatch& rTheHatch) :
4275 	NameOrIndex(XATTR_FILLHATCH, nIndex),
4276 	aHatch(rTheHatch)
4277 {
4278 }
4279 
4280 /*************************************************************************
4281 |*
4282 |*	  XFillHatchItem::XFillHatchItem(const XubString& rName,
4283 |*								   const XHatch& rTheHatch)
4284 |*
4285 |*	  Beschreibung
4286 |*	  Ersterstellung	15.11.94
4287 |*	  Letzte Aenderung	15.11.94
4288 |*
4289 *************************************************************************/
4290 
4291 XFillHatchItem::XFillHatchItem(const XubString& rName,
4292 							 const XHatch& rTheHatch) :
4293 	NameOrIndex(XATTR_FILLHATCH, rName),
4294 	aHatch(rTheHatch)
4295 {
4296 }
4297 
4298 /*************************************************************************
4299 |*
4300 |*	  XFillHatchItem::XFillHatchItem(const XFillHatchItem& rItem)
4301 |*
4302 |*	  Beschreibung
4303 |*	  Ersterstellung	15.11.94
4304 |*	  Letzte Aenderung	15.11.94
4305 |*
4306 *************************************************************************/
4307 
4308 XFillHatchItem::XFillHatchItem(const XFillHatchItem& rItem) :
4309 	NameOrIndex(rItem),
4310 	aHatch(rItem.aHatch)
4311 {
4312 }
4313 
4314 /*************************************************************************
4315 |*
4316 |*	  XFillHatchItem::XFillHatchItem(SvStream& rIn)
4317 |*
4318 |*	  Beschreibung
4319 |*	  Ersterstellung	15.11.94
4320 |*	  Letzte Aenderung	15.11.94
4321 |*
4322 *************************************************************************/
4323 
4324 XFillHatchItem::XFillHatchItem(SvStream& rIn) :
4325 	NameOrIndex(XATTR_FILLHATCH, rIn),
4326 	aHatch(COL_BLACK)
4327 {
4328 	if (!IsIndex())
4329 	{
4330 		sal_uInt16 nRed;
4331 		sal_uInt16 nGreen;
4332 		sal_uInt16 nBlue;
4333 		sal_Int16  nITemp;
4334 		sal_Int32  nLTemp;
4335 
4336 		rIn >> nITemp; aHatch.SetHatchStyle((XHatchStyle)nITemp);
4337 		rIn >> nRed;
4338 		rIn >> nGreen;
4339 		rIn >> nBlue;
4340 
4341 		Color aCol;
4342 		aCol = Color( (sal_uInt8)( nRed >> 8 ), (sal_uInt8)( nGreen >> 8 ), (sal_uInt8)( nBlue >> 8 ) );
4343 		aHatch.SetColor(aCol);
4344 		rIn >> nLTemp; aHatch.SetDistance(nLTemp);
4345 		rIn >> nLTemp; aHatch.SetAngle(nLTemp);
4346 	}
4347 }
4348 
4349 //*************************************************************************
4350 
4351 XFillHatchItem::XFillHatchItem(SfxItemPool* /*pPool*/, const XHatch& rTheHatch)
4352 : 	NameOrIndex( XATTR_FILLHATCH, -1 ),
4353 	aHatch(rTheHatch)
4354 {
4355 }
4356 
4357 //*************************************************************************
4358 
4359 XFillHatchItem::XFillHatchItem(SfxItemPool* /*pPool*/)
4360 : NameOrIndex(XATTR_FILLHATCH, -1 )
4361 {
4362 }
4363 
4364 /*************************************************************************
4365 |*
4366 |*	  XFillHatchItem::Clone(SfxItemPool* pPool) const
4367 |*
4368 |*	  Beschreibung
4369 |*	  Ersterstellung	15.11.94
4370 |*	  Letzte Aenderung	15.11.94
4371 |*
4372 *************************************************************************/
4373 
4374 SfxPoolItem* XFillHatchItem::Clone(SfxItemPool* /*pPool*/) const
4375 {
4376 	return new XFillHatchItem(*this);
4377 }
4378 
4379 /*************************************************************************
4380 |*
4381 |*	  int XFillHatchItem::operator==(const SfxPoolItem& rItem) const
4382 |*
4383 |*	  Beschreibung
4384 |*	  Ersterstellung	15.11.94
4385 |*	  Letzte Aenderung	15.11.94
4386 |*
4387 *************************************************************************/
4388 
4389 int XFillHatchItem::operator==(const SfxPoolItem& rItem) const
4390 {
4391 	return ( NameOrIndex::operator==(rItem) &&
4392 			 aHatch == ((const XFillHatchItem&) rItem).aHatch );
4393 }
4394 
4395 /*************************************************************************
4396 |*
4397 |*	  SfxPoolItem* XFillHatchItem::Create(SvStream& rIn, sal_uInt16 nVer) const
4398 |*
4399 |*	  Beschreibung
4400 |*	  Ersterstellung	15.11.94
4401 |*	  Letzte Aenderung	15.11.94
4402 |*
4403 *************************************************************************/
4404 
4405 SfxPoolItem* XFillHatchItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
4406 {
4407 	return new XFillHatchItem(rIn);
4408 }
4409 
4410 /*************************************************************************
4411 |*
4412 |*	  SfxPoolItem* XFillHatchItem::Store(SvStream& rOut) const
4413 |*
4414 |*	  Beschreibung
4415 |*	  Ersterstellung	15.11.94
4416 |*	  Letzte Aenderung	15.11.94
4417 |*
4418 *************************************************************************/
4419 
4420 SvStream& XFillHatchItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
4421 {
4422 	NameOrIndex::Store( rOut, nItemVersion );
4423 
4424 	if (!IsIndex())
4425 	{
4426 		rOut << (sal_Int16)aHatch.GetHatchStyle();
4427 
4428 		sal_uInt16 nTmp;
4429 		nTmp = VCLTOSVCOL( aHatch.GetColor().GetRed() ); rOut << nTmp;
4430 		nTmp = VCLTOSVCOL( aHatch.GetColor().GetGreen() ); rOut << nTmp;
4431 		nTmp = VCLTOSVCOL( aHatch.GetColor().GetBlue() ); rOut << nTmp;
4432 
4433 		rOut << (sal_Int32) aHatch.GetDistance();
4434 		rOut << (sal_Int32) aHatch.GetAngle();
4435 	}
4436 
4437 	return rOut;
4438 }
4439 
4440 /*************************************************************************
4441 |*
4442 |*	  const XHatch& XFillHatchItem::GetValue(const XHatchList* pTable) const
4443 |*
4444 |*	  Beschreibung
4445 |*	  Ersterstellung	15.11.94
4446 |*	  Letzte Aenderung	18.11.94
4447 |*
4448 *************************************************************************/
4449 
4450 const XHatch& XFillHatchItem::GetHatchValue(const XHatchList* pTable) const // GetValue -> GetHatchValue
4451 {
4452 	if (!IsIndex())
4453 		return aHatch;
4454 	else
4455 		return pTable->GetHatch(GetIndex())->GetHatch();
4456 }
4457 
4458 //------------------------------------------------------------------------
4459 
4460 SfxItemPresentation XFillHatchItem::GetPresentation
4461 (
4462 	SfxItemPresentation ePres,
4463 	SfxMapUnit			/*eCoreUnit*/,
4464 	SfxMapUnit			/*ePresUnit*/,
4465     XubString&          rText, const IntlWrapper *
4466 )	const
4467 {
4468 	switch ( ePres )
4469 	{
4470 		case SFX_ITEM_PRESENTATION_NONE:
4471 			rText.Erase();
4472 			return ePres;
4473 		case SFX_ITEM_PRESENTATION_NAMELESS:
4474 		case SFX_ITEM_PRESENTATION_COMPLETE:
4475 			rText = GetName();
4476 			return ePres;
4477 		default:
4478 			return SFX_ITEM_PRESENTATION_NONE;
4479 	}
4480 }
4481 
4482 //------------------------------------------------------------------------
4483 
4484 FASTBOOL XFillHatchItem::HasMetrics() const
4485 {
4486 	return sal_True;
4487 }
4488 
4489 //------------------------------------------------------------------------
4490 
4491 FASTBOOL XFillHatchItem::ScaleMetrics(long nMul, long nDiv)
4492 {
4493 	aHatch.SetDistance( ScaleMetricValue( aHatch.GetDistance(), nMul, nDiv ) );
4494 	return sal_True;
4495 }
4496 
4497 // -----------------------------------------------------------------------
4498 sal_Bool XFillHatchItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
4499 {
4500 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
4501     nMemberId &= ~CONVERT_TWIPS;
4502 
4503 	switch ( nMemberId )
4504 	{
4505         case 0:
4506         {
4507             uno::Sequence< beans::PropertyValue > aPropSeq( 2 );
4508 
4509 			::com::sun::star::drawing::Hatch aUnoHatch;
4510 
4511 			aUnoHatch.Style = (::com::sun::star::drawing::HatchStyle)aHatch.GetHatchStyle();
4512 			aUnoHatch.Color = aHatch.GetColor().GetColor();
4513 			aUnoHatch.Distance = aHatch.GetDistance();
4514 			aUnoHatch.Angle = aHatch.GetAngle();
4515 
4516 			rtl::OUString aApiName;
4517 			SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
4518             aPropSeq[0].Name    = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Name" ));
4519             aPropSeq[0].Value   = uno::makeAny( aApiName );
4520             aPropSeq[1].Name    = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FillHatch" ));
4521             aPropSeq[1].Value   = uno::makeAny( aUnoHatch );
4522             rVal = uno::makeAny( aPropSeq );
4523             break;
4524         }
4525 
4526 		case MID_FILLHATCH:
4527 		{
4528 			::com::sun::star::drawing::Hatch aUnoHatch;
4529 
4530 			aUnoHatch.Style = (::com::sun::star::drawing::HatchStyle)aHatch.GetHatchStyle();
4531 			aUnoHatch.Color = aHatch.GetColor().GetColor();
4532 			aUnoHatch.Distance = aHatch.GetDistance();
4533 			aUnoHatch.Angle = aHatch.GetAngle();
4534 			rVal <<= aUnoHatch;
4535 			break;
4536 		}
4537 
4538 		case MID_NAME:
4539 		{
4540 			rtl::OUString aApiName;
4541 			SvxUnogetApiNameForItem( Which(), GetName(), aApiName );
4542 			rVal <<= aApiName;
4543 			break;
4544 		}
4545 
4546 		case MID_HATCH_STYLE:
4547 			rVal <<= (::com::sun::star::drawing::HatchStyle)aHatch.GetHatchStyle(); break;
4548 		case MID_HATCH_COLOR:
4549 			rVal <<= (sal_Int32)aHatch.GetColor().GetColor(); break;
4550 		case MID_HATCH_DISTANCE:
4551 			rVal <<= aHatch.GetDistance(); break;
4552 		case MID_HATCH_ANGLE:
4553 			rVal <<= aHatch.GetAngle(); break;
4554 
4555 		default: DBG_ERROR("Wrong MemberId!"); return sal_False;
4556 	}
4557 
4558 	return sal_True;
4559 }
4560 
4561 // -----------------------------------------------------------------------
4562 sal_Bool XFillHatchItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
4563 {
4564 //    sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
4565     nMemberId &= ~CONVERT_TWIPS;
4566 
4567 	switch ( nMemberId )
4568 	{
4569         case 0:
4570         {
4571             uno::Sequence< beans::PropertyValue >   aPropSeq;
4572 			::com::sun::star::drawing::Hatch        aUnoHatch;
4573             rtl::OUString                           aName;
4574             bool                                    bHatch( false );
4575 
4576             if ( rVal >>= aPropSeq )
4577             {
4578                 for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
4579                 {
4580                     if ( aPropSeq[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Name" )))
4581                         aPropSeq[n].Value >>= aName;
4582                     else if ( aPropSeq[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FillHatch" )))
4583                     {
4584                         if ( aPropSeq[n].Value >>= aUnoHatch )
4585                             bHatch = true;
4586                     }
4587                 }
4588 
4589                 SetName( aName );
4590                 if ( bHatch )
4591                 {
4592                     aHatch.SetHatchStyle( (XHatchStyle)aUnoHatch.Style );
4593                     aHatch.SetColor( aUnoHatch.Color );
4594                     aHatch.SetDistance( aUnoHatch.Distance );
4595                     aHatch.SetAngle( aUnoHatch.Angle );
4596                 }
4597 
4598                 return sal_True;
4599             }
4600 
4601             return sal_False;
4602         }
4603 
4604 		case MID_FILLHATCH:
4605 		{
4606 			::com::sun::star::drawing::Hatch aUnoHatch;
4607 			if(!(rVal >>= aUnoHatch))
4608 				return sal_False;
4609 
4610 			aHatch.SetHatchStyle( (XHatchStyle)aUnoHatch.Style );
4611 			aHatch.SetColor( aUnoHatch.Color );
4612 			aHatch.SetDistance( aUnoHatch.Distance );
4613 			aHatch.SetAngle( aUnoHatch.Angle );
4614 			break;
4615 		}
4616 
4617 		case MID_NAME:
4618 		{
4619 			rtl::OUString aName;
4620 			if (!(rVal >>= aName ))
4621 				return sal_False;
4622 			SetName( aName );
4623 			break;
4624 		}
4625 
4626 		case MID_HATCH_STYLE:
4627 		{
4628 			sal_Int16 nVal = sal_Int16();
4629 			if (!(rVal >>= nVal ))
4630 				return sal_False;
4631 			aHatch.SetHatchStyle( (XHatchStyle)nVal );
4632 			break;
4633 		}
4634 
4635 		case MID_HATCH_COLOR:
4636 		case MID_HATCH_DISTANCE:
4637 		case MID_HATCH_ANGLE:
4638 		{
4639 			sal_Int32 nVal = 0;
4640 			if (!(rVal >>= nVal ))
4641 				return sal_False;
4642 
4643 			if ( nMemberId == MID_HATCH_COLOR )
4644 				aHatch.SetColor( nVal );
4645 			else if ( nMemberId == MID_HATCH_DISTANCE )
4646 				aHatch.SetDistance( nVal );
4647 			else
4648 				aHatch.SetAngle( nVal );
4649 			break;
4650 		}
4651 
4652 		default: DBG_ERROR("Wrong MemberId!"); return sal_False;
4653 	}
4654 
4655 	return sal_True;
4656 }
4657 
4658 sal_Bool XFillHatchItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
4659 {
4660 	return ((XFillHatchItem*)p1)->GetHatchValue() == ((XFillHatchItem*)p2)->GetHatchValue();
4661 }
4662 
4663 XFillHatchItem* XFillHatchItem::checkForUniqueItem( SdrModel* pModel ) const
4664 {
4665 	if( pModel )
4666 	{
4667 		const String aUniqueName = NameOrIndex::CheckNamedItem(	this,
4668 																XATTR_FILLHATCH,
4669 																&pModel->GetItemPool(),
4670 																pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
4671 																XFillHatchItem::CompareValueFunc,
4672 																RID_SVXSTR_HATCH10,
4673 																pModel->GetHatchListFromSdrModel().get() );
4674 
4675 		// if the given name is not valid, replace it!
4676 		if( aUniqueName != GetName() )
4677 		{
4678 			return new XFillHatchItem( aUniqueName, aHatch );
4679 		}
4680 	}
4681 
4682 	return (XFillHatchItem*)this;
4683 }
4684 
4685 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4686 //							FormText-Attribute
4687 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4688 
4689 //-------------------------
4690 // class XFormTextStyleItem
4691 //-------------------------
4692 TYPEINIT1_AUTOFACTORY(XFormTextStyleItem, SfxEnumItem);
4693 
4694 /*************************************************************************
4695 |*
4696 |*	  XFormTextStyleItem::XFormTextStyleItem()
4697 |*
4698 |*	  Beschreibung
4699 |*	  Ersterstellung	02.02.95 ESO
4700 |*	  Letzte Aenderung	02.02.95 ESO
4701 |*
4702 *************************************************************************/
4703 
4704 XFormTextStyleItem::XFormTextStyleItem(XFormTextStyle eTheStyle) :
4705 	SfxEnumItem(XATTR_FORMTXTSTYLE, sal::static_int_cast< sal_uInt16 >(eTheStyle))
4706 {
4707 }
4708 
4709 /*************************************************************************
4710 |*
4711 |*	  XFormTextStyleItem::XFormTextStyleItem(SvStream& rIn)
4712 |*
4713 |*	  Beschreibung
4714 |*	  Ersterstellung	02.02.95 ESO
4715 |*	  Letzte Aenderung	02.02.95 ESO
4716 |*
4717 *************************************************************************/
4718 
4719 XFormTextStyleItem::XFormTextStyleItem(SvStream& rIn) :
4720 	SfxEnumItem(XATTR_FORMTXTSTYLE, rIn)
4721 {
4722 }
4723 
4724 /*************************************************************************
4725 |*
4726 |*	  XFormTextStyleItem::Clone(SfxItemPool* pPool) const
4727 |*
4728 |*	  Beschreibung
4729 |*	  Ersterstellung	02.02.95 ESO
4730 |*	  Letzte Aenderung	02.02.95 ESO
4731 |*
4732 *************************************************************************/
4733 
4734 SfxPoolItem* XFormTextStyleItem::Clone(SfxItemPool* /*pPool*/) const
4735 {
4736 	return new XFormTextStyleItem( *this );
4737 }
4738 
4739 /*************************************************************************
4740 |*
4741 |*	  SfxPoolItem* XFormTextStyleItem::Create(SvStream& rIn, sal_uInt16 nVer) const
4742 |*
4743 |*	  Beschreibung
4744 |*	  Ersterstellung	02.02.95 ESO
4745 |*	  Letzte Aenderung	02.02.95 ESO
4746 |*
4747 *************************************************************************/
4748 
4749 SfxPoolItem* XFormTextStyleItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
4750 {
4751 	return new XFormTextStyleItem(rIn);
4752 }
4753 
4754 /*************************************************************************
4755 |*
4756 |*
4757 |*
4758 \*************************************************************************/
4759 
4760 sal_uInt16 XFormTextStyleItem::GetValueCount() const
4761 {
4762 	return 5;
4763 }
4764 
4765 /*************************************************************************
4766 |*
4767 |*
4768 |*
4769 \*************************************************************************/
4770 
4771 // #FontWork#
4772 sal_Bool XFormTextStyleItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
4773 {
4774 	rVal <<= (sal_Int32)GetValue();
4775 	return sal_True;
4776 }
4777 
4778 /*************************************************************************
4779 |*
4780 |*
4781 |*
4782 \*************************************************************************/
4783 
4784 // #FontWork#
4785 sal_Bool XFormTextStyleItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
4786 {
4787 	sal_Int32 nValue = 0;
4788 	rVal >>= nValue;
4789 	SetValue(sal::static_int_cast< sal_uInt16 >(nValue));
4790 
4791 	return sal_True;
4792 }
4793 
4794 //-------------------------
4795 // class XFormTextAdjustItem
4796 //-------------------------
4797 TYPEINIT1_AUTOFACTORY(XFormTextAdjustItem, SfxEnumItem);
4798 
4799 /*************************************************************************
4800 |*
4801 |*	  XFormTextAdjustItem::XFormTextAdjustItem()
4802 |*
4803 |*	  Beschreibung
4804 |*	  Ersterstellung	02.02.95 ESO
4805 |*	  Letzte Aenderung	02.02.95 ESO
4806 |*
4807 *************************************************************************/
4808 
4809 XFormTextAdjustItem::XFormTextAdjustItem(XFormTextAdjust eTheAdjust) :
4810 	SfxEnumItem(XATTR_FORMTXTADJUST, sal::static_int_cast< sal_uInt16 >(eTheAdjust))
4811 {
4812 }
4813 
4814 /*************************************************************************
4815 |*
4816 |*	  XFormTextAdjustItem::XFormTextAdjustItem(SvStream& rIn)
4817 |*
4818 |*	  Beschreibung
4819 |*	  Ersterstellung	02.02.95 ESO
4820 |*	  Letzte Aenderung	02.02.95 ESO
4821 |*
4822 *************************************************************************/
4823 
4824 XFormTextAdjustItem::XFormTextAdjustItem(SvStream& rIn) :
4825 	SfxEnumItem(XATTR_FORMTXTADJUST, rIn)
4826 {
4827 }
4828 
4829 /*************************************************************************
4830 |*
4831 |*	  XFormTextAdjustItem::Clone(SfxItemPool* pPool) const
4832 |*
4833 |*	  Beschreibung
4834 |*	  Ersterstellung	02.02.95 ESO
4835 |*	  Letzte Aenderung	02.02.95 ESO
4836 |*
4837 *************************************************************************/
4838 
4839 SfxPoolItem* XFormTextAdjustItem::Clone(SfxItemPool* /*pPool*/) const
4840 {
4841 	return new XFormTextAdjustItem( *this );
4842 }
4843 
4844 /*************************************************************************
4845 |*
4846 |*	  SfxPoolItem* XFormTextAdjustItem::Create(SvStream& rIn, sal_uInt16 nVer) const
4847 |*
4848 |*	  Beschreibung
4849 |*	  Ersterstellung	02.02.95 ESO
4850 |*	  Letzte Aenderung	02.02.95 ESO
4851 |*
4852 *************************************************************************/
4853 
4854 SfxPoolItem* XFormTextAdjustItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
4855 {
4856 	return new XFormTextAdjustItem(rIn);
4857 }
4858 
4859 /*************************************************************************
4860 |*
4861 |*
4862 |*
4863 \*************************************************************************/
4864 
4865 sal_uInt16 XFormTextAdjustItem::GetValueCount() const
4866 {
4867 	return 4;
4868 }
4869 
4870 /*************************************************************************
4871 |*
4872 |*
4873 |*
4874 \*************************************************************************/
4875 
4876 // #FontWork#
4877 sal_Bool XFormTextAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
4878 {
4879 	rVal <<= (sal_Int32)GetValue();
4880 	return sal_True;
4881 }
4882 
4883 /*************************************************************************
4884 |*
4885 |*
4886 |*
4887 \*************************************************************************/
4888 
4889 // #FontWork#
4890 sal_Bool XFormTextAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
4891 {
4892 	sal_Int32 nValue = 0;
4893 	rVal >>= nValue;
4894 	SetValue(sal::static_int_cast< sal_uInt16 >(nValue));
4895 
4896 	return sal_True;
4897 }
4898 
4899 //----------------------------
4900 // class XFormTextDistanceItem
4901 //----------------------------
4902 TYPEINIT1_AUTOFACTORY(XFormTextDistanceItem, SfxMetricItem);
4903 
4904 /*************************************************************************
4905 |*
4906 |*	  XFormTextDistanceItem::XFormTextDistanceItem()
4907 |*
4908 |*	  Beschreibung
4909 |*	  Ersterstellung	02.02.95 ESO
4910 |*	  Letzte Aenderung	02.02.95 ESO
4911 |*
4912 *************************************************************************/
4913 
4914 XFormTextDistanceItem::XFormTextDistanceItem(long nDist) :
4915 	SfxMetricItem(XATTR_FORMTXTDISTANCE, nDist)
4916 {
4917 }
4918 
4919 /*************************************************************************
4920 |*
4921 |*	  XFormTextDistanceItem::XFormTextDistanceItem(SvStream& rIn)
4922 |*
4923 |*	  Beschreibung
4924 |*	  Ersterstellung	02.02.95 ESO
4925 |*	  Letzte Aenderung	02.02.95 ESO
4926 |*
4927 *************************************************************************/
4928 
4929 XFormTextDistanceItem::XFormTextDistanceItem(SvStream& rIn) :
4930 	SfxMetricItem(XATTR_FORMTXTDISTANCE, rIn)
4931 {
4932 }
4933 
4934 /*************************************************************************
4935 |*
4936 |*	  XFormTextDistanceItem::Clone(SfxItemPool* pPool) const
4937 |*
4938 |*	  Beschreibung
4939 |*	  Ersterstellung	02.02.95 ESO
4940 |*	  Letzte Aenderung	02.02.95 ESO
4941 |*
4942 *************************************************************************/
4943 
4944 SfxPoolItem* XFormTextDistanceItem::Clone(SfxItemPool* /*pPool*/) const
4945 {
4946 	return new XFormTextDistanceItem(*this);
4947 }
4948 
4949 /*************************************************************************
4950 |*
4951 |*	  SfxPoolItem* XFormTextDistanceItem::Create(SvStream& rIn, sal_uInt16 nVer) const
4952 |*
4953 |*	  Beschreibung
4954 |*	  Ersterstellung	02.02.95 ESO
4955 |*	  Letzte Aenderung	02.02.95 ESO
4956 |*
4957 *************************************************************************/
4958 
4959 SfxPoolItem* XFormTextDistanceItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
4960 {
4961 	return new XFormTextDistanceItem(rIn);
4962 }
4963 
4964 //-------------------------
4965 // class XFormTextStartItem
4966 //-------------------------
4967 TYPEINIT1_AUTOFACTORY(XFormTextStartItem, SfxMetricItem);
4968 
4969 /*************************************************************************
4970 |*
4971 |*	  XFormTextStartItem::XFormTextStartItem(long nStart)
4972 |*
4973 |*	  Beschreibung
4974 |*	  Ersterstellung	02.02.95 ESO
4975 |*	  Letzte Aenderung	02.02.95 ESO
4976 |*
4977 *************************************************************************/
4978 
4979 XFormTextStartItem::XFormTextStartItem(long nStart) :
4980 	SfxMetricItem(XATTR_FORMTXTSTART, nStart)
4981 {
4982 }
4983 
4984 /*************************************************************************
4985 |*
4986 |*	  XFormTextStartItem::XFormTextStartItem(SvStream& rIn)
4987 |*
4988 |*	  Beschreibung
4989 |*	  Ersterstellung	02.02.95 ESO
4990 |*	  Letzte Aenderung	02.02.95 ESO
4991 |*
4992 *************************************************************************/
4993 
4994 XFormTextStartItem::XFormTextStartItem(SvStream& rIn) :
4995 	SfxMetricItem(XATTR_FORMTXTSTART, rIn)
4996 {
4997 }
4998 
4999 /*************************************************************************
5000 |*
5001 |*	  XFormTextStartItem::Clone(SfxItemPool* pPool) const
5002 |*
5003 |*	  Beschreibung
5004 |*	  Ersterstellung	02.02.95 ESO
5005 |*	  Letzte Aenderung	02.02.95 ESO
5006 |*
5007 *************************************************************************/
5008 
5009 SfxPoolItem* XFormTextStartItem::Clone(SfxItemPool* /*pPool*/) const
5010 {
5011 	return new XFormTextStartItem(*this);
5012 }
5013 
5014 /*************************************************************************
5015 |*
5016 |*	  SfxPoolItem* XFormTextStartItem::Create(SvStream& rIn, sal_uInt16 nVer) const
5017 |*
5018 |*	  Beschreibung
5019 |*	  Ersterstellung	02.02.95 ESO
5020 |*	  Letzte Aenderung	02.02.95 ESO
5021 |*
5022 *************************************************************************/
5023 
5024 SfxPoolItem* XFormTextStartItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5025 {
5026 	return new XFormTextStartItem(rIn);
5027 }
5028 
5029 // -------------------------
5030 // class XFormTextMirrorItem
5031 // -------------------------
5032 TYPEINIT1_AUTOFACTORY(XFormTextMirrorItem, SfxBoolItem);
5033 
5034 /*************************************************************************
5035 |*
5036 |*	  XFormTextMirrorItem::XFormTextMirrorItem(sal_Bool bMirror)
5037 |*
5038 |*	  Ersterstellung	06.02.95 ESO
5039 |*	  Letzte Aenderung	06.02.95 ESO
5040 |*
5041 *************************************************************************/
5042 
5043 XFormTextMirrorItem::XFormTextMirrorItem(sal_Bool bMirror) :
5044 	SfxBoolItem(XATTR_FORMTXTMIRROR, bMirror)
5045 {
5046 }
5047 
5048 /*************************************************************************
5049 |*
5050 |*	  XFormTextMirrorItem::XFormTextMirrorItem(SvStream& rIn)
5051 |*
5052 |*	  Ersterstellung	06.02.95 ESO
5053 |*	  Letzte Aenderung	06.02.95 ESO
5054 |*
5055 *************************************************************************/
5056 
5057 XFormTextMirrorItem::XFormTextMirrorItem(SvStream& rIn) :
5058 	SfxBoolItem(XATTR_FORMTXTMIRROR, rIn)
5059 {
5060 }
5061 
5062 /*************************************************************************
5063 |*
5064 |*	  XFormTextMirrorItem::Clone(SfxItemPool* pPool) const
5065 |*
5066 |*	  Ersterstellung	06.02.95 ESO
5067 |*	  Letzte Aenderung	06.02.95 ESO
5068 |*
5069 *************************************************************************/
5070 
5071 SfxPoolItem* XFormTextMirrorItem::Clone(SfxItemPool* /*pPool*/) const
5072 {
5073 	return new XFormTextMirrorItem(*this);
5074 }
5075 
5076 /*************************************************************************
5077 |*
5078 |*	  SfxPoolItem* XFormTextMirrorItem::Create(SvStream& rIn, sal_uInt16 nVer)
5079 |*												const
5080 |*
5081 |*	  Ersterstellung	06.02.95 ESO
5082 |*	  Letzte Aenderung	06.02.95 ESO
5083 |*
5084 *************************************************************************/
5085 
5086 SfxPoolItem* XFormTextMirrorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5087 {
5088 	return new XFormTextMirrorItem(rIn);
5089 }
5090 
5091 
5092 // --------------------------
5093 // class XFormTextOutlineItem
5094 // --------------------------
5095 TYPEINIT1_AUTOFACTORY(XFormTextOutlineItem, SfxBoolItem);
5096 
5097 /*************************************************************************
5098 |*
5099 |*	  XFormTextOutlineItem::XFormTextOutlineItem()
5100 |*
5101 |*	  Ersterstellung	27.06.95 ESO
5102 |*	  Letzte Aenderung	27.06.95 ESO
5103 |*
5104 *************************************************************************/
5105 
5106 XFormTextOutlineItem::XFormTextOutlineItem(sal_Bool bOutline) :
5107 	SfxBoolItem(XATTR_FORMTXTOUTLINE, bOutline)
5108 {
5109 }
5110 
5111 /*************************************************************************
5112 |*
5113 |*	  XFormTextOutlineItem::XFormTextOutlineItem(SvStream& rIn)
5114 |*
5115 |*	  Ersterstellung	27.06.95 ESO
5116 |*	  Letzte Aenderung	27.06.95 ESO
5117 |*
5118 *************************************************************************/
5119 
5120 XFormTextOutlineItem::XFormTextOutlineItem(SvStream& rIn) :
5121 	SfxBoolItem(XATTR_FORMTXTOUTLINE, rIn)
5122 {
5123 }
5124 
5125 /*************************************************************************
5126 |*
5127 |*	  XFormTextOutlineItem::Clone(SfxItemPool* pPool) const
5128 |*
5129 |*	  Ersterstellung	27.06.95 ESO
5130 |*	  Letzte Aenderung	27.06.95 ESO
5131 |*
5132 *************************************************************************/
5133 
5134 SfxPoolItem* XFormTextOutlineItem::Clone(SfxItemPool* /*pPool*/) const
5135 {
5136 	return new XFormTextOutlineItem(*this);
5137 }
5138 
5139 /*************************************************************************
5140 |*
5141 |*	  SfxPoolItem* XFormTextOutlineItem::Create(SvStream& rIn, sal_uInt16 nVer)
5142 |*												const
5143 |*
5144 |*	  Ersterstellung	27.06.95 ESO
5145 |*	  Letzte Aenderung	27.06.95 ESO
5146 |*
5147 *************************************************************************/
5148 
5149 SfxPoolItem* XFormTextOutlineItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5150 {
5151 	return new XFormTextOutlineItem(rIn);
5152 }
5153 
5154 //--------------------------
5155 // class XFormTextShadowItem
5156 //--------------------------
5157 TYPEINIT1_AUTOFACTORY(XFormTextShadowItem, SfxEnumItem);
5158 
5159 /*************************************************************************
5160 |*
5161 |*	  XFormTextShadowItem::XFormTextShadowItem()
5162 |*
5163 |*	  Beschreibung
5164 |*	  Ersterstellung	27.06.95
5165 |*	  Letzte Aenderung	27.06.95
5166 |*
5167 *************************************************************************/
5168 
5169 XFormTextShadowItem::XFormTextShadowItem(XFormTextShadow eFormTextShadow) :
5170 	SfxEnumItem(
5171         XATTR_FORMTXTSHADOW, sal::static_int_cast< sal_uInt16 >(eFormTextShadow))
5172 {
5173 }
5174 
5175 /*************************************************************************
5176 |*
5177 |*	  XFormTextShadowItem::XFormTextShadowItem(SvStream& rIn)
5178 |*
5179 |*	  Beschreibung
5180 |*	  Ersterstellung	27.06.95
5181 |*	  Letzte Aenderung	27.06.95
5182 |*
5183 *************************************************************************/
5184 
5185 XFormTextShadowItem::XFormTextShadowItem(SvStream& rIn) :
5186 	SfxEnumItem(XATTR_FORMTXTSHADOW, rIn)
5187 {
5188 }
5189 
5190 /*************************************************************************
5191 |*
5192 |*	  XFormTextShadowItem::Clone(SfxItemPool* pPool) const
5193 |*
5194 |*	  Beschreibung
5195 |*	  Ersterstellung	27.06.95
5196 |*	  Letzte Aenderung	27.06.95
5197 |*
5198 *************************************************************************/
5199 
5200 SfxPoolItem* XFormTextShadowItem::Clone(SfxItemPool* /*pPool*/) const
5201 {
5202 	return new XFormTextShadowItem( *this );
5203 }
5204 
5205 /*************************************************************************
5206 |*
5207 |*	  SfxPoolItem* XFormTextShadowItem::Create(SvStream& rIn, sal_uInt16 nVer) const
5208 |*
5209 |*	  Beschreibung
5210 |*	  Ersterstellung	27.06.95
5211 |*	  Letzte Aenderung	27.06.95
5212 |*
5213 *************************************************************************/
5214 
5215 SfxPoolItem* XFormTextShadowItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5216 {
5217 	return new XFormTextShadowItem(rIn);
5218 }
5219 
5220 
5221 /*************************************************************************
5222 |*
5223 |*
5224 |*
5225 \*************************************************************************/
5226 
5227 sal_uInt16 XFormTextShadowItem::GetValueCount() const
5228 {
5229 	return 3;
5230 }
5231 
5232 /*************************************************************************
5233 |*
5234 |*
5235 |*
5236 \*************************************************************************/
5237 
5238 // #FontWork#
5239 sal_Bool XFormTextShadowItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/) const
5240 {
5241 	rVal <<= (sal_Int32)GetValue();
5242 	return sal_True;
5243 }
5244 
5245 /*************************************************************************
5246 |*
5247 |*
5248 |*
5249 \*************************************************************************/
5250 
5251 // #FontWork#
5252 sal_Bool XFormTextShadowItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/)
5253 {
5254 	sal_Int32 nValue = 0;
5255 	rVal >>= nValue;
5256 	SetValue(sal::static_int_cast< sal_uInt16 >(nValue));
5257 
5258 	return sal_True;
5259 }
5260 
5261 // -------------------------------
5262 // class XFormTextShadowColorItem
5263 // -------------------------------
5264 TYPEINIT1_AUTOFACTORY(XFormTextShadowColorItem, XColorItem);
5265 
5266 /*************************************************************************
5267 |*
5268 |*	  XFormTextShadowColorItem::XFormTextShadowColorItem()
5269 |*
5270 |*	  Beschreibung
5271 |*	  Ersterstellung	27.06.95
5272 |*	  Letzte Aenderung	27.06.95
5273 |*
5274 *************************************************************************/
5275 
5276 XFormTextShadowColorItem::XFormTextShadowColorItem(sal_Int32 nIndex,
5277 													 const Color& rTheColor) :
5278 	XColorItem(XATTR_FORMTXTSHDWCOLOR, nIndex, rTheColor)
5279 {
5280 }
5281 
5282 /*************************************************************************
5283 |*
5284 |*	  XFormTextShadowColorItem::XFormTextShadowColorItem(const XubString& rName, const Color& rTheColor)
5285 |*
5286 |*	  Beschreibung
5287 |*	  Ersterstellung	27.06.95
5288 |*	  Letzte Aenderung	27.06.95
5289 |*
5290 *************************************************************************/
5291 
5292 XFormTextShadowColorItem::XFormTextShadowColorItem(const XubString& rName,
5293 													 const Color& rTheColor) :
5294 	XColorItem(XATTR_FORMTXTSHDWCOLOR, rName, rTheColor)
5295 {
5296 }
5297 
5298 /*************************************************************************
5299 |*
5300 |*	  XFormTextShadowColorItem::XFormTextShadowColorItem(SvStream& rIn)
5301 |*
5302 |*	  Beschreibung
5303 |*	  Ersterstellung	27.06.95
5304 |*	  Letzte Aenderung	27.06.95
5305 |*
5306 *************************************************************************/
5307 
5308 XFormTextShadowColorItem::XFormTextShadowColorItem(SvStream& rIn) :
5309 	XColorItem(XATTR_FORMTXTSHDWCOLOR, rIn)
5310 {
5311 }
5312 
5313 /*************************************************************************
5314 |*
5315 |*	  XFormTextShadowColorItem::Clone(SfxItemPool* pPool) const
5316 |*
5317 |*	  Beschreibung
5318 |*	  Ersterstellung	27.06.95
5319 |*	  Letzte Aenderung	27.06.95
5320 |*
5321 *************************************************************************/
5322 
5323 SfxPoolItem* XFormTextShadowColorItem::Clone(SfxItemPool* /*pPool*/) const
5324 {
5325 	return new XFormTextShadowColorItem(*this);
5326 }
5327 
5328 /*************************************************************************
5329 |*
5330 |*	  SfxPoolItem* XFormTextShadowColorItem::Create(SvStream& rIn, sal_uInt16 nVer) const
5331 |*
5332 |*	  Beschreibung
5333 |*	  Ersterstellung	27.06.95
5334 |*	  Letzte Aenderung	27.06.95
5335 |*
5336 *************************************************************************/
5337 
5338 SfxPoolItem* XFormTextShadowColorItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5339 {
5340 	return new XFormTextShadowColorItem(rIn);
5341 }
5342 
5343 //------------------------------
5344 // class XFormTextShadowXValItem
5345 //------------------------------
5346 TYPEINIT1_AUTOFACTORY(XFormTextShadowXValItem, SfxMetricItem);
5347 
5348 /*************************************************************************
5349 |*
5350 |*	  XFormTextShadowXValItem::XFormTextShadowXValItem(long)
5351 |*
5352 |*	  Beschreibung
5353 |*	  Ersterstellung	28.06.95 ESO
5354 |*	  Letzte Aenderung	28.06.95 ESO
5355 |*
5356 *************************************************************************/
5357 
5358 XFormTextShadowXValItem::XFormTextShadowXValItem(long nVal) :
5359 	SfxMetricItem(XATTR_FORMTXTSHDWXVAL, nVal)
5360 {
5361 }
5362 
5363 /*************************************************************************
5364 |*
5365 |*	  XFormTextShadowXValItem::XFormTextShadowXValItem(SvStream& rIn)
5366 |*
5367 |*	  Beschreibung
5368 |*	  Ersterstellung	28.06.95 ESO
5369 |*	  Letzte Aenderung	28.06.95 ESO
5370 |*
5371 *************************************************************************/
5372 
5373 XFormTextShadowXValItem::XFormTextShadowXValItem(SvStream& rIn) :
5374 	SfxMetricItem(XATTR_FORMTXTSHDWXVAL, rIn)
5375 {
5376 }
5377 
5378 /*************************************************************************
5379 |*
5380 |*	  XFormTextShadowXValItem::Clone(SfxItemPool* pPool) const
5381 |*
5382 |*	  Beschreibung
5383 |*	  Ersterstellung	28.06.95 ESO
5384 |*	  Letzte Aenderung	28.06.95 ESO
5385 |*
5386 *************************************************************************/
5387 
5388 SfxPoolItem* XFormTextShadowXValItem::Clone(SfxItemPool* /*pPool*/) const
5389 {
5390 	return new XFormTextShadowXValItem(*this);
5391 }
5392 
5393 /*************************************************************************
5394 |*
5395 |*	  SfxPoolItem* XFormTextShadowXValItem::Create(SvStream& rIn, sal_uInt16 nVer) const
5396 |*
5397 |*	  Beschreibung
5398 |*	  Ersterstellung	28.06.95 ESO
5399 |*	  Letzte Aenderung	28.06.95 ESO
5400 |*
5401 *************************************************************************/
5402 
5403 SfxPoolItem* XFormTextShadowXValItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5404 {
5405 	return new XFormTextShadowXValItem(rIn);
5406 }
5407 
5408 //------------------------------
5409 // class XFormTextShadowYValItem
5410 //------------------------------
5411 TYPEINIT1_AUTOFACTORY(XFormTextShadowYValItem, SfxMetricItem);
5412 
5413 /*************************************************************************
5414 |*
5415 |*	  XFormTextShadowYValItem::XFormTextShadowYValItem(long)
5416 |*
5417 |*	  Beschreibung
5418 |*	  Ersterstellung	28.06.95 ESO
5419 |*	  Letzte Aenderung	28.06.95 ESO
5420 |*
5421 *************************************************************************/
5422 
5423 XFormTextShadowYValItem::XFormTextShadowYValItem(long nVal) :
5424 	SfxMetricItem(XATTR_FORMTXTSHDWYVAL, nVal)
5425 {
5426 }
5427 
5428 /*************************************************************************
5429 |*
5430 |*	  XFormTextShadowYValItem::XFormTextShadowYValItem(SvStream& rIn)
5431 |*
5432 |*	  Beschreibung
5433 |*	  Ersterstellung	28.06.95 ESO
5434 |*	  Letzte Aenderung	28.06.95 ESO
5435 |*
5436 *************************************************************************/
5437 
5438 XFormTextShadowYValItem::XFormTextShadowYValItem(SvStream& rIn) :
5439 	SfxMetricItem(XATTR_FORMTXTSHDWYVAL, rIn)
5440 {
5441 }
5442 
5443 /*************************************************************************
5444 |*
5445 |*	  XFormTextShadowYValItem::Clone(SfxItemPool* pPool) const
5446 |*
5447 |*	  Beschreibung
5448 |*	  Ersterstellung	28.06.95 ESO
5449 |*	  Letzte Aenderung	28.06.95 ESO
5450 |*
5451 *************************************************************************/
5452 
5453 SfxPoolItem* XFormTextShadowYValItem::Clone(SfxItemPool* /*pPool*/) const
5454 {
5455 	return new XFormTextShadowYValItem(*this);
5456 }
5457 
5458 /*************************************************************************
5459 |*
5460 |*	  SfxPoolItem* XFormTextShadowYValItem::Create(SvStream& rIn, sal_uInt16 nVer) const
5461 |*
5462 |*	  Beschreibung
5463 |*	  Ersterstellung	28.06.95 ESO
5464 |*	  Letzte Aenderung	28.06.95 ESO
5465 |*
5466 *************************************************************************/
5467 
5468 SfxPoolItem* XFormTextShadowYValItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5469 {
5470 	return new XFormTextShadowYValItem(rIn);
5471 }
5472 
5473 // --------------------------
5474 // class XFormTextHideFormItem
5475 // --------------------------
5476 TYPEINIT1_AUTOFACTORY(XFormTextHideFormItem, SfxBoolItem);
5477 
5478 /*************************************************************************
5479 |*
5480 |*	  XFormTextHideFormItem::XFormTextHideFormItem()
5481 |*
5482 |*	  Ersterstellung	27.06.95 ESO
5483 |*	  Letzte Aenderung	27.06.95 ESO
5484 |*
5485 *************************************************************************/
5486 
5487 XFormTextHideFormItem::XFormTextHideFormItem(sal_Bool bHide) :
5488 	SfxBoolItem(XATTR_FORMTXTHIDEFORM, bHide)
5489 {
5490 }
5491 
5492 /*************************************************************************
5493 |*
5494 |*	  XFormTextHideFormItem::XFormTextHideFormItem(SvStream& rIn)
5495 |*
5496 |*	  Ersterstellung	27.06.95 ESO
5497 |*	  Letzte Aenderung	27.06.95 ESO
5498 |*
5499 *************************************************************************/
5500 
5501 XFormTextHideFormItem::XFormTextHideFormItem(SvStream& rIn) :
5502 	SfxBoolItem(XATTR_FORMTXTHIDEFORM, rIn)
5503 {
5504 }
5505 
5506 /*************************************************************************
5507 |*
5508 |*	  XFormTextHideFormItem::Clone(SfxItemPool* pPool) const
5509 |*
5510 |*	  Ersterstellung	27.06.95 ESO
5511 |*	  Letzte Aenderung	27.06.95 ESO
5512 |*
5513 *************************************************************************/
5514 
5515 SfxPoolItem* XFormTextHideFormItem::Clone(SfxItemPool* /*pPool*/) const
5516 {
5517 	return new XFormTextHideFormItem(*this);
5518 }
5519 
5520 /*************************************************************************
5521 |*
5522 |*	  SfxPoolItem* XFormTextHideFormItem::Create(SvStream& rIn, sal_uInt16 nVer)
5523 |*												const
5524 |*
5525 |*	  Ersterstellung	27.06.95 ESO
5526 |*	  Letzte Aenderung	27.06.95 ESO
5527 |*
5528 *************************************************************************/
5529 
5530 SfxPoolItem* XFormTextHideFormItem::Create(SvStream& rIn, sal_uInt16 /*nVer*/) const
5531 {
5532 	return new XFormTextHideFormItem(rIn);
5533 }
5534 
5535 
5536 
5537 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5538 //								SetItems
5539 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5540 
5541 TYPEINIT1(XLineAttrSetItem, SfxSetItem);
5542 
5543 /*************************************************************************
5544 |*
5545 |* Konstruktoren fuer Linienattribute-SetItem
5546 |*
5547 \************************************************************************/
5548 
5549 XLineAttrSetItem::XLineAttrSetItem( SfxItemSet* pItemSet ) :
5550 	SfxSetItem( XATTRSET_LINE, pItemSet)
5551 {
5552 }
5553 
5554 /************************************************************************/
5555 
5556 XLineAttrSetItem::XLineAttrSetItem( SfxItemPool* pItemPool ) :
5557 	SfxSetItem( XATTRSET_LINE,
5558 		new SfxItemSet( *pItemPool, XATTR_LINE_FIRST, XATTR_LINE_LAST))
5559 {
5560 }
5561 
5562 /************************************************************************/
5563 
5564 XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr ) :
5565 	SfxSetItem( rLineAttr )
5566 {
5567 }
5568 
5569 /************************************************************************/
5570 
5571 XLineAttrSetItem::XLineAttrSetItem( const XLineAttrSetItem& rLineAttr,
5572 									SfxItemPool* pItemPool) :
5573 	SfxSetItem( rLineAttr, pItemPool )
5574 {
5575 }
5576 
5577 /*************************************************************************
5578 |*
5579 |* Clone-Funktion
5580 |*
5581 \************************************************************************/
5582 
5583 SfxPoolItem* XLineAttrSetItem::Clone( SfxItemPool* pPool ) const
5584 {
5585 	return new XLineAttrSetItem( *this, pPool );
5586 }
5587 
5588 /*************************************************************************
5589 |*
5590 |* SetItem aus Stream erzeugen
5591 |*
5592 \************************************************************************/
5593 
5594 SfxPoolItem* XLineAttrSetItem::Create( SvStream& rStream, sal_uInt16 /*nVersion*/) const
5595 {
5596 	SfxItemSet *pSet2 = new SfxItemSet( *GetItemSet().GetPool(),
5597 									XATTR_LINE_FIRST, XATTR_LINE_LAST);
5598 	pSet2->Load( rStream );
5599 	return new XLineAttrSetItem( pSet2 );
5600 }
5601 
5602 /*************************************************************************
5603 |*
5604 |* SetItem in Stream speichern
5605 |*
5606 \************************************************************************/
5607 
5608 SvStream& XLineAttrSetItem::Store( SvStream& rStream, sal_uInt16 nItemVersion ) const
5609 {
5610 	return SfxSetItem::Store( rStream, nItemVersion );
5611 }
5612 
5613 
5614 TYPEINIT1(XFillAttrSetItem, SfxSetItem);
5615 
5616 /*************************************************************************
5617 |*
5618 |* Konstruktoren fuer Fuellattribute-SetItem
5619 |*
5620 \************************************************************************/
5621 
5622 XFillAttrSetItem::XFillAttrSetItem( SfxItemSet* pItemSet ) :
5623 	SfxSetItem( XATTRSET_FILL, pItemSet)
5624 {
5625 }
5626 
5627 /************************************************************************/
5628 
5629 XFillAttrSetItem::XFillAttrSetItem( SfxItemPool* pItemPool ) :
5630 	SfxSetItem( XATTRSET_FILL,
5631 		new SfxItemSet( *pItemPool, XATTR_FILL_FIRST, XATTR_FILL_LAST))
5632 {
5633 }
5634 
5635 /************************************************************************/
5636 
5637 XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr ) :
5638 	SfxSetItem( rFillAttr )
5639 {
5640 }
5641 
5642 /************************************************************************/
5643 
5644 XFillAttrSetItem::XFillAttrSetItem( const XFillAttrSetItem& rFillAttr,
5645 									SfxItemPool* pItemPool ) :
5646 	SfxSetItem( rFillAttr, pItemPool )
5647 {
5648 }
5649 
5650 /*************************************************************************
5651 |*
5652 |* Clone-Funktion
5653 |*
5654 \************************************************************************/
5655 
5656 SfxPoolItem* XFillAttrSetItem::Clone( SfxItemPool* pPool ) const
5657 {
5658 	return new XFillAttrSetItem( *this, pPool );
5659 }
5660 
5661 /*************************************************************************
5662 |*
5663 |* SetItem aus Stream erzeugen
5664 |*
5665 \************************************************************************/
5666 
5667 SfxPoolItem* XFillAttrSetItem::Create( SvStream& rStream, sal_uInt16 /*nVersion*/) const
5668 {
5669 	SfxItemSet *pSet2 = new SfxItemSet( *GetItemSet().GetPool(),
5670 									XATTR_FILL_FIRST, XATTR_FILL_LAST);
5671 	pSet2->Load( rStream );
5672 	return new XFillAttrSetItem( pSet2 );
5673 }
5674 
5675 /*************************************************************************
5676 |*
5677 |* SetItem in Stream speichern
5678 |*
5679 \************************************************************************/
5680 
5681 SvStream& XFillAttrSetItem::Store( SvStream& rStream, sal_uInt16 nItemVersion ) const
5682 {
5683 	return SfxSetItem::Store( rStream, nItemVersion );
5684 }
5685 
5686 // eof
5687 
5688