svx/source/xoutdev/xattr.cxx

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