svx/source/xoutdev/xattr.cxx

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