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 (%lld 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 }
 332
 333 void
 334 DispatcherTimer::Start ()
 335 {
 336         started = true;
 337         stopped = false;
 338
 339         Surface *surface = Deployment::GetCurrent ()->GetSurface ();
 340
 341         if (clock) {
 342                 clock->Reset ();
 343                 clock->BeginOnTick ();
 344                 clock->SetRootParentTime (surface->GetTimeManager()->GetCurrentTime());
 345         } else {
 346                 AllocateClock ();
 347                 char *name = g_strdup_printf ("DispatcherTimer (%p)", this);
 348                 clock->SetValue (DependencyObject::NameProperty, name);
 349                 g_free (name);
 350
 351                 surface->GetTimeManager()->AddClock (clock);
 352
 353                 clock->BeginOnTick ();
 354         }
 355 }
 356
 357 void
 358 DispatcherTimer::Stop ()
 359 {
 360         clock->Stop ();
 361         stopped = true;
 362         started = false;
 363 }
 364
 365 void
 366 DispatcherTimer::Restart ()
 367 {
 368         started = false;
 369         stopped = false;
 370         clock->Reset ();
 371         TimeSpan time = clock->GetParentClock()->GetCurrentTime();
 372         clock->SetRootParentTime (time);
 373         clock->Begin (time);
 374 }
 375
 376 void
 377 DispatcherTimer::OnClockCompleted ()
 378 {
 379         started = false;
 380         Emit (DispatcherTimer::TickEvent);
 381
 382         /* if the timer wasn't stopped on started on
 383            the tick event, restart it. Unlike Start,
 384            which makes it go on the next tick, Restart
 385            includes the time spent on the tick.
 386         */
 387         if (!IsStopped () && !IsStarted ())
 388                 Restart ();
 389 }
 390
 391 Duration
 392 DispatcherTimer::GetNaturalDurationCore (Clock *clock)
 393 {
 394         return Duration::FromSeconds (0);
 395 }
 396
 397 void
 398 DispatcherTimer::TeardownClock ()
 399 {
 400         if (clock) {
 401                 Stop ();
 402                 Timeline::TeardownClock ();
 403         }
 404 }