svtools/source/items1/slstitm.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: slstitm.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #include <svtools/slstitm.hxx>
  35 #include <svtools/poolitem.hxx>
  36 #include <com/sun/star/uno/Any.hxx>
  37 #include <com/sun/star/uno/Sequence.hxx>
  38 #include <tools/stream.hxx>
  39
  40 // STATIC DATA -----------------------------------------------------------
  41
  42 DBG_NAME(SfxStringListItem)
  43
  44 // -----------------------------------------------------------------------
  45
  46 TYPEINIT1_AUTOFACTORY(SfxStringListItem, SfxPoolItem);
  47
  48 class SfxImpStringList
  49 {
  50 public:
  51     USHORT      nRefCount;
  52     List        aList;
  53
  54             SfxImpStringList() { nRefCount = 1; }
  55             ~SfxImpStringList();
  56     void        Sort( BOOL bAscending, List* );
  57 };
  58
  59 //------------------------------------------------------------------------
  60
  61 SfxImpStringList::~SfxImpStringList()
  62 {
  63     DBG_ASSERT(nRefCount!=0xffff,"ImpList already deleted");
  64     String* pStr = (String*)aList.First();
  65     while( pStr )
  66     {
  67         delete pStr;
  68         pStr = (String*)aList.Next();
  69     }
  70     nRefCount = 0xffff;
  71 }
  72
  73 //------------------------------------------------------------------------
  74
  75 void SfxImpStringList::Sort( BOOL bAscending, List* pParallelList )
  76 {
  77     DBG_ASSERT(!pParallelList || pParallelList->Count() >= aList.Count(),"Sort:ParallelList too small");
  78     ULONG nCount = aList.Count();
  79     if( nCount > 1 )
  80     {
  81         nCount -= 2;
  82         // Bubble Dir Einen
  83         BOOL bSwapped = TRUE;
  84         while( bSwapped )
  85         {
  86             bSwapped = FALSE;
  87             for( ULONG nCur = 0; nCur <= nCount; nCur++ )
  88             {
  89                 String* pStr1 = (String*)aList.GetObject( nCur );
  90                 String* pStr2 = (String*)aList.GetObject( nCur+1 );
  91                 // COMPARE_GREATER => pStr2 ist groesser als pStr1
  92                 StringCompare eCompare = pStr1->CompareIgnoreCaseToAscii( *pStr2 ); //@@@
  93                 BOOL bSwap = FALSE;
  94                 if( bAscending )
  95                 {
  96                     if( eCompare == COMPARE_LESS )
  97                         bSwap = TRUE;
  98                 }
  99                 else if( eCompare == COMPARE_GREATER )
 100                     bSwap = TRUE;
 101
 102                 if( bSwap )
 103                 {
 104                     bSwapped = TRUE;
 105                     aList.Replace( pStr1, nCur + 1 );
 106                     aList.Replace( pStr2, nCur );
 107                     if( pParallelList )
 108                     {
 109                         void* p1 = pParallelList->GetObject( nCur );
 110                         void* p2 = pParallelList->GetObject( nCur + 1 );
 111                         pParallelList->Replace( p1, nCur + 1 );
 112                         pParallelList->Replace( p2, nCur );
 113                     }
 114                 }
 115             }
 116         }
 117     }
 118 }
 119
 120 // class SfxStringListItem -----------------------------------------------
 121
 122 SfxStringListItem::SfxStringListItem() :
 123     pImp(NULL)
 124 {
 125 }
 126
 127 //------------------------------------------------------------------------
 128
 129 SfxStringListItem::SfxStringListItem( USHORT which, const List* pList ) :
 130     SfxPoolItem( which ),
 131     pImp(NULL)
 132 {
 133     // PB: das Putten einer leeren Liste funktionierte nicht,
 134     // deshalb habe ich hier die Abfrage nach dem Count auskommentiert
 135     if( pList /*!!! && pList->Count() */ )
 136     {
 137         pImp = new SfxImpStringList;
 138
 139         long i, nCount = pList->Count();
 140         String  *pStr1, *pStr2;
 141         for( i=0; i < nCount; i++ )
 142         {
 143             pStr1 = (String*)pList->GetObject(i);
 144             pStr2 = new String( *pStr1 );
 145             pImp->aList.Insert( pStr2, LIST_APPEND );
 146         }
 147     }
 148 }
 149
 150 //------------------------------------------------------------------------
 151
 152 SfxStringListItem::SfxStringListItem( USHORT which, SvStream& rStream ) :
 153     SfxPoolItem( which ),
 154     pImp(NULL)
 155 {
 156     long nEntryCount;
 157     rStream >> nEntryCount;
 158
 159     if( nEntryCount )
 160         pImp = new SfxImpStringList;
 161
 162     long   i;
 163     String*  pStr;
 164     for( i=0; i < nEntryCount; i++ )
 165     {
 166         pStr = new String;
 167         readByteString(rStream, *pStr);
 168         pImp->aList.Insert( pStr, LIST_APPEND );
 169     }
 170 }
 171
 172 //------------------------------------------------------------------------
 173
 174 SfxStringListItem::SfxStringListItem( const SfxStringListItem& rItem ) :
 175     SfxPoolItem( rItem ),
 176     pImp(NULL)
 177 {
 178     pImp = rItem.pImp;
 179
 180     if( pImp )
 181     {
 182         DBG_ASSERT(pImp->nRefCount!=0xffff,"ImpList not valid");
 183         pImp->nRefCount++;
 184     }
 185 }
 186
 187 //------------------------------------------------------------------------
 188
 189 SfxStringListItem::~SfxStringListItem()
 190 {
 191     if( pImp )
 192     {
 193         DBG_ASSERT(pImp->nRefCount!=0xffff,"ImpList not valid");
 194         if( pImp->nRefCount > 1 )
 195             pImp->nRefCount--;
 196         else
 197             delete pImp;
 198     }
 199 }
 200
 201 //------------------------------------------------------------------------
 202
 203 List* SfxStringListItem::GetList()
 204 {
 205     if( !pImp )
 206         pImp = new SfxImpStringList;
 207     DBG_ASSERT(pImp->nRefCount!=0xffff,"ImpList not valid");
 208     return &(pImp->aList);
 209 }
 210
 211 //------------------------------------------------------------------------
 212
 213 int SfxStringListItem::operator==( const SfxPoolItem& rItem ) const
 214 {
 215     DBG_ASSERT( SfxPoolItem::operator==( rItem ), "unequal type" );
 216
 217     SfxStringListItem* pItem = (SfxStringListItem*)&rItem;
 218
 219     if( pImp == pItem->pImp )
 220         return TRUE;
 221     else
 222         return FALSE;
 223 }
 224
 225 //------------------------------------------------------------------------
 226
 227 SfxItemPresentation SfxStringListItem::GetPresentation
 228 (
 229     SfxItemPresentation         /*ePresentation*/,
 230     SfxMapUnit                          /*eCoreMetric*/,
 231     SfxMapUnit                          /*ePresentationMetric*/,
 232     XubString&                          rText,
 233     const IntlWrapper *
 234 )       const
 235 {
 236     rText.AssignAscii(RTL_CONSTASCII_STRINGPARAM("(List)"));
 237     return SFX_ITEM_PRESENTATION_NONE;
 238 }
 239
 240 //------------------------------------------------------------------------
 241
 242 SfxPoolItem* SfxStringListItem::Clone( SfxItemPool *) const
 243 {
 244     return new SfxStringListItem( *this );
 245     /*
 246     if( pImp )
 247         return new SfxStringListItem( Which(), &(pImp->aList) );
 248     else
 249         return new SfxStringListItem( Which(), NULL );
 250     */
 251
 252 }
 253
 254 //------------------------------------------------------------------------
 255
 256 SfxPoolItem* SfxStringListItem::Create( SvStream & rStream, USHORT ) const
 257 {
 258     return new SfxStringListItem( Which(), rStream );
 259 }
 260
 261 //------------------------------------------------------------------------
 262
 263 SvStream& SfxStringListItem::Store( SvStream & rStream, USHORT ) const
 264 {
 265     if( !pImp )
 266     {
 267         rStream << 0L;
 268         return rStream;
 269     }
 270
 271     DBG_ASSERT(pImp->nRefCount!=0xffff,"ImpList not valid");
 272
 273     long nCount = pImp->aList.Count();
 274     rStream << nCount;
 275
 276     long i;
 277     String* pStr;
 278     for( i=0; i < nCount; i++ )
 279     {
 280         pStr = (String*)(pImp->aList.GetObject( i ));
 281         writeByteString(rStream, *pStr);
 282     }
 283
 284     return rStream;
 285 }
 286
 287 //------------------------------------------------------------------------
 288
 289 void SfxStringListItem::SetString( const XubString& rStr )
 290 {
 291     DBG_ASSERT(GetRefCount()==0,"SetString:RefCount!=0");
 292
 293     if ( pImp && (pImp->nRefCount == 1) )
 294         delete pImp;
 295     else
 296     if( pImp )
 297         pImp->nRefCount--;
 298     pImp = new SfxImpStringList;
 299
 300     xub_StrLen nStart = 0;
 301     xub_StrLen nDelimPos;
 302     XubString aStr(rStr);
 303     aStr.ConvertLineEnd(LINEEND_CR);
 304     do
 305     {
 306         nDelimPos = aStr.Search( _CR, nStart );
 307         xub_StrLen nLen;
 308         if ( nDelimPos == STRING_NOTFOUND )
 309             nLen = 0xffff;
 310         else
 311             nLen = nDelimPos - nStart;
 312
 313         XubString* pStr = new XubString(aStr.Copy(nStart, nLen));
 314         // String gehoert der Liste
 315         pImp->aList.Insert( pStr, LIST_APPEND );
 316
 317         nStart += nLen + 1 ;    // delimiter ueberspringen
 318     } while( nDelimPos != STRING_NOTFOUND );
 319
 320     // Kein Leerstring am Ende
 321     if( pImp->aList.Last() &&
 322         !((XubString*)pImp->aList.Last())->Len() )
 323         delete (XubString*)pImp->aList.Remove( pImp->aList.Count()-1 );
 324 }
 325
 326 //------------------------------------------------------------------------
 327
 328 XubString SfxStringListItem::GetString()
 329 {
 330     XubString aStr;
 331     if ( pImp )
 332     {
 333         DBG_ASSERT(pImp->nRefCount!=0xffff,"ImpList not valid");
 334         XubString* pStr = (XubString*)(pImp->aList.First());
 335         while( pStr )
 336         {
 337             aStr += *pStr;
 338             pStr = (XubString*)(pImp->aList.Next());
 339             if ( pStr )
 340                 aStr += '\r';
 341         }
 342     }
 343     aStr.ConvertLineEnd();
 344     return aStr;
 345 }
 346
 347 //------------------------------------------------------------------------
 348
 349 #ifndef TF_POOLABLE
 350
 351 int SfxStringListItem::IsPoolable() const
 352 {
 353     return FALSE;
 354 }
 355
 356 #endif
 357
 358 //------------------------------------------------------------------------
 359
 360 void SfxStringListItem::Sort( BOOL bAscending, List* pParallelList )
 361 {
 362     DBG_ASSERT(GetRefCount()==0,"Sort:RefCount!=0");
 363     if( pImp )
 364         pImp->Sort( bAscending, pParallelList );
 365 }
 366
 367 //----------------------------------------------------------------------------
 368 void SfxStringListItem::SetStringList( const com::sun::star::uno::Sequence< rtl::OUString >& rList )
 369 {
 370     DBG_ASSERT(GetRefCount()==0,"SetString:RefCount!=0");
 371
 372     if ( pImp && (pImp->nRefCount == 1) )
 373         delete pImp;
 374     else
 375     if( pImp )
 376         pImp->nRefCount--;
 377     pImp = new SfxImpStringList;
 378
 379     for ( sal_Int32 n = 0; n < rList.getLength(); n++ )
 380     {
 381         XubString* pStr = new XubString( rList[n] );
 382         // String gehoert der Liste
 383         pImp->aList.Insert( pStr, LIST_APPEND );
 384     }
 385 }
 386
 387 //----------------------------------------------------------------------------
 388 void SfxStringListItem::GetStringList( com::sun::star::uno::Sequence< rtl::OUString >& rList ) const
 389 {
 390     long nCount = pImp->aList.Count();
 391
 392     rList.realloc( nCount );
 393     for( long i=0; i < nCount; i++ )
 394         rList[i] = *(String*)(pImp->aList.GetObject( i ));
 395 }
 396
 397 //----------------------------------------------------------------------------
 398 // virtual
 399 BOOL SfxStringListItem::PutValue( const com::sun::star::uno::Any& rVal,BYTE )
 400 {
 401     com::sun::star::uno::Sequence< rtl::OUString > aValue;
 402     if ( rVal >>= aValue )
 403     {
 404         SetStringList( aValue );
 405         return TRUE;
 406     }
 407
 408     DBG_ERROR( "SfxStringListItem::PutValue - Wrong type!" );
 409     return FALSE;
 410 }
 411
 412 //----------------------------------------------------------------------------
 413 // virtual
 414 BOOL SfxStringListItem::QueryValue( com::sun::star::uno::Any& rVal,BYTE ) const
 415 {
 416     // GetString() is not const!!!
 417     SfxStringListItem* pThis = const_cast< SfxStringListItem * >( this );
 418
 419     com::sun::star::uno::Sequence< rtl::OUString > aStringList;
 420     pThis->GetStringList( aStringList );
 421     rVal = ::com::sun::star::uno::makeAny( aStringList );
 422     return TRUE;
 423 }
 424
 425