svx/source/xoutdev/xattr.cxx

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