src/clock.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * clock.h: Clock management
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #ifndef MOON_CLOCK_H
  15 #define MOON_CLOCK_H
  16
  17 #include <glib.h>
  18 #include "collection.h"
  19
  20 /*
  21  * Time units:
  22  *  TimeSpan: signed int64 value, 100-nanosecond units (10 000 000 ticks per second)
  23  *  Pts: unsigned int64 value, same units as TimeSpan
  24  *  Milliseconds
  25  *  Seconds
  26  */
  27
  28 typedef guint64 TimePts;
  29
  30 #define TIMESPANTICKS_IN_SECOND 10000000
  31 #define TIMESPANTICKS_IN_SECOND_FLOAT 10000000.0
  32
  33 #define TimeSpan_FromSeconds(s)  ((TimeSpan)(s) * TIMESPANTICKS_IN_SECOND)
  34 #define TimeSpan_ToSeconds(s)  ((TimeSpan)(s) / TIMESPANTICKS_IN_SECOND)
  35
  36 #define TimeSpan_FromSecondsFloat(s)  ((TimeSpan)((s) * TIMESPANTICKS_IN_SECOND_FLOAT))
  37 #define TimeSpan_ToSecondsFloat(s)  (((TimeSpan)(s)) / TIMESPANTICKS_IN_SECOND_FLOAT)
  38
  39 #define TimeSpan_ToPts(s)       ((guint64) (s))
  40 #define TimeSpan_FromPts(s)     ((TimeSpan) (s))
  41
  42 #define PTS_PER_MILLISECOND     10000
  43
  44 #define MilliSeconds_ToPts(s) ((guint64) (s) * PTS_PER_MILLISECOND)
  45 #define MilliSeconds_FromPts(s) ((s) / PTS_PER_MILLISECOND)
  46
  47 /* @IncludeInKinds */
  48 /* @Namespace=System.Windows */
  49 struct Duration {
  50         enum DurationKind {
  51                 TIMESPAN,
  52                 AUTOMATIC,
  53                 FOREVER
  54         };
  55
  56         Duration (TimeSpan duration)
  57           : k (TIMESPAN),
  58             timespan (duration) { }
  59
  60         Duration (const Duration &duration)
  61         {
  62                 k = duration.k;
  63                 timespan = duration.timespan;
  64         }
  65
  66         Duration (DurationKind kind) : k(kind) { };
  67
  68         bool HasTimeSpan () { return k == TIMESPAN; }
  69         TimeSpan GetTimeSpan() { return timespan; }
  70
  71         bool IsAutomatic () { return k == AUTOMATIC; }
  72         bool IsForever () { return k == FOREVER; }
  73
  74         static Duration Automatic;
  75         static Duration Forever;
  76
  77         // XXX tons more operators here
  78         bool operator!= (const Duration &v) const
  79         {
  80                 return !(*this == v);
  81         }
  82
  83         bool operator== (const Duration &v) const
  84         {
  85                 if (v.k != k)
  86                         return false;
  87
  88                 if (v.k == TIMESPAN)
  89                         return timespan == v.timespan;
  90
  91                 return true;
  92         }
  93
  94         gint32 ToSeconds () { return TimeSpan_ToSeconds (timespan); }
  95
  96         double ToSecondsFloat () { return TimeSpan_ToSecondsFloat (timespan); }
  97
  98         // This should live in a TimeSpan class, but oh well.. */
  99         static Duration FromSeconds (int seconds) { return Duration (TimeSpan_FromSeconds (seconds)); }
 100         static Duration FromSecondsFloat (double seconds) { return Duration (TimeSpan_FromSecondsFloat (seconds)); }
 101
 102 private:
 103         DurationKind k;
 104         gint32 padding;
 105         TimeSpan timespan;
 106 };
 107
 108
 109 /* @IncludeInKinds */
 110 /* @Namespace=System.Windows.Media.Animation */
 111 struct RepeatBehavior {
 112         enum RepeatKind {
 113                 COUNT,
 114                 DURATION,
 115                 FOREVER
 116         };
 117
 118         RepeatBehavior (const RepeatBehavior &repeat)
 119         {
 120                 k = repeat.k;
 121                 duration = repeat.duration;
 122                 count = repeat.count;
 123         }
 124
 125         RepeatBehavior (double count)
 126           : k (COUNT),
 127             count (count) { }
 128
 129         RepeatBehavior (RepeatKind kind) : k(kind) { }
 130
 131         RepeatBehavior (TimeSpan duration)
 132           : k (DURATION),
 133             duration (duration)
 134         {
 135         }
 136
 137         static RepeatBehavior Forever;
 138
 139         bool operator!= (const RepeatBehavior &v) const
 140         {
 141                 return !(*this == v);
 142         }
 143
 144         bool operator== (const RepeatBehavior &v) const
 145         {
 146                 if (v.k != k)
 147                         return false;
 148
 149                 switch (k) {
 150                 case DURATION: return duration == v.duration;
 151                 case COUNT: return count == v.count;
 152                 case FOREVER: return true;
 153                 }
 154
 155                 /* not reached.  quiet g++ -Wall */
 156                 return false;
 157         }
 158
 159         double GetCount () { return count; }
 160         TimeSpan GetDuration() { return duration; }
 161
 162         bool HasCount() { return k == COUNT; }
 163         bool HasDuration () { return k == DURATION; }
 164
 165         bool IsForever () { return k == FOREVER; }
 166
 167 private:
 168         RepeatKind k;
 169         gint32 padding;
 170         double count;
 171         TimeSpan duration;
 172 };
 173
 174
 175 //
 176 // Clocks and timelines
 177 //
 178
 179 class TimeManager;
 180 class Timeline;
 181 class TimelineGroup;
 182
 183 /* our clock is a mixture of the WPF Clock and ClockController
 184    classes.  as such, all clocks are controllable */
 185 /* @Namespace=None,ManagedDependencyProperties=None */
 186 class Clock : public DependencyObject {
 187 public:
 188         Clock (Timeline *timeline);
 189
 190         ClockGroup* GetParentClock ()     { return parent_clock; }
 191         double      GetCurrentProgress () { return progress; }
 192         virtual TimeSpan    GetCurrentTime ()     { return current_time; }
 193         Timeline*   GetTimeline ()        { return timeline; }
 194         Duration    GetNaturalDuration ();
 195         bool        GetIsPaused ()        { return is_paused; }
 196         bool        GetHasStarted ()      { return has_started; }
 197         bool        GetWasStopped ()      { return was_stopped; }
 198         void        ClearHasStarted ()    { has_started = false; }
 199         TimeManager* GetTimeManager ()    { return time_manager; }
 200
 201         TimeSpan begin_time;
 202
 203         enum ClockState {
 204                 Active,  /* time is progressing.  each tick results in a property value changing */
 205                 Filling, /* time is progressing.  each tick results in NO property value changing */
 206                 Stopped  /* time is no longer progressing */
 207         };
 208         ClockState GetClockState () { return state; }
 209
 210         // ClockController methods
 211         virtual void Begin (TimeSpan parentTime);
 212         void Pause ();
 213         void Resume ();
 214         virtual void Seek (TimeSpan timespan);
 215         virtual void SeekAlignedToLastTick (TimeSpan timespan);
 216         virtual void SkipToFill ();
 217         virtual void Stop ();
 218
 219         void BeginOnTick (bool begin = true);
 220         bool GetBeginOnTick () { return begin_on_tick; }
 221
 222         void SetRootParentTime (TimeSpan parentTime);
 223
 224         /* these shouldn't be used.  they're called by the TimeManager and parent Clocks */
 225         virtual void RaiseAccumulatedEvents ();
 226         virtual void RaiseAccumulatedCompleted ();
 227         virtual void ExtraRepeatAction () {};
 228         virtual bool UpdateFromParentTime (TimeSpan parentTime);
 229         void SetParentClock (ClockGroup *parent) { parent_clock = parent; }
 230         virtual void SetTimeManager (TimeManager *manager) { time_manager = manager; }
 231         virtual void Reset ();
 232
 233         // Events you can AddHandler to
 234         const static int CurrentTimeInvalidatedEvent;
 235         const static int CurrentStateInvalidatedEvent;
 236         const static int CompletedEvent;
 237
 238 protected:
 239         virtual ~Clock ();
 240
 241         TimeSpan ComputeNewTime ();
 242
 243         void FillOnNextTick ();
 244
 245         void SetClockState (ClockState state);
 246         void SetCurrentTime (TimeSpan ts);
 247
 248         void Completed ();
 249
 250         // events to queue up
 251         enum {
 252                 CURRENT_STATE_INVALIDATED        = 0x01,
 253                 CURRENT_TIME_INVALIDATED         = 0x02
 254         };
 255         void QueueEvent (int event);
 256
 257         bool calculated_natural_duration;
 258         Duration natural_duration;
 259
 260         TimeSpan root_parent_time;
 261         bool begin_on_tick;
 262
 263         // the start time of the current pause
 264         TimeSpan begin_pause_time;
 265
 266         // the total amount of pause time we've accumulated
 267         TimeSpan accumulated_pause_time;
 268
 269         ClockState state;
 270
 271         double progress;
 272
 273         TimeSpan current_time;
 274
 275         bool seeking;
 276         TimeSpan seek_time;
 277
 278 private:
 279         bool emit_completed;
 280         bool has_completed;
 281         TimeManager *time_manager;
 282         ClockGroup *parent_clock;
 283
 284         bool is_paused;
 285
 286         bool has_started;
 287         bool was_stopped;
 288         Timeline *timeline;
 289         int queued_events;
 290
 291         // for clocks with repeatbehavior that's not Forever and
 292         // durations that aren't forever, this represents the time at
 293         // which we'll hit our Fill.
 294         TimeSpan fillTime;
 295 };
 296
 297
 298 /* @Namespace=None,ManagedDependencyProperties=None */
 299 class ClockGroup : public Clock {
 300 public:
 301         ClockGroup (TimelineGroup *timeline, bool timeManagerClockGroup = false);
 302
 303         void AddChild (Clock *clock);
 304         void RemoveChild (Clock *clock);
 305         bool IsIdle () { return idle_hint; };
 306
 307         virtual void SetTimeManager (TimeManager *manager);
 308
 309         virtual void Begin (TimeSpan parentTime);
 310         virtual void Seek (TimeSpan timespan);
 311         virtual void SkipToFill ();
 312         virtual void Stop ();
 313
 314         /* these shouldn't be used.  they're called by the TimeManager and parent Clocks */
 315         virtual void RaiseAccumulatedEvents ();
 316         virtual void RaiseAccumulatedCompleted ();
 317
 318         virtual bool UpdateFromParentTime (TimeSpan parentTime);
 319
 320         GList *child_clocks;
 321
 322         virtual void Reset ();
 323
 324 protected:
 325         virtual ~ClockGroup ();
 326
 327 private:
 328         TimelineGroup *timeline;
 329         bool idle_hint;
 330         bool timemanager_clockgroup;
 331 };
 332
 333 #endif /* MOON_CLOCK_H */