vcl/source/app/timer.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: timer.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_vcl.hxx"
  33
  34 #ifndef _SV_SVSYS_HXX
  35 #include <svsys.h>
  36 #endif
  37 #include <vcl/saltimer.hxx>
  38 #include <tools/time.hxx>
  39 #include <vcl/svdata.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <vcl/salinst.hxx>
  42 #include <tools/debug.hxx>
  43 #include <vcl/timer.hxx>
  44
  45
  46
  47 // =======================================================================
  48
  49 #define MAX_TIMER_PERIOD        ((ULONG)0xFFFFFFFF)
  50
  51 // ---------------------
  52 // - TimeManager-Types -
  53 // ---------------------
  54
  55 struct ImplTimerData
  56 {
  57     ImplTimerData*      mpNext;                 // Pointer to the next Instance
  58     Timer*                      mpSVTimer;              // Pointer to SV Timer instance
  59     ULONG                       mnUpdateTime;   // Last Update Time
  60     ULONG                       mnTimerUpdate;  // TimerCallbackProcs on stack
  61     BOOL                        mbDelete;               // Wurde Timer waehren Update() geloescht
  62     BOOL                        mbInTimeout;    // Befinden wir uns im Timeout-Handler
  63 };
  64
  65 // =======================================================================
  66
  67 void Timer::ImplDeInitTimer()
  68 {
  69     ImplSVData*         pSVData = ImplGetSVData();
  70     ImplTimerData*      pTimerData = pSVData->mpFirstTimerData;
  71
  72     if ( pTimerData )
  73     {
  74         do
  75         {
  76             ImplTimerData* pTempTimerData = pTimerData;
  77             if ( pTimerData->mpSVTimer )
  78             {
  79                 pTimerData->mpSVTimer->mbActive = FALSE;
  80                 pTimerData->mpSVTimer->mpTimerData = NULL;
  81             }
  82             pTimerData = pTimerData->mpNext;
  83             delete pTempTimerData;
  84         }
  85         while ( pTimerData );
  86
  87         pSVData->mpFirstTimerData       = NULL;
  88         pSVData->mnTimerPeriod          = 0;
  89         delete pSVData->mpSalTimer;
  90         pSVData->mpSalTimer = NULL;
  91     }
  92 }
  93
  94 // -----------------------------------------------------------------------
  95
  96 static void ImplStartTimer( ImplSVData* pSVData, ULONG nMS )
  97 {
  98     if ( !nMS )
  99         nMS = 1;
 100
 101     if ( nMS != pSVData->mnTimerPeriod )
 102     {
 103         pSVData->mnTimerPeriod = nMS;
 104         pSVData->mpSalTimer->Start( nMS );
 105     }
 106 }
 107
 108 // -----------------------------------------------------------------------
 109
 110 void Timer::ImplTimerCallbackProc()
 111 {
 112     ImplSVData*         pSVData = ImplGetSVData();
 113     ImplTimerData*      pTimerData;
 114     ImplTimerData*      pPrevTimerData;
 115     ULONG                       nMinPeriod = MAX_TIMER_PERIOD;
 116     ULONG                       nDeltaTime;
 117     ULONG                       nTime = Time::GetSystemTicks();
 118
 119     if ( pSVData->mbNoCallTimer )
 120         return;
 121
 122     pSVData->mnTimerUpdate++;
 123     pSVData->mbNotAllTimerCalled = TRUE;
 124
 125     // Suche Timer raus, wo der Timeout-Handler gerufen werden muss
 126     pTimerData = pSVData->mpFirstTimerData;
 127     while ( pTimerData )
 128     {
 129         // Wenn Timer noch nicht neu ist und noch nicht geloescht wurde
 130         // und er sich nicht im Timeout-Handler befindet,
 131         // dann den Handler rufen, wenn die Zeit abgelaufen ist
 132         if ( (pTimerData->mnTimerUpdate < pSVData->mnTimerUpdate) &&
 133              !pTimerData->mbDelete && !pTimerData->mbInTimeout )
 134         {
 135             // Zeit abgelaufen
 136             if ( (pTimerData->mnUpdateTime+pTimerData->mpSVTimer->mnTimeout) <= nTime )
 137             {
 138                 // Neue Updatezeit setzen
 139                 pTimerData->mnUpdateTime = nTime;
 140
 141                 // kein AutoTimer, dann anhalten
 142                 if ( !pTimerData->mpSVTimer->mbAuto )
 143                 {
 144                     pTimerData->mpSVTimer->mbActive = FALSE;
 145                     pTimerData->mbDelete = TRUE;
 146                 }
 147
 148                 // call Timeout
 149                 pTimerData->mbInTimeout = TRUE;
 150                 pTimerData->mpSVTimer->Timeout();
 151                 pTimerData->mbInTimeout = FALSE;
 152             }
 153         }
 154
 155         pTimerData = pTimerData->mpNext;
 156     }
 157
 158     // Neue Zeit ermitteln
 159     ULONG nNewTime = Time::GetSystemTicks();
 160     pPrevTimerData = NULL;
 161     pTimerData = pSVData->mpFirstTimerData;
 162     while ( pTimerData )
 163     {
 164         // Befindet sich Timer noch im Timeout-Handler, dann ignorieren
 165         if ( pTimerData->mbInTimeout )
 166         {
 167             pPrevTimerData = pTimerData;
 168             pTimerData = pTimerData->mpNext;
 169         }
 170         // Wurde Timer zwischenzeitlich zerstoert ?
 171         else if ( pTimerData->mbDelete )
 172         {
 173             if ( pPrevTimerData )
 174                 pPrevTimerData->mpNext = pTimerData->mpNext;
 175             else
 176                 pSVData->mpFirstTimerData = pTimerData->mpNext;
 177             if ( pTimerData->mpSVTimer )
 178                 pTimerData->mpSVTimer->mpTimerData = NULL;
 179             ImplTimerData* pTempTimerData = pTimerData;
 180             pTimerData = pTimerData->mpNext;
 181             delete pTempTimerData;
 182         }
 183         else
 184         {
 185             pTimerData->mnTimerUpdate = 0;
 186             // kleinste Zeitspanne ermitteln
 187             if ( pTimerData->mnUpdateTime == nTime )
 188             {
 189                 nDeltaTime = pTimerData->mpSVTimer->mnTimeout;
 190                 if ( nDeltaTime < nMinPeriod )
 191                     nMinPeriod = nDeltaTime;
 192             }
 193             else
 194             {
 195                 nDeltaTime = pTimerData->mnUpdateTime + pTimerData->mpSVTimer->mnTimeout;
 196                 if ( nDeltaTime < nNewTime )
 197                     nMinPeriod = 1;
 198                 else
 199                 {
 200                     nDeltaTime -= nNewTime;
 201                     if ( nDeltaTime < nMinPeriod )
 202                         nMinPeriod = nDeltaTime;
 203                 }
 204             }
 205             pPrevTimerData = pTimerData;
 206             pTimerData = pTimerData->mpNext;
 207         }
 208     }
 209
 210     // Wenn keine Timer mehr existieren, dann Clock loeschen
 211     if ( !pSVData->mpFirstTimerData )
 212     {
 213         pSVData->mpSalTimer->Stop();
 214         pSVData->mnTimerPeriod = MAX_TIMER_PERIOD;
 215     }
 216     else
 217         ImplStartTimer( pSVData, nMinPeriod );
 218
 219     pSVData->mnTimerUpdate--;
 220     pSVData->mbNotAllTimerCalled = FALSE;
 221 }
 222
 223 // =======================================================================
 224
 225 Timer::Timer()
 226 {
 227     mpTimerData         = NULL;
 228     mnTimeout           = 1;
 229     mbAuto                      = FALSE;
 230     mbActive            = FALSE;
 231 }
 232
 233 // -----------------------------------------------------------------------
 234
 235 Timer::Timer( const Timer& rTimer )
 236 {
 237     mpTimerData         = NULL;
 238     mnTimeout           = rTimer.mnTimeout;
 239     mbAuto                      = FALSE;
 240     mbActive            = FALSE;
 241     maTimeoutHdl        = rTimer.maTimeoutHdl;
 242
 243     if ( rTimer.IsActive() )
 244         Start();
 245 }
 246
 247 // -----------------------------------------------------------------------
 248
 249 Timer::~Timer()
 250 {
 251     if ( mpTimerData )
 252     {
 253         mpTimerData->mbDelete = TRUE;
 254         mpTimerData->mpSVTimer = NULL;
 255     }
 256 }
 257
 258 // -----------------------------------------------------------------------
 259
 260 void Timer::Timeout()
 261 {
 262     maTimeoutHdl.Call( this );
 263 }
 264
 265 // -----------------------------------------------------------------------
 266
 267 void Timer::SetTimeout( ULONG nNewTimeout )
 268 {
 269     mnTimeout = nNewTimeout;
 270
 271     // Wenn Timer aktiv, dann Clock erneuern
 272     if ( mbActive )
 273     {
 274         ImplSVData* pSVData = ImplGetSVData();
 275         if ( !pSVData->mnTimerUpdate && (mnTimeout < pSVData->mnTimerPeriod) )
 276             ImplStartTimer( pSVData, mnTimeout );
 277     }
 278 }
 279
 280 // -----------------------------------------------------------------------
 281
 282 void Timer::Start()
 283 {
 284     mbActive = TRUE;
 285
 286     ImplSVData* pSVData = ImplGetSVData();
 287     if ( !mpTimerData )
 288     {
 289         if ( !pSVData->mpFirstTimerData )
 290         {
 291             pSVData->mnTimerPeriod = MAX_TIMER_PERIOD;
 292             if( ! pSVData->mpSalTimer )
 293             {
 294                 pSVData->mpSalTimer = pSVData->mpDefInst->CreateSalTimer();
 295                 pSVData->mpSalTimer->SetCallback( ImplTimerCallbackProc );
 296             }
 297         }
 298
 299         // insert timer and start
 300         mpTimerData                             = new ImplTimerData;
 301         mpTimerData->mpSVTimer          = this;
 302         mpTimerData->mnUpdateTime       = Time::GetSystemTicks();
 303         mpTimerData->mnTimerUpdate      = pSVData->mnTimerUpdate;
 304         mpTimerData->mbDelete           = FALSE;
 305         mpTimerData->mbInTimeout        = FALSE;
 306
 307         // !!!!! Wegen SFX hinten einordnen !!!!!
 308         ImplTimerData* pPrev = NULL;
 309         ImplTimerData* pData = pSVData->mpFirstTimerData;
 310         while ( pData )
 311         {
 312             pPrev = pData;
 313             pData = pData->mpNext;
 314         }
 315         mpTimerData->mpNext = NULL;
 316         if ( pPrev )
 317             pPrev->mpNext = mpTimerData;
 318         else
 319             pSVData->mpFirstTimerData = mpTimerData;
 320
 321         if ( mnTimeout < pSVData->mnTimerPeriod )
 322             ImplStartTimer( pSVData, mnTimeout );
 323     }
 324     else if( !mpTimerData->mpSVTimer ) // TODO: remove when guilty found
 325     {
 326         DBG_ERROR( "Timer::Start() on a destroyed Timer!" );
 327     }
 328     else
 329     {
 330         mpTimerData->mnUpdateTime        = Time::GetSystemTicks();
 331         mpTimerData->mnTimerUpdate       = pSVData->mnTimerUpdate;
 332         mpTimerData->mbDelete            = FALSE;
 333     }
 334 }
 335
 336 // -----------------------------------------------------------------------
 337
 338 void Timer::Stop()
 339 {
 340     mbActive = FALSE;
 341
 342     if ( mpTimerData )
 343         mpTimerData->mbDelete = TRUE;
 344 }
 345
 346 // -----------------------------------------------------------------------
 347
 348 Timer& Timer::operator=( const Timer& rTimer )
 349 {
 350     if ( IsActive() )
 351         Stop();
 352
 353     mbActive            = FALSE;
 354     mnTimeout           = rTimer.mnTimeout;
 355     maTimeoutHdl        = rTimer.maTimeoutHdl;
 356
 357     if ( rTimer.IsActive() )
 358         Start();
 359
 360     return *this;
 361 }
 362
 363 // =======================================================================
 364
 365 AutoTimer::AutoTimer()
 366 {
 367     mbAuto = TRUE;
 368 }
 369
 370 // -----------------------------------------------------------------------
 371
 372 AutoTimer::AutoTimer( const AutoTimer& rTimer ) : Timer( rTimer )
 373 {
 374     mbAuto = TRUE;
 375 }
 376
 377 // -----------------------------------------------------------------------
 378
 379 AutoTimer& AutoTimer::operator=( const AutoTimer& rTimer )
 380 {
 381     Timer::operator=( rTimer );
 382     return *this;
 383 }