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