sw/source/core/attr/calbck.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: calbck.cxx,v $
  10  * $Revision: 1.13 $
  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_sw.hxx"
  33
  34
  35 #include <hintids.hxx>          // fuer RES_..
  36 #include <frame.hxx>
  37 #include <hints.hxx>
  38 #include <swcache.hxx>
  39 #include <swfntcch.hxx>
  40
  41 #ifndef PRODUCT
  42 #include <unotextmarkup.hxx>
  43 #endif
  44
  45 static SwClientIter* pClientIters = 0;
  46
  47 TYPEINIT0(SwClient);    //rtti
  48
  49 /*************************************************************************
  50 |*        SwClient::SwClient(SwModify *)
  51 |*
  52 |*        Beschreibung          callback.doc V1.14
  53 |*        Ersterstellung        VB 20.03.91
  54 |*        Letzte Aenderung      MA 20. Mar. 95
  55 *************************************************************************/
  56
  57
  58 SwClient::SwClient(SwModify *pToRegisterIn)
  59     : pLeft( 0 ), pRight( 0 ), pRegisteredIn( 0 )
  60 {
  61     bModifyLocked =
  62     bInModify =
  63     bInDocDTOR =
  64     bInCache = FALSE;
  65     bInSwFntCache = FALSE;
  66
  67     if(pToRegisterIn)
  68         pToRegisterIn->Add(this);
  69 }
  70
  71 /*************************************************************************
  72 |*        SwClient::Modify()
  73 |*
  74 |*        Beschreibung          callback.doc V1.14
  75 |*        Ersterstellung        VB 20.03.91
  76 |*        Letzte Aenderung      VB 20.03.91
  77 *************************************************************************/
  78
  79
  80 void SwClient::Modify( SfxPoolItem *pOld, SfxPoolItem * )
  81 {
  82     if( (!pOld || pOld->Which() != RES_OBJECTDYING) )
  83         return;
  84
  85     SwPtrMsgPoolItem *pDead = (SwPtrMsgPoolItem *)pOld;
  86     if(pDead->pObject == pRegisteredIn)
  87     {
  88         SwModify *pAbove = (SwModify*)pRegisteredIn->GetRegisteredIn();
  89         if(pAbove)
  90         {
  91             pAbove->Add(this);
  92             return;
  93         }
  94         pRegisteredIn->Remove(this);
  95     }
  96 }
  97
  98 /*************************************************************************
  99 |*        SwClient::~SwClient()
 100 |*
 101 |*        Beschreibung          callback.doc V1.14
 102 |*        Ersterstellung        VB 20.03.91
 103 |*        Letzte Aenderung      MA 25. Jan. 94
 104 *************************************************************************/
 105
 106
 107 SwClient::~SwClient()
 108 {
 109     if( pRegisteredIn && pRegisteredIn->GetDepends() )
 110         pRegisteredIn->Remove( this );
 111
 112     ASSERT( !IsModifyLocked(), "Modify destroyed but locked." );
 113 }
 114
 115
 116     // erfrage vom Client Informationen
 117 BOOL SwClient::GetInfo( SfxPoolItem& ) const
 118 {
 119     return TRUE;                // und weiter
 120 }
 121
 122 /*************************************************************************
 123 |*        SwModify::SwModify( SwModify * )
 124 |*
 125 |*        Beschreibung          Dokument 1.7
 126 |*        Ersterstellung        JP 20.11.90
 127 |*        Letzte Aenderung      VB 20.03.91
 128 *************************************************************************/
 129
 130
 131 SwModify::SwModify( SwModify *pToRegisterIn )
 132     : SwClient(pToRegisterIn), pRoot( 0 )
 133 {
 134 }
 135
 136 // @@@ forbidden and not implemented, but needs to be accessible (protected).
 137 SwModify::SwModify( const SwModify & )
 138     : SwClient( 0 )
 139 {
 140     OSL_PRECOND(0, "SwModify(const SwModify&): not implemented.");
 141 }
 142
 143 /*************************************************************************
 144 |*        SwModify::~SwModify()
 145 |*
 146 |*        Beschreibung          Dokument 1.7
 147 |*        Ersterstellung        JP 20.11.90
 148 |*        Letzte Aenderung      JP 15.04.94
 149 *************************************************************************/
 150
 151
 152
 153 SwModify::~SwModify()
 154 {
 155     if ( IsInCache() )
 156         SwFrm::GetCache().Delete( this );
 157
 158     if ( IsInSwFntCache() )
 159         pSwFontCache->Delete( this );
 160
 161     if( pRoot )
 162     {
 163         if( IsInDocDTOR() )
 164         {
 165             // alle Clients "logisch" austragen
 166             SwClientIter aIter( *this );
 167             SwClient* p;
 168             while( 0 != ( p = aIter++ ) )
 169                 p->pRegisteredIn = 0;
 170
 171             p = aIter.GoRoot();                 // wieder ab Root (==Start) anfangen
 172             do {
 173                 p->pRegisteredIn = 0;
 174             } while( 0 != ( p = aIter-- ) );
 175         }
 176         else
 177         {
 178             // verschicke die Nachricht an die abgeleiteten Objekte.
 179             SwPtrMsgPoolItem aDyObject( RES_OBJECTDYING, this );
 180             Modify( &aDyObject, &aDyObject );
 181
 182             // Zwangsummeldung aller derjenigen, die sich nicht ausgetragen
 183             // haben, durch Aufruf von SwClient::Modify()
 184             while( pRoot )
 185                 pRoot->SwClient::Modify(&aDyObject, &aDyObject);
 186         }
 187     }
 188 }
 189
 190 /*************************************************************************
 191 |*        SwModify::Modify( SwHint * pOldValue, SwHint * pNewValue )
 192 |*
 193 |*        Beschreibung          Dokument 1.7
 194 |*        Ersterstellung        JP 20.11.90
 195 |*        Letzte Aenderung      MA 20. Mar. 95
 196 *************************************************************************/
 197
 198
 199
 200 void SwModify::Modify( SfxPoolItem* pOldValue, SfxPoolItem* pNewValue )
 201 {
 202     if (IsInCache() || IsInSwFntCache())
 203     {
 204         const USHORT nWhich = pOldValue ? pOldValue->Which() :
 205                                         pNewValue ? pNewValue->Which() : 0;
 206         CheckCaching( nWhich );
 207     }
 208
 209       if (!pRoot || IsModifyLocked())
 210         return;
 211
 212     LockModify();
 213
 214 #ifdef PRODUCT
 215     bInModify = TRUE;
 216 #else
 217     if( !pOldValue )
 218         bInModify = TRUE;
 219     else
 220         // following Modifies don't calls an ASSRT
 221         switch( pOldValue->Which() )
 222         {
 223         case RES_OBJECTDYING:
 224          case RES_REMOVE_UNO_OBJECT:
 225             bInModify = ((SwPtrMsgPoolItem *)pOldValue)->pObject != this;
 226             break;
 227
 228         case RES_FOOTNOTE_DELETED:
 229         case RES_REFMARK_DELETED:
 230         case RES_TOXMARK_DELETED:
 231         case RES_FIELD_DELETED:
 232             bInModify = FALSE;
 233             break;
 234         default:
 235             bInModify = TRUE;
 236         }
 237 #endif
 238
 239     SwClientIter aIter( *this );
 240     SwClient * pLast = aIter.GoStart();
 241     if( pLast )         // konnte zum Anfang gesprungen werden ??
 242         do
 243         {
 244             pLast->Modify( pOldValue, pNewValue );
 245             if( !pRoot )        // Baum schon Weg ??
 246                 break;
 247         } while( 0 != ( pLast = aIter++ ));
 248
 249     bInModify = FALSE;
 250     UnlockModify();
 251 }
 252
 253 // erfrage vom Modify Informationen
 254
 255 BOOL SwModify::GetInfo( SfxPoolItem& rInfo ) const
 256 {
 257     BOOL bRet = TRUE;           // bedeutet weiter zum naechsten
 258
 259     if( pRoot )
 260     {
 261         SwClientIter aIter( *(SwModify*)this );
 262
 263         SwClient* pLast = aIter.GoStart();
 264         if( pLast )
 265             while( 0 != ( bRet = pLast->GetInfo( rInfo )) &&
 266                     0 != ( pLast = aIter++ ) )
 267                 ;
 268     }
 269
 270     return bRet;                // und weiter
 271 }
 272
 273 /*************************************************************************
 274 |*        SwModify::Add( SwClient *pDepend )
 275 |*
 276 |*        Beschreibung          Dokument 1.7
 277 |*        Ersterstellung        JP 20.11.90
 278 |*        Letzte Aenderung      JP 14.09.94
 279 *************************************************************************/
 280
 281
 282
 283 void SwModify::Add(SwClient *pDepend)
 284 {
 285     ASSERT( !bInModify, "Client innerhalb des eigenen Modifies einfuegen?" );
 286
 287     // nur wenn das hier noch nicht eingetragen ist einfuegen
 288     if(pDepend->pRegisteredIn != this )
 289     {
 290 #ifndef PRODUCT
 291         SwClientIter* pTmp = pClientIters;
 292         while( pTmp )
 293         {
 294             ASSERT( &pTmp->rRoot != pRoot,
 295                 "Client beim angemeldeten ClientIter einfuegen?" );
 296             pTmp = pTmp->pNxtIter;
 297         }
 298 #endif
 299         // wenn schon wanders angemeldet, dann dort abmelden
 300         if( pDepend->pRegisteredIn != 0 )
 301             pDepend->pRegisteredIn->Remove( pDepend );
 302
 303         if( !pRoot )
 304         {
 305             pRoot = pDepend;
 306             pRoot->pLeft = 0;
 307             pRoot->pRight = 0;
 308         }
 309         else
 310         {
 311             // immer hinter die Root haengen
 312             pDepend->pRight = pRoot->pRight;
 313             pRoot->pRight = pDepend;
 314             pDepend->pLeft = pRoot;
 315             if( pDepend->pRight )
 316                 pDepend->pRight->pLeft = pDepend;
 317         }
 318
 319         pDepend->pRegisteredIn = this;
 320     }
 321 }
 322
 323 /*************************************************************************
 324 |*        SwModify::_Remove( SwClient *pDepend )
 325 |*
 326 |*        Beschreibung          Dokument 1.7
 327 |*        Ersterstellung        JP 20.11.90
 328 |*        Letzte Aenderung      JP 14.09.94
 329 *************************************************************************/
 330
 331
 332
 333 SwClient *SwModify::_Remove(SwClient * pDepend)
 334 {
 335     // FME 2007-07-16 #i79641# SwXTextMarkup is allowed to be removed ...
 336     ASSERT( !bInModify || 0 != dynamic_cast<SwXTextMarkup*>(pDepend), "Client innerhalb des eigenen Modifies loeschen?" );
 337
 338     // loesche das Object aus der Liste und setze den
 339     // Registrierungs-Pointer zurueck
 340     if( pDepend->pRegisteredIn == this )
 341     {
 342         SwClient* pR = pDepend->pRight;
 343         SwClient* pL = pDepend->pLeft;
 344         if( pRoot == pDepend )
 345             pRoot = pL ? pL : pR;
 346
 347         if( pL )
 348             pL->pRight = pR;
 349         if( pR )
 350             pR->pLeft = pL;
 351
 352         // alle Client-Iters updaten
 353         SwClientIter* pTmp = pClientIters;
 354         while( pTmp )
 355         {
 356             if( pTmp->pAkt == pDepend || pTmp->pDelNext == pDepend )
 357                 pTmp->pDelNext = pR;
 358
 359             // --> FME 2006-02-03 #127369# Notify SwClientIter if mpWatchClient is removed
 360             if ( pTmp->mpWatchClient == pDepend )
 361                 pTmp->mpWatchClient = 0;
 362             // <--
 363
 364             pTmp = pTmp->pNxtIter;
 365         }
 366
 367         pDepend->pLeft = 0;
 368         pDepend->pRight = 0;
 369     }
 370     else {
 371         ASSERT( FALSE, "SwModify::Remove(): pDepend nicht gefunden");
 372     }
 373     pDepend->pRegisteredIn = 0;
 374     return pDepend;
 375 }
 376
 377
 378 /*************************************************************************
 379 |*        SwModify::CheckCaching( const USHORT nWhich )
 380 |*
 381 |*        Ersterstellung        JP 25.06.95
 382 |*        Letzte Aenderung      JP 25.06.95
 383 *************************************************************************/
 384
 385
 386
 387 void SwModify::CheckCaching( const USHORT nWhich )
 388 {
 389     if (isCHRATR(nWhich))
 390     {
 391         SetInSwFntCache( FALSE );
 392     }
 393     else
 394         switch ( nWhich )
 395         {
 396         case RES_OBJECTDYING:
 397         case RES_FMT_CHG:
 398         case RES_ATTRSET_CHG:
 399             SetInSwFntCache( FALSE );
 400
 401         case RES_UL_SPACE:
 402         case RES_LR_SPACE:
 403         case RES_BOX:
 404         case RES_SHADOW:
 405         case RES_FRM_SIZE:
 406         case RES_KEEP:
 407         case RES_BREAK:
 408             if ( IsInCache() )
 409             {
 410                 SwFrm::GetCache().Delete( this );
 411                 SetInCache( FALSE );
 412             }
 413             break;
 414         }
 415 }
 416
 417
 418 // ----------
 419 // SwDepend
 420 // ----------
 421
 422 /*************************************************************************
 423 |*        SwDepend::SwDepend(SwClient *pTellHim,SwModify *pDepend)
 424 |*
 425 |*        Beschreibung          callback.doc V1.14
 426 |*        Ersterstellung        VB 20.03.91
 427 |*        Letzte Aenderung      VB 20.03.91
 428 *************************************************************************/
 429
 430
 431 SwDepend::SwDepend(SwClient *pTellHim, SwModify *pDepend)
 432     : SwClient(pDepend)
 433 {
 434     pToTell  = pTellHim;
 435 }
 436
 437 /*************************************************************************
 438 |*
 439 |*        SwDepend::Modify(SwHint *, SwHint *)
 440 |*
 441 |*        Beschreibung          callback.doc V1.14
 442 |*        Ersterstellung        VB 20.03.91
 443 |*        Letzte Aenderung      VB 20.03.91
 444 |*
 445 *************************************************************************/
 446
 447
 448 void SwDepend::Modify( SfxPoolItem *pOldValue, SfxPoolItem *pNewValue )
 449 {
 450     if(pNewValue && pNewValue->Which() == RES_OBJECTDYING)
 451         SwClient::Modify(pOldValue,pNewValue);
 452     else if(pToTell)
 453         pToTell->Modify(pOldValue, pNewValue);
 454 }
 455
 456
 457     // erfrage vom Modify Informationen
 458 BOOL SwDepend::GetInfo( SfxPoolItem& rInfo ) const
 459 {
 460     return pToTell ? pToTell->GetInfo( rInfo ) : TRUE;
 461 }
 462
 463 /********************************************************************/
 464
 465
 466 SwClientIter::SwClientIter( SwModify& rModify )
 467     : rRoot( rModify )
 468 {
 469     // hinten einketten!
 470     pNxtIter = 0;
 471     if( pClientIters )
 472     {
 473         SwClientIter* pTmp = pClientIters;
 474         while( pTmp->pNxtIter )
 475             pTmp = pTmp->pNxtIter;
 476         pTmp->pNxtIter = this;
 477     }
 478     else
 479         pClientIters = this;
 480
 481     pAkt = rRoot.pRoot;
 482     pDelNext = pAkt;
 483     mpWatchClient = 0;
 484 }
 485
 486
 487
 488 SwClientIter::~SwClientIter()
 489 {
 490     if( pClientIters )
 491     {
 492         if( pClientIters == this )
 493             pClientIters = pNxtIter;
 494         else
 495         {
 496             SwClientIter* pTmp = pClientIters;
 497             while( pTmp->pNxtIter != this )
 498                 if( 0 == ( pTmp = pTmp->pNxtIter ) )
 499                 {
 500                     ASSERT( this, "wo ist mein Pointer" );
 501                     return ;
 502                 }
 503             pTmp->pNxtIter = pNxtIter;
 504         }
 505     }
 506 }
 507
 508
 509 #ifndef CFRONT
 510     // Postfix Operator
 511 SwClient* SwClientIter::operator++(int)
 512 {
 513 // solange der CFRONT Prefix und PostFix nicht unterscheiden kann, immer
 514 // als Prefix-Operator arbeiten. Wenn der CFRONT es kann, muss auch der
 515 // Code entsprechen umgestellt werden !!!
 516     if( pDelNext == pAkt )
 517     {
 518         pAkt = pAkt->pRight;
 519         pDelNext = pAkt;
 520     }
 521     else
 522         pAkt = pDelNext;
 523     return pAkt;
 524 }
 525 #endif
 526
 527
 528     // Prefix Operator
 529 SwClient* SwClientIter::operator++()
 530 {
 531     if( pDelNext == pAkt )
 532     {
 533         pAkt = pAkt->pRight;
 534         pDelNext = pAkt;
 535     }
 536     else
 537         pAkt = pDelNext;
 538     return pAkt;
 539 }
 540
 541
 542 #ifndef CFRONT
 543     // Postfix Operator
 544 SwClient* SwClientIter::operator--(int)
 545 {
 546 // solange der CFRONT Prefix und PostFix nicht unterscheiden kann, immer
 547 // als Prefix-Operator arbeiten. Wenn der CFRONT es kann, muss auch der
 548 // Code entsprechen umgestellt werden !!!
 549     if( pDelNext == pAkt )
 550         pAkt = pAkt->pLeft;
 551     else
 552         pAkt = pDelNext->pLeft;
 553     pDelNext = pAkt;
 554     return pAkt;
 555 }
 556 #endif
 557
 558
 559     // Prefix Operator
 560 SwClient* SwClientIter::operator--()
 561 {
 562     if( pDelNext == pAkt )
 563         pAkt = pAkt->pLeft;
 564     else
 565         pAkt = pDelNext->pLeft;
 566     pDelNext = pAkt;
 567     return pAkt;
 568 }
 569
 570
 571 SwClient* SwClientIter::GoStart()               // zum Anfang des Baums
 572 {
 573     pAkt = rRoot.pRoot;
 574     if( pAkt )
 575         while( pAkt->pLeft )
 576             pAkt = pAkt->pLeft;
 577     pDelNext = pAkt;
 578     return pAkt;
 579 }
 580
 581
 582 SwClient* SwClientIter::GoEnd()                 // zum End des Baums
 583 {
 584     pAkt = pDelNext;
 585     if( !pAkt )
 586         pAkt = rRoot.pRoot;
 587     if( pAkt )
 588         while( pAkt->pRight )
 589             pAkt = pAkt->pRight;
 590     pDelNext = pAkt;
 591     return pAkt;
 592 }
 593
 594
 595
 596 SwClient* SwClientIter::First( TypeId nType )
 597 {
 598     aSrchId = nType;
 599     GoStart();
 600     if( pAkt )
 601         do {
 602             if( pAkt->IsA( aSrchId ) )
 603                 break;
 604
 605             if( pDelNext == pAkt )
 606             {
 607                 pAkt = pAkt->pRight;
 608                 pDelNext = pAkt;
 609             }
 610             else
 611                 pAkt = pDelNext;
 612
 613         } while( pAkt );
 614     return pAkt;
 615 }
 616
 617
 618 SwClient* SwClientIter::Next()
 619 {
 620     do {
 621         // erstmal zum naechsten
 622         if( pDelNext == pAkt )
 623         {
 624             pAkt = pAkt->pRight;
 625             pDelNext = pAkt;
 626         }
 627         else
 628             pAkt = pDelNext;
 629
 630         if( pAkt && pAkt->IsA( aSrchId ) )
 631             break;
 632     } while( pAkt );
 633     return pAkt;
 634 }
 635
 636
 637