src/timeline.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * clock.cpp: 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 #include <config.h>
  15
  16 #include <glib.h>
  17
  18 #include <stdlib.h>
  19 #include <string.h>
  20
  21 #include "timeline.h"
  22 #include "timemanager.h"
  23
  24 #include "uielement.h"
  25 #include "runtime.h"
  26 #include "deployment.h"
  27 #include "ptr.h"
  28
  29 /* timeline */
  30
  31 Timeline::Timeline ()
  32 {
  33         SetObjectType (Type::TIMELINE);
  34
  35         had_parent = false;
  36         manual_target = NULL;
  37         timeline_status = TIMELINE_STATUS_OK;
  38         clock = NULL;
  39 }
  40
  41 Timeline::~Timeline ()
  42 {
  43 }
  44
  45 Clock*
  46 Timeline::AllocateClock ()
  47 {
  48         clock = new Clock (this);
  49
  50         AttachCompletedHandler ();
  51
  52         return clock;
  53 }
  54
  55 Clock*
  56 Timeline::GetClock ()
  57 {
  58         return clock;
  59 }
  60
  61 bool
  62 Timeline::Validate ()
  63 {
  64         RepeatBehavior *repeat = GetRepeatBehavior ();
  65         Duration *duration = GetDuration ();
  66
  67         if (duration->HasTimeSpan () && duration->GetTimeSpan () == 0 &&
  68             (GetFillBehavior () == FillBehaviorStop || (repeat->HasCount () && repeat->GetCount () > 1.0)))
  69                 timeline_status = TIMELINE_STATUS_DETACHED;
  70
  71         // FIXME This should prolly be changed to a more generic if BeginTime > Duration
  72         // Need to investigate, though SL checking seems to be very selective
  73         if (duration->HasTimeSpan () && duration->GetTimeSpan () == 0 &&
  74             this->GetBeginTime () > 0)
  75                 return false;
  76
  77         return true;
  78 }
  79
  80 void
  81 Timeline::SetRepeatBehavior (RepeatBehavior behavior)
  82 {
  83         SetValue (Timeline::RepeatBehaviorProperty, Value(behavior));
  84 }
  85
  86 RepeatBehavior *
  87 Timeline::GetRepeatBehavior ()
  88 {
  89         return GetValue (Timeline::RepeatBehaviorProperty)->AsRepeatBehavior();
  90 }
  91
  92 void
  93 Timeline::SetDuration (Duration duration)
  94 {
  95         SetValue (Timeline::DurationProperty, Value(duration));
  96 }
  97
  98 Duration*
  99 Timeline::GetDuration ()
 100 {
 101         return GetValue (Timeline::DurationProperty)->AsDuration();
 102 }
 103
 104 Duration
 105 Timeline::GetNaturalDuration (Clock *clock)
 106 {
 107         Duration* d = GetDuration ();
 108         if (*d == Duration::Automatic) {
 109 //              printf ("automatic duration, we need to calculate it\n");
 110                 Duration cd = GetNaturalDurationCore (clock);
 111 //              if (cd.HasTimeSpan ())
 112 //                      printf (" + duration (%" G_GINT64_FORMAT " timespan)\n", cd.GetTimeSpan ());
 113 //              else if (cd == Duration::Automatic)
 114 //                      printf (" + automatic\n");
 115 //              else if (cd == Duration::Forever)
 116 //                      printf (" + forever\n");
 117                 return cd;
 118         }
 119         else {
 120                 return *d;
 121         }
 122 }
 123
 124 Duration
 125 Timeline::GetNaturalDurationCore (Clock *clock)
 126 {
 127         return Duration::Automatic;
 128 }
 129
 130 TimeSpan
 131 Timeline::GetBeginTime ()
 132 {
 133         Value *v = GetValue (Timeline::BeginTimeProperty);
 134         return v == NULL ? 0LL : v->AsTimeSpan();
 135 }
 136
 137 void
 138 Timeline::AttachCompletedHandler ()
 139 {
 140         clock->AddHandler (Clock::CompletedEvent, clock_completed, this);
 141 }
 142
 143 void
 144 Timeline::DetachCompletedHandler ()
 145 {
 146         clock->RemoveHandler (Clock::CompletedEvent, clock_completed, this);
 147 }
 148
 149 void
 150 Timeline::clock_completed (EventObject *sender, EventArgs *calldata, gpointer closure)
 151 {
 152         Timeline *timeline = (Timeline *) closure;
 153         timeline->OnClockCompleted ();
 154 }
 155
 156 void
 157 Timeline::OnClockCompleted ()
 158 {
 159         Emit (Timeline::CompletedEvent);
 160 }
 161
 162 void
 163 Timeline::TeardownClock ()
 164 {
 165         if (clock) {
 166                 DetachCompletedHandler ();
 167                 Clock *c = clock;
 168                 ClockGroup *group = c->GetParentClock();
 169                 if (group)
 170                         group->RemoveChild (c);
 171                 clock = NULL;
 172                 c->unref ();
 173         }
 174 }
 175
 176 /* timeline group */
 177
 178 TimelineGroup::TimelineGroup ()
 179 {
 180         SetObjectType (Type::TIMELINEGROUP);
 181 }
 182
 183 TimelineGroup::~TimelineGroup ()
 184 {
 185 }
 186
 187 Clock *
 188 TimelineGroup::AllocateClock ()
 189 {
 190         clock = new ClockGroup (this);
 191         TimelineCollection *collection = GetChildren ();
 192
 193         for (int i = 0; i < collection->GetCount (); i++)
 194                 ((ClockGroup*)clock)->AddChild (collection->GetValueAt (i)->AsTimeline ()->AllocateClock ());
 195
 196         AttachCompletedHandler ();
 197         return clock;
 198 }
 199
 200 // Validate this TimelineGroup by validating all of it's children
 201 bool
 202 TimelineGroup::Validate ()
 203 {
 204         TimelineCollection *collection = GetChildren ();
 205         Timeline *timeline;
 206
 207         for (int i = 0; i < collection->GetCount (); i++) {
 208                 timeline = collection->GetValueAt (i)->AsTimeline ();
 209                 if (!timeline->Validate ())
 210                         return false;
 211         }
 212
 213         return Timeline::Validate ();
 214 }
 215
 216 void
 217 TimelineGroup::AddChild (Timeline *child)
 218 {
 219         TimelineCollection *children = GetChildren ();
 220         children->Add (child);
 221 }
 222
 223 void
 224 TimelineGroup::RemoveChild (Timeline *child)
 225 {
 226         TimelineCollection *children = GetChildren ();
 227
 228         children->Remove (child);
 229 }
 230
 231 void
 232 TimelineGroup::OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args)
 233 {
 234         if (col == GetChildren()) {
 235                 if (args->GetChangedAction() == CollectionChangedActionAdd ||
 236                     args->GetChangedAction() == CollectionChangedActionReplace) {
 237                         Timeline *timeline = args->GetNewItem()->AsTimeline ();
 238                         if (timeline)
 239                                 timeline->SetHadParent (true);
 240                 }
 241         }
 242 }
 243
 244
 245 TimelineCollection::TimelineCollection ()
 246 {
 247         SetObjectType (Type::TIMELINE_COLLECTION);
 248 }
 249
 250 TimelineCollection::~TimelineCollection ()
 251 {
 252 }
 253
 254 ParallelTimeline::ParallelTimeline ()
 255 {
 256         SetObjectType (Type::PARALLELTIMELINE);
 257 }
 258
 259 ParallelTimeline::~ParallelTimeline ()
 260 {
 261 }
 262
 263 Duration
 264 ParallelTimeline::GetNaturalDurationCore (Clock *clock)
 265 {
 266         TimelineCollection *collection = GetChildren ();
 267         Duration d = Duration::Automatic;
 268         TimeSpan duration_span = 0;
 269         Timeline *timeline;
 270
 271         if (collection->GetCount () == 0)
 272                 return Duration::FromSeconds (0);
 273
 274         for (int i = 0; i < collection->GetCount (); i++) {
 275                 timeline = collection->GetValueAt (i)->AsTimeline ();
 276
 277                 Duration duration = timeline->GetNaturalDuration (clock);
 278                 if (duration.IsAutomatic())
 279                         continue;
 280
 281                 if (duration.IsForever())
 282                         return Duration::Forever;
 283
 284                 TimeSpan span = duration.GetTimeSpan ();
 285
 286                 RepeatBehavior *repeat = timeline->GetRepeatBehavior ();
 287                 if (repeat->IsForever())
 288                         return Duration::Forever;
 289
 290                 if (repeat->HasCount ())
 291                         span = (TimeSpan) (span * repeat->GetCount ());
 292
 293                 if (timeline->GetAutoReverse ())
 294                         span *= 2;
 295
 296                 // If we have duration-base repeat behavior,
 297                 // clamp/up our span to that.
 298                 if (repeat->HasDuration ())
 299                         span = repeat->GetDuration ();
 300
 301                 if (span != 0)
 302                         span = (TimeSpan)(span / timeline->GetSpeedRatio());
 303
 304                 span += timeline->GetBeginTime ();
 305
 306                 if (duration_span <= span) {
 307                         duration_span = span;
 308                         d = Duration (duration_span);
 309                 }
 310         }
 311
 312         return d;
 313 }
 314
 315 TimelineMarker::TimelineMarker ()
 316 {
 317         SetObjectType (Type::TIMELINEMARKER);
 318 }
 319
 320 TimelineMarker::~TimelineMarker ()
 321 {
 322 }
 323
 324 DispatcherTimer::DispatcherTimer ()
 325 {
 326         SetObjectType (Type::DISPATCHERTIMER);
 327
 328         clock = NULL;
 329         stopped = false;
 330         started = false;
 331         ontick = false;
 332 }
 333
 334 void
 335 DispatcherTimer::Start ()
 336 {
 337         started = true;
 338         stopped = false;
 339
 340         Surface *surface = Deployment::GetCurrent ()->GetSurface ();
 341
 342         if (clock) {
 343                 clock->Reset ();
 344                 clock->BeginOnTick ();
 345                 clock->SetRootParentTime (surface->GetTimeManager()->GetCurrentTime());
 346         } else {
 347                 AllocateClock ();
 348                 char *name = g_strdup_printf ("DispatcherTimer (%p)", this);
 349                 clock->SetValue (DependencyObject::NameProperty, name);
 350                 g_free (name);
 351
 352                 surface->GetTimeManager()->AddClock (clock);
 353
 354                 clock->BeginOnTick ();
 355         }
 356 }
 357
 358 void
 359 DispatcherTimer::Stop ()
 360 {
 361         if (clock)
 362                 clock->Stop ();
 363         stopped = true;
 364         started = false;
 365         if (!ontick)
 366                 Timeline::TeardownClock ();
 367 }
 368
 369 void
 370 DispatcherTimer::Restart ()
 371 {
 372         started = false;
 373         stopped = false;
 374         clock->Reset ();
 375         TimeSpan time = clock->GetParentClock()->GetCurrentTime();
 376         clock->SetRootParentTime (time);
 377         clock->Begin (time);
 378 }
 379
 380 void
 381 DispatcherTimer::OnClockCompleted ()
 382 {
 383         started = false;
 384         ontick = true;
 385         Emit (DispatcherTimer::TickEvent);
 386         ontick = false;
 387
 388         /* if the timer wasn't stopped or started on
 389            the tick event, restart it. Unlike Start,
 390            which makes it go on the next tick, Restart
 391            includes the time spent on the tick.
 392
 393            if the timer was stopped but not started
 394            on the tick event, we don't need to keep
 395            the clock around anymore.
 396         */
 397         if (!stopped && !started)
 398                 Restart ();
 399         else if (stopped && !started)
 400                 Timeline::TeardownClock ();
 401 }
 402
 403 Duration
 404 DispatcherTimer::GetNaturalDurationCore (Clock *clock)
 405 {
 406         return Duration::FromSeconds (0);
 407 }
 408
 409 void
 410 DispatcherTimer::TeardownClock ()
 411 {
 412         if (clock) {
 413                 Stop ();
 414                 Timeline::TeardownClock ();
 415         }
 416 }