svx/source/sdr/animation/scheduler.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <svx/sdr/animation/scheduler.hxx>
  21
  22 #include <vector>
  23
  24
  25 // event class
  26
  27 namespace sdr
  28 {
  29     namespace animation
  30     {
  31         Event::Event() : mnTime(0)
  32         {
  33         }
  34
  35         Event::~Event()
  36         {
  37         }
  38
  39
  40         void Event::SetTime(sal_uInt32 nNew)
  41         {
  42             if(mnTime != nNew)
  43             {
  44                 mnTime = nNew;
  45             }
  46         }
  47
  48         bool CompareEvent::operator()(Event* const& lhs, Event* const& rhs) const
  49         {
  50             return lhs->GetTime() < rhs->GetTime();
  51         }
  52
  53
  54         Scheduler::Scheduler()
  55         :   mnTime(0L),
  56             mnDeltaTime(0L),
  57             mbIsPaused(false)
  58         {
  59         }
  60
  61         Scheduler::~Scheduler()
  62         {
  63             Stop();
  64         }
  65
  66         void Scheduler::Invoke()
  67         {
  68             // stop timer and add time
  69             Stop();
  70             mnTime += mnDeltaTime;
  71
  72             // execute events
  73             triggerEvents();
  74
  75             // re-start or stop timer according to event list
  76             checkTimeout();
  77         }
  78
  79         void Scheduler::triggerEvents()
  80         {
  81             if (maList.empty())
  82                 return;
  83
  84             // copy events which need to be executed to a vector. Remove them from
  85             // the scheduler
  86             ::std::vector< Event* > aToBeExecutedList;
  87
  88             while(!maList.empty() && maList[0]->GetTime() <= mnTime)
  89             {
  90                 Event* pNextEvent = maList.front();
  91                 maList.erase(maList.begin());
  92                 aToBeExecutedList.push_back(pNextEvent);
  93             }
  94
  95             // execute events from the vector
  96             ::std::vector< Event* >::const_iterator aEnd = aToBeExecutedList.end();
  97             for(::std::vector< Event* >::iterator aCandidate = aToBeExecutedList.begin();
  98                 aCandidate != aEnd; ++aCandidate)
  99             {
 100                 // trigger event. This may re-insert the event to the scheduler again
 101                 (*aCandidate)->Trigger(mnTime);
 102             }
 103         }
 104
 105         void Scheduler::checkTimeout()
 106         {
 107             // re-start or stop timer according to event list
 108             if(!IsPaused() && !maList.empty())
 109             {
 110                 mnDeltaTime = maList.front()->GetTime() - mnTime;
 111
 112                 if(0L != mnDeltaTime)
 113                 {
 114                     SetTimeout(mnDeltaTime);
 115                     Start();
 116                 }
 117             }
 118             else
 119             {
 120                 Stop();
 121             }
 122         }
 123
 124
 125         // #i38135#
 126         void Scheduler::SetTime(sal_uInt32 nTime)
 127         {
 128             // reset time
 129             Stop();
 130             mnTime = nTime;
 131
 132             if (maList.empty())
 133                 return;
 134
 135             // reset event time points
 136             for (auto & rEvent : maList)
 137             {
 138                 rEvent->SetTime(nTime);
 139             }
 140
 141             if(!IsPaused())
 142             {
 143                 // without delta time, init events by triggering them. This will invalidate
 144                 // painted objects and add them to the scheduler again
 145                 mnDeltaTime = 0L;
 146                 triggerEvents();
 147                 checkTimeout();
 148              }
 149         }
 150
 151         void Scheduler::InsertEvent(Event* pNew)
 152         {
 153             maList.insert(pNew);
 154             checkTimeout();
 155         }
 156
 157         void Scheduler::RemoveEvent(Event* pOld)
 158         {
 159             if(!maList.empty())
 160             {
 161                 auto it = maList.find(pOld);
 162                 if (it != maList.end())
 163                     maList.erase(it);
 164                 checkTimeout();
 165             }
 166         }
 167
 168         void Scheduler::SetPaused(bool bNew)
 169         {
 170             if(bNew != mbIsPaused)
 171             {
 172                 mbIsPaused = bNew;
 173                 checkTimeout();
 174             }
 175         }
 176     } // end of namespace animation
 177 } // end of namespace sdr
 178
 179 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */