svtools/source/items1/poolitem.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: poolitem.cxx,v $
  10  * $Revision: 1.8 $
  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/poolitem.hxx>
  35 #include <tools/stream.hxx>
  36
  37 // STATIC DATA -----------------------------------------------------------
  38
  39 DBG_NAME(SfxPoolItem)
  40 DBG_NAME(SfxVoidItem)
  41 // @@@ DBG_NAME(SfxInvalidItem);
  42 DBG_NAME(SfxItemHandle)
  43
  44 BYTE nSfxFlag8Val[8] =
  45 {
  46     1, 2, 4, 8, 16, 32, 64, 128
  47 };
  48
  49 USHORT nSfxFlag16Val[16] =
  50 {
  51     1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
  52     1024, 2048, 4096, 8192, 16384, 32768
  53 };
  54
  55 ULONG nSfxFlag32Val[32] =
  56 {
  57     0x1L, 0x2L, 0x4L, 0x8L,
  58     0x10L, 0x20L, 0x40L, 0x80L,
  59     0x100L, 0x200L, 0x400L, 0x800L,
  60     0x1000L, 0x2000L, 0x40000L, 0x8000L,
  61     0x10000L, 0x20000L, 0x40000L, 0x80000L,
  62     0x100000L, 0x200000L, 0x400000L, 0x800000L,
  63     0x1000000L, 0x2000000L, 0x4000000L, 0x8000000L,
  64     0x10000000L, 0x20000000L, 0x40000000L, 0x80000000L
  65 };
  66
  67 // RTTI ------------------------------------------------------------------
  68
  69 TYPEINIT0(SfxPoolItem);
  70 TYPEINIT1(SfxVoidItem, SfxPoolItem);
  71 // @@@ TYPEINIT1(SfxInvalidItem, SfxPoolItem);
  72 TYPEINIT1(SfxSetItem, SfxPoolItem);
  73 // @@@ TYPEINIT1(SfxItemChangedHint, SfxHint);
  74
  75 // ------------------------------------------------------------------------
  76 #if OSL_DEBUG_LEVEL > 1
  77 static ULONG nItemCount = 0;
  78
  79 const char* pw1 = "Wow! 10.000 items!";
  80 const char* pw2 = "Wow! 100.000 items!";
  81 const char* pw3 = "Wow! 1.000.000 items!";
  82 const char* pw4 = "Wow! 50.000.000 items!";
  83 const char* pw5 = "Wow! 10.000.000 items!";
  84 #endif
  85
  86 IMPL_PTRHINT(SfxPoolItemHint,SfxPoolItem)
  87
  88 // SfxPoolItem -----------------------------------------------------------
  89 SfxPoolItem::SfxPoolItem( USHORT nW )
  90     : nRefCount( 0 ),
  91       nWhich( nW )
  92       , nKind( 0 )
  93 {
  94     DBG_CTOR(SfxPoolItem, 0);
  95     DBG_ASSERT(nW <= SHRT_MAX, "Which Bereich ueberschritten");
  96 #if OSL_DEBUG_LEVEL > 1
  97     ++nItemCount;
  98     if ( pw1 && nItemCount>=10000 )
  99     {
 100         DBG_WARNING( pw1 );
 101         pw1 = NULL;
 102     }
 103     if ( pw2 && nItemCount>=100000 )
 104     {
 105         DBG_WARNING( pw2 );
 106         pw2 = NULL;
 107     }
 108     if ( pw3 && nItemCount>=1000000 )
 109     {
 110         DBG_WARNING( pw3 );
 111         pw3 = NULL;
 112     }
 113     if ( pw4 && nItemCount>=5000000 )
 114     {
 115         DBG_WARNING( pw4 );
 116         pw4 = NULL;
 117     }
 118     if ( pw5 && nItemCount>=10000000 )
 119     {
 120         DBG_WARNING( pw5 );
 121         pw5 = NULL;
 122     }
 123 #endif
 124 }
 125
 126 // -----------------------------------------------------------------------
 127 SfxPoolItem::SfxPoolItem( const SfxPoolItem& rCpy )
 128     : nRefCount( 0 ),                           // wird ja ein neues Object!
 129       nWhich( rCpy.Which() )    // Funktion rufen wg. ChkThis()
 130       , nKind( 0 )
 131 {
 132     DBG_CTOR(SfxPoolItem, 0);
 133 #if OSL_DEBUG_LEVEL > 1
 134     ++nItemCount;
 135     if ( pw1 && nItemCount>=10000 )
 136     {
 137         DBG_WARNING( pw1 );
 138         pw1 = NULL;
 139     }
 140     if ( pw2 && nItemCount>=100000 )
 141     {
 142         DBG_WARNING( pw2 );
 143         pw2 = NULL;
 144     }
 145     if ( pw3 && nItemCount>=1000000 )
 146     {
 147         DBG_WARNING( pw3 );
 148         pw3 = NULL;
 149     }
 150     if ( pw4 && nItemCount>=5000000 )
 151     {
 152         DBG_WARNING( pw4 );
 153         pw4 = NULL;
 154     }
 155     if ( pw5 && nItemCount>=10000000 )
 156     {
 157         DBG_WARNING( pw5 );
 158         pw5 = NULL;
 159     }
 160 #endif
 161 }
 162
 163 // ------------------------------------------------------------------------
 164 SfxPoolItem::~SfxPoolItem()
 165 {
 166     DBG_DTOR(SfxPoolItem, 0);
 167     DBG_ASSERT(nRefCount == 0 || nRefCount > SFX_ITEMS_MAXREF, "destroying item in use" );
 168 #if OSL_DEBUG_LEVEL > 1
 169     --nItemCount;
 170 #endif
 171 }
 172
 173 // ------------------------------------------------------------------------
 174 int SfxPoolItem::Compare( const SfxPoolItem& ) const
 175 {
 176     return 0;
 177 }
 178
 179 // ------------------------------------------------------------------------
 180 int SfxPoolItem::Compare( const SfxPoolItem& rWith, const IntlWrapper& ) const
 181 {
 182     return Compare( rWith );
 183 }
 184
 185 // ------------------------------------------------------------------------
 186 int SfxPoolItem::operator==( const SfxPoolItem& rCmp ) const
 187 {
 188     DBG_CHKTHIS(SfxPoolItem, 0);
 189     return rCmp.Type() == Type();
 190 }
 191
 192 // -----------------------------------------------------------------------
 193 #ifndef TF_POOLABLE
 194
 195 int SfxPoolItem::IsPoolable() const
 196 {
 197     DBG_CHKTHIS(SfxPoolItem, 0);
 198     return TRUE;
 199 }
 200 #endif
 201
 202 // -----------------------------------------------------------------------
 203 SfxPoolItem* SfxPoolItem::Create(SvStream &, USHORT) const
 204 {
 205     DBG_CHKTHIS(SfxPoolItem, 0);
 206     return Clone(0);
 207 }
 208
 209 // -----------------------------------------------------------------------
 210 USHORT SfxPoolItem::GetVersion( USHORT ) const
 211 {
 212     DBG_CHKTHIS(SfxPoolItem, 0);
 213     return 0;
 214 }
 215
 216 // -----------------------------------------------------------------------
 217 SvStream& SfxPoolItem::Store(SvStream &rStream, USHORT ) const
 218 {
 219     DBG_CHKTHIS(SfxPoolItem, 0);
 220     return rStream;
 221 }
 222
 223 //============================================================================
 224 // static
 225 bool SfxPoolItem::readByteString(SvStream & rStream, UniString & rString)
 226 {
 227     rStream.ReadByteString(rString);
 228     return rStream.GetError() == ERRCODE_NONE;
 229 }
 230
 231 //============================================================================
 232 // static
 233 void SfxPoolItem::writeByteString(SvStream & rStream,
 234                                   UniString const & rString)
 235 {
 236     rStream.WriteByteString(rString);
 237 }
 238
 239 //============================================================================
 240 // static
 241 bool SfxPoolItem::readUnicodeString(SvStream & rStream, UniString & rString,
 242                                     bool bUnicode)
 243 {
 244     rStream.ReadByteString(rString,
 245                            bUnicode ? RTL_TEXTENCODING_UCS2 :
 246                                       rStream.GetStreamCharSet());
 247     return rStream.GetError() == ERRCODE_NONE;
 248 }
 249
 250 //============================================================================
 251 // static
 252 void SfxPoolItem::writeUnicodeString(SvStream & rStream,
 253                                      UniString const & rString)
 254 {
 255     rStream.WriteByteString(rString, RTL_TEXTENCODING_UCS2);
 256 }
 257
 258 // ------------------------------------------------------------------------
 259 SfxItemPresentation SfxPoolItem::GetPresentation
 260 (
 261     SfxItemPresentation /*ePresentation*/,       // IN:  wie formatiert werden soll
 262     SfxMapUnit                  /*eCoreMetric*/,                 // IN:  Ma\seinheit des SfxPoolItems
 263     SfxMapUnit                  /*ePresentationMetric*/, // IN:  Wunsch-Ma\einheit der Darstellung
 264     XubString&                  /*rText*/,                               // OUT: textuelle Darstellung
 265     const IntlWrapper *
 266 )       const
 267
 268 /*      [Beschreibung]
 269
 270     "Uber diese virtuelle Methode kann von den SfxPoolItem-Subklassen
 271     eine textuelle Datstellung des Wertes erhalten werden. Sie sollte
 272     von allen UI-relevanten SfxPoolItem-Subklassen "uberladen werden.
 273
 274     Da die Ma\seinheit des Wertes im SfxItemPool nur "uber
 275     <SfxItemPool::GetMetric(USHORT)const> erfragbar ist, und nicht etwa
 276     in der SfxPoolItem-Instanz oder -Subklasse  verf"ugbar ist, wird die
 277     eigene Ma\seinheit als 'eCoreMetric' "ubergeben.
 278
 279     Die darzustellende Ma\seinheit wird als 'ePresentationMetric'
 280     "ubergeben.
 281
 282
 283     [R"uckgabewert]
 284
 285     SfxItemPresentation         SFX_ITEM_PRESENTATION_NONE
 286                             es konnte keine Text-Darstellung erzeugt werden
 287
 288                             SFX_ITEM_PRESENTATION_NAMELESS
 289                             es konnte eine Text-Darstellung (ggf. mit
 290                             Ma\seinheit) erzeugt werden, die jedoch keine
 291                             semantische Bedeutung enth"alt
 292
 293                             SFX_ITEM_PRESENTATION_COMPLETE
 294                             es konnte eine komplette Text-Darstellung mit
 295                             semantischer Bedeutung (und ggf. Ma\seinheit)
 296                             erzeugt werden
 297
 298
 299     [Beispiele]
 300
 301     pSvxFontItem->GetPresentation( SFX_PRESENTATION_NAMELESS, ... )
 302         "12pt" mit return SFX_ITEM_PRESENTATION_NAMELESS
 303
 304     pSvxColorItem->GetPresentation( SFX_PRESENTATION_COMPLETE, ... )
 305         "rot" mit return SFX_ITEM_PRESENTATION_NAMELESS
 306         (das das SvxColorItem nicht wei\s, was f"ur eine Farbe es darstellt,
 307         kann es keinen Namen angeben, was durch den Returnwert mitgeteilt wird.
 308
 309     pSvxBorderItem->GetPresentation( SFX_PRESENTATION_COMPLETE, ... )
 310         "1cm oberer Rand, 2cm linker Rand, 0,2cm unterer Rand, ..."
 311 */
 312
 313 {
 314     return SFX_ITEM_PRESENTATION_NONE;
 315 }
 316
 317 // SfxVoidItem ------------------------------------------------------------
 318 SfxVoidItem::SfxVoidItem( USHORT which ):
 319     SfxPoolItem(which)
 320 {
 321     DBG_CTOR(SfxVoidItem, 0);
 322 }
 323
 324 // SfxVoidItem ------------------------------------------------------------
 325 SfxVoidItem::SfxVoidItem( const SfxVoidItem& rCopy):
 326     SfxPoolItem(rCopy)
 327 {
 328     DBG_CTOR(SfxVoidItem, 0);
 329 }
 330
 331 // ------------------------------------------------------------------------
 332 int SfxVoidItem::operator==( const SfxPoolItem&
 333 #ifdef DBG_UTIL
 334 rCmp
 335 #endif
 336 ) const
 337 {
 338     DBG_CHKTHIS(SfxVoidItem, 0);
 339     DBG_ASSERT( SfxPoolItem::operator==( rCmp ), "unequal type" );
 340     return TRUE;
 341 }
 342
 343 // ------------------------------------------------------------------------
 344 SfxItemPresentation SfxVoidItem::GetPresentation
 345 (
 346     SfxItemPresentation         /*ePresentation*/,
 347     SfxMapUnit                          /*eCoreMetric*/,
 348     SfxMapUnit                          /*ePresentationMetric*/,
 349     XubString&                          rText,
 350     const IntlWrapper *
 351 )       const
 352 {
 353     DBG_CHKTHIS(SfxVoidItem, 0);
 354     rText.AssignAscii(RTL_CONSTASCII_STRINGPARAM("Void"));
 355     return SFX_ITEM_PRESENTATION_NAMELESS;
 356 }
 357
 358 // ------------------------------------------------------------------------
 359 SfxPoolItem* SfxVoidItem::Clone(SfxItemPool *) const
 360 {
 361     DBG_CHKTHIS(SfxVoidItem, 0);
 362     return new SfxVoidItem(*this);
 363 }
 364
 365 // SfxInvalidItem ---------------------------------------------------------
 366 #if 0  /* @@@ NOT USED @@@ */
 367 SfxInvalidItem::SfxInvalidItem( USHORT nWhich, const SfxPoolItem &rDefault ):
 368     SfxPoolItem(nWhich),
 369     pDefaultItem(&rDefault)
 370 {
 371     DBG_CTOR(SfxInvalidItem, 0);
 372 }
 373
 374 // ------------------------------------------------------------------------
 375 SfxInvalidItem::SfxInvalidItem( const SfxInvalidItem& rCopy):
 376     SfxPoolItem(rCopy),
 377     pDefaultItem(rCopy.pDefaultItem)
 378 {
 379     DBG_CTOR(SfxInvalidItem, 0);
 380     //! pDefaultItem->ReleaseRef?
 381 }
 382
 383 // ------------------------------------------------------------------------
 384 SfxInvalidItem::~SfxInvalidItem()
 385 {
 386     DBG_DTOR(SfxInvalidItem, 0);
 387 }
 388
 389 // ------------------------------------------------------------------------
 390 int SfxInvalidItem::operator==( const SfxPoolItem& rCmp) const
 391 {
 392     DBG_CHKTHIS(SfxInvalidItem, 0);
 393     DBG_ASSERT( SfxPoolItem::operator==(rCmp), "unequal type" );
 394     return *pDefaultItem == *((SfxInvalidItem&)rCmp).pDefaultItem;
 395 }
 396
 397 // ------------------------------------------------------------------------
 398 SfxItemPresentation SfxInvalidItem::GetPresentation
 399 (
 400     SfxItemPresentation         ePresentation,
 401     SfxMapUnit                          eCoreMetric,
 402     SfxMapUnit                          ePresentationMetric,
 403     XubString&                          rText,
 404     const IntlWrapper *
 405 )       const
 406 {
 407     DBG_CHKTHIS(SfxInvalidItem, 0);
 408     rText.AssignAscii(RTL_CONSTASCII_STRINGPARAM("Invalid"));
 409     return SFX_ITEM_PRESENTATION_NAMELESS;
 410 }
 411
 412 // ------------------------------------------------------------------------
 413 SfxPoolItem* SfxInvalidItem::Clone(SfxItemPool *) const
 414 {
 415     DBG_CHKTHIS(SfxInvalidItem, 0);
 416     return new SfxInvalidItem(*this);
 417 }
 418
 419 // ------------------------------------------------------------------------
 420 SfxPoolItem* SfxInvalidItem::Create(SvStream &, USHORT nVersion) const
 421 {
 422     DBG_CHKTHIS(SfxInvalidItem, 0);
 423     DBG_ERROR("SfxInvalidItem::Create() ist sinnlos");
 424     return Clone();
 425 }
 426
 427 // ------------------------------------------------------------------------
 428 SvStream& SfxInvalidItem::Store(SvStream &rStream, USHORT nItemVersion ) const
 429 {
 430     DBG_CHKTHIS(SfxInvalidItem, 0);
 431     DBG_ERROR("SfxInvalidItem::Store() ist sinnlos");
 432     return rStream;
 433 }
 434 #endif /* @@@ NOT USED @@@ */
 435
 436 // SfxItemHandle ----------------------------------------------------------
 437 SfxItemHandle::SfxItemHandle(SfxPoolItem &rItem):
 438     pRef(new USHORT(1)),
 439     pItem(rItem.Clone(0))
 440 {
 441     DBG_CTOR(SfxItemHandle, 0);
 442 }
 443
 444 // ------------------------------------------------------------------------
 445 SfxItemHandle::SfxItemHandle(const SfxItemHandle &rCopy):
 446     pRef(rCopy.pRef),
 447     pItem(rCopy.pItem)
 448 {
 449     DBG_CTOR(SfxItemHandle, 0);
 450     ++(*pRef);
 451 }
 452
 453 // ------------------------------------------------------------------------
 454 const SfxItemHandle &SfxItemHandle::operator=(const SfxItemHandle &rCopy)
 455 {
 456     DBG_CHKTHIS(SfxItemHandle, 0);
 457     if(&rCopy == this || pItem == rCopy.pItem)
 458         return *this;
 459     --(*pRef);
 460     if(!(*pRef))
 461     {
 462         delete pItem;
 463         pItem = 0;
 464     }
 465     pRef = rCopy.pRef;
 466     ++(*pRef);
 467     pItem = rCopy.pItem;
 468     return *this;
 469 }
 470
 471 // ------------------------------------------------------------------------
 472 SfxItemHandle::~SfxItemHandle()
 473 {
 474     DBG_DTOR(SfxItemHandle, 0);
 475     --(*pRef);
 476     if(!(*pRef)) {
 477         delete pRef; pRef = 0;
 478         delete pItem; pItem = 0;
 479     }
 480 }
 481
 482 // ------------------------------------------------------------------------
 483 int SfxPoolItem::ScaleMetrics( long /*lMult*/, long /*lDiv*/ )
 484 {
 485     return 0;
 486 }
 487
 488 // ------------------------------------------------------------------------
 489 int SfxPoolItem::HasMetrics() const
 490 {
 491     return 0;
 492 }
 493
 494 // -----------------------------------------------------------------------
 495 #if 0  /* @@@ NOT USED @@@ */
 496 void SfxPoolItem::GetVersion() const
 497 {
 498     DBG_ERROR( "dummy called" );
 499 }
 500
 501 // -----------------------------------------------------------------------
 502 void SfxPoolItem::Store(SvStream &rStream) const
 503 {
 504     DBG_ERROR( "dummy called" );
 505 }
 506 #endif /* @@@ NOT USED @@@ */
 507
 508 // -----------------------------------------------------------------------
 509
 510 BOOL SfxPoolItem::QueryValue( com::sun::star::uno::Any&, BYTE ) const
 511 {
 512     DBG_ERROR("There is no implementation for QueryValue for this item!");
 513     return FALSE;
 514 }
 515
 516 // -----------------------------------------------------------------------
 517
 518 BOOL SfxPoolItem::PutValue( const com::sun::star::uno::Any&, BYTE )
 519 {
 520     DBG_ERROR("There is no implementation for PutValue for this item!");
 521     return FALSE;
 522 }
 523
 524 SfxVoidItem::~SfxVoidItem()
 525 {
 526     DBG_DTOR(SfxVoidItem, 0);
 527 }