sot/source/base/object.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: object.cxx,v $
  10  * $Revision: 1.10 $
  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_sot.hxx"
  33
  34 #define _SOT_OBJECT_CXX
  35
  36 #include <tools/debug.hxx>
  37 #include <sot/object.hxx>
  38 #include <sot/factory.hxx>
  39 #include <agg.hxx>
  40
  41 /************** class SvAggregateMemberList *****************************/
  42 /************************************************************************/
  43 PRV_SV_IMPL_OWNER_LIST(SvAggregateMemberList,SvAggregate);
  44
  45 /************** class SotObject ******************************************/
  46 class SotObjectFactory : public SotFactory
  47 {
  48 public:
  49          TYPEINFO();
  50         SotObjectFactory( const SvGlobalName & rName,
  51                               const String & rClassName,
  52                               CreateInstanceType pCreateFuncP )
  53             : SotFactory( rName, rClassName, pCreateFuncP )
  54         {}
  55 };
  56 TYPEINIT1(SotObjectFactory,SotFactory);
  57
  58
  59 SO2_IMPL_BASIC_CLASS_DLL(SotObject,SotObjectFactory,
  60                     SvGlobalName( 0xf44b7830, 0xf83c, 0x11d0,
  61                             0xaa, 0xa1, 0x0, 0xa0, 0x24, 0x9d, 0x55, 0x90 ) )
  62 SO2_IMPL_INVARIANT(SotObject)
  63
  64 /*************************************************************************
  65 |*  SotObject::TestMemberObjRef()
  66 |*
  67 |*      Beschreibung:
  68 *************************************************************************/
  69 void SotObject::TestMemberObjRef( BOOL /*bFree*/ )
  70 {
  71 }
  72
  73 /*************************************************************************
  74 |*  SotObject::TestMemberObjRef()
  75 |*
  76 |*      Beschreibung:
  77 *************************************************************************/
  78 #ifdef TEST_INVARIANT
  79 void SotObject::TestMemberInvariant( BOOL /*bPrint*/ )
  80 {
  81 }
  82 #endif
  83
  84 /*************************************************************************
  85 |*    SotObject::SotObject()
  86 |*
  87 |*    Beschreibung
  88 *************************************************************************/
  89 SotObject::SotObject()
  90     : pAggList    ( NULL )
  91     , nStrongLockCount( 0 )
  92     , nOwnerLockCount( 0 )
  93     , bOwner      ( TRUE )
  94     , bSVObject   ( FALSE )
  95     , bInClose    ( FALSE )
  96 {
  97     SotFactory::IncSvObjectCount( this );
  98 }
  99
 100 /*************************************************************************
 101 |*
 102 |*    SotObject::~SotObject()
 103 |*
 104 |*    Beschreibung
 105 |*    Ersterstellung    MM 05.06.94
 106 |*    Letzte Aenderung  MM 05.06.94
 107 |*
 108 *************************************************************************/
 109 SotObject::~SotObject()
 110 {
 111     SotFactory::DecSvObjectCount( this );
 112 }
 113
 114 /*************************************************************************
 115 |*    SotObject::GetInterface()
 116 |*
 117 |*    Beschreibung: Um so3 zu helfen
 118 *************************************************************************/
 119 IUnknown * SotObject::GetInterface( const SvGlobalName & )
 120 {
 121     return NULL;
 122 }
 123
 124 /*************************************************************************
 125 |*    SotObject::IsSvClass()
 126 |*
 127 |*    Beschreibung
 128 *************************************************************************/
 129 BOOL SotObject::IsSvObject() const
 130 {
 131     return Owner() || bSVObject;
 132 }
 133
 134 /*************************************************************************
 135 |*    SotObject::QueryDelete()
 136 |*
 137 |*    Beschreibung:     Bei allen aggregierten Objekte muss der RefCount auf
 138 |*                                      0 gehen, damit das Gesammt-Objekt zerstoert wird. Das
 139 |*                                      zerst�ren von Teilen ist verboten. Da der Aggregator
 140 |*                                      (oder Cast-Verwalter) den Zaehler der aggregierten
 141 |*                                      Objekte um 1 erhoeht, muss dies bei der Berechnung
 142 |*                                      des 0-RefCounts beruecksichtigt werden.
 143 *************************************************************************/
 144 BOOL SotObject::ShouldDelete()
 145 {
 146     if( !pAggList )
 147         return TRUE;
 148
 149     SvAggregate & rMO = pAggList->GetObject( 0 );
 150     if(  rMO.bMainObj )
 151     {
 152         AddRef();
 153         pAggList->GetObject( 0 ).pObj->ReleaseRef();
 154         return FALSE;
 155     }
 156
 157    ULONG i;
 158     for( i = 1; i < pAggList->Count(); i++ )
 159     {
 160         SvAggregate & rAgg = pAggList->GetObject( i );
 161         // Groesser 1, wegen AddRef() bei AddInterface
 162         if( !rAgg.bFactory && rAgg.pObj->GetRefCount() > 1 )
 163         {
 164             // den eigenen hochzaehelen
 165             AddRef();
 166             // einen Aggregierten runterzaehlen
 167             rAgg.pObj->ReleaseRef();
 168             return FALSE;
 169         }
 170     }
 171     AddNextRef(); // rekursion stoppen
 172     for( i = pAggList->Count() -1; i > 0; i-- )
 173     {
 174         // Referenzen aufloesen
 175         DBG_ASSERT( !pAggList->GetObject( i ).bMainObj, "main object reference is opened" );
 176         RemoveInterface( i );
 177     }
 178     delete pAggList;
 179     pAggList = NULL;
 180     // und zerstoeren, dies ist unabhaengig vom RefCount
 181     return TRUE;
 182 }
 183
 184 /*************************************************************************
 185 |*    SotObject::QueryDelete()
 186 |*
 187 |*    Beschreibung
 188 *************************************************************************/
 189 void SotObject::QueryDelete()
 190 {
 191     if( ShouldDelete() )
 192         SvRefBase::QueryDelete();
 193 }
 194
 195
 196
 197 /*************************************************************************
 198 |*    SotObject::GetAggList()
 199 |*
 200 |*    Beschreibung
 201 *************************************************************************/
 202 SvAggregateMemberList & SotObject::GetAggList()
 203 {
 204     if( !pAggList )
 205     {
 206         pAggList = new SvAggregateMemberList( 2, 1 );
 207         pAggList->Append( SvAggregate() );
 208     }
 209     return *pAggList;
 210 }
 211
 212
 213 /*************************************************************************
 214 |*    SotObject::RemoveInterface()
 215 |*
 216 |*    Beschreibung
 217 *************************************************************************/
 218 void SotObject::RemoveInterface( ULONG nPos )
 219 {
 220     SvAggregate & rAgg = pAggList->GetObject( nPos );
 221     if( !rAgg.bFactory )
 222     {
 223         DBG_ASSERT( rAgg.pObj->pAggList, "no aggregation list" );
 224         DBG_ASSERT( rAgg.pObj->pAggList->GetObject( 0 ).pObj == this,
 225                         "not owner of aggregated object" );
 226         // sich selbst als Cast-Verwalter austragen
 227         rAgg.pObj->pAggList->GetObject( 0 ) = SvAggregate();
 228         // Referenz aufloesen
 229         rAgg.pObj->ReleaseRef();
 230         // Aus der eigenen List austragen
 231         pAggList->Remove( nPos );
 232     }
 233 }
 234
 235 /*************************************************************************
 236 |*    SotObject::RemoveInterface()
 237 |*
 238 |*    Beschreibung
 239 *************************************************************************/
 240 void SotObject::RemoveInterface( SotObject * pObjP )
 241 {
 242     DBG_ASSERT( pObjP, "null pointer" );
 243     DBG_ASSERT( pAggList, "no aggregation list" );
 244     ULONG i;
 245     for( i = 0; i < pAggList->Count(); i++ )
 246     {
 247         SvAggregate & rAgg = pAggList->GetObject( i );
 248         if( !rAgg.bFactory && pObjP == rAgg.pObj )
 249             RemoveInterface( i );
 250     }
 251     DBG_ASSERT( i < pAggList->Count(), "object not found" );
 252 }
 253
 254 /*************************************************************************
 255 |*    SotObject::AddInterface()
 256 |*
 257 |*    Beschreibung
 258 *************************************************************************/
 259 void SotObject::AddInterface( SotObject * pObjP )
 260 {
 261     pObjP->AddRef(); // Objekt festhalten
 262     GetAggList();
 263     pAggList->Append( SvAggregate( pObjP, FALSE ) );
 264
 265     // sich selbst als Typecast-Verwalter eintragen
 266     SvAggregateMemberList & rAList = pObjP->GetAggList();
 267     DBG_ASSERT( !rAList.GetObject( 0 ).bMainObj, "try to aggregate twice" );
 268     rAList[ 0 ] = SvAggregate( this, TRUE );
 269 }
 270
 271 /*************************************************************************
 272 |*    SotObject::AddInterface()
 273 |*
 274 |*    Beschreibung
 275 *************************************************************************/
 276 void SotObject::AddInterface( SotFactory * pFactP )
 277 {
 278     GetAggList();
 279     pAggList->Append( SvAggregate( pFactP ) );
 280 }
 281
 282 /*************************************************************************
 283 |*    SotObject::CreateAggObj()
 284 |*
 285 |*    Beschreibung
 286 *************************************************************************/
 287 SotObjectRef SotObject::CreateAggObj( const SotFactory * )
 288 {
 289     return SotObjectRef();
 290 }
 291
 292
 293 /*************************************************************************
 294 |*    SotObject::DownAggCast()
 295 |*
 296 |*    Beschreibung
 297 *************************************************************************/
 298 void * SotObject::DownAggCast( const SotFactory * pFact )
 299 {
 300     void * pCast = NULL;
 301     // geht den Pfad nur Richtung aggregierte Objekte
 302     if( pAggList )
 303     {
 304         for( ULONG i = 1; !pCast || i < pAggList->Count(); i++ )
 305         {
 306             SvAggregate & rAgg = pAggList->GetObject( i );
 307             if( rAgg.bFactory )
 308             {
 309                 if( rAgg.pFact->Is( pFact ) )
 310                 {
 311                     // On-Demand erzeugen, wenn Typ gebraucht
 312                     SotObjectRef aObj( CreateAggObj( rAgg.pFact ) );
 313                     rAgg.bFactory = FALSE;
 314                     rAgg.pObj = aObj;
 315                     rAgg.pObj->AddRef();
 316
 317                     // sich selbst als Typecast-Verwalter eintragen
 318                     SvAggregateMemberList & rAList = rAgg.pObj->GetAggList();
 319                     DBG_ASSERT( !rAList.GetObject( 0 ).bMainObj, "try to aggregate twice" );
 320                     rAList[ 0 ] = SvAggregate( this, TRUE );
 321                 }
 322             }
 323             if( !rAgg.bFactory )
 324             {
 325                 // muss der (void *) auf Klasse pFact sein
 326                 pCast = rAgg.pObj->Cast( pFact );
 327                 if( !pCast )
 328                     pCast = rAgg.pObj->DownAggCast( pFact );
 329                 if( pCast )
 330                     break;
 331             }
 332         }
 333     }
 334     return pCast;
 335 }
 336
 337 /*************************************************************************
 338 |*    SotObject::AggCast()
 339 |*
 340 |*    Beschreibung
 341 *************************************************************************/
 342 void * SotObject::AggCast( const SotFactory * pFact )
 343 {
 344     void * pCast = NULL;
 345     if( pAggList )
 346     {
 347         SvAggregate & rAgg = pAggList->GetObject( 0 );
 348         if( rAgg.bMainObj )
 349             return rAgg.pObj->AggCast( pFact );
 350         pCast = Cast( pFact );
 351         if( !pCast )
 352             pCast = DownAggCast( pFact );
 353     }
 354     else
 355         pCast = Cast( pFact );
 356     return pCast;
 357 }
 358
 359 /*************************************************************************
 360 |*    SotObject::CastAndAddRef()
 361 |*
 362 |*    Beschreibung
 363 *************************************************************************/
 364 void * SotObject::CastAndAddRef( const SotFactory * pFact )
 365 {
 366     void * pCast = Cast( pFact );
 367     if( pCast )
 368         AddRef();
 369     return pCast;
 370 }
 371
 372 /*************************************************************************
 373 |*    SotObject::GetMainObj()
 374 |*
 375 |*    Beschreibung
 376 *************************************************************************/
 377 SotObject * SotObject::GetMainObj() const
 378 {
 379     if( pAggList )
 380     {
 381         if( pAggList->GetObject( 0 ).bMainObj )
 382             return pAggList->GetObject( 0 ).pObj->GetMainObj();
 383     }
 384     return (SotObject *)this;
 385 }
 386
 387 //=========================================================================
 388 USHORT SotObject::FuzzyLock
 389 (
 390     BOOL bLock,             /* TRUE, lock. FALSE, unlock. */
 391     BOOL /*bIntern*/,   /* TRUE, es handelt sich um einen internen Lock.
 392                            FALSE, der Lock kam von aussen (Ole2, Ipc2) */
 393     BOOL bClose             /* TRUE, Close aufrufen wenn letzte Lock */
 394 )
 395 /*      [Beschreibung]
 396
 397     Erlaubte Parameterkombinationen:
 398     ( TRUE,  TRUE,  *     )     ->      interner Lock.
 399     ( FALSE, TRUE,  TRUE  )     ->      interner Unlock mit Close,
 400                                  wenn LockCount() == 0
 401     ( TRUE,  FALSE, *     )     ->      externer Lock.
 402     ( FALSE, FALSE, TRUE  )     ->      externer Unlock mit Close,
 403                                  wenn LockCount() == 0
 404     ( FALSE, FALSE, FALSE )     ->      externer Unlock
 405
 406     F"ur !Owner() wird der Aufruf an das externe Objekt weitergeleitet.
 407      F"ur diese muss das <IOleItemContainer>-Interface zur Vef"ugung stehen.
 408     bIntern und bClose werden dann ignoriert.
 409     Wenn der LockCount auf 0 wechselt, wird <SotObject::DoClose>
 410     gerufen, wenn kein OwnerLock besteht.
 411
 412     [Anmerkung]
 413
 414 */
 415 {
 416     SotObjectRef xHoldAlive( this );
 417     USHORT nRet;
 418     if( bLock )
 419     {
 420         AddRef();
 421         nRet = ++nStrongLockCount;
 422     }
 423     else
 424     {
 425         nRet = --nStrongLockCount;
 426         ReleaseRef();
 427     }
 428
 429     if( !nRet && bClose && !nOwnerLockCount )
 430         DoClose();
 431     return nRet;
 432 }
 433
 434 //=========================================================================
 435 void SotObject::OwnerLock
 436 (
 437     BOOL bLock          /* TRUE, lock. FALSE, unlock. */
 438 )
 439 /*      [Beschreibung]
 440
 441     Wenn der OwnerLock auf Null dekrementiert, dann wird die Methode
 442     DoClose gerufen. Dies geschieht unabh"angig vom Lock. bzw. RefCount.
 443     Ist der OwnerLock-Z"ahler != Null, dann wird kein DoClose durch
 444     <SotObject::FuzzyLock> gerufen.
 445 */
 446 {
 447     if( bLock )
 448     {
 449         nOwnerLockCount++;
 450         AddRef();
 451     }
 452     else if ( nOwnerLockCount )
 453     {
 454         if( 0 == --nOwnerLockCount )
 455             DoClose();
 456         ReleaseRef();
 457     }
 458 }
 459
 460 void SotObject::RemoveOwnerLock()
 461 {
 462     if ( nOwnerLockCount )
 463     {
 464         --nOwnerLockCount;
 465         ReleaseRef();
 466     }
 467     else {
 468         DBG_ERROR("OwnerLockCount underflow!");
 469     }
 470 }
 471
 472 //=========================================================================
 473 BOOL SotObject::DoClose()
 474 {
 475     BOOL bRet = FALSE;
 476     if( !bInClose )
 477     {
 478         SotObjectRef xHoldAlive( this );
 479         bInClose = TRUE;
 480         bRet = Close();
 481         bInClose = FALSE;
 482     }
 483     return bRet;
 484 }
 485
 486 //=========================================================================
 487 BOOL SotObject::Close()
 488 {
 489     return TRUE;
 490 }
 491
 492