svx/source/sdr/animation/scheduler.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: scheduler.cxx,v $
  10  * $Revision: 1.9 $
  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_svx.hxx"
  33 #include <svx/sdr/animation/scheduler.hxx>
  34
  35 #include <vector>
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38 // event class
  39
  40 namespace sdr
  41 {
  42     namespace animation
  43     {
  44         Event::Event(sal_uInt32 nTime)
  45         :       mnTime(nTime),
  46             mpNext(0L)
  47         {
  48         }
  49
  50         Event::~Event()
  51         {
  52         }
  53
  54         Event* Event::GetNext() const
  55         {
  56             return mpNext;
  57         }
  58
  59         void Event::SetNext(Event* pNew)
  60         {
  61             if(pNew != mpNext)
  62             {
  63                 mpNext = pNew;
  64             }
  65         }
  66
  67         sal_uInt32 Event::GetTime() const
  68         {
  69             return mnTime;
  70         }
  71
  72         void Event::SetTime(sal_uInt32 nNew)
  73         {
  74             if(mnTime != nNew)
  75             {
  76                 mnTime = nNew;
  77             }
  78         }
  79     } // end of namespace animation
  80 } // end of namespace sdr
  81
  82 //////////////////////////////////////////////////////////////////////////////
  83 // eventlist class
  84
  85 namespace sdr
  86 {
  87     namespace animation
  88     {
  89         EventList::EventList()
  90         :       mpHead(0L)
  91         {
  92         }
  93
  94         EventList::~EventList()
  95         {
  96             Clear();
  97         }
  98
  99         void EventList::Insert(Event* pNew)
 100         {
 101             if(pNew)
 102             {
 103                 Event* pCurrent = mpHead;
 104                 Event* pPrev = 0L;
 105
 106                 while(pCurrent && pCurrent->GetTime() < pNew->GetTime())
 107                 {
 108                     pPrev = pCurrent;
 109                     pCurrent = pCurrent->GetNext();
 110                 }
 111
 112                 if(pPrev)
 113                 {
 114                     pNew->SetNext(pPrev->GetNext());
 115                     pPrev->SetNext(pNew);
 116                 }
 117                 else
 118                 {
 119                     pNew->SetNext(mpHead);
 120                     mpHead = pNew;
 121                 }
 122             }
 123         }
 124
 125         void EventList::Remove(Event* pOld)
 126         {
 127             if(pOld && mpHead)
 128             {
 129                 Event* pCurrent = mpHead;
 130                 Event* pPrev = 0L;
 131
 132                 while(pCurrent && pCurrent != pOld)
 133                 {
 134                     pPrev = pCurrent;
 135                     pCurrent = pCurrent->GetNext();
 136                 }
 137
 138                 if(pPrev)
 139                 {
 140                     pPrev->SetNext(pOld->GetNext());
 141                 }
 142                 else
 143                 {
 144                     mpHead = pOld->GetNext();
 145                 }
 146
 147                 pOld->SetNext(0L);
 148             }
 149         }
 150
 151         void EventList::Clear()
 152         {
 153             while(mpHead)
 154             {
 155                 Event* pNext = mpHead->GetNext();
 156                 mpHead->SetNext(0L);
 157                 mpHead = pNext;
 158             }
 159         }
 160
 161         Event* EventList::GetFirst()
 162         {
 163             return mpHead;
 164         }
 165     } // end of namespace animation
 166 } // end of namespace sdr
 167
 168 //////////////////////////////////////////////////////////////////////////////
 169 // scheduler class
 170
 171 namespace sdr
 172 {
 173     namespace animation
 174     {
 175         Scheduler::Scheduler()
 176         :       mnTime(0L),
 177             mnDeltaTime(0L),
 178             mbIsPaused(false)
 179         {
 180         }
 181
 182         Scheduler::~Scheduler()
 183         {
 184             Stop();
 185         }
 186
 187         void Scheduler::Timeout()
 188         {
 189             // stop timer and add time
 190             Stop();
 191             mnTime += mnDeltaTime;
 192
 193             // execute events
 194             triggerEvents();
 195
 196             // re-start or stop timer according to event list
 197             checkTimeout();
 198         }
 199
 200         void Scheduler::triggerEvents()
 201         {
 202             Event* pNextEvent = maList.GetFirst();
 203
 204             if(pNextEvent)
 205             {
 206                 // copy events which need to be executed to a vector. Remove them from
 207                 // the scheduler
 208                 ::std::vector< Event* > EventPointerVector;
 209
 210                 while(pNextEvent && pNextEvent->GetTime() <= mnTime)
 211                 {
 212                     maList.Remove(pNextEvent);
 213                     EventPointerVector.push_back(pNextEvent);
 214                     pNextEvent = maList.GetFirst();
 215                 }
 216
 217                 // execute events from the vector
 218                 for(::std::vector< Event* >::iterator aCandidate = EventPointerVector.begin();
 219                     aCandidate != EventPointerVector.end(); aCandidate++)
 220                 {
 221                     // trigger event. This may re-insert the event to the scheduler again
 222                     (*aCandidate)->Trigger(mnTime);
 223                 }
 224             }
 225         }
 226
 227         void Scheduler::checkTimeout()
 228         {
 229             // re-start or stop timer according to event list
 230             if(!IsPaused() && maList.GetFirst())
 231             {
 232                 mnDeltaTime = maList.GetFirst()->GetTime() - mnTime;
 233
 234                 if(0L != mnDeltaTime)
 235                 {
 236                     SetTimeout(mnDeltaTime);
 237                     Start();
 238                 }
 239             }
 240             else
 241             {
 242                 Stop();
 243             }
 244         }
 245
 246         sal_uInt32 Scheduler::GetTime()
 247         {
 248             return mnTime;
 249         }
 250
 251         // #i38135#
 252         void Scheduler::SetTime(sal_uInt32 nTime)
 253         {
 254             // reset time
 255             Stop();
 256             mnTime = nTime;
 257
 258             // get event pointer
 259             Event* pEvent = maList.GetFirst();
 260
 261             if(pEvent)
 262             {
 263                 // retet event time points
 264                 while(pEvent)
 265                 {
 266                     pEvent->SetTime(nTime);
 267                     pEvent = pEvent->GetNext();
 268                 }
 269
 270                 if(!IsPaused())
 271                 {
 272                     // without delta time, init events by triggering them. This will invalidate
 273                     // painted objects and add them to the scheduler again
 274                     mnDeltaTime = 0L;
 275                     triggerEvents();
 276                     checkTimeout();
 277                 }
 278             }
 279         }
 280
 281         void Scheduler::Reset(sal_uInt32 nTime)
 282         {
 283             mnTime = nTime;
 284             mnDeltaTime = 0L;
 285             maList.Clear();
 286         }
 287
 288         void Scheduler::InsertEvent(Event* pNew)
 289         {
 290             if(pNew)
 291             {
 292                 maList.Insert(pNew);
 293                 checkTimeout();
 294             }
 295         }
 296
 297         void Scheduler::RemoveEvent(Event* pOld)
 298         {
 299             if(pOld && maList.GetFirst())
 300             {
 301                 maList.Remove(pOld);
 302                 checkTimeout();
 303             }
 304         }
 305
 306         void Scheduler::SetPaused(bool bNew)
 307         {
 308             if(bNew != mbIsPaused)
 309             {
 310                 mbIsPaused = bNew;
 311                 checkTimeout();
 312             }
 313         }
 314     } // end of namespace animation
 315 } // end of namespace sdr
 316
 317 //////////////////////////////////////////////////////////////////////////////
 318 // eof