svtools/source/notify/listeneriter.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: listeneriter.cxx,v $
  10  * $Revision: 1.5 $
  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 #ifndef GCC
  34 #endif
  35 #include <tools/debug.hxx>
  36
  37 #include "listenerbase.hxx"
  38 #include "listeneriter.hxx"
  39 #include "broadcast.hxx"
  40 #include "listener.hxx"
  41
  42 SvtListenerIter* SvtListenerIter::pListenerIters = 0;
  43
  44 SvtListenerIter::SvtListenerIter( SvtBroadcaster& rBrdcst )
  45     : rRoot( rBrdcst )
  46 {
  47     // hinten einketten!
  48     pNxtIter = 0;
  49     if( pListenerIters )
  50     {
  51         SvtListenerIter* pTmp = pListenerIters;
  52         while( pTmp->pNxtIter )
  53             pTmp = pTmp->pNxtIter;
  54         pTmp->pNxtIter = this;
  55     }
  56     else
  57         pListenerIters = this;
  58
  59     pAkt = rRoot.pRoot;
  60     pDelNext = pAkt;
  61 }
  62
  63
  64
  65 SvtListenerIter::~SvtListenerIter()
  66 {
  67     if( pListenerIters )
  68     {
  69         if( pListenerIters == this )
  70             pListenerIters = pNxtIter;
  71         else
  72         {
  73             SvtListenerIter* pTmp = pListenerIters;
  74             while( pTmp->pNxtIter != this )
  75                 if( 0 == ( pTmp = pTmp->pNxtIter ) )
  76                     return ;
  77             pTmp->pNxtIter = pNxtIter;
  78         }
  79     }
  80 }
  81
  82 void SvtListenerIter::RemoveListener( SvtListenerBase& rDel,
  83                                         SvtListenerBase* pNext )
  84 {
  85     // Update the ListenerIter
  86     SvtListenerIter* pTmp = pListenerIters;
  87     while( pTmp )
  88     {
  89         if( pTmp->pAkt == &rDel || pTmp->pDelNext == &rDel )
  90             pTmp->pDelNext = pNext;
  91         pTmp = pTmp->pNxtIter;
  92     }
  93 }
  94
  95 SvtListener* SvtListenerIter::GoNext()
  96 {
  97     if( pDelNext == pAkt )
  98     {
  99         pAkt = pAkt->GetRight();
 100         pDelNext = pAkt;
 101     }
 102     else
 103         pAkt = pDelNext;
 104     return pAkt ? pAkt->GetListener() : 0;
 105 }
 106
 107
 108 SvtListener* SvtListenerIter::GoPrev()
 109 {
 110     if( pDelNext == pAkt )
 111         pAkt = pAkt->GetLeft();
 112     else
 113         pAkt = pDelNext->GetLeft();
 114     pDelNext = pAkt;
 115     return pAkt ? pAkt->GetListener() : 0;
 116 }
 117
 118
 119 SvtListener* SvtListenerIter::GoStart()                 // zum Anfang des Baums
 120 {
 121     pAkt = rRoot.pRoot;
 122     if( pAkt )
 123         while( pAkt->GetLeft() )
 124             pAkt = pAkt->GetLeft();
 125     pDelNext = pAkt;
 126     return pAkt ? pAkt->GetListener() : 0;
 127 }
 128
 129
 130 SvtListener* SvtListenerIter::GoEnd()                   // zum End des Baums
 131 {
 132     pAkt = pDelNext;
 133     if( !pAkt )
 134         pAkt = rRoot.pRoot;
 135     if( pAkt )
 136         while( pAkt->GetRight() )
 137             pAkt = pAkt->GetRight();
 138     pDelNext = pAkt;
 139     return pAkt ? pAkt->GetListener() : 0;
 140 }
 141
 142
 143
 144 SvtListener* SvtListenerIter::First( TypeId nType )
 145 {
 146     aSrchId = nType;
 147     GoStart();
 148     if( pAkt )
 149         do {
 150             if( pAkt->GetListener()->IsA( aSrchId ) )
 151                 break;
 152
 153             if( pDelNext == pAkt )
 154             {
 155                 pAkt = pAkt->GetRight();
 156                 pDelNext = pAkt;
 157             }
 158             else
 159                 pAkt = pDelNext;
 160
 161         } while( pAkt );
 162     return pAkt ? pAkt->GetListener() : 0;
 163 }
 164
 165
 166 SvtListener* SvtListenerIter::Next()
 167 {
 168     do {
 169         // erstmal zum naechsten
 170         if( pDelNext == pAkt )
 171         {
 172             pAkt = pAkt->GetRight();
 173             pDelNext = pAkt;
 174         }
 175         else
 176             pAkt = pDelNext;
 177
 178         if( pAkt && pAkt->GetListener()->IsA( aSrchId ) )
 179             break;
 180     } while( pAkt );
 181     return pAkt ? pAkt->GetListener() : 0;
 182 }
 183
 184
 185 SvtListener* SvtListenerIter::GoRoot()          // wieder ab Root anfangen
 186 {
 187     pDelNext = pAkt = rRoot.pRoot;
 188     return pAkt ? pAkt->GetListener() : 0;
 189 }
 190
 191 SvtListener* SvtListenerIter::GetCurr() const   // returns the current
 192 {
 193     return pDelNext ? pDelNext->GetListener() : 0;
 194 }
 195