src/animation.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * animation.h: Animation engine
   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_ANIMATION_H
  15 #define MOON_ANIMATION_H
  16
  17 #include <glib.h>
  18
  19 #include "trigger.h"
  20 #include "collection.h"
  21 #include "clock.h"
  22 #include "timeline.h"
  23 #include "list.h"
  24 #include "point.h"
  25 #include "propertypath.h"
  26 #include "moon-curves.h"
  27 #include "easing.h"
  28 #include "applier.h"
  29
  30 // misc types
  31 /* @Namespace=System.Windows.Media.Animation */
  32 class KeySpline : public DependencyObject {
  33 public:
  34         /* @GenerateCBinding,GeneratePInvoke */
  35         KeySpline ();
  36
  37         KeySpline (Point controlPoint1, Point controlPoint2);
  38         KeySpline (double x1, double y1, double x2, double y2);
  39
  40         virtual void OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error);
  41
  42         void RegenerateQuadratics ();
  43
  44         double GetSplineProgress (double linearProgress);
  45         /* @PropertyType=Point,ManagedPropertyType=Point,DefaultValue=Point (0\,0),ManagedFieldAccess=Internal,GenerateAccessors */
  46         const static int ControlPoint1Property;
  47         /* @PropertyType=Point,ManagedPropertyType=Point,DefaultValue=Point (1.0\, 1.0),ManagedFieldAccess=Internal,GenerateAccessors */
  48         const static int ControlPoint2Property;
  49
  50         Point *GetControlPoint1 ();
  51         void SetControlPoint1 (Point *controlPoint1);
  52
  53         Point *GetControlPoint2 ();
  54         void SetControlPoint2 (Point *controlPoint2);
  55
  56 protected:
  57         virtual ~KeySpline ();
  58
  59
  60 private:
  61         moon_quadratic *quadraticsArray;
  62 };
  63
  64 /* @Namespace=System.Windows.Media.Animation */
  65 /* @IncludeInKinds */
  66 struct KeyTime {
  67         enum KeyTimeType {
  68                 UNIFORM,
  69                 PERCENT,
  70                 TIMESPAN,
  71                 PACED
  72         };
  73
  74         KeyTime (const KeyTime &keytime)
  75         {
  76                 k = keytime.k;
  77                 percent = keytime.percent;
  78                 timespan = keytime.timespan;
  79         }
  80
  81         KeyTime (double percent)
  82           : k (PERCENT),
  83             percent (percent),
  84             timespan (0) { }
  85
  86         KeyTime (TimeSpan timeSpan)
  87           : k (TIMESPAN),
  88             timespan (timeSpan) { }
  89
  90
  91         KeyTime (KeyTimeType kind) : k(kind) { }
  92
  93         static KeyTime FromPercent (double percent) { return KeyTime (percent); }
  94         static KeyTime FromTimeSpan (TimeSpan timeSpan) { return KeyTime (timeSpan); }
  95
  96         static KeyTime Paced;
  97         static KeyTime Uniform;
  98
  99         bool operator!= (const KeyTime &v) const
 100         {
 101                 return !(*this == v);
 102         }
 103
 104         bool operator== (const KeyTime &v) const
 105         {
 106                 if (v.k != k)
 107                         return false;
 108
 109                 switch (k) {
 110                 case PERCENT: return percent == v.percent;
 111                 case TIMESPAN: return timespan == v.timespan;
 112                 default: return true;
 113                 }
 114         }
 115
 116         bool HasPercent () { return k == PERCENT; }
 117         double GetPercent () { return percent; }
 118
 119         bool HasTimeSpan () { return k == TIMESPAN; }
 120         TimeSpan GetTimeSpan () { return timespan; }
 121
 122 private:
 123         KeyTimeType k;
 124         gint32 padding;
 125         double percent;
 126         TimeSpan timespan;
 127 };
 128
 129
 130 //
 131 // Animations (more specialized clocks and timelines) and their subclasses
 132 //
 133 class AnimationClock;
 134
 135
 136 /* @Namespace=None */
 137 class Animation : public Timeline {
 138 public:
 139
 140         Animation () { };
 141
 142         virtual Clock *AllocateClock ();
 143
 144         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 145                                         AnimationClock* animationClock);
 146         virtual Value *GetTargetValue (Value *defaultOriginValue);
 147
 148         virtual Duration GetNaturalDurationCore (Clock* clock);
 149
 150
 151         virtual bool Resolve (DependencyObject *target, DependencyProperty *property) { return true; };
 152
 153         /* The kind of values this animation generates */
 154         virtual Type::Kind GetValueKind () { return Type::INVALID; };
 155
 156 protected:
 157         virtual ~Animation () {}
 158 };
 159
 160 /* @Namespace=System.Windows.Media.Animation */
 161 class DoubleAnimation : public Animation {
 162 public:
 163         /* @PropertyType=double,Nullable,GenerateAccessors */
 164         const static int ByProperty;
 165         /* @PropertyType=double,Nullable,GenerateAccessors */
 166         const static int FromProperty;
 167         /* @PropertyType=double,Nullable,GenerateAccessors */
 168         const static int ToProperty;
 169         /* @PropertyType=EasingFunctionBase,ManagedPropertyType=IEasingFunction,GenerateAccessors */
 170         const static int EasingFunctionProperty;
 171
 172         /* @GenerateCBinding,GeneratePInvoke */
 173         DoubleAnimation ();
 174
 175         virtual Type::Kind GetValueKind () { return Type::DOUBLE; };
 176
 177         virtual void OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error);
 178
 179         virtual Value *GetTargetValue (Value *defaultOriginValue);
 180         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 181                                         AnimationClock *animationClock);
 182
 183         //
 184         // Property Accessors
 185         //
 186         double *GetBy ();
 187         void    SetBy (double *pv);
 188         void    SetBy (double v);
 189
 190         double *GetFrom ();
 191         void    SetFrom (double *pv);
 192         void    SetFrom (double v);
 193
 194         double *GetTo ();
 195         void    SetTo (double *pv);
 196         void    SetTo (double v);
 197
 198         EasingFunctionBase* GetEasingFunction ();
 199         void SetEasingFunction (EasingFunctionBase* value);
 200
 201 protected:
 202         virtual ~DoubleAnimation () {}
 203
 204 private:
 205         double *doubleToCached;
 206         double *doubleFromCached;
 207         double *doubleByCached;
 208         bool hasCached;
 209
 210         void EnsureCache (void);
 211
 212 };
 213
 214
 215 /* @Namespace=System.Windows.Media.Animation */
 216 class ColorAnimation : public Animation {
 217  public:
 218         /* @PropertyType=Color,Nullable,GenerateAccessors */
 219         const static int ByProperty;
 220         /* @PropertyType=Color,Nullable,GenerateAccessors */
 221         const static int FromProperty;
 222         /* @PropertyType=Color,Nullable,GenerateAccessors */
 223         const static int ToProperty;
 224         /* @PropertyType=EasingFunctionBase,ManagedPropertyType=IEasingFunction,GenerateAccessors */
 225         const static int EasingFunctionProperty;
 226
 227         /* @GenerateCBinding,GeneratePInvoke */
 228         ColorAnimation ();
 229
 230         virtual Type::Kind GetValueKind () { return Type::COLOR; };
 231
 232         virtual void OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error);
 233
 234         virtual Value *GetTargetValue (Value *defaultOriginValue);
 235         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 236                                         AnimationClock *animationClock);
 237
 238         //
 239         // Property Accessors
 240         //
 241         Color *GetBy ();
 242         void   SetBy (Color *pv);
 243         void   SetBy (Color v);
 244
 245         Color *GetFrom ();
 246         void   SetFrom (Color *pv);
 247         void   SetFrom (Color v);
 248
 249         Color *GetTo ();
 250         void   SetTo (Color *pv);
 251         void   SetTo (Color v);
 252
 253         EasingFunctionBase* GetEasingFunction ();
 254         void SetEasingFunction (EasingFunctionBase* value);
 255
 256 protected:
 257         virtual ~ColorAnimation () {}
 258
 259 private:
 260         Color *colorToCached;
 261         Color *colorFromCached;
 262         Color *colorByCached;
 263         bool hasCached;
 264
 265         void EnsureCache (void);
 266 };
 267
 268
 269 /* @Namespace=System.Windows.Media.Animation */
 270 class PointAnimation : public Animation {
 271 public:
 272         /* @PropertyType=Point,Nullable,GenerateAccessors */
 273         const static int ByProperty;
 274         /* @PropertyType=Point,Nullable,GenerateAccessors */
 275         const static int FromProperty;
 276         /* @PropertyType=Point,Nullable,GenerateAccessors */
 277         const static int ToProperty;
 278         /* @PropertyType=EasingFunctionBase,ManagedPropertyType=IEasingFunction,GenerateAccessors */
 279         const static int EasingFunctionProperty;
 280
 281         /* @GenerateCBinding,GeneratePInvoke */
 282         PointAnimation ();
 283
 284         virtual Type::Kind GetValueKind () { return Type::POINT; };
 285
 286         virtual void OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error);
 287
 288         virtual Value *GetTargetValue (Value *defaultOriginValue);
 289         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 290                                         AnimationClock *animationClock);
 291
 292         //
 293         // Property Accessors
 294         //
 295         Point *GetBy ();
 296         void   SetBy (Point *pv);
 297         void   SetBy (Point v);
 298
 299         Point *GetFrom ();
 300         void   SetFrom (Point *pv);
 301         void   SetFrom (Point v);
 302
 303         Point *GetTo ();
 304         void   SetTo (Point *pv);
 305         void   SetTo (Point v);
 306
 307         EasingFunctionBase* GetEasingFunction ();
 308         void SetEasingFunction (EasingFunctionBase* value);
 309
 310 protected:
 311         virtual ~PointAnimation ();
 312
 313 private:
 314         Point *pointToCached;
 315         Point *pointFromCached;
 316         Point *pointByCached;
 317         bool hasCached;
 318
 319         void EnsureCache (void);
 320
 321 };
 322
 323
 324 /* @Namespace=None,ManagedDependencyProperties=None */
 325 class KeyFrame : public DependencyObject {
 326 public:
 327         TimeSpan resolved_keytime;
 328         bool resolved;
 329
 330         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 331
 332         //
 333         // Property Accessors
 334         //
 335         virtual KeyTime *GetKeyTime () = 0;
 336         virtual void SetKeyTime (KeyTime keytime) = 0;
 337         virtual void SetKeyTime (KeyTime *keytime) = 0;
 338
 339 protected:
 340         virtual ~KeyFrame ();
 341         KeyFrame ();
 342 };
 343
 344 /* @Namespace=None */
 345 class KeyFrameCollection : public DependencyObjectCollection {
 346 public:
 347         GPtrArray *sorted_list;
 348         bool resolved;
 349
 350         /* @GenerateCBinding,GeneratePInvoke */
 351         KeyFrameCollection ();
 352
 353         virtual Type::Kind GetElementType() { return Type::KEYFRAME; }
 354
 355         virtual bool Clear ();
 356
 357         KeyFrame *GetKeyFrameForTime (TimeSpan t, KeyFrame **previous_frame);
 358
 359         virtual void OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args);
 360
 361 protected:
 362         virtual bool AddedToCollection (Value *value, MoonError *error);
 363         virtual void RemovedFromCollection (Value *value);
 364
 365         virtual ~KeyFrameCollection ();
 366 };
 367
 368 /* @Namespace=System.Windows.Media.Animation */
 369 class ColorKeyFrameCollection : public KeyFrameCollection {
 370 public:
 371         /* @GenerateCBinding,GeneratePInvoke */
 372         ColorKeyFrameCollection ();
 373
 374         virtual Type::Kind GetElementType() { return Type::COLORKEYFRAME; }
 375
 376 protected:
 377         virtual ~ColorKeyFrameCollection ();
 378 };
 379
 380 /* @Namespace=System.Windows.Media.Animation */
 381 class DoubleKeyFrameCollection : public KeyFrameCollection {
 382 public:
 383         /* @GenerateCBinding,GeneratePInvoke */
 384         DoubleKeyFrameCollection ();
 385
 386         virtual Type::Kind GetElementType() { return Type::DOUBLEKEYFRAME; }
 387
 388 protected:
 389         virtual ~DoubleKeyFrameCollection ();
 390 };
 391
 392 /* @Namespace=System.Windows.Media.Animation */
 393 class PointKeyFrameCollection : public KeyFrameCollection {
 394 public:
 395         /* @GenerateCBinding,GeneratePInvoke */
 396         PointKeyFrameCollection ();
 397
 398         virtual Type::Kind GetElementType() { return Type::POINTKEYFRAME; }
 399
 400 protected:
 401         virtual ~PointKeyFrameCollection ();
 402 };
 403
 404 /* @Version=2,Namespace=System.Windows.Media.Animation */
 405 class ObjectKeyFrameCollection : public KeyFrameCollection {
 406 public:
 407         /* @GenerateCBinding,GeneratePInvoke */
 408         ObjectKeyFrameCollection ();
 409
 410         virtual Type::Kind GetElementType() { return Type::OBJECTKEYFRAME; }
 411
 412 protected:
 413         virtual ~ObjectKeyFrameCollection ();
 414 };
 415
 416 /* @Namespace=System.Windows.Media.Animation */
 417 class DoubleKeyFrame : public KeyFrame {
 418 public:
 419         /* @PropertyType=double,Nullable,ManagedPropertyType=double,GenerateAccessors */
 420         const static int ValueProperty;
 421         /* @PropertyType=KeyTime,Nullable,ManagedPropertyType=KeyTime,GenerateAccessors */
 422         const static int KeyTimeProperty;
 423
 424         /* @GenerateCBinding,GeneratePInvoke,ManagedAccess=Protected */
 425         DoubleKeyFrame ();
 426
 427         //
 428         // Property Accessors
 429         //
 430         double *GetValue ();
 431         void    SetValue (double *pv);
 432         void    SetValue (double v);
 433
 434         virtual KeyTime *GetKeyTime ();
 435         virtual void SetKeyTime (KeyTime keytime);
 436         virtual void SetKeyTime (KeyTime *keytime);
 437
 438 protected:
 439         virtual ~DoubleKeyFrame ();
 440 };
 441
 442 /* @Namespace=System.Windows.Media.Animation */
 443 class ColorKeyFrame : public KeyFrame {
 444 public:
 445         /* @PropertyType=Color,Nullable,ManagedPropertyType=Color,GenerateAccessors */
 446         const static int ValueProperty;
 447         /* @PropertyType=KeyTime,Nullable,ManagedPropertyType=KeyTime,GenerateAccessors */
 448         const static int KeyTimeProperty;
 449
 450         /* @GenerateCBinding,GeneratePInvoke,ManagedAccess=Protected */
 451         ColorKeyFrame ();
 452
 453         //
 454         // Property Accessors
 455         //
 456         Color *GetValue ();
 457         void   SetValue (Color *pv);
 458         void   SetValue (Color v);
 459
 460         virtual KeyTime *GetKeyTime ();
 461         virtual void SetKeyTime (KeyTime keytime);
 462         virtual void SetKeyTime (KeyTime *keytime);
 463
 464 protected:
 465         virtual ~ColorKeyFrame ();
 466 };
 467
 468 /* @Version=2,Namespace=System.Windows.Media.Animation */
 469 class ObjectKeyFrame : public KeyFrame /* The managed class derives directly from DependencyObject */ {
 470 public:
 471         /* @GenerateCBinding,GeneratePInvoke,ManagedAccess=Protected */
 472         ObjectKeyFrame ();
 473
 474         /* @PropertyType=object,GenerateAccessors,GenerateManagedAccessors=false,ManagedFieldAccess=Internal */
 475         const static int ConvertedValueProperty;
 476         /* @PropertyType=object,ManagedPropertyType=object */
 477         const static int ValueProperty;
 478         /* @PropertyType=KeyTime,Nullable,ManagedPropertyType=KeyTime,GenerateAccessors */
 479         const static int KeyTimeProperty;
 480
 481         Value *GetConvertedValue ();
 482         void SetConvertedValue (Value *value);
 483         Value *GetValue ();
 484
 485         virtual KeyTime *GetKeyTime ();
 486         virtual void SetKeyTime (KeyTime keytime);
 487         virtual void SetKeyTime (KeyTime *keytime);
 488
 489 protected:
 490         virtual ~ObjectKeyFrame ();
 491 };
 492
 493 /* @Namespace=System.Windows.Media.Animation */
 494 class PointKeyFrame : public KeyFrame {
 495 public:
 496         /* @PropertyType=Point,Nullable,ManagedPropertyType=Point,GenerateAccessors */
 497         const static int ValueProperty;
 498         /* @PropertyType=KeyTime,Nullable,ManagedPropertyType=KeyTime,GenerateAccessors */
 499         const static int KeyTimeProperty;
 500
 501         /* @GenerateCBinding,GeneratePInvoke,ManagedAccess=Protected */
 502         PointKeyFrame ();
 503
 504         //
 505         // Property Accessors
 506         //
 507         Point *GetValue ();
 508         void   SetValue (Point *pv);
 509         void   SetValue (Point v);
 510
 511         virtual KeyTime *GetKeyTime ();
 512         virtual void SetKeyTime (KeyTime keytime);
 513         virtual void SetKeyTime (KeyTime *keytime);
 514
 515 protected:
 516         virtual ~PointKeyFrame ();
 517 };
 518
 519
 520
 521 /* @Namespace=System.Windows.Media.Animation */
 522 class DiscreteDoubleKeyFrame : public DoubleKeyFrame {
 523 public:
 524         /* @GenerateCBinding,GeneratePInvoke */
 525         DiscreteDoubleKeyFrame ();
 526
 527         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 528
 529 protected:
 530         virtual ~DiscreteDoubleKeyFrame ();
 531 };
 532
 533
 534
 535
 536 /* @Namespace=System.Windows.Media.Animation */
 537 class DiscreteColorKeyFrame : public ColorKeyFrame {
 538 public:
 539         /* @GenerateCBinding,GeneratePInvoke */
 540         DiscreteColorKeyFrame ();
 541
 542         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 543
 544 protected:
 545         virtual ~DiscreteColorKeyFrame ();
 546 };
 547
 548
 549 /* @Version=2,Namespace=System.Windows.Media.Animation */
 550 class DiscreteObjectKeyFrame : public ObjectKeyFrame {
 551 public:
 552         /* @GenerateCBinding,GeneratePInvoke */
 553         DiscreteObjectKeyFrame ();
 554
 555         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 556
 557 protected:
 558         virtual ~DiscreteObjectKeyFrame ();
 559 };
 560
 561 /* @Namespace=System.Windows.Media.Animation */
 562 class DiscretePointKeyFrame : public PointKeyFrame {
 563 public:
 564         /* @GenerateCBinding,GeneratePInvoke */
 565         DiscretePointKeyFrame ();
 566
 567         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 568
 569 protected:
 570         virtual ~DiscretePointKeyFrame ();
 571 };
 572
 573
 574 /* @Namespace=System.Windows.Media.Animation */
 575 class LinearDoubleKeyFrame : public DoubleKeyFrame {
 576 public:
 577         /* @GenerateCBinding,GeneratePInvoke */
 578         LinearDoubleKeyFrame ();
 579
 580         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 581
 582 protected:
 583         virtual ~LinearDoubleKeyFrame ();
 584 };
 585
 586
 587
 588 /* @Namespace=System.Windows.Media.Animation */
 589 class LinearColorKeyFrame : public ColorKeyFrame {
 590 public:
 591         /* @GenerateCBinding,GeneratePInvoke */
 592         LinearColorKeyFrame ();
 593
 594         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 595
 596 protected:
 597         virtual ~LinearColorKeyFrame ();
 598 };
 599
 600
 601
 602 /* @Namespace=System.Windows.Media.Animation */
 603 class LinearPointKeyFrame : public PointKeyFrame {
 604 public:
 605         /* @GenerateCBinding,GeneratePInvoke */
 606         LinearPointKeyFrame ();
 607
 608         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 609
 610 protected:
 611         virtual ~LinearPointKeyFrame ();
 612 };
 613
 614
 615
 616 /* @Namespace=System.Windows.Media.Animation */
 617 class SplineDoubleKeyFrame : public DoubleKeyFrame {
 618 public:
 619         /* @PropertyType=KeySpline,AutoCreateValue,GenerateAccessors */
 620         const static int KeySplineProperty;
 621
 622         /* @GenerateCBinding,GeneratePInvoke */
 623         SplineDoubleKeyFrame ();
 624
 625         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 626
 627         //
 628         // Property Accessors
 629         //
 630         KeySpline *GetKeySpline ();
 631         void SetKeySpline (KeySpline* value);
 632
 633 protected:
 634         virtual ~SplineDoubleKeyFrame ();
 635 };
 636
 637
 638
 639 /* @Namespace=System.Windows.Media.Animation */
 640 class SplineColorKeyFrame : public ColorKeyFrame {
 641 public:
 642         /* @PropertyType=KeySpline,AutoCreateValue,GenerateAccessors */
 643         const static int KeySplineProperty;
 644
 645         /* @GenerateCBinding,GeneratePInvoke */
 646         SplineColorKeyFrame ();
 647
 648         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 649
 650         //
 651         // Property Accessors
 652         //
 653         KeySpline *GetKeySpline ();
 654         void SetKeySpline (KeySpline* value);
 655
 656 protected:
 657         virtual ~SplineColorKeyFrame ();
 658 };
 659
 660
 661
 662 /* @Namespace=System.Windows.Media.Animation */
 663 class SplinePointKeyFrame : public PointKeyFrame {
 664 public:
 665         /* @PropertyType=KeySpline,AutoCreateValue,GenerateAccessors */
 666         const static int KeySplineProperty;
 667
 668         /* @GenerateCBinding,GeneratePInvoke */
 669         SplinePointKeyFrame ();
 670
 671         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 672
 673         //
 674         // Property Accessors
 675         //
 676         KeySpline *GetKeySpline ();
 677         void SetKeySpline (KeySpline* value);
 678
 679 protected:
 680         virtual ~SplinePointKeyFrame ();
 681 };
 682
 683 /* @Namespace=System.Windows.Media.Animation */
 684 class EasingColorKeyFrame : public ColorKeyFrame {
 685 public:
 686         /* @PropertyType=EasingFunctionBase,ManagedPropertyType=IEasingFunction,GenerateAccessors */
 687         const static int EasingFunctionProperty;
 688
 689         /* @GenerateCBinding,GeneratePInvoke */
 690         EasingColorKeyFrame ();
 691
 692         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 693
 694         //
 695         // Property Accessors
 696         //
 697         EasingFunctionBase *GetEasingFunction ();
 698         void SetEasingFunction (EasingFunctionBase* value);
 699
 700 protected:
 701         virtual ~EasingColorKeyFrame ();
 702 };
 703
 704 /* @Namespace=System.Windows.Media.Animation */
 705 class EasingDoubleKeyFrame : public DoubleKeyFrame {
 706 public:
 707         /* @PropertyType=EasingFunctionBase,ManagedPropertyType=IEasingFunction,GenerateAccessors */
 708         const static int EasingFunctionProperty;
 709
 710         /* @GenerateCBinding,GeneratePInvoke */
 711         EasingDoubleKeyFrame ();
 712
 713         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 714
 715         //
 716         // Property Accessors
 717         //
 718         EasingFunctionBase *GetEasingFunction ();
 719         void SetEasingFunction (EasingFunctionBase* value);
 720
 721 protected:
 722         virtual ~EasingDoubleKeyFrame ();
 723 };
 724
 725 /* @Namespace=System.Windows.Media.Animation */
 726 class EasingPointKeyFrame : public PointKeyFrame {
 727 public:
 728         /* @PropertyType=EasingFunctionBase,ManagedPropertyType=IEasingFunction,GenerateAccessors */
 729         const static int EasingFunctionProperty;
 730
 731         /* @GenerateCBinding,GeneratePInvoke */
 732         EasingPointKeyFrame ();
 733
 734         virtual Value *InterpolateValue (Value *baseValue, double keyFrameProgress);
 735
 736         //
 737         // Property Accessors
 738         //
 739         EasingFunctionBase *GetEasingFunction ();
 740         void SetEasingFunction (EasingFunctionBase* value);
 741
 742 protected:
 743         virtual ~EasingPointKeyFrame ();
 744 };
 745
 746 /* @Namespace=System.Windows.Media.Animation */
 747 /* @ContentProperty="KeyFrames" */
 748 class DoubleAnimationUsingKeyFrames : public DoubleAnimation {
 749 public:
 750         /* @PropertyType=DoubleKeyFrameCollection,AutoCreateValue,ManagedFieldAccess=Internal,ManagedSetterAccess=Internal,GenerateAccessors */
 751         const static int KeyFramesProperty;
 752
 753         /* @GenerateCBinding,GeneratePInvoke */
 754         DoubleAnimationUsingKeyFrames ();
 755
 756         void AddKeyFrame (DoubleKeyFrame *frame);
 757         void RemoveKeyFrame (DoubleKeyFrame *frame);
 758
 759         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 760                                         AnimationClock *animationClock);
 761         virtual bool Resolve (DependencyObject *target, DependencyProperty *property);
 762
 763         virtual Duration GetNaturalDurationCore (Clock* clock);
 764
 765         virtual bool Validate ();
 766
 767         //
 768         // Property Accessors
 769         //
 770         DoubleKeyFrameCollection *GetKeyFrames ();
 771         void SetKeyFrames (DoubleKeyFrameCollection* value);
 772
 773 protected:
 774         virtual ~DoubleAnimationUsingKeyFrames ();
 775 };
 776
 777 /* @Namespace=System.Windows.Media.Animation */
 778 /* @ContentProperty="KeyFrames" */
 779 class ColorAnimationUsingKeyFrames : public ColorAnimation {
 780 public:
 781         /* @PropertyType=ColorKeyFrameCollection,AutoCreateValue,ManagedFieldAccess=Internal,ManagedSetterAccess=Internal,GenerateAccessors */
 782         const static int KeyFramesProperty;
 783
 784         /* @GenerateCBinding,GeneratePInvoke */
 785         ColorAnimationUsingKeyFrames ();
 786
 787         void AddKeyFrame (ColorKeyFrame *frame);
 788         void RemoveKeyFrame (ColorKeyFrame *frame);
 789
 790         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 791                                         AnimationClock *animationClock);
 792         virtual bool Resolve (DependencyObject *target, DependencyProperty *property);
 793
 794         virtual Duration GetNaturalDurationCore (Clock* clock);
 795
 796         virtual bool Validate ();
 797
 798         //
 799         // Property Accessors
 800         //
 801         ColorKeyFrameCollection *GetKeyFrames ();
 802         void SetKeyFrames (ColorKeyFrameCollection* value);
 803
 804 protected:
 805         virtual ~ColorAnimationUsingKeyFrames ();
 806 };
 807
 808 /* @Version=2 */
 809 /* @Namespace=System.Windows.Media.Animation */
 810 /* @ContentProperty="KeyFrames" */
 811 class ObjectAnimationUsingKeyFrames : public /*Object*/Animation {
 812 public:
 813         /* @PropertyType=ObjectKeyFrameCollection,ManagedFieldAccess=Internal,ManagedSetterAccess=Internal,GenerateAccessors,AutoCreateValue */
 814         const static int KeyFramesProperty;
 815
 816         /* @GenerateCBinding,GeneratePInvoke */
 817         ObjectAnimationUsingKeyFrames ();
 818
 819         void AddKeyFrame (ObjectKeyFrame *frame);
 820         void RemoveKeyFrame (ObjectKeyFrame *frame);
 821
 822         // Property accessors
 823         ObjectKeyFrameCollection *GetKeyFrames ();
 824         void SetKeyFrames (ObjectKeyFrameCollection* value);
 825
 826         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 827                                         AnimationClock* animationClock);
 828
 829         virtual bool Resolve (DependencyObject *target, DependencyProperty *property);
 830
 831         virtual Duration GetNaturalDurationCore (Clock* clock);
 832         virtual bool Validate ();
 833
 834         virtual Type::Kind GetValueKind () { return Type::INVALID; };
 835
 836 protected:
 837         virtual ~ObjectAnimationUsingKeyFrames ();
 838 };
 839
 840 /* @Namespace=System.Windows.Media.Animation */
 841 /* @ContentProperty="KeyFrames" */
 842 class PointAnimationUsingKeyFrames : public PointAnimation {
 843 public:
 844         /* @PropertyType=PointKeyFrameCollection,AutoCreateValue,ManagedFieldAccess=Internal,ManagedSetterAccess=Internal,GenerateAccessors */
 845         const static int KeyFramesProperty;
 846
 847         /* @GenerateCBinding,GeneratePInvoke */
 848         PointAnimationUsingKeyFrames ();
 849
 850         void AddKeyFrame (PointKeyFrame *frame);
 851         void RemoveKeyFrame (PointKeyFrame *frame);
 852
 853         virtual Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue,
 854                                         AnimationClock *animationClock);
 855         virtual bool Resolve (DependencyObject *target, DependencyProperty *property);
 856
 857         virtual Duration GetNaturalDurationCore (Clock *clock);
 858
 859         virtual bool Validate ();
 860
 861         //
 862         // Property Accessors
 863         //
 864         PointKeyFrameCollection *GetKeyFrames ();
 865         void SetKeyFrames (PointKeyFrameCollection* value);
 866
 867 protected:
 868         virtual ~PointAnimationUsingKeyFrames ();
 869 };
 870
 871 /* @Namespace=System.Windows.Media.Animation */
 872 /* @ContentProperty="Children" */
 873 class Storyboard : public ParallelTimeline {
 874 public:
 875         /* @PropertyType=string,Attached,GenerateAccessors,Validator=IsTimelineValidator */
 876         const static int TargetNameProperty;
 877         /* @PropertyType=PropertyPath,Attached,GenerateAccessors,Validator=StoryboardTargetPropertyValidator */
 878         const static int TargetPropertyProperty;
 879
 880         /* @GenerateCBinding,GeneratePInvoke */
 881         Storyboard ();
 882
 883         /* @GenerateCBinding,GeneratePInvoke */
 884         bool BeginWithError (MoonError *error);
 885
 886         /* @GenerateCBinding,GeneratePInvoke */
 887         void PauseWithError (MoonError *error);
 888
 889         /* @GenerateCBinding,GeneratePInvoke */
 890         void ResumeWithError (MoonError *error);
 891
 892         /* @GenerateCBinding,GeneratePInvoke */
 893         void SeekWithError (TimeSpan timespan, MoonError *error);
 894
 895         /* @GenerateCBinding,GeneratePInvoke */
 896         void SeekAlignedToLastTickWithError (TimeSpan timespan, MoonError *error);
 897
 898         /* @GenerateCBinding,GeneratePInvoke */
 899         void SkipToFillWithError (MoonError *error);
 900
 901         /* @GenerateCBinding,GeneratePInvoke */
 902         void StopWithError (MoonError *error);
 903
 904         /* @GenerateCBinding,GeneratePInvoke */
 905         TimeSpan GetCurrentTime ();
 906
 907         /* @GenerateCBinding,GeneratePInvoke */
 908         int GetCurrentState ();
 909
 910         /* @GenerateCBinding,GeneratePInvoke */
 911         DependencyProperty *GetTargetDependencyProperty ();
 912
 913         static void SetTargetName (DependencyObject *o, const char *targetName);
 914         static const char *GetTargetName (DependencyObject *o);
 915         static void SetTargetProperty (DependencyObject *o, PropertyPath *targetProperty);
 916         static PropertyPath *GetTargetProperty (DependencyObject *o);
 917
 918 protected:
 919         virtual ~Storyboard ();
 920
 921 private:
 922         bool HookupAnimationsRecurse (Clock *clock,
 923                                       DependencyObject *targetObject, PropertyPath *targetPropertyPath,
 924                                       GHashTable *promoted_values,
 925                                       MoonError *error);
 926 };
 927
 928 /* @Namespace=System.Windows.Media.Animation */
 929 /* @ContentProperty="Storyboard" */
 930 class BeginStoryboard : public TriggerAction {
 931 public:
 932         /* @PropertyType=Storyboard,GenerateAccessors */
 933         const static int StoryboardProperty;
 934
 935         /* @GenerateCBinding,GeneratePInvoke */
 936         BeginStoryboard ();
 937
 938         virtual void Fire ();
 939
 940         //
 941         // Property Accessors
 942         //
 943         void SetStoryboard (Storyboard *sb);
 944         Storyboard *GetStoryboard ();
 945
 946 protected:
 947         virtual ~BeginStoryboard ();
 948 };
 949
 950 // internal WPF class gleaned from stack traces
 951 class AnimationStorage {
 952 public:
 953
 954         class Node : public List::Node {
 955         public:
 956                 AnimationStorage *storage;
 957                 DependencyProperty *key;
 958
 959                 Node (DependencyProperty *key, AnimationStorage *storage) {
 960                         this->key = key;
 961                         this->storage = storage;
 962                 }
 963
 964                 Node *Clone () {
 965                         return new Node (key, storage);
 966                 }
 967         };
 968
 969         AnimationStorage (AnimationClock *clock, Animation *timeline,
 970                           DependencyObject *targetobj, DependencyProperty *targetprop);
 971         ~AnimationStorage ();
 972
 973         void SwitchTarget (DependencyObject *target);
 974         void Enable ();
 975         void Disable ();
 976         void Stop ();
 977         bool IsCurrentStorage ();
 978
 979         Value* GetResetValue ();
 980         void SetStopValue (Value *value);
 981
 982         AnimationClock *GetClock ();
 983         Animation *GetTimeline ();
 984
 985 private:
 986
 987         void ResetPropertyValue ();
 988         void UpdatePropertyValue ();
 989         static void update_property_value (EventObject *sender, EventArgs *calldata, gpointer data);
 990
 991         void TargetObjectDestroyed ();
 992         static void target_object_destroyed (EventObject *sender, EventArgs *calldata, gpointer data);
 993
 994         void AttachUpdateHandler ();
 995         void DetachUpdateHandler ();
 996         void AttachTargetHandler ();
 997         void DetachTargetHandler ();
 998         void DetachFromProperty ();
 999
1000         AnimationClock *clock;
1001         Animation* timeline;
1002         DependencyObject *targetobj;
1003         DependencyProperty *targetprop;
1004         Value *baseValue;
1005         Value *stopValue;
1006         bool disabled;
1007 };
1008
1009 /* @Namespace=None,ManagedDependencyProperties=None */
1010 class AnimationClock : public Clock {
1011 public:
1012         AnimationClock (Animation *timeline);
1013
1014         Value *GetCurrentValue (Value *defaultOriginValue, Value *defaultDestinationValue);
1015
1016         AnimationStorage *HookupStorage (DependencyObject *targetobj, DependencyProperty *targetprop);
1017         void DetachStorage ();
1018
1019         virtual void Stop ();
1020         virtual void Begin (TimeSpan parentTime);
1021
1022 protected:
1023         virtual ~AnimationClock ();
1024
1025 private:
1026         Animation *timeline;
1027         AnimationStorage *storage;
1028 };
1029
1030 #endif /* MOON_ANIMATION_H */