src/cbinding.cpp

   1 /*
   2  * Automatically generated, do not edit this file directly
   3  */
   4
   5 #include <config.h>
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9
  10 #include "cbinding.h"
  11
  12 #include "animation.h"
  13 #include "application.h"
  14 #include "bitmapcache.h"
  15 #include "bitmapimage.h"
  16 #include "bitmapsource.h"
  17 #include "border.h"
  18 #include "brush.h"
  19 #include "canvas.h"
  20 #include "collection.h"
  21 #include "contentcontrol.h"
  22 #include "control.h"
  23 #include "deepzoomimagetilesource.h"
  24 #include "dependencyobject.h"
  25 #include "dependencyproperty.h"
  26 #include "deployment.h"
  27 #include "downloader.h"
  28 #include "easing.h"
  29 #include "effect.h"
  30 #include "eventargs.h"
  31 #include "frameworkelement.h"
  32 #include "geometry.h"
  33 #include "glyphs.h"
  34 #include "grid.h"
  35 #include "imagesource.h"
  36 #include "keyboard.h"
  37 #include "media.h"
  38 #include "mediaelement.h"
  39 #include "multiscaleimage.h"
  40 #include "multiscalesubimage.h"
  41 #include "namescope.h"
  42 #include "panel.h"
  43 #include "pipeline.h"
  44 #include "popup.h"
  45 #include "projection.h"
  46 #include "resources.h"
  47 #include "runtime.h"
  48 #include "shape.h"
  49 #include "size.h"
  50 #include "style.h"
  51 #include "stylus.h"
  52 #include "tabnavigationwalker.h"
  53 #include "template.h"
  54 #include "textblock.h"
  55 #include "textbox.h"
  56 #include "tilesource.h"
  57 #include "timeline.h"
  58 #include "timemanager.h"
  59 #include "transform.h"
  60 #include "trigger.h"
  61 #include "type.h"
  62 #include "uielement.h"
  63 #include "uri.h"
  64 #include "usercontrol.h"
  65 #include "window.h"
  66 #include "window-gtk.h"
  67 #include "writeablebitmap.h"
  68 #include "xaml.h"
  69 #include "xap.h"
  70 /**
  71  * Application
  72  **/
  73 Application *
  74 application_new (void)
  75 {
  76         return new Application ();
  77 }
  78
  79
  80 Application *
  81 application_get_current (void)
  82 {
  83         return Application::GetCurrent ();
  84 }
  85
  86
  87 void
  88 application_register_callbacks (Application *instance, ApplyDefaultStyleCallback apply_default_style_cb, ApplyStyleCallback apply_style_cb, GetResourceCallback get_resource_cb, ConvertKeyframeValueCallback convert_keyframe_callback)
  89 {
  90         if (instance == NULL)
  91                 return;
  92
  93         instance->RegisterCallbacks (apply_default_style_cb, apply_style_cb, get_resource_cb, convert_keyframe_callback);
  94 }
  95
  96
  97 void
  98 application_set_current (Application *current)
  99 {
 100         Application::SetCurrent (current);
 101 }
 102
 103
 104 /**
 105  * ArcSegment
 106  **/
 107 ArcSegment *
 108 arc_segment_new (void)
 109 {
 110         return new ArcSegment ();
 111 }
 112
 113
 114 /**
 115  * AssemblyPart
 116  **/
 117 AssemblyPart *
 118 assembly_part_new (void)
 119 {
 120         return new AssemblyPart ();
 121 }
 122
 123
 124 /**
 125  * AssemblyPartCollection
 126  **/
 127 AssemblyPartCollection *
 128 assembly_part_collection_new (void)
 129 {
 130         return new AssemblyPartCollection ();
 131 }
 132
 133
 134 /**
 135  * AudioStream
 136  **/
 137 AudioStream *
 138 audio_stream_new (Media *media, int codec_id, int bits_per_sample, int block_align, int sample_rate, int channels, int bit_rate, gpointer extra_data, guint32 extra_data_size)
 139 {
 140         return new AudioStream (media, codec_id, bits_per_sample, block_align, sample_rate, channels, bit_rate, extra_data, extra_data_size);
 141 }
 142
 143
 144 int
 145 audio_stream_get_bit_rate (AudioStream *instance)
 146 {
 147         if (instance == NULL)
 148                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 149                 return (int) 0;
 150
 151         return instance->GetBitRate ();
 152 }
 153
 154
 155 int
 156 audio_stream_get_bits_per_sample (AudioStream *instance)
 157 {
 158         if (instance == NULL)
 159                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 160                 return (int) 0;
 161
 162         return instance->GetBitsPerSample ();
 163 }
 164
 165
 166 int
 167 audio_stream_get_block_align (AudioStream *instance)
 168 {
 169         if (instance == NULL)
 170                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 171                 return (int) 0;
 172
 173         return instance->GetBlockAlign ();
 174 }
 175
 176
 177 int
 178 audio_stream_get_channels (AudioStream *instance)
 179 {
 180         if (instance == NULL)
 181                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 182                 return (int) 0;
 183
 184         return instance->GetChannels ();
 185 }
 186
 187
 188 int
 189 audio_stream_get_input_bit_rate (AudioStream *instance)
 190 {
 191         if (instance == NULL)
 192                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 193                 return (int) 0;
 194
 195         return instance->GetInputBitRate ();
 196 }
 197
 198
 199 int
 200 audio_stream_get_input_bits_per_sample (AudioStream *instance)
 201 {
 202         if (instance == NULL)
 203                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 204                 return (int) 0;
 205
 206         return instance->GetInputBitsPerSample ();
 207 }
 208
 209
 210 int
 211 audio_stream_get_input_block_align (AudioStream *instance)
 212 {
 213         if (instance == NULL)
 214                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 215                 return (int) 0;
 216
 217         return instance->GetInputBlockAlign ();
 218 }
 219
 220
 221 int
 222 audio_stream_get_input_channels (AudioStream *instance)
 223 {
 224         if (instance == NULL)
 225                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 226                 return (int) 0;
 227
 228         return instance->GetInputChannels ();
 229 }
 230
 231
 232 int
 233 audio_stream_get_input_sample_rate (AudioStream *instance)
 234 {
 235         if (instance == NULL)
 236                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 237                 return (int) 0;
 238
 239         return instance->GetInputSampleRate ();
 240 }
 241
 242
 243 int
 244 audio_stream_get_output_bit_rate (AudioStream *instance)
 245 {
 246         if (instance == NULL)
 247                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 248                 return (int) 0;
 249
 250         return instance->GetOutputBitRate ();
 251 }
 252
 253
 254 int
 255 audio_stream_get_output_bits_per_sample (AudioStream *instance)
 256 {
 257         if (instance == NULL)
 258                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 259                 return (int) 0;
 260
 261         return instance->GetOutputBitsPerSample ();
 262 }
 263
 264
 265 int
 266 audio_stream_get_output_block_align (AudioStream *instance)
 267 {
 268         if (instance == NULL)
 269                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 270                 return (int) 0;
 271
 272         return instance->GetOutputBlockAlign ();
 273 }
 274
 275
 276 int
 277 audio_stream_get_output_channels (AudioStream *instance)
 278 {
 279         if (instance == NULL)
 280                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 281                 return (int) 0;
 282
 283         return instance->GetOutputChannels ();
 284 }
 285
 286
 287 int
 288 audio_stream_get_output_sample_rate (AudioStream *instance)
 289 {
 290         if (instance == NULL)
 291                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 292                 return (int) 0;
 293
 294         return instance->GetOutputSampleRate ();
 295 }
 296
 297
 298 int
 299 audio_stream_get_sample_rate (AudioStream *instance)
 300 {
 301         if (instance == NULL)
 302                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 303                 return (int) 0;
 304
 305         return instance->GetSampleRate ();
 306 }
 307
 308
 309 void
 310 audio_stream_set_bit_rate (AudioStream *instance, int value)
 311 {
 312         if (instance == NULL)
 313                 return;
 314
 315         instance->SetBitRate (value);
 316 }
 317
 318
 319 void
 320 audio_stream_set_bits_per_sample (AudioStream *instance, int value)
 321 {
 322         if (instance == NULL)
 323                 return;
 324
 325         instance->SetBitsPerSample (value);
 326 }
 327
 328
 329 void
 330 audio_stream_set_block_align (AudioStream *instance, int value)
 331 {
 332         if (instance == NULL)
 333                 return;
 334
 335         instance->SetBlockAlign (value);
 336 }
 337
 338
 339 void
 340 audio_stream_set_channels (AudioStream *instance, int value)
 341 {
 342         if (instance == NULL)
 343                 return;
 344
 345         instance->SetChannels (value);
 346 }
 347
 348
 349 void
 350 audio_stream_set_input_bit_rate (AudioStream *instance, int value)
 351 {
 352         if (instance == NULL)
 353                 return;
 354
 355         instance->SetInputBitRate (value);
 356 }
 357
 358
 359 void
 360 audio_stream_set_input_bits_per_sample (AudioStream *instance, int value)
 361 {
 362         if (instance == NULL)
 363                 return;
 364
 365         instance->SetInputBitsPerSample (value);
 366 }
 367
 368
 369 void
 370 audio_stream_set_input_block_align (AudioStream *instance, int value)
 371 {
 372         if (instance == NULL)
 373                 return;
 374
 375         instance->SetInputBlockAlign (value);
 376 }
 377
 378
 379 void
 380 audio_stream_set_input_channels (AudioStream *instance, int value)
 381 {
 382         if (instance == NULL)
 383                 return;
 384
 385         instance->SetInputChannels (value);
 386 }
 387
 388
 389 void
 390 audio_stream_set_input_sample_rate (AudioStream *instance, int value)
 391 {
 392         if (instance == NULL)
 393                 return;
 394
 395         instance->SetInputSampleRate (value);
 396 }
 397
 398
 399 void
 400 audio_stream_set_output_bit_rate (AudioStream *instance, int value)
 401 {
 402         if (instance == NULL)
 403                 return;
 404
 405         instance->SetOutputBitRate (value);
 406 }
 407
 408
 409 void
 410 audio_stream_set_output_bits_per_sample (AudioStream *instance, int value)
 411 {
 412         if (instance == NULL)
 413                 return;
 414
 415         instance->SetOutputBitsPerSample (value);
 416 }
 417
 418
 419 void
 420 audio_stream_set_output_block_align (AudioStream *instance, int value)
 421 {
 422         if (instance == NULL)
 423                 return;
 424
 425         instance->SetOutputBlockAlign (value);
 426 }
 427
 428
 429 void
 430 audio_stream_set_output_channels (AudioStream *instance, int value)
 431 {
 432         if (instance == NULL)
 433                 return;
 434
 435         instance->SetOutputChannels (value);
 436 }
 437
 438
 439 void
 440 audio_stream_set_output_sample_rate (AudioStream *instance, int value)
 441 {
 442         if (instance == NULL)
 443                 return;
 444
 445         instance->SetOutputSampleRate (value);
 446 }
 447
 448
 449 void
 450 audio_stream_set_sample_rate (AudioStream *instance, int value)
 451 {
 452         if (instance == NULL)
 453                 return;
 454
 455         instance->SetSampleRate (value);
 456 }
 457
 458
 459 /**
 460  * BackEase
 461  **/
 462 BackEase *
 463 back_ease_new (void)
 464 {
 465         return new BackEase ();
 466 }
 467
 468
 469 double
 470 back_ease_ease_in_core (BackEase *instance, double normalizedTime)
 471 {
 472         if (instance == NULL)
 473                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 474                 return (double) 0;
 475
 476         return instance->EaseInCore (normalizedTime);
 477 }
 478
 479
 480 /**
 481  * BeginStoryboard
 482  **/
 483 BeginStoryboard *
 484 begin_storyboard_new (void)
 485 {
 486         return new BeginStoryboard ();
 487 }
 488
 489
 490 /**
 491  * BezierSegment
 492  **/
 493 BezierSegment *
 494 bezier_segment_new (void)
 495 {
 496         return new BezierSegment ();
 497 }
 498
 499
 500 /**
 501  * BitmapCache
 502  **/
 503 BitmapCache *
 504 bitmap_cache_new (void)
 505 {
 506         return new BitmapCache ();
 507 }
 508
 509
 510 /**
 511  * BitmapImage
 512  **/
 513 BitmapImage *
 514 bitmap_image_new (void)
 515 {
 516         return new BitmapImage ();
 517 }
 518
 519
 520 void
 521 bitmap_image_pixbuf_write (BitmapImage *instance, gpointer buffer, gint32 offset, gint32 n)
 522 {
 523         if (instance == NULL)
 524                 return;
 525
 526         instance->PixbufWrite (buffer, offset, n);
 527 }
 528
 529
 530 void
 531 bitmap_image_pixmap_complete (BitmapImage *instance)
 532 {
 533         if (instance == NULL)
 534                 return;
 535
 536         instance->PixmapComplete ();
 537 }
 538
 539
 540 /**
 541  * BitmapSource
 542  **/
 543 BitmapSource *
 544 bitmap_source_new (void)
 545 {
 546         return new BitmapSource ();
 547 }
 548
 549
 550 gpointer
 551 bitmap_source_get_bitmap_data (BitmapSource *instance)
 552 {
 553         if (instance == NULL)
 554                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 555                 return (gpointer) 0;
 556
 557         return instance->GetBitmapData ();
 558 }
 559
 560
 561 void
 562 bitmap_source_invalidate (BitmapSource *instance)
 563 {
 564         if (instance == NULL)
 565                 return;
 566
 567         instance->Invalidate ();
 568 }
 569
 570
 571 void
 572 bitmap_source_set_bitmap_data (BitmapSource *instance, gpointer data, bool own)
 573 {
 574         if (instance == NULL)
 575                 return;
 576
 577         instance->SetBitmapData (data, own);
 578 }
 579
 580
 581 /**
 582  * BlurEffect
 583  **/
 584 BlurEffect *
 585 blur_effect_new (void)
 586 {
 587         return new BlurEffect ();
 588 }
 589
 590
 591 /**
 592  * Border
 593  **/
 594 Border *
 595 border_new (void)
 596 {
 597         return new Border ();
 598 }
 599
 600
 601 /**
 602  * BounceEase
 603  **/
 604 BounceEase *
 605 bounce_ease_new (void)
 606 {
 607         return new BounceEase ();
 608 }
 609
 610
 611 double
 612 bounce_ease_ease_in_core (BounceEase *instance, double normalizedTime)
 613 {
 614         if (instance == NULL)
 615                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 616                 return (double) 0;
 617
 618         return instance->EaseInCore (normalizedTime);
 619 }
 620
 621
 622 /**
 623  * Brush
 624  **/
 625 Brush *
 626 brush_new (void)
 627 {
 628         return new Brush ();
 629 }
 630
 631
 632 /**
 633  * CacheMode
 634  **/
 635 CacheMode *
 636 cache_mode_new (void)
 637 {
 638         return new CacheMode ();
 639 }
 640
 641
 642 /**
 643  * Canvas
 644  **/
 645 Canvas *
 646 canvas_new (void)
 647 {
 648         return new Canvas ();
 649 }
 650
 651
 652 /**
 653  * CircleEase
 654  **/
 655 CircleEase *
 656 circle_ease_new (void)
 657 {
 658         return new CircleEase ();
 659 }
 660
 661
 662 double
 663 circle_ease_ease_in_core (CircleEase *instance, double normalizedTime)
 664 {
 665         if (instance == NULL)
 666                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 667                 return (double) 0;
 668
 669         return instance->EaseInCore (normalizedTime);
 670 }
 671
 672
 673 /**
 674  * Collection
 675  **/
 676 int
 677 collection_add_with_error (Collection *instance, Value *value, MoonError *error)
 678 {
 679         if (instance == NULL)
 680                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 681                 return (int) 0;
 682
 683         if (error == NULL)
 684                 g_warning ("Moonlight: Called collection_add_with_error () with error == NULL.");
 685         return instance->AddWithError (value, error);
 686 }
 687
 688
 689 bool
 690 collection_clear (Collection *instance)
 691 {
 692         if (instance == NULL)
 693                 return false;
 694
 695         return instance->Clear ();
 696 }
 697
 698
 699 bool
 700 collection_contains (Collection *instance, Value *value)
 701 {
 702         if (instance == NULL)
 703                 return false;
 704
 705         return instance->Contains (value);
 706 }
 707
 708
 709 int
 710 collection_get_count (Collection *instance)
 711 {
 712         if (instance == NULL)
 713                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 714                 return (int) 0;
 715
 716         return instance->GetCount ();
 717 }
 718
 719
 720 int
 721 collection_get_element_type (Collection *instance)
 722 {
 723         if (instance == NULL)
 724                 return Type::INVALID;
 725
 726         return instance->GetElementType ();
 727 }
 728
 729
 730 CollectionIterator *
 731 collection_get_iterator (Collection *instance)
 732 {
 733         if (instance == NULL)
 734                 return NULL;
 735
 736         return instance->GetIterator ();
 737 }
 738
 739
 740 Value *
 741 collection_get_value_at_with_error (Collection *instance, int index, MoonError *error)
 742 {
 743         if (instance == NULL)
 744                 return NULL;
 745
 746         if (error == NULL)
 747                 g_warning ("Moonlight: Called collection_get_value_at_with_error () with error == NULL.");
 748         return instance->GetValueAtWithError (index, error);
 749 }
 750
 751
 752 int
 753 collection_index_of (Collection *instance, Value *value)
 754 {
 755         if (instance == NULL)
 756                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 757                 return (int) 0;
 758
 759         return instance->IndexOf (value);
 760 }
 761
 762
 763 bool
 764 collection_insert_with_error (Collection *instance, int index, Value *value, MoonError *error)
 765 {
 766         if (instance == NULL)
 767                 return false;
 768
 769         if (error == NULL)
 770                 g_warning ("Moonlight: Called collection_insert_with_error () with error == NULL.");
 771         return instance->InsertWithError (index, value, error);
 772 }
 773
 774
 775 bool
 776 collection_remove (Collection *instance, Value *value)
 777 {
 778         if (instance == NULL)
 779                 return false;
 780
 781         return instance->Remove (value);
 782 }
 783
 784
 785 bool
 786 collection_remove_at_with_error (Collection *instance, int index, MoonError *error)
 787 {
 788         if (instance == NULL)
 789                 return false;
 790
 791         if (error == NULL)
 792                 g_warning ("Moonlight: Called collection_remove_at_with_error () with error == NULL.");
 793         return instance->RemoveAtWithError (index, error);
 794 }
 795
 796
 797 bool
 798 collection_set_value_at_with_error (Collection *instance, int index, Value *value, MoonError *error)
 799 {
 800         if (instance == NULL)
 801                 return false;
 802
 803         if (error == NULL)
 804                 g_warning ("Moonlight: Called collection_set_value_at_with_error () with error == NULL.");
 805         return instance->SetValueAtWithError (index, value, error);
 806 }
 807
 808
 809 /**
 810  * CollectionChangedEventArgs
 811  **/
 812 CollectionChangedEventArgs *
 813 collection_changed_event_args_new (void)
 814 {
 815         return new CollectionChangedEventArgs ();
 816 }
 817
 818
 819 int
 820 collection_changed_event_args_get_changed_action (CollectionChangedEventArgs *instance)
 821 {
 822         if (instance == NULL)
 823                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 824                 return (CollectionChangedAction) 0;
 825
 826         return instance->GetChangedAction ();
 827 }
 828
 829
 830 int
 831 collection_changed_event_args_get_index (CollectionChangedEventArgs *instance)
 832 {
 833         if (instance == NULL)
 834                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
 835                 return (int) 0;
 836
 837         return instance->GetIndex ();
 838 }
 839
 840
 841 Value *
 842 collection_changed_event_args_get_new_item (CollectionChangedEventArgs *instance)
 843 {
 844         if (instance == NULL)
 845                 return NULL;
 846
 847         return instance->GetNewItem ();
 848 }
 849
 850
 851 Value *
 852 collection_changed_event_args_get_old_item (CollectionChangedEventArgs *instance)
 853 {
 854         if (instance == NULL)
 855                 return NULL;
 856
 857         return instance->GetOldItem ();
 858 }
 859
 860
 861 void
 862 collection_changed_event_args_set_changed_action (CollectionChangedEventArgs *instance, int action)
 863 {
 864         if (instance == NULL)
 865                 return;
 866
 867         instance->SetChangedAction ((CollectionChangedAction) action);
 868 }
 869
 870
 871 void
 872 collection_changed_event_args_set_index (CollectionChangedEventArgs *instance, int index)
 873 {
 874         if (instance == NULL)
 875                 return;
 876
 877         instance->SetIndex (index);
 878 }
 879
 880
 881 void
 882 collection_changed_event_args_set_new_item (CollectionChangedEventArgs *instance, Value *item)
 883 {
 884         if (instance == NULL)
 885                 return;
 886
 887         instance->SetNewItem (item);
 888 }
 889
 890
 891 void
 892 collection_changed_event_args_set_old_item (CollectionChangedEventArgs *instance, Value *item)
 893 {
 894         if (instance == NULL)
 895                 return;
 896
 897         instance->SetOldItem (item);
 898 }
 899
 900
 901 /**
 902  * CollectionIterator
 903  **/
 904 void
 905 collection_iterator_destroy (CollectionIterator *iterator)
 906 {
 907         CollectionIterator::Destroy (iterator);
 908 }
 909
 910
 911 Value *
 912 collection_iterator_get_current (CollectionIterator *instance, MoonError *error)
 913 {
 914         if (instance == NULL)
 915                 return NULL;
 916
 917         if (error == NULL)
 918                 g_warning ("Moonlight: Called collection_iterator_get_current () with error == NULL.");
 919         return instance->GetCurrent (error);
 920 }
 921
 922
 923 bool
 924 collection_iterator_next (CollectionIterator *instance, MoonError *error)
 925 {
 926         if (instance == NULL)
 927                 return false;
 928
 929         if (error == NULL)
 930                 g_warning ("Moonlight: Called collection_iterator_next () with error == NULL.");
 931         return instance->Next (error);
 932 }
 933
 934
 935 bool
 936 collection_iterator_reset (CollectionIterator *instance)
 937 {
 938         if (instance == NULL)
 939                 return false;
 940
 941         return instance->Reset ();
 942 }
 943
 944
 945 /**
 946  * ColorAnimation
 947  **/
 948 ColorAnimation *
 949 color_animation_new (void)
 950 {
 951         return new ColorAnimation ();
 952 }
 953
 954
 955 /**
 956  * ColorAnimationUsingKeyFrames
 957  **/
 958 ColorAnimationUsingKeyFrames *
 959 color_animation_using_key_frames_new (void)
 960 {
 961         return new ColorAnimationUsingKeyFrames ();
 962 }
 963
 964
 965 /**
 966  * ColorKeyFrame
 967  **/
 968 ColorKeyFrame *
 969 color_key_frame_new (void)
 970 {
 971         return new ColorKeyFrame ();
 972 }
 973
 974
 975 /**
 976  * ColorKeyFrameCollection
 977  **/
 978 ColorKeyFrameCollection *
 979 color_key_frame_collection_new (void)
 980 {
 981         return new ColorKeyFrameCollection ();
 982 }
 983
 984
 985 /**
 986  * ColumnDefinition
 987  **/
 988 ColumnDefinition *
 989 column_definition_new (void)
 990 {
 991         return new ColumnDefinition ();
 992 }
 993
 994
 995 /**
 996  * ColumnDefinitionCollection
 997  **/
 998 ColumnDefinitionCollection *
 999 column_definition_collection_new (void)
1000 {
1001         return new ColumnDefinitionCollection ();
1002 }
1003
1004
1005 /**
1006  * ContentChangedEventArgs
1007  **/
1008 Value *
1009 content_changed_event_args_get_new_content (ContentChangedEventArgs *instance)
1010 {
1011         if (instance == NULL)
1012                 return NULL;
1013
1014         return instance->GetNewContent ();
1015 }
1016
1017
1018 Value *
1019 content_changed_event_args_get_old_content (ContentChangedEventArgs *instance)
1020 {
1021         if (instance == NULL)
1022                 return NULL;
1023
1024         return instance->GetOldContent ();
1025 }
1026
1027
1028 /**
1029  * ContentControl
1030  **/
1031 ContentControl *
1032 content_control_new (void)
1033 {
1034         return new ContentControl ();
1035 }
1036
1037
1038 bool
1039 content_control_get_content_sets_parent (ContentControl *instance)
1040 {
1041         if (instance == NULL)
1042                 return false;
1043
1044         return instance->GetContentSetsParent ();
1045 }
1046
1047
1048 void
1049 content_control_set_content_sets_parent (ContentControl *instance, bool value)
1050 {
1051         if (instance == NULL)
1052                 return;
1053
1054         instance->SetContentSetsParent (value);
1055 }
1056
1057
1058 /**
1059  * Control
1060  **/
1061 Control *
1062 control_new (void)
1063 {
1064         return new Control ();
1065 }
1066
1067
1068 DependencyObject *
1069 control_get_template_child (Control *instance, const char *name)
1070 {
1071         if (instance == NULL)
1072                 return NULL;
1073
1074         return instance->GetTemplateChild (name);
1075 }
1076
1077
1078 /**
1079  * ControlTemplate
1080  **/
1081 ControlTemplate *
1082 control_template_new (void)
1083 {
1084         return new ControlTemplate ();
1085 }
1086
1087
1088 /**
1089  * CubicEase
1090  **/
1091 CubicEase *
1092 cubic_ease_new (void)
1093 {
1094         return new CubicEase ();
1095 }
1096
1097
1098 double
1099 cubic_ease_ease_in_core (CubicEase *instance, double normalizedTime)
1100 {
1101         if (instance == NULL)
1102                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1103                 return (double) 0;
1104
1105         return instance->EaseInCore (normalizedTime);
1106 }
1107
1108
1109 /**
1110  * CursorPositionChangedEventArgs
1111  **/
1112 CursorPositionChangedEventArgs *
1113 cursor_position_changed_event_args_new (void)
1114 {
1115         return new CursorPositionChangedEventArgs ();
1116 }
1117
1118
1119 double
1120 cursor_position_changed_event_args_get_cursor_height (CursorPositionChangedEventArgs *instance)
1121 {
1122         if (instance == NULL)
1123                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1124                 return (double) 0;
1125
1126         return instance->GetCursorHeight ();
1127 }
1128
1129
1130 double
1131 cursor_position_changed_event_args_get_cursor_x (CursorPositionChangedEventArgs *instance)
1132 {
1133         if (instance == NULL)
1134                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1135                 return (double) 0;
1136
1137         return instance->GetCursorX ();
1138 }
1139
1140
1141 double
1142 cursor_position_changed_event_args_get_cursor_y (CursorPositionChangedEventArgs *instance)
1143 {
1144         if (instance == NULL)
1145                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1146                 return (double) 0;
1147
1148         return instance->GetCursorY ();
1149 }
1150
1151
1152 /**
1153  * DataTemplate
1154  **/
1155 DataTemplate *
1156 data_template_new (void)
1157 {
1158         return new DataTemplate ();
1159 }
1160
1161
1162 /**
1163  * DeepZoomImageTileSource
1164  **/
1165 DeepZoomImageTileSource *
1166 deep_zoom_image_tile_source_new (void)
1167 {
1168         return new DeepZoomImageTileSource ();
1169 }
1170
1171
1172 /**
1173  * DependencyObject
1174  **/
1175 void
1176 dependency_object_add_property_change_handler (DependencyObject *instance, DependencyProperty *property, PropertyChangeHandler cb, gpointer closure)
1177 {
1178         if (instance == NULL)
1179                 return;
1180
1181         instance->AddPropertyChangeHandler (property, cb, closure);
1182 }
1183
1184
1185 void
1186 dependency_object_clear_value (DependencyObject *instance, DependencyProperty *property, bool notify_listeners, MoonError *error)
1187 {
1188         if (instance == NULL)
1189                 return;
1190
1191         if (error == NULL)
1192                 g_warning ("Moonlight: Called dependency_object_clear_value () with error == NULL.");
1193         instance->ClearValue (property, notify_listeners, error);
1194 }
1195
1196
1197 DependencyObject *
1198 dependency_object_new (void)
1199 {
1200         return new DependencyObject ();
1201 }
1202
1203
1204 DependencyObject *
1205 dependency_object_find_name (DependencyObject *instance, const char *name, int *element_kind)
1206 {
1207         if (instance == NULL)
1208                 return NULL;
1209
1210         return instance->FindName (name, (Type::Kind*) element_kind);
1211 }
1212
1213
1214 const char *
1215 dependency_object_get_name (DependencyObject *instance)
1216 {
1217         if (instance == NULL)
1218                 return NULL;
1219
1220         return instance->GetName ();
1221 }
1222
1223
1224 DependencyObject *
1225 dependency_object_get_template_owner (DependencyObject *instance)
1226 {
1227         if (instance == NULL)
1228                 return NULL;
1229
1230         return instance->GetTemplateOwner ();
1231 }
1232
1233
1234 Value *
1235 dependency_object_get_value_no_default_with_error (DependencyObject *instance, DependencyProperty *property, MoonError *error)
1236 {
1237         if (instance == NULL)
1238                 return NULL;
1239
1240         if (error == NULL)
1241                 g_warning ("Moonlight: Called dependency_object_get_value_no_default_with_error () with error == NULL.");
1242         return instance->GetValueNoDefaultWithError (property, error);
1243 }
1244
1245
1246 Value *
1247 dependency_object_get_value_with_error (DependencyObject *instance, int whatami, DependencyProperty *property, MoonError *error)
1248 {
1249         if (instance == NULL)
1250                 return NULL;
1251
1252         if (error == NULL)
1253                 g_warning ("Moonlight: Called dependency_object_get_value_with_error () with error == NULL.");
1254         return instance->GetValueWithError ((Type::Kind) whatami, property, error);
1255 }
1256
1257
1258 Value *
1259 dependency_object_read_local_value_with_error (DependencyObject *instance, DependencyProperty *property, MoonError *error)
1260 {
1261         if (instance == NULL)
1262                 return NULL;
1263
1264         if (error == NULL)
1265                 g_warning ("Moonlight: Called dependency_object_read_local_value_with_error () with error == NULL.");
1266         return instance->ReadLocalValueWithError (property, error);
1267 }
1268
1269
1270 void
1271 dependency_object_remove_property_change_handler (DependencyObject *instance, DependencyProperty *property, PropertyChangeHandler cb)
1272 {
1273         if (instance == NULL)
1274                 return;
1275
1276         instance->RemovePropertyChangeHandler (property, cb);
1277 }
1278
1279
1280 void
1281 dependency_object_set_name (DependencyObject *instance, const char *name)
1282 {
1283         if (instance == NULL)
1284                 return;
1285
1286         instance->SetName (name);
1287 }
1288
1289
1290 void
1291 dependency_object_set_parent_safe (DependencyObject *instance, DependencyObject *parent, MoonError *error)
1292 {
1293         if (instance == NULL)
1294                 return;
1295
1296         if (error == NULL)
1297                 g_warning ("Moonlight: Called dependency_object_set_parent_safe () with error == NULL.");
1298         instance->SetParentSafe (parent, error);
1299 }
1300
1301
1302 void
1303 dependency_object_set_template_owner (DependencyObject *instance, DependencyObject *value)
1304 {
1305         if (instance == NULL)
1306                 return;
1307
1308         instance->SetTemplateOwner (value);
1309 }
1310
1311
1312 bool
1313 dependency_object_set_value_with_error (DependencyObject *instance, DependencyProperty *property, Value *value, MoonError *error)
1314 {
1315         if (instance == NULL)
1316                 return false;
1317
1318         if (error == NULL)
1319                 g_warning ("Moonlight: Called dependency_object_set_value_with_error () with error == NULL.");
1320         return instance->SetValueWithError (property, value, error);
1321 }
1322
1323
1324 /**
1325  * DependencyObjectCollection
1326  **/
1327 DependencyObjectCollection *
1328 dependency_object_collection_new (void)
1329 {
1330         return new DependencyObjectCollection ();
1331 }
1332
1333
1334 /**
1335  * DependencyProperty
1336  **/
1337 Value *
1338 dependency_property_get_default_value (DependencyProperty *instance)
1339 {
1340         if (instance == NULL)
1341                 return NULL;
1342
1343         return instance->GetDefaultValue ();
1344 }
1345
1346
1347 DependencyProperty *
1348 dependency_property_get_dependency_property (int type, const char *name)
1349 {
1350         return DependencyProperty::GetDependencyProperty ((Type::Kind) type, name);
1351 }
1352
1353
1354 DependencyProperty *
1355 dependency_property_get_dependency_property_full (int type, const char *name, bool inherits)
1356 {
1357         return DependencyProperty::GetDependencyPropertyFull ((Type::Kind) type, name, inherits);
1358 }
1359
1360
1361 const char *
1362 dependency_property_get_name (DependencyProperty *instance)
1363 {
1364         if (instance == NULL)
1365                 return NULL;
1366
1367         return instance->GetName ();
1368 }
1369
1370
1371 int
1372 dependency_property_get_property_type (DependencyProperty *instance)
1373 {
1374         if (instance == NULL)
1375                 return Type::INVALID;
1376
1377         return instance->GetPropertyType ();
1378 }
1379
1380
1381 bool
1382 dependency_property_is_attached (DependencyProperty *instance)
1383 {
1384         if (instance == NULL)
1385                 return false;
1386
1387         return instance->IsAttached ();
1388 }
1389
1390
1391 bool
1392 dependency_property_is_nullable (DependencyProperty *instance)
1393 {
1394         if (instance == NULL)
1395                 return false;
1396
1397         return instance->IsNullable ();
1398 }
1399
1400
1401 bool
1402 dependency_property_is_read_only (DependencyProperty *instance)
1403 {
1404         if (instance == NULL)
1405                 return false;
1406
1407         return instance->IsReadOnly ();
1408 }
1409
1410
1411 DependencyProperty *
1412 dependency_property_register_core_property (const char *name, int property_type, int owner_type, Value *defaultValue, bool attached, bool read_only, PropertyChangeHandler callback)
1413 {
1414         return DependencyProperty::RegisterCoreProperty (name, (Type::Kind) property_type, (Type::Kind) owner_type, defaultValue, attached, read_only, callback);
1415 }
1416
1417
1418 DependencyProperty *
1419 dependency_property_register_custom_property (const char *name, int property_type, int owner_type, Value *defaultValue, bool attached, bool read_only, PropertyChangeHandler callback)
1420 {
1421         return DependencyProperty::RegisterCustomProperty (name, (Type::Kind) property_type, (Type::Kind) owner_type, defaultValue, attached, read_only, callback);
1422 }
1423
1424
1425 void
1426 dependency_property_set_is_nullable (DependencyProperty *instance, bool value)
1427 {
1428         if (instance == NULL)
1429                 return;
1430
1431         instance->SetIsNullable (value);
1432 }
1433
1434
1435 void
1436 dependency_property_set_property_changed_callback (DependencyProperty *instance, PropertyChangeHandler changed_callback)
1437 {
1438         if (instance == NULL)
1439                 return;
1440
1441         instance->SetPropertyChangedCallback (changed_callback);
1442 }
1443
1444
1445 /**
1446  * Deployment
1447  **/
1448 Deployment *
1449 deployment_new (void)
1450 {
1451         return new Deployment ();
1452 }
1453
1454
1455 Deployment *
1456 deployment_get_current (void)
1457 {
1458         return Deployment::GetCurrent ();
1459 }
1460
1461
1462 Surface *
1463 deployment_get_surface_reffed (Deployment *instance)
1464 {
1465         if (instance == NULL)
1466                 return NULL;
1467
1468         return instance->GetSurfaceReffed ();
1469 }
1470
1471
1472 Types *
1473 deployment_get_types (Deployment *instance)
1474 {
1475         if (instance == NULL)
1476                 return NULL;
1477
1478         return instance->GetTypes ();
1479 }
1480
1481
1482 void
1483 deployment_set_current (Deployment *value)
1484 {
1485         Deployment::SetCurrent (value);
1486 }
1487
1488
1489 void
1490 deployment_set_current_application (Deployment *instance, Application *value)
1491 {
1492         if (instance == NULL)
1493                 return;
1494
1495         instance->SetCurrentApplication (value);
1496 }
1497
1498
1499 void
1500 deployment_set_is_loaded_from_xap (Deployment *instance, bool flag)
1501 {
1502         if (instance == NULL)
1503                 return;
1504
1505         instance->SetIsLoadedFromXap (flag);
1506 }
1507
1508
1509 /**
1510  * DiscreteColorKeyFrame
1511  **/
1512 DiscreteColorKeyFrame *
1513 discrete_color_key_frame_new (void)
1514 {
1515         return new DiscreteColorKeyFrame ();
1516 }
1517
1518
1519 /**
1520  * DiscreteDoubleKeyFrame
1521  **/
1522 DiscreteDoubleKeyFrame *
1523 discrete_double_key_frame_new (void)
1524 {
1525         return new DiscreteDoubleKeyFrame ();
1526 }
1527
1528
1529 /**
1530  * DiscreteObjectKeyFrame
1531  **/
1532 DiscreteObjectKeyFrame *
1533 discrete_object_key_frame_new (void)
1534 {
1535         return new DiscreteObjectKeyFrame ();
1536 }
1537
1538
1539 /**
1540  * DiscretePointKeyFrame
1541  **/
1542 DiscretePointKeyFrame *
1543 discrete_point_key_frame_new (void)
1544 {
1545         return new DiscretePointKeyFrame ();
1546 }
1547
1548
1549 /**
1550  * DispatcherTimer
1551  **/
1552 DispatcherTimer *
1553 dispatcher_timer_new (void)
1554 {
1555         return new DispatcherTimer ();
1556 }
1557
1558
1559 void
1560 dispatcher_timer_start (DispatcherTimer *instance)
1561 {
1562         if (instance == NULL)
1563                 return;
1564
1565         instance->Start ();
1566 }
1567
1568
1569 void
1570 dispatcher_timer_stop (DispatcherTimer *instance)
1571 {
1572         if (instance == NULL)
1573                 return;
1574
1575         instance->Stop ();
1576 }
1577
1578
1579 /**
1580  * DoubleAnimation
1581  **/
1582 DoubleAnimation *
1583 double_animation_new (void)
1584 {
1585         return new DoubleAnimation ();
1586 }
1587
1588
1589 /**
1590  * DoubleAnimationUsingKeyFrames
1591  **/
1592 DoubleAnimationUsingKeyFrames *
1593 double_animation_using_key_frames_new (void)
1594 {
1595         return new DoubleAnimationUsingKeyFrames ();
1596 }
1597
1598
1599 /**
1600  * DoubleCollection
1601  **/
1602 DoubleCollection *
1603 double_collection_new (void)
1604 {
1605         return new DoubleCollection ();
1606 }
1607
1608
1609 /**
1610  * DoubleKeyFrame
1611  **/
1612 DoubleKeyFrame *
1613 double_key_frame_new (void)
1614 {
1615         return new DoubleKeyFrame ();
1616 }
1617
1618
1619 /**
1620  * DoubleKeyFrameCollection
1621  **/
1622 DoubleKeyFrameCollection *
1623 double_key_frame_collection_new (void)
1624 {
1625         return new DoubleKeyFrameCollection ();
1626 }
1627
1628
1629 /**
1630  * Downloader
1631  **/
1632 void *
1633 downloader_create_web_request (Downloader *instance, const char *method, const char *uri)
1634 {
1635         if (instance == NULL)
1636                 return NULL;
1637
1638         return instance->CreateWebRequest (method, uri);
1639 }
1640
1641
1642 Downloader *
1643 downloader_new (void)
1644 {
1645         return new Downloader ();
1646 }
1647
1648
1649 void
1650 downloader_notify_failed (Downloader *instance, const char *msg)
1651 {
1652         if (instance == NULL)
1653                 return;
1654
1655         instance->NotifyFailed (msg);
1656 }
1657
1658
1659 void
1660 downloader_notify_finished (Downloader *instance, const char *final_uri)
1661 {
1662         if (instance == NULL)
1663                 return;
1664
1665         instance->NotifyFinished (final_uri);
1666 }
1667
1668
1669 void
1670 downloader_notify_size (Downloader *instance, gint64 size)
1671 {
1672         if (instance == NULL)
1673                 return;
1674
1675         instance->NotifySize (size);
1676 }
1677
1678
1679 void
1680 downloader_set_functions (DownloaderCreateStateFunc create_state, DownloaderDestroyStateFunc destroy_state, DownloaderOpenFunc open, DownloaderSendFunc send, DownloaderAbortFunc abort, DownloaderHeaderFunc header, DownloaderBodyFunc body, DownloaderCreateWebRequestFunc request, DownloaderSetResponseHeaderCallbackFunc response_header_callback, DownloaderGetResponseFunc get_response)
1681 {
1682         Downloader::SetFunctions (create_state, destroy_state, open, send, abort, header, body, request, response_header_callback, get_response);
1683 }
1684
1685
1686 void
1687 downloader_write (Downloader *instance, void *buf, gint32 offset, gint32 n)
1688 {
1689         if (instance == NULL)
1690                 return;
1691
1692         instance->Write (buf, offset, n);
1693 }
1694
1695
1696 /**
1697  * DownloaderRequest
1698  **/
1699 void
1700 downloader_request_free (DownloaderRequest *instance)
1701 {
1702         delete instance;
1703 }
1704
1705
1706 void
1707 downloader_request_abort (DownloaderRequest *instance)
1708 {
1709         if (instance == NULL)
1710                 return;
1711
1712         instance->Abort ();
1713 }
1714
1715
1716 DownloaderResponse *
1717 downloader_request_get_downloader_response (DownloaderRequest *instance)
1718 {
1719         if (instance == NULL)
1720                 return NULL;
1721
1722         return instance->GetDownloaderResponse ();
1723 }
1724
1725
1726 bool
1727 downloader_request_get_response (DownloaderRequest *instance, DownloaderResponseStartedHandler started, DownloaderResponseDataAvailableHandler available, DownloaderResponseFinishedHandler finished, gpointer context)
1728 {
1729         if (instance == NULL)
1730                 return false;
1731
1732         return instance->GetResponse (started, available, finished, context);
1733 }
1734
1735
1736 const bool
1737 downloader_request_is_aborted (DownloaderRequest *instance)
1738 {
1739         if (instance == NULL)
1740                 return false;
1741
1742         return instance->IsAborted ();
1743 }
1744
1745
1746 void
1747 downloader_request_set_body (DownloaderRequest *instance, void *body, int size)
1748 {
1749         if (instance == NULL)
1750                 return;
1751
1752         instance->SetBody (body, size);
1753 }
1754
1755
1756 void
1757 downloader_request_set_http_header (DownloaderRequest *instance, const char *name, const char *value)
1758 {
1759         if (instance == NULL)
1760                 return;
1761
1762         instance->SetHttpHeader (name, value);
1763 }
1764
1765
1766 /**
1767  * DownloaderResponse
1768  **/
1769 void
1770 downloader_response_free (DownloaderResponse *instance)
1771 {
1772         delete instance;
1773 }
1774
1775
1776 void
1777 downloader_response_abort (DownloaderResponse *instance)
1778 {
1779         if (instance == NULL)
1780                 return;
1781
1782         instance->Abort ();
1783 }
1784
1785
1786 int
1787 downloader_response_get_response_status (DownloaderResponse *instance)
1788 {
1789         if (instance == NULL)
1790                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1791                 return (int) 0;
1792
1793         return instance->GetResponseStatus ();
1794 }
1795
1796
1797 const char *
1798 downloader_response_get_response_status_text (DownloaderResponse *instance)
1799 {
1800         if (instance == NULL)
1801                 return NULL;
1802
1803         return instance->GetResponseStatusText ();
1804 }
1805
1806
1807 void
1808 downloader_response_set_header_visitor (DownloaderResponse *instance, DownloaderResponseHeaderCallback visitor, gpointer context)
1809 {
1810         if (instance == NULL)
1811                 return;
1812
1813         instance->SetHeaderVisitor (visitor, context);
1814 }
1815
1816
1817 /**
1818  * DownloadProgressEventArgs
1819  **/
1820 double
1821 download_progress_event_args_get_progress (DownloadProgressEventArgs *instance)
1822 {
1823         if (instance == NULL)
1824                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1825                 return (double) 0;
1826
1827         return instance->GetProgress ();
1828 }
1829
1830
1831 /**
1832  * DrawingAttributes
1833  **/
1834 DrawingAttributes *
1835 drawing_attributes_new (void)
1836 {
1837         return new DrawingAttributes ();
1838 }
1839
1840
1841 /**
1842  * DropShadowEffect
1843  **/
1844 DropShadowEffect *
1845 drop_shadow_effect_new (void)
1846 {
1847         return new DropShadowEffect ();
1848 }
1849
1850
1851 /**
1852  * EasingColorKeyFrame
1853  **/
1854 EasingColorKeyFrame *
1855 easing_color_key_frame_new (void)
1856 {
1857         return new EasingColorKeyFrame ();
1858 }
1859
1860
1861 /**
1862  * EasingDoubleKeyFrame
1863  **/
1864 EasingDoubleKeyFrame *
1865 easing_double_key_frame_new (void)
1866 {
1867         return new EasingDoubleKeyFrame ();
1868 }
1869
1870
1871 /**
1872  * EasingFunctionBase
1873  **/
1874 EasingFunctionBase *
1875 easing_function_base_new (void)
1876 {
1877         return new EasingFunctionBase ();
1878 }
1879
1880
1881 void
1882 easing_function_base_set_easing_function (EasingFunctionBase *instance, EasingFunction value)
1883 {
1884         if (instance == NULL)
1885                 return;
1886
1887         instance->SetEasingFunction (value);
1888 }
1889
1890
1891 /**
1892  * EasingPointKeyFrame
1893  **/
1894 EasingPointKeyFrame *
1895 easing_point_key_frame_new (void)
1896 {
1897         return new EasingPointKeyFrame ();
1898 }
1899
1900
1901 /**
1902  * Effect
1903  **/
1904 Effect *
1905 effect_new (void)
1906 {
1907         return new Effect ();
1908 }
1909
1910
1911 /**
1912  * ElasticEase
1913  **/
1914 double
1915 elastic_ease_ease_in_core (ElasticEase *instance, double normalizedTime)
1916 {
1917         if (instance == NULL)
1918                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1919                 return (double) 0;
1920
1921         return instance->EaseInCore (normalizedTime);
1922 }
1923
1924
1925 ElasticEase *
1926 elastic_ease_new (void)
1927 {
1928         return new ElasticEase ();
1929 }
1930
1931
1932 /**
1933  * Ellipse
1934  **/
1935 Ellipse *
1936 ellipse_new (void)
1937 {
1938         return new Ellipse ();
1939 }
1940
1941
1942 /**
1943  * EllipseGeometry
1944  **/
1945 EllipseGeometry *
1946 ellipse_geometry_new (void)
1947 {
1948         return new EllipseGeometry ();
1949 }
1950
1951
1952 /**
1953  * ErrorEventArgs
1954  **/
1955 int
1956 error_event_args_get_error_code (ErrorEventArgs *instance)
1957 {
1958         if (instance == NULL)
1959                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1960                 return (int) 0;
1961
1962         return instance->GetErrorCode ();
1963 }
1964
1965
1966 const char *
1967 error_event_args_get_error_message (ErrorEventArgs *instance)
1968 {
1969         if (instance == NULL)
1970                 return NULL;
1971
1972         return instance->GetErrorMessage ();
1973 }
1974
1975
1976 int
1977 error_event_args_get_error_type (ErrorEventArgs *instance)
1978 {
1979         if (instance == NULL)
1980                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1981                 return (int) 0;
1982
1983         return instance->GetErrorType ();
1984 }
1985
1986
1987 gpointer
1988 error_event_args_get_moon_error (ErrorEventArgs *instance)
1989 {
1990         if (instance == NULL)
1991                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
1992                 return (gpointer) 0;
1993
1994         return instance->GetMoonError ();
1995 }
1996
1997
1998 /**
1999  * EventObject
2000  **/
2001 int
2002 event_object_add_handler (EventObject *instance, int event_id, EventHandler handler, gpointer data, GDestroyNotify data_dtor)
2003 {
2004         if (instance == NULL)
2005                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2006                 return (int) 0;
2007
2008         return instance->AddHandler (event_id, handler, data, data_dtor);
2009 }
2010
2011
2012 void
2013 event_object_add_on_event_handler (EventObject *instance, int event_id, EventHandler handler, gpointer data, GDestroyNotify data_dtor)
2014 {
2015         if (instance == NULL)
2016                 return;
2017
2018         instance->AddOnEventHandler (event_id, handler, data, data_dtor);
2019 }
2020
2021
2022 void
2023 event_object_add_toggle_ref_notifier (EventObject *instance, ToggleNotifyHandler tr)
2024 {
2025         if (instance == NULL)
2026                 return;
2027
2028         instance->AddToggleRefNotifier (tr);
2029 }
2030
2031
2032 int
2033 event_object_add_xaml_handler (EventObject *instance, int event_id, EventHandler handler, gpointer data, GDestroyNotify data_dtor)
2034 {
2035         if (instance == NULL)
2036                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2037                 return (int) 0;
2038
2039         return instance->AddXamlHandler (event_id, handler, data, data_dtor);
2040 }
2041
2042
2043 void
2044 event_object_do_emit_current_context (EventObject *instance, int event_id, EventArgs *calldata)
2045 {
2046         if (instance == NULL)
2047                 return;
2048
2049         instance->DoEmitCurrentContext (event_id, calldata);
2050 }
2051
2052
2053 int
2054 event_object_get_object_type (EventObject *instance)
2055 {
2056         if (instance == NULL)
2057                 return Type::INVALID;
2058
2059         return instance->GetObjectType ();
2060 }
2061
2062
2063 const char *
2064 event_object_get_type_name (EventObject *instance)
2065 {
2066         if (instance == NULL)
2067                 return NULL;
2068
2069         return instance->GetTypeName ();
2070 }
2071
2072
2073 void
2074 event_object_ref (EventObject *instance)
2075 {
2076         if (instance == NULL)
2077                 return;
2078
2079         instance->ref ();
2080 }
2081
2082
2083 int
2084 event_object_remove_handler (EventObject *instance, int event_id, EventHandler handler, gpointer data)
2085 {
2086         if (instance == NULL)
2087                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2088                 return (int) 0;
2089
2090         return instance->RemoveHandler (event_id, handler, data);
2091 }
2092
2093
2094 void
2095 event_object_remove_on_event_handler (EventObject *instance, int event_id, EventHandler handler, gpointer data)
2096 {
2097         if (instance == NULL)
2098                 return;
2099
2100         instance->RemoveOnEventHandler (event_id, handler, data);
2101 }
2102
2103
2104 void
2105 event_object_remove_toggle_ref_notifier (EventObject *instance)
2106 {
2107         if (instance == NULL)
2108                 return;
2109
2110         instance->RemoveToggleRefNotifier ();
2111 }
2112
2113
2114 void
2115 event_object_set_object_type (EventObject *instance, int value)
2116 {
2117         if (instance == NULL)
2118                 return;
2119
2120         instance->SetObjectType ((Type::Kind) value);
2121 }
2122
2123
2124 void
2125 event_object_unref (EventObject *instance)
2126 {
2127         if (instance == NULL)
2128                 return;
2129
2130         instance->unref ();
2131 }
2132
2133
2134 /**
2135  * EventTrigger
2136  **/
2137 EventTrigger *
2138 event_trigger_new (void)
2139 {
2140         return new EventTrigger ();
2141 }
2142
2143
2144 /**
2145  * ExponentialEase
2146  **/
2147 double
2148 exponential_ease_ease_in_core (ExponentialEase *instance, double normalizedTime)
2149 {
2150         if (instance == NULL)
2151                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2152                 return (double) 0;
2153
2154         return instance->EaseInCore (normalizedTime);
2155 }
2156
2157
2158 ExponentialEase *
2159 exponential_ease_new (void)
2160 {
2161         return new ExponentialEase ();
2162 }
2163
2164
2165 /**
2166  * ExtensionPart
2167  **/
2168 ExtensionPart *
2169 extension_part_new (void)
2170 {
2171         return new ExtensionPart ();
2172 }
2173
2174
2175 /**
2176  * ExternalDecoder
2177  **/
2178 ExternalDecoder *
2179 external_decoder_new (Media *media, IMediaStream *stream, void *instance, const char *name, ExternalDecoder_DecodeFrameAsyncCallback decode_frame_async, ExternalDecoder_OpenDecoderAsyncCallback open_decoder_async, ExternalDecoder_CleanupCallback cleanup, ExternalDecoder_CleanStateCallback clean_state, ExternalDecoder_HasDelayedFrameCallback has_delayed_frame, ExternalDecoder_DisposeCallback dispose, ExternalDecoder_DtorCallback dtor)
2180 {
2181         return new ExternalDecoder (media, stream, instance, name, decode_frame_async, open_decoder_async, cleanup, clean_state, has_delayed_frame, dispose, dtor);
2182 }
2183
2184
2185 /**
2186  * ExternalDecoderInfo
2187  **/
2188 ExternalDecoderInfo *
2189 external_decoder_info_new (void *instance, const char *name, ExternalDecoderInfo_SupportsCallback supports, ExternalDecoderInfo_Create create, ExternalDecoderInfo_dtor dtor)
2190 {
2191         return new ExternalDecoderInfo (instance, name, supports, create, dtor);
2192 }
2193
2194
2195 /**
2196  * ExternalDemuxer
2197  **/
2198 gint32
2199 external_demuxer_add_stream (ExternalDemuxer *instance, IMediaStream *stream)
2200 {
2201         if (instance == NULL)
2202                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2203                 return (gint32) 0;
2204
2205         return instance->AddStream (stream);
2206 }
2207
2208
2209 void
2210 external_demuxer_clear_callbacks (ExternalDemuxer *instance)
2211 {
2212         if (instance == NULL)
2213                 return;
2214
2215         instance->ClearCallbacks ();
2216 }
2217
2218
2219 void
2220 external_demuxer_set_can_seek (ExternalDemuxer *instance, bool value)
2221 {
2222         if (instance == NULL)
2223                 return;
2224
2225         instance->SetCanSeek (value);
2226 }
2227
2228
2229 /**
2230  * ExternalPart
2231  **/
2232 ExternalPart *
2233 external_part_new (void)
2234 {
2235         return new ExternalPart ();
2236 }
2237
2238
2239 /**
2240  * ExternalPartCollection
2241  **/
2242 ExternalPartCollection *
2243 external_part_collection_new (void)
2244 {
2245         return new ExternalPartCollection ();
2246 }
2247
2248
2249 /**
2250  * FrameworkElement
2251  **/
2252 bool
2253 framework_element_apply_template (FrameworkElement *instance)
2254 {
2255         if (instance == NULL)
2256                 return false;
2257
2258         return instance->ApplyTemplate ();
2259 }
2260
2261
2262 Size
2263 framework_element_arrange_override (FrameworkElement *instance, Size finalSize)
2264 {
2265         if (instance == NULL)
2266                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2267                 return (Size) 0;
2268
2269         return instance->ArrangeOverride (finalSize);
2270 }
2271
2272
2273 FrameworkElement *
2274 framework_element_new (void)
2275 {
2276         return new FrameworkElement ();
2277 }
2278
2279
2280 DependencyObject *
2281 framework_element_get_logical_parent (FrameworkElement *instance)
2282 {
2283         if (instance == NULL)
2284                 return NULL;
2285
2286         return instance->GetLogicalParent ();
2287 }
2288
2289
2290 Size
2291 framework_element_measure_override (FrameworkElement *instance, Size availableSize)
2292 {
2293         if (instance == NULL)
2294                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2295                 return (Size) 0;
2296
2297         return instance->MeasureOverride (availableSize);
2298 }
2299
2300
2301 void
2302 framework_element_register_managed_overrides (FrameworkElement *instance, MeasureOverrideCallback measure_cb, ArrangeOverrideCallback arrange_cb, GetDefaultTemplateCallback get_default_template_cb, LoadedCallback loaded_cb)
2303 {
2304         if (instance == NULL)
2305                 return;
2306
2307         instance->RegisterManagedOverrides (measure_cb, arrange_cb, get_default_template_cb, loaded_cb);
2308 }
2309
2310
2311 void
2312 framework_element_set_default_style (FrameworkElement *instance, Style *value)
2313 {
2314         if (instance == NULL)
2315                 return;
2316
2317         instance->SetDefaultStyle (value);
2318 }
2319
2320
2321 void
2322 framework_element_set_logical_parent (FrameworkElement *instance, DependencyObject *logical_parent, MoonError *error)
2323 {
2324         if (instance == NULL)
2325                 return;
2326
2327         if (error == NULL)
2328                 g_warning ("Moonlight: Called framework_element_set_logical_parent () with error == NULL.");
2329         instance->SetLogicalParent (logical_parent, error);
2330 }
2331
2332
2333 /**
2334  * FrameworkTemplate
2335  **/
2336 FrameworkTemplate *
2337 framework_template_new (void)
2338 {
2339         return new FrameworkTemplate ();
2340 }
2341
2342
2343 DependencyObject *
2344 framework_template_get_visual_tree (FrameworkTemplate *instance, FrameworkElement *templateBindingSource)
2345 {
2346         if (instance == NULL)
2347                 return NULL;
2348
2349         return instance->GetVisualTree (templateBindingSource);
2350 }
2351
2352
2353 /**
2354  * GeneralTransform
2355  **/
2356 GeneralTransform *
2357 general_transform_new (void)
2358 {
2359         return new GeneralTransform ();
2360 }
2361
2362
2363 Matrix *
2364 general_transform_get_matrix (GeneralTransform *instance)
2365 {
2366         if (instance == NULL)
2367                 return NULL;
2368
2369         return instance->GetMatrix ();
2370 }
2371
2372
2373 /**
2374  * Geometry
2375  **/
2376 Geometry *
2377 geometry_new (void)
2378 {
2379         return new Geometry ();
2380 }
2381
2382
2383 Rect
2384 geometry_get_bounds (Geometry *instance)
2385 {
2386         if (instance == NULL)
2387                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2388                 return (Rect) 0;
2389
2390         return instance->GetBounds ();
2391 }
2392
2393
2394 /**
2395  * GeometryCollection
2396  **/
2397 GeometryCollection *
2398 geometry_collection_new (void)
2399 {
2400         return new GeometryCollection ();
2401 }
2402
2403
2404 /**
2405  * GeometryGroup
2406  **/
2407 GeometryGroup *
2408 geometry_group_new (void)
2409 {
2410         return new GeometryGroup ();
2411 }
2412
2413
2414 /**
2415  * Glyphs
2416  **/
2417 Glyphs *
2418 glyphs_new (void)
2419 {
2420         return new Glyphs ();
2421 }
2422
2423
2424 /**
2425  * GradientBrush
2426  **/
2427 GradientBrush *
2428 gradient_brush_new (void)
2429 {
2430         return new GradientBrush ();
2431 }
2432
2433
2434 /**
2435  * GradientStop
2436  **/
2437 GradientStop *
2438 gradient_stop_new (void)
2439 {
2440         return new GradientStop ();
2441 }
2442
2443
2444 /**
2445  * GradientStopCollection
2446  **/
2447 GradientStopCollection *
2448 gradient_stop_collection_new (void)
2449 {
2450         return new GradientStopCollection ();
2451 }
2452
2453
2454 /**
2455  * Grid
2456  **/
2457 Grid *
2458 grid_new (void)
2459 {
2460         return new Grid ();
2461 }
2462
2463
2464 /**
2465  * HitTestCollection
2466  **/
2467 HitTestCollection *
2468 hit_test_collection_new (void)
2469 {
2470         return new HitTestCollection ();
2471 }
2472
2473
2474 /**
2475  * Icon
2476  **/
2477 Icon *
2478 icon_new (void)
2479 {
2480         return new Icon ();
2481 }
2482
2483
2484 /**
2485  * IconCollection
2486  **/
2487 IconCollection *
2488 icon_collection_new (void)
2489 {
2490         return new IconCollection ();
2491 }
2492
2493
2494 /**
2495  * Image
2496  **/
2497 Image *
2498 image_new (void)
2499 {
2500         return new Image ();
2501 }
2502
2503
2504 void
2505 image_set_source (Image *instance, ImageSource *source)
2506 {
2507         if (instance == NULL)
2508                 return;
2509
2510         instance->SetSource (source);
2511 }
2512
2513
2514 /**
2515  * ImageBrush
2516  **/
2517 ImageBrush *
2518 image_brush_new (void)
2519 {
2520         return new ImageBrush ();
2521 }
2522
2523
2524 /**
2525  * ImageSource
2526  **/
2527 ImageSource *
2528 image_source_new (void)
2529 {
2530         return new ImageSource ();
2531 }
2532
2533
2534 /**
2535  * IMediaDecoder
2536  **/
2537 void
2538 imedia_decoder_report_decode_frame_completed (IMediaDecoder *instance, MediaFrame *frame)
2539 {
2540         if (instance == NULL)
2541                 return;
2542
2543         instance->ReportDecodeFrameCompleted (frame);
2544 }
2545
2546
2547 void
2548 imedia_decoder_report_open_decoder_completed (IMediaDecoder *instance)
2549 {
2550         if (instance == NULL)
2551                 return;
2552
2553         instance->ReportOpenDecoderCompleted ();
2554 }
2555
2556
2557 void
2558 imedia_decoder_set_pixel_format (IMediaDecoder *instance, int value)
2559 {
2560         if (instance == NULL)
2561                 return;
2562
2563         instance->SetPixelFormat ((MoonPixelFormat) value);
2564 }
2565
2566
2567 /**
2568  * IMediaDemuxer
2569  **/
2570 void
2571 imedia_demuxer_report_get_diagnostic_completed (IMediaDemuxer *instance, int diagnosticKind, gint64 diagnosticValue)
2572 {
2573         if (instance == NULL)
2574                 return;
2575
2576         instance->ReportGetDiagnosticCompleted ((MediaStreamSourceDiagnosticKind) diagnosticKind, diagnosticValue);
2577 }
2578
2579
2580 void
2581 imedia_demuxer_report_get_frame_completed (IMediaDemuxer *instance, MediaFrame *frame)
2582 {
2583         if (instance == NULL)
2584                 return;
2585
2586         instance->ReportGetFrameCompleted (frame);
2587 }
2588
2589
2590 void
2591 imedia_demuxer_report_get_frame_progress (IMediaDemuxer *instance, double bufferingProgress)
2592 {
2593         if (instance == NULL)
2594                 return;
2595
2596         instance->ReportGetFrameProgress (bufferingProgress);
2597 }
2598
2599
2600 void
2601 imedia_demuxer_report_open_demuxer_completed (IMediaDemuxer *instance)
2602 {
2603         if (instance == NULL)
2604                 return;
2605
2606         instance->ReportOpenDemuxerCompleted ();
2607 }
2608
2609
2610 void
2611 imedia_demuxer_report_seek_completed (IMediaDemuxer *instance, guint64 pts)
2612 {
2613         if (instance == NULL)
2614                 return;
2615
2616         instance->ReportSeekCompleted (pts);
2617 }
2618
2619
2620 void
2621 imedia_demuxer_report_switch_media_stream_completed (IMediaDemuxer *instance, IMediaStream *stream)
2622 {
2623         if (instance == NULL)
2624                 return;
2625
2626         instance->ReportSwitchMediaStreamCompleted (stream);
2627 }
2628
2629
2630 /**
2631  * IMediaObject
2632  **/
2633 Media *
2634 imedia_object_get_media_reffed (IMediaObject *instance)
2635 {
2636         if (instance == NULL)
2637                 return NULL;
2638
2639         return instance->GetMediaReffed ();
2640 }
2641
2642
2643 void
2644 imedia_object_report_error_occurred (IMediaObject *instance, const char *message)
2645 {
2646         if (instance == NULL)
2647                 return;
2648
2649         instance->ReportErrorOccurred (message);
2650 }
2651
2652
2653 /**
2654  * IMediaStream
2655  **/
2656 const char *
2657 imedia_stream_get_codec (IMediaStream *instance)
2658 {
2659         if (instance == NULL)
2660                 return NULL;
2661
2662         return instance->GetCodec ();
2663 }
2664
2665
2666 int
2667 imedia_stream_get_codec_id (IMediaStream *instance)
2668 {
2669         if (instance == NULL)
2670                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2671                 return (int) 0;
2672
2673         return instance->GetCodecId ();
2674 }
2675
2676
2677 guint64
2678 imedia_stream_get_duration (IMediaStream *instance)
2679 {
2680         if (instance == NULL)
2681                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2682                 return (guint64) 0;
2683
2684         return instance->GetDuration ();
2685 }
2686
2687
2688 void *
2689 imedia_stream_get_extra_data (IMediaStream *instance)
2690 {
2691         if (instance == NULL)
2692                 return NULL;
2693
2694         return instance->GetExtraData ();
2695 }
2696
2697
2698 int
2699 imedia_stream_get_extra_data_size (IMediaStream *instance)
2700 {
2701         if (instance == NULL)
2702                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2703                 return (int) 0;
2704
2705         return instance->GetExtraDataSize ();
2706 }
2707
2708
2709 int
2710 imedia_stream_get_stream_type (IMediaStream *instance)
2711 {
2712         if (instance == NULL)
2713                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2714                 return (MediaStreamType) 0;
2715
2716         return instance->GetStreamType ();
2717 }
2718
2719
2720 void
2721 imedia_stream_set_codec_id (IMediaStream *instance, int value)
2722 {
2723         if (instance == NULL)
2724                 return;
2725
2726         instance->SetCodecId (value);
2727 }
2728
2729
2730 void
2731 imedia_stream_set_duration (IMediaStream *instance, guint64 value)
2732 {
2733         if (instance == NULL)
2734                 return;
2735
2736         instance->SetDuration (value);
2737 }
2738
2739
2740 void
2741 imedia_stream_set_extra_data (IMediaStream *instance, void *value)
2742 {
2743         if (instance == NULL)
2744                 return;
2745
2746         instance->SetExtraData (value);
2747 }
2748
2749
2750 void
2751 imedia_stream_set_extra_data_size (IMediaStream *instance, int value)
2752 {
2753         if (instance == NULL)
2754                 return;
2755
2756         instance->SetExtraDataSize (value);
2757 }
2758
2759
2760 /**
2761  * InkPresenter
2762  **/
2763 InkPresenter *
2764 ink_presenter_new (void)
2765 {
2766         return new InkPresenter ();
2767 }
2768
2769
2770 /**
2771  * Inline
2772  **/
2773 Inline *
2774 inline_new (void)
2775 {
2776         return new Inline ();
2777 }
2778
2779
2780 /**
2781  * InlineCollection
2782  **/
2783 InlineCollection *
2784 inline_collection_new (void)
2785 {
2786         return new InlineCollection ();
2787 }
2788
2789
2790 /**
2791  * InputMethod
2792  **/
2793 InputMethod *
2794 input_method_new (void)
2795 {
2796         return new InputMethod ();
2797 }
2798
2799
2800 /**
2801  * ItemCollection
2802  **/
2803 ItemCollection *
2804 item_collection_new (void)
2805 {
2806         return new ItemCollection ();
2807 }
2808
2809
2810 /**
2811  * Keyboard
2812  **/
2813 int
2814 keyboard_get_modifiers (void)
2815 {
2816         return Keyboard::GetModifiers ();
2817 }
2818
2819
2820 /**
2821  * KeyEventArgs
2822  **/
2823 int
2824 key_event_args_get_key (KeyEventArgs *instance)
2825 {
2826         if (instance == NULL)
2827                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2828                 return (int) 0;
2829
2830         return instance->GetKey ();
2831 }
2832
2833
2834 int
2835 key_event_args_get_platform_key_code (KeyEventArgs *instance)
2836 {
2837         if (instance == NULL)
2838                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2839                 return (int) 0;
2840
2841         return instance->GetPlatformKeyCode ();
2842 }
2843
2844
2845 KeyEventArgs *
2846 key_event_args_new (void)
2847 {
2848         return new KeyEventArgs ();
2849 }
2850
2851
2852 /**
2853  * KeyFrameCollection
2854  **/
2855 KeyFrameCollection *
2856 key_frame_collection_new (void)
2857 {
2858         return new KeyFrameCollection ();
2859 }
2860
2861
2862 /**
2863  * KeySpline
2864  **/
2865 KeySpline *
2866 key_spline_new (void)
2867 {
2868         return new KeySpline ();
2869 }
2870
2871
2872 /**
2873  * Line
2874  **/
2875 Line *
2876 line_new (void)
2877 {
2878         return new Line ();
2879 }
2880
2881
2882 /**
2883  * LinearColorKeyFrame
2884  **/
2885 LinearColorKeyFrame *
2886 linear_color_key_frame_new (void)
2887 {
2888         return new LinearColorKeyFrame ();
2889 }
2890
2891
2892 /**
2893  * LinearDoubleKeyFrame
2894  **/
2895 LinearDoubleKeyFrame *
2896 linear_double_key_frame_new (void)
2897 {
2898         return new LinearDoubleKeyFrame ();
2899 }
2900
2901
2902 /**
2903  * LinearGradientBrush
2904  **/
2905 LinearGradientBrush *
2906 linear_gradient_brush_new (void)
2907 {
2908         return new LinearGradientBrush ();
2909 }
2910
2911
2912 /**
2913  * LinearPointKeyFrame
2914  **/
2915 LinearPointKeyFrame *
2916 linear_point_key_frame_new (void)
2917 {
2918         return new LinearPointKeyFrame ();
2919 }
2920
2921
2922 /**
2923  * LineBreak
2924  **/
2925 LineBreak *
2926 line_break_new (void)
2927 {
2928         return new LineBreak ();
2929 }
2930
2931
2932 /**
2933  * LineGeometry
2934  **/
2935 LineGeometry *
2936 line_geometry_new (void)
2937 {
2938         return new LineGeometry ();
2939 }
2940
2941
2942 /**
2943  * LineSegment
2944  **/
2945 LineSegment *
2946 line_segment_new (void)
2947 {
2948         return new LineSegment ();
2949 }
2950
2951
2952 /**
2953  * LogReadyRoutedEventArgs
2954  **/
2955 LogReadyRoutedEventArgs *
2956 log_ready_routed_event_args_new (void)
2957 {
2958         return new LogReadyRoutedEventArgs ();
2959 }
2960
2961
2962 /**
2963  * Matrix
2964  **/
2965 cairo_matrix_t *
2966 matrix_get_matrix_values (Matrix *instance)
2967 {
2968         if (instance == NULL)
2969                 return NULL;
2970
2971         return instance->GetMatrixValues ();
2972 }
2973
2974
2975 Matrix *
2976 matrix_new (void)
2977 {
2978         return new Matrix ();
2979 }
2980
2981
2982 /**
2983  * Matrix3D
2984  **/
2985 gpointer
2986 matrix3_d_get_matrix_values (Matrix3D *instance)
2987 {
2988         if (instance == NULL)
2989                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
2990                 return (gpointer) 0;
2991
2992         return instance->GetMatrixValues ();
2993 }
2994
2995
2996 Matrix3D *
2997 matrix3_d_new (void)
2998 {
2999         return new Matrix3D ();
3000 }
3001
3002
3003 /**
3004  * Matrix3DProjection
3005  **/
3006 Matrix3DProjection *
3007 matrix3_dprojection_new (void)
3008 {
3009         return new Matrix3DProjection ();
3010 }
3011
3012
3013 /**
3014  * MatrixTransform
3015  **/
3016 MatrixTransform *
3017 matrix_transform_new (void)
3018 {
3019         return new MatrixTransform ();
3020 }
3021
3022
3023 /**
3024  * Media
3025  **/
3026 void
3027 media_register_decoder (DecoderInfo *info)
3028 {
3029         Media::RegisterDecoder (info);
3030 }
3031
3032
3033 /**
3034  * MediaAttribute
3035  **/
3036 MediaAttribute *
3037 media_attribute_new (void)
3038 {
3039         return new MediaAttribute ();
3040 }
3041
3042
3043 /**
3044  * MediaAttributeCollection
3045  **/
3046 MediaAttribute *
3047 media_attribute_collection_get_item_by_name (MediaAttributeCollection *instance, const char *name)
3048 {
3049         if (instance == NULL)
3050                 return NULL;
3051
3052         return instance->GetItemByName (name);
3053 }
3054
3055
3056 MediaAttributeCollection *
3057 media_attribute_collection_new (void)
3058 {
3059         return new MediaAttributeCollection ();
3060 }
3061
3062
3063 /**
3064  * MediaBase
3065  **/
3066 MediaBase *
3067 media_base_new (void)
3068 {
3069         return new MediaBase ();
3070 }
3071
3072
3073 void
3074 media_base_set_source (MediaBase *instance, const char *uri)
3075 {
3076         if (instance == NULL)
3077                 return;
3078
3079         instance->SetSource (uri);
3080 }
3081
3082
3083 /**
3084  * MediaElement
3085  **/
3086 MediaElement *
3087 media_element_new (void)
3088 {
3089         return new MediaElement ();
3090 }
3091
3092
3093 void
3094 media_element_pause (MediaElement *instance)
3095 {
3096         if (instance == NULL)
3097                 return;
3098
3099         instance->Pause ();
3100 }
3101
3102
3103 void
3104 media_element_play (MediaElement *instance)
3105 {
3106         if (instance == NULL)
3107                 return;
3108
3109         instance->Play ();
3110 }
3111
3112
3113 void
3114 media_element_report_error_occurred (MediaElement *instance, const char *args)
3115 {
3116         if (instance == NULL)
3117                 return;
3118
3119         instance->ReportErrorOccurred (args);
3120 }
3121
3122
3123 IMediaDemuxer *
3124 media_element_set_demuxer_source (MediaElement *instance, void *context, CloseDemuxerCallback close_demuxer, GetDiagnosticAsyncCallback get_diagnostic, GetFrameAsyncCallback get_sample, OpenDemuxerAsyncCallback open_demuxer, SeekAsyncCallback seek, SwitchMediaStreamAsyncCallback switch_media_stream)
3125 {
3126         if (instance == NULL)
3127                 return NULL;
3128
3129         return instance->SetDemuxerSource (context, close_demuxer, get_diagnostic, get_sample, open_demuxer, seek, switch_media_stream);
3130 }
3131
3132
3133 void
3134 media_element_set_stream_source (MediaElement *instance, ManagedStreamCallbacks *stream)
3135 {
3136         if (instance == NULL)
3137                 return;
3138
3139         instance->SetStreamSource (stream);
3140 }
3141
3142
3143 void
3144 media_element_stop (MediaElement *instance)
3145 {
3146         if (instance == NULL)
3147                 return;
3148
3149         instance->Stop ();
3150 }
3151
3152
3153 /**
3154  * MediaFrame
3155  **/
3156 void
3157 media_frame_add_state (MediaFrame *instance, int state)
3158 {
3159         if (instance == NULL)
3160                 return;
3161
3162         instance->AddState ((MediaFrameState) state);
3163 }
3164
3165
3166 guint8 *
3167 media_frame_get_buffer (MediaFrame *instance)
3168 {
3169         if (instance == NULL)
3170                 return NULL;
3171
3172         return instance->GetBuffer ();
3173 }
3174
3175
3176 guint32
3177 media_frame_get_buf_len (MediaFrame *instance)
3178 {
3179         if (instance == NULL)
3180                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3181                 return (guint32) 0;
3182
3183         return instance->GetBufLen ();
3184 }
3185
3186
3187 gint32
3188 media_frame_get_height (MediaFrame *instance)
3189 {
3190         if (instance == NULL)
3191                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3192                 return (gint32) 0;
3193
3194         return instance->GetHeight ();
3195 }
3196
3197
3198 guint64
3199 media_frame_get_pts (MediaFrame *instance)
3200 {
3201         if (instance == NULL)
3202                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3203                 return (guint64) 0;
3204
3205         return instance->GetPts ();
3206 }
3207
3208
3209 gint32
3210 media_frame_get_width (MediaFrame *instance)
3211 {
3212         if (instance == NULL)
3213                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3214                 return (gint32) 0;
3215
3216         return instance->GetWidth ();
3217 }
3218
3219
3220 bool
3221 media_frame_is_key_frame (MediaFrame *instance)
3222 {
3223         if (instance == NULL)
3224                 return false;
3225
3226         return instance->IsKeyFrame ();
3227 }
3228
3229
3230 MediaFrame *
3231 media_frame_new (IMediaStream *stream, guint8 *buffer, guint32 buflen, guint64 pts, bool keyframe)
3232 {
3233         return new MediaFrame (stream, buffer, buflen, pts, keyframe);
3234 }
3235
3236
3237 void
3238 media_frame_set_buffer (MediaFrame *instance, guint8 *value)
3239 {
3240         if (instance == NULL)
3241                 return;
3242
3243         instance->SetBuffer (value);
3244 }
3245
3246
3247 void
3248 media_frame_set_buf_len (MediaFrame *instance, guint32 value)
3249 {
3250         if (instance == NULL)
3251                 return;
3252
3253         instance->SetBufLen (value);
3254 }
3255
3256
3257 void
3258 media_frame_set_data_stride (MediaFrame *instance, guint8 *a, guint8 *b, guint8 *c, guint8 *d)
3259 {
3260         if (instance == NULL)
3261                 return;
3262
3263         instance->SetDataStride (a, b, c, d);
3264 }
3265
3266
3267 void
3268 media_frame_set_decoder_specific_data (MediaFrame *instance, void *value)
3269 {
3270         if (instance == NULL)
3271                 return;
3272
3273         instance->SetDecoderSpecificData (value);
3274 }
3275
3276
3277 void
3278 media_frame_set_height (MediaFrame *instance, gint32 value)
3279 {
3280         if (instance == NULL)
3281                 return;
3282
3283         instance->SetHeight (value);
3284 }
3285
3286
3287 void
3288 media_frame_set_pts (MediaFrame *instance, guint64 value)
3289 {
3290         if (instance == NULL)
3291                 return;
3292
3293         instance->SetPts (value);
3294 }
3295
3296
3297 void
3298 media_frame_set_src_slide_h (MediaFrame *instance, int value)
3299 {
3300         if (instance == NULL)
3301                 return;
3302
3303         instance->SetSrcSlideH (value);
3304 }
3305
3306
3307 void
3308 media_frame_set_src_slide_y (MediaFrame *instance, int value)
3309 {
3310         if (instance == NULL)
3311                 return;
3312
3313         instance->SetSrcSlideY (value);
3314 }
3315
3316
3317 void
3318 media_frame_set_src_stride (MediaFrame *instance, int a, int b, int c, int d)
3319 {
3320         if (instance == NULL)
3321                 return;
3322
3323         instance->SetSrcStride (a, b, c, d);
3324 }
3325
3326
3327 void
3328 media_frame_set_width (MediaFrame *instance, gint32 value)
3329 {
3330         if (instance == NULL)
3331                 return;
3332
3333         instance->SetWidth (value);
3334 }
3335
3336
3337 /**
3338  * MoonWindow
3339  **/
3340 bool
3341 moon_window_get_transparent (MoonWindow *instance)
3342 {
3343         if (instance == NULL)
3344                 return false;
3345
3346         return instance->GetTransparent ();
3347 }
3348
3349
3350 void
3351 moon_window_set_transparent (MoonWindow *instance, bool flag)
3352 {
3353         if (instance == NULL)
3354                 return;
3355
3356         instance->SetTransparent (flag);
3357 }
3358
3359
3360 /**
3361  * MoonWindowGtk
3362  **/
3363 void *
3364 moon_window_gtk_get_native_widget (MoonWindowGtk *instance)
3365 {
3366         if (instance == NULL)
3367                 return NULL;
3368
3369         return instance->GetNativeWidget ();
3370 }
3371
3372
3373 MoonWindowGtk *
3374 moon_window_gtk_new (bool fullscreen, int w, int h, MoonWindow *parent, Surface *surface)
3375 {
3376         return new MoonWindowGtk (fullscreen, w, h, parent, surface);
3377 }
3378
3379
3380 /**
3381  * MouseButtonEventArgs
3382  **/
3383 MouseButtonEventArgs *
3384 mouse_button_event_args_new (void)
3385 {
3386         return new MouseButtonEventArgs ();
3387 }
3388
3389
3390 /**
3391  * MouseEventArgs
3392  **/
3393 void
3394 mouse_event_args_get_position (MouseEventArgs *instance, UIElement *relative_to, double *x, double *y)
3395 {
3396         if (instance == NULL)
3397                 return;
3398
3399         instance->GetPosition (relative_to, x, y);
3400 }
3401
3402
3403 StylusInfo *
3404 mouse_event_args_get_stylus_info (MouseEventArgs *instance)
3405 {
3406         if (instance == NULL)
3407                 return NULL;
3408
3409         return instance->GetStylusInfo ();
3410 }
3411
3412
3413 StylusPointCollection *
3414 mouse_event_args_get_stylus_points (MouseEventArgs *instance, UIElement *ink_presenter)
3415 {
3416         if (instance == NULL)
3417                 return NULL;
3418
3419         return instance->GetStylusPoints (ink_presenter);
3420 }
3421
3422
3423 MouseEventArgs *
3424 mouse_event_args_new (void)
3425 {
3426         return new MouseEventArgs ();
3427 }
3428
3429
3430 /**
3431  * MouseWheelEventArgs
3432  **/
3433 int
3434 mouse_wheel_event_args_get_wheel_delta (MouseWheelEventArgs *instance)
3435 {
3436         if (instance == NULL)
3437                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3438                 return (int) 0;
3439
3440         return instance->GetWheelDelta ();
3441 }
3442
3443
3444 MouseWheelEventArgs *
3445 mouse_wheel_event_args_new (void)
3446 {
3447         return new MouseWheelEventArgs ();
3448 }
3449
3450
3451 /**
3452  * MultiScaleImage
3453  **/
3454 Point
3455 multi_scale_image_element_to_logical_point (MultiScaleImage *instance, Point elementPoint)
3456 {
3457         if (instance == NULL)
3458                 return Point (0, 0);
3459
3460         return instance->ElementToLogicalPoint (elementPoint);
3461 }
3462
3463
3464 void
3465 multi_scale_image_emit_image_failed (MultiScaleImage *instance)
3466 {
3467         if (instance == NULL)
3468                 return;
3469
3470         instance->EmitImageFailed ();
3471 }
3472
3473
3474 void
3475 multi_scale_image_emit_image_open_failed (MultiScaleImage *instance)
3476 {
3477         if (instance == NULL)
3478                 return;
3479
3480         instance->EmitImageOpenFailed ();
3481 }
3482
3483
3484 void
3485 multi_scale_image_emit_motion_finished (MultiScaleImage *instance)
3486 {
3487         if (instance == NULL)
3488                 return;
3489
3490         instance->EmitMotionFinished ();
3491 }
3492
3493
3494 void
3495 multi_scale_image_handle_dz_parsed (MultiScaleImage *instance)
3496 {
3497         if (instance == NULL)
3498                 return;
3499
3500         instance->HandleDzParsed ();
3501 }
3502
3503
3504 void
3505 multi_scale_image_invalidate_tile_layer (MultiScaleImage *instance, int level, int tilePositionX, int tilePositionY, int tileLayer)
3506 {
3507         if (instance == NULL)
3508                 return;
3509
3510         instance->InvalidateTileLayer (level, tilePositionX, tilePositionY, tileLayer);
3511 }
3512
3513
3514 Point
3515 multi_scale_image_logical_to_element_point (MultiScaleImage *instance, Point logicalPoint)
3516 {
3517         if (instance == NULL)
3518                 return Point (0, 0);
3519
3520         return instance->LogicalToElementPoint (logicalPoint);
3521 }
3522
3523
3524 MultiScaleImage *
3525 multi_scale_image_new (void)
3526 {
3527         return new MultiScaleImage ();
3528 }
3529
3530
3531 void
3532 multi_scale_image_on_source_property_changed (MultiScaleImage *instance)
3533 {
3534         if (instance == NULL)
3535                 return;
3536
3537         instance->OnSourcePropertyChanged ();
3538 }
3539
3540
3541 void
3542 multi_scale_image_zoom_about_logical_point (MultiScaleImage *instance, double zoomIncrementFactor, double zoomCenterLogicalX, double zoomCenterLogicalY)
3543 {
3544         if (instance == NULL)
3545                 return;
3546
3547         instance->ZoomAboutLogicalPoint (zoomIncrementFactor, zoomCenterLogicalX, zoomCenterLogicalY);
3548 }
3549
3550
3551 /**
3552  * MultiScaleSubImage
3553  **/
3554 gint32
3555 multi_scale_sub_image_get_zindex (MultiScaleSubImage *instance)
3556 {
3557         if (instance == NULL)
3558                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3559                 return (gint32) 0;
3560
3561         return instance->GetZIndex ();
3562 }
3563
3564
3565 MultiScaleSubImage *
3566 multi_scale_sub_image_new (void)
3567 {
3568         return new MultiScaleSubImage ();
3569 }
3570
3571
3572 /**
3573  * MultiScaleSubImageCollection
3574  **/
3575 MultiScaleSubImageCollection *
3576 multi_scale_sub_image_collection_new (void)
3577 {
3578         return new MultiScaleSubImageCollection ();
3579 }
3580
3581
3582 /**
3583  * MultiScaleTileSource
3584  **/
3585 void
3586 multi_scale_tile_source_invalidate_tile_layer (MultiScaleTileSource *instance, int level, int tilePositionX, int tilePositionY, int tileLayer)
3587 {
3588         if (instance == NULL)
3589                 return;
3590
3591         instance->InvalidateTileLayer (level, tilePositionX, tilePositionY, tileLayer);
3592 }
3593
3594
3595 MultiScaleTileSource *
3596 multi_scale_tile_source_new (void)
3597 {
3598         return new MultiScaleTileSource ();
3599 }
3600
3601
3602 void
3603 multi_scale_tile_source_set_image_uri_func (MultiScaleTileSource *instance, get_image_uri_func func)
3604 {
3605         if (instance == NULL)
3606                 return;
3607
3608         instance->set_image_uri_func (func);
3609 }
3610
3611
3612 /**
3613  * NameScope
3614  **/
3615 NameScope *
3616 name_scope_new (void)
3617 {
3618         return new NameScope ();
3619 }
3620
3621
3622 /**
3623  * ObjectAnimationUsingKeyFrames
3624  **/
3625 ObjectAnimationUsingKeyFrames *
3626 object_animation_using_key_frames_new (void)
3627 {
3628         return new ObjectAnimationUsingKeyFrames ();
3629 }
3630
3631
3632 /**
3633  * ObjectKeyFrame
3634  **/
3635 ObjectKeyFrame *
3636 object_key_frame_new (void)
3637 {
3638         return new ObjectKeyFrame ();
3639 }
3640
3641
3642 /**
3643  * ObjectKeyFrameCollection
3644  **/
3645 ObjectKeyFrameCollection *
3646 object_key_frame_collection_new (void)
3647 {
3648         return new ObjectKeyFrameCollection ();
3649 }
3650
3651
3652 /**
3653  * OutOfBrowserSettings
3654  **/
3655 OutOfBrowserSettings *
3656 out_of_browser_settings_new (void)
3657 {
3658         return new OutOfBrowserSettings ();
3659 }
3660
3661
3662 /**
3663  * Panel
3664  **/
3665 Panel *
3666 panel_new (void)
3667 {
3668         return new Panel ();
3669 }
3670
3671
3672 /**
3673  * ParallelTimeline
3674  **/
3675 ParallelTimeline *
3676 parallel_timeline_new (void)
3677 {
3678         return new ParallelTimeline ();
3679 }
3680
3681
3682 /**
3683  * PasswordBox
3684  **/
3685 PasswordBox *
3686 password_box_new (void)
3687 {
3688         return new PasswordBox ();
3689 }
3690
3691
3692 /**
3693  * Path
3694  **/
3695 Path *
3696 path_new (void)
3697 {
3698         return new Path ();
3699 }
3700
3701
3702 /**
3703  * PathFigure
3704  **/
3705 PathFigure *
3706 path_figure_new (void)
3707 {
3708         return new PathFigure ();
3709 }
3710
3711
3712 /**
3713  * PathFigureCollection
3714  **/
3715 PathFigureCollection *
3716 path_figure_collection_new (void)
3717 {
3718         return new PathFigureCollection ();
3719 }
3720
3721
3722 /**
3723  * PathGeometry
3724  **/
3725 PathGeometry *
3726 path_geometry_new (void)
3727 {
3728         return new PathGeometry ();
3729 }
3730
3731
3732 /**
3733  * PathSegment
3734  **/
3735 PathSegment *
3736 path_segment_new (void)
3737 {
3738         return new PathSegment ();
3739 }
3740
3741
3742 /**
3743  * PathSegmentCollection
3744  **/
3745 PathSegmentCollection *
3746 path_segment_collection_new (void)
3747 {
3748         return new PathSegmentCollection ();
3749 }
3750
3751
3752 /**
3753  * PixelShader
3754  **/
3755 PixelShader *
3756 pixel_shader_new (void)
3757 {
3758         return new PixelShader ();
3759 }
3760
3761
3762 /**
3763  * PlaneProjection
3764  **/
3765 PlaneProjection *
3766 plane_projection_new (void)
3767 {
3768         return new PlaneProjection ();
3769 }
3770
3771
3772 /**
3773  * PointAnimation
3774  **/
3775 PointAnimation *
3776 point_animation_new (void)
3777 {
3778         return new PointAnimation ();
3779 }
3780
3781
3782 /**
3783  * PointAnimationUsingKeyFrames
3784  **/
3785 PointAnimationUsingKeyFrames *
3786 point_animation_using_key_frames_new (void)
3787 {
3788         return new PointAnimationUsingKeyFrames ();
3789 }
3790
3791
3792 /**
3793  * PointCollection
3794  **/
3795 PointCollection *
3796 point_collection_new (void)
3797 {
3798         return new PointCollection ();
3799 }
3800
3801
3802 /**
3803  * PointKeyFrame
3804  **/
3805 PointKeyFrame *
3806 point_key_frame_new (void)
3807 {
3808         return new PointKeyFrame ();
3809 }
3810
3811
3812 /**
3813  * PointKeyFrameCollection
3814  **/
3815 PointKeyFrameCollection *
3816 point_key_frame_collection_new (void)
3817 {
3818         return new PointKeyFrameCollection ();
3819 }
3820
3821
3822 /**
3823  * PolyBezierSegment
3824  **/
3825 PolyBezierSegment *
3826 poly_bezier_segment_new (void)
3827 {
3828         return new PolyBezierSegment ();
3829 }
3830
3831
3832 void
3833 poly_bezier_segment_set_points (PolyBezierSegment *instance, PointCollection *points)
3834 {
3835         if (instance == NULL)
3836                 return;
3837
3838         instance->SetPoints (points);
3839 }
3840
3841
3842 /**
3843  * Polygon
3844  **/
3845 Polygon *
3846 polygon_new (void)
3847 {
3848         return new Polygon ();
3849 }
3850
3851
3852 /**
3853  * Polyline
3854  **/
3855 Polyline *
3856 polyline_new (void)
3857 {
3858         return new Polyline ();
3859 }
3860
3861
3862 /**
3863  * PolyLineSegment
3864  **/
3865 PolyLineSegment *
3866 poly_line_segment_new (void)
3867 {
3868         return new PolyLineSegment ();
3869 }
3870
3871
3872 /**
3873  * PolyQuadraticBezierSegment
3874  **/
3875 PolyQuadraticBezierSegment *
3876 poly_quadratic_bezier_segment_new (void)
3877 {
3878         return new PolyQuadraticBezierSegment ();
3879 }
3880
3881
3882 /**
3883  * Popup
3884  **/
3885 Popup *
3886 popup_new (void)
3887 {
3888         return new Popup ();
3889 }
3890
3891
3892 /**
3893  * PowerEase
3894  **/
3895 double
3896 power_ease_ease_in_core (PowerEase *instance, double normalizedTime)
3897 {
3898         if (instance == NULL)
3899                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3900                 return (double) 0;
3901
3902         return instance->EaseInCore (normalizedTime);
3903 }
3904
3905
3906 PowerEase *
3907 power_ease_new (void)
3908 {
3909         return new PowerEase ();
3910 }
3911
3912
3913 /**
3914  * Projection
3915  **/
3916 Projection *
3917 projection_new (void)
3918 {
3919         return new Projection ();
3920 }
3921
3922
3923 /**
3924  * PropertyChangedEventArgs
3925  **/
3926 int
3927 property_changed_event_args_get_id (PropertyChangedEventArgs *instance)
3928 {
3929         if (instance == NULL)
3930                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3931                 return (int) 0;
3932
3933         return instance->GetId ();
3934 }
3935
3936
3937 Value *
3938 property_changed_event_args_get_new_value (PropertyChangedEventArgs *instance)
3939 {
3940         if (instance == NULL)
3941                 return NULL;
3942
3943         return instance->GetNewValue ();
3944 }
3945
3946
3947 Value *
3948 property_changed_event_args_get_old_value (PropertyChangedEventArgs *instance)
3949 {
3950         if (instance == NULL)
3951                 return NULL;
3952
3953         return instance->GetOldValue ();
3954 }
3955
3956
3957 DependencyProperty *
3958 property_changed_event_args_get_property (PropertyChangedEventArgs *instance)
3959 {
3960         if (instance == NULL)
3961                 return NULL;
3962
3963         return instance->GetProperty ();
3964 }
3965
3966
3967 /**
3968  * QuadraticBezierSegment
3969  **/
3970 QuadraticBezierSegment *
3971 quadratic_bezier_segment_new (void)
3972 {
3973         return new QuadraticBezierSegment ();
3974 }
3975
3976
3977 /**
3978  * QuadraticEase
3979  **/
3980 double
3981 quadratic_ease_ease_in_core (QuadraticEase *instance, double normalizedTime)
3982 {
3983         if (instance == NULL)
3984                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
3985                 return (double) 0;
3986
3987         return instance->EaseInCore (normalizedTime);
3988 }
3989
3990
3991 QuadraticEase *
3992 quadratic_ease_new (void)
3993 {
3994         return new QuadraticEase ();
3995 }
3996
3997
3998 /**
3999  * QuarticEase
4000  **/
4001 double
4002 quartic_ease_ease_in_core (QuarticEase *instance, double normalizedTime)
4003 {
4004         if (instance == NULL)
4005                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4006                 return (double) 0;
4007
4008         return instance->EaseInCore (normalizedTime);
4009 }
4010
4011
4012 QuarticEase *
4013 quartic_ease_new (void)
4014 {
4015         return new QuarticEase ();
4016 }
4017
4018
4019 /**
4020  * QuinticEase
4021  **/
4022 double
4023 quintic_ease_ease_in_core (QuinticEase *instance, double normalizedTime)
4024 {
4025         if (instance == NULL)
4026                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4027                 return (double) 0;
4028
4029         return instance->EaseInCore (normalizedTime);
4030 }
4031
4032
4033 QuinticEase *
4034 quintic_ease_new (void)
4035 {
4036         return new QuinticEase ();
4037 }
4038
4039
4040 /**
4041  * RadialGradientBrush
4042  **/
4043 RadialGradientBrush *
4044 radial_gradient_brush_new (void)
4045 {
4046         return new RadialGradientBrush ();
4047 }
4048
4049
4050 /**
4051  * Rectangle
4052  **/
4053 Rectangle *
4054 rectangle_new (void)
4055 {
4056         return new Rectangle ();
4057 }
4058
4059
4060 /**
4061  * RectangleGeometry
4062  **/
4063 RectangleGeometry *
4064 rectangle_geometry_new (void)
4065 {
4066         return new RectangleGeometry ();
4067 }
4068
4069
4070 /**
4071  * RenderingEventArgs
4072  **/
4073 TimeSpan
4074 rendering_event_args_get_rendering_time (RenderingEventArgs *instance)
4075 {
4076         if (instance == NULL)
4077                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4078                 return (TimeSpan) 0;
4079
4080         return instance->GetRenderingTime ();
4081 }
4082
4083
4084 /**
4085  * ResourceDictionary
4086  **/
4087 bool
4088 resource_dictionary_add_with_error (ResourceDictionary *instance, const char *key, Value *value, MoonError *error)
4089 {
4090         if (instance == NULL)
4091                 return false;
4092
4093         if (error == NULL)
4094                 g_warning ("Moonlight: Called resource_dictionary_add_with_error () with error == NULL.");
4095         return instance->AddWithError (key, value, error);
4096 }
4097
4098
4099 bool
4100 resource_dictionary_clear (ResourceDictionary *instance)
4101 {
4102         if (instance == NULL)
4103                 return false;
4104
4105         return instance->Clear ();
4106 }
4107
4108
4109 bool
4110 resource_dictionary_contains_key (ResourceDictionary *instance, const char *key)
4111 {
4112         if (instance == NULL)
4113                 return false;
4114
4115         return instance->ContainsKey (key);
4116 }
4117
4118
4119 Value *
4120 resource_dictionary_get (ResourceDictionary *instance, const char *key, bool *exists)
4121 {
4122         if (instance == NULL)
4123                 return NULL;
4124
4125         return instance->Get (key, exists);
4126 }
4127
4128
4129 bool
4130 resource_dictionary_remove (ResourceDictionary *instance, const char *key)
4131 {
4132         if (instance == NULL)
4133                 return false;
4134
4135         return instance->Remove (key);
4136 }
4137
4138
4139 ResourceDictionary *
4140 resource_dictionary_new (void)
4141 {
4142         return new ResourceDictionary ();
4143 }
4144
4145
4146 bool
4147 resource_dictionary_set (ResourceDictionary *instance, const char *key, Value *value)
4148 {
4149         if (instance == NULL)
4150                 return false;
4151
4152         return instance->Set (key, value);
4153 }
4154
4155
4156 /**
4157  * ResourceDictionaryCollection
4158  **/
4159 ResourceDictionaryCollection *
4160 resource_dictionary_collection_new (void)
4161 {
4162         return new ResourceDictionaryCollection ();
4163 }
4164
4165
4166 /**
4167  * ResourceDictionaryIterator
4168  **/
4169 const char *
4170 resource_dictionary_iterator_get_current_key (ResourceDictionaryIterator *instance, MoonError *error)
4171 {
4172         if (instance == NULL)
4173                 return NULL;
4174
4175         if (error == NULL)
4176                 g_warning ("Moonlight: Called resource_dictionary_iterator_get_current_key () with error == NULL.");
4177         return instance->GetCurrentKey (error);
4178 }
4179
4180
4181 /**
4182  * RotateTransform
4183  **/
4184 RotateTransform *
4185 rotate_transform_new (void)
4186 {
4187         return new RotateTransform ();
4188 }
4189
4190
4191 /**
4192  * RoutedEventArgs
4193  **/
4194 bool
4195 routed_event_args_get_handled (RoutedEventArgs *instance)
4196 {
4197         if (instance == NULL)
4198                 return false;
4199
4200         return instance->GetHandled ();
4201 }
4202
4203
4204 DependencyObject *
4205 routed_event_args_get_source (RoutedEventArgs *instance)
4206 {
4207         if (instance == NULL)
4208                 return NULL;
4209
4210         return instance->GetSource ();
4211 }
4212
4213
4214 RoutedEventArgs *
4215 routed_event_args_new (void)
4216 {
4217         return new RoutedEventArgs ();
4218 }
4219
4220
4221 void
4222 routed_event_args_set_handled (RoutedEventArgs *instance, bool handled)
4223 {
4224         if (instance == NULL)
4225                 return;
4226
4227         instance->SetHandled (handled);
4228 }
4229
4230
4231 void
4232 routed_event_args_set_source (RoutedEventArgs *instance, DependencyObject *el)
4233 {
4234         if (instance == NULL)
4235                 return;
4236
4237         instance->SetSource (el);
4238 }
4239
4240
4241 /**
4242  * RowDefinition
4243  **/
4244 RowDefinition *
4245 row_definition_new (void)
4246 {
4247         return new RowDefinition ();
4248 }
4249
4250
4251 /**
4252  * RowDefinitionCollection
4253  **/
4254 RowDefinitionCollection *
4255 row_definition_collection_new (void)
4256 {
4257         return new RowDefinitionCollection ();
4258 }
4259
4260
4261 /**
4262  * Run
4263  **/
4264 Run *
4265 run_new (void)
4266 {
4267         return new Run ();
4268 }
4269
4270
4271 /**
4272  * ScaleTransform
4273  **/
4274 ScaleTransform *
4275 scale_transform_new (void)
4276 {
4277         return new ScaleTransform ();
4278 }
4279
4280
4281 /**
4282  * Setter
4283  **/
4284 Setter *
4285 setter_new (void)
4286 {
4287         return new Setter ();
4288 }
4289
4290
4291 /**
4292  * SetterBase
4293  **/
4294 SetterBase *
4295 setter_base_new (void)
4296 {
4297         return new SetterBase ();
4298 }
4299
4300
4301 /**
4302  * SetterBaseCollection
4303  **/
4304 SetterBaseCollection *
4305 setter_base_collection_new (void)
4306 {
4307         return new SetterBaseCollection ();
4308 }
4309
4310
4311 /**
4312  * ShaderEffect
4313  **/
4314 ShaderEffect *
4315 shader_effect_new (void)
4316 {
4317         return new ShaderEffect ();
4318 }
4319
4320
4321 /**
4322  * Shape
4323  **/
4324 Transform *
4325 shape_get_geometry_transform (Shape *instance)
4326 {
4327         if (instance == NULL)
4328                 return NULL;
4329
4330         return instance->GetGeometryTransform ();
4331 }
4332
4333
4334 Shape *
4335 shape_new (void)
4336 {
4337         return new Shape ();
4338 }
4339
4340
4341 /**
4342  * SineEase
4343  **/
4344 double
4345 sine_ease_ease_in_core (SineEase *instance, double normalizedTime)
4346 {
4347         if (instance == NULL)
4348                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4349                 return (double) 0;
4350
4351         return instance->EaseInCore (normalizedTime);
4352 }
4353
4354
4355 SineEase *
4356 sine_ease_new (void)
4357 {
4358         return new SineEase ();
4359 }
4360
4361
4362 /**
4363  * SizeChangedEventArgs
4364  **/
4365 SizeChangedEventArgs *
4366 size_changed_event_args_new (void)
4367 {
4368         return new SizeChangedEventArgs ();
4369 }
4370
4371
4372 /**
4373  * SkewTransform
4374  **/
4375 SkewTransform *
4376 skew_transform_new (void)
4377 {
4378         return new SkewTransform ();
4379 }
4380
4381
4382 /**
4383  * SolidColorBrush
4384  **/
4385 SolidColorBrush *
4386 solid_color_brush_new (void)
4387 {
4388         return new SolidColorBrush ();
4389 }
4390
4391
4392 /**
4393  * SplineColorKeyFrame
4394  **/
4395 SplineColorKeyFrame *
4396 spline_color_key_frame_new (void)
4397 {
4398         return new SplineColorKeyFrame ();
4399 }
4400
4401
4402 /**
4403  * SplineDoubleKeyFrame
4404  **/
4405 SplineDoubleKeyFrame *
4406 spline_double_key_frame_new (void)
4407 {
4408         return new SplineDoubleKeyFrame ();
4409 }
4410
4411
4412 /**
4413  * SplinePointKeyFrame
4414  **/
4415 SplinePointKeyFrame *
4416 spline_point_key_frame_new (void)
4417 {
4418         return new SplinePointKeyFrame ();
4419 }
4420
4421
4422 /**
4423  * Storyboard
4424  **/
4425 bool
4426 storyboard_begin_with_error (Storyboard *instance, MoonError *error)
4427 {
4428         if (instance == NULL)
4429                 return false;
4430
4431         if (error == NULL)
4432                 g_warning ("Moonlight: Called storyboard_begin_with_error () with error == NULL.");
4433         return instance->BeginWithError (error);
4434 }
4435
4436
4437 int
4438 storyboard_get_current_state (Storyboard *instance)
4439 {
4440         if (instance == NULL)
4441                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4442                 return (int) 0;
4443
4444         return instance->GetCurrentState ();
4445 }
4446
4447
4448 TimeSpan
4449 storyboard_get_current_time (Storyboard *instance)
4450 {
4451         if (instance == NULL)
4452                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4453                 return (TimeSpan) 0;
4454
4455         return instance->GetCurrentTime ();
4456 }
4457
4458
4459 DependencyProperty *
4460 storyboard_get_target_dependency_property (Storyboard *instance)
4461 {
4462         if (instance == NULL)
4463                 return NULL;
4464
4465         return instance->GetTargetDependencyProperty ();
4466 }
4467
4468
4469 void
4470 storyboard_pause_with_error (Storyboard *instance, MoonError *error)
4471 {
4472         if (instance == NULL)
4473                 return;
4474
4475         if (error == NULL)
4476                 g_warning ("Moonlight: Called storyboard_pause_with_error () with error == NULL.");
4477         instance->PauseWithError (error);
4478 }
4479
4480
4481 void
4482 storyboard_resume_with_error (Storyboard *instance, MoonError *error)
4483 {
4484         if (instance == NULL)
4485                 return;
4486
4487         if (error == NULL)
4488                 g_warning ("Moonlight: Called storyboard_resume_with_error () with error == NULL.");
4489         instance->ResumeWithError (error);
4490 }
4491
4492
4493 void
4494 storyboard_seek_aligned_to_last_tick_with_error (Storyboard *instance, TimeSpan timespan, MoonError *error)
4495 {
4496         if (instance == NULL)
4497                 return;
4498
4499         if (error == NULL)
4500                 g_warning ("Moonlight: Called storyboard_seek_aligned_to_last_tick_with_error () with error == NULL.");
4501         instance->SeekAlignedToLastTickWithError (timespan, error);
4502 }
4503
4504
4505 void
4506 storyboard_seek_with_error (Storyboard *instance, TimeSpan timespan, MoonError *error)
4507 {
4508         if (instance == NULL)
4509                 return;
4510
4511         if (error == NULL)
4512                 g_warning ("Moonlight: Called storyboard_seek_with_error () with error == NULL.");
4513         instance->SeekWithError (timespan, error);
4514 }
4515
4516
4517 void
4518 storyboard_skip_to_fill_with_error (Storyboard *instance, MoonError *error)
4519 {
4520         if (instance == NULL)
4521                 return;
4522
4523         if (error == NULL)
4524                 g_warning ("Moonlight: Called storyboard_skip_to_fill_with_error () with error == NULL.");
4525         instance->SkipToFillWithError (error);
4526 }
4527
4528
4529 void
4530 storyboard_stop_with_error (Storyboard *instance, MoonError *error)
4531 {
4532         if (instance == NULL)
4533                 return;
4534
4535         if (error == NULL)
4536                 g_warning ("Moonlight: Called storyboard_stop_with_error () with error == NULL.");
4537         instance->StopWithError (error);
4538 }
4539
4540
4541 Storyboard *
4542 storyboard_new (void)
4543 {
4544         return new Storyboard ();
4545 }
4546
4547
4548 /**
4549  * Stroke
4550  **/
4551 bool
4552 stroke_hit_test (Stroke *instance, StylusPointCollection *stylusPoints)
4553 {
4554         if (instance == NULL)
4555                 return false;
4556
4557         return instance->HitTest (stylusPoints);
4558 }
4559
4560
4561 Stroke *
4562 stroke_new (void)
4563 {
4564         return new Stroke ();
4565 }
4566
4567
4568 /**
4569  * StrokeCollection
4570  **/
4571 StrokeCollection *
4572 stroke_collection_hit_test (StrokeCollection *instance, StylusPointCollection *stylusPoints)
4573 {
4574         if (instance == NULL)
4575                 return NULL;
4576
4577         return instance->HitTest (stylusPoints);
4578 }
4579
4580
4581 StrokeCollection *
4582 stroke_collection_new (void)
4583 {
4584         return new StrokeCollection ();
4585 }
4586
4587
4588 /**
4589  * Style
4590  **/
4591 void
4592 style_seal (Style *instance)
4593 {
4594         if (instance == NULL)
4595                 return;
4596
4597         instance->Seal ();
4598 }
4599
4600
4601 Style *
4602 style_new (void)
4603 {
4604         return new Style ();
4605 }
4606
4607
4608 /**
4609  * StylusInfo
4610  **/
4611 StylusInfo *
4612 stylus_info_new (void)
4613 {
4614         return new StylusInfo ();
4615 }
4616
4617
4618 /**
4619  * StylusPoint
4620  **/
4621 double
4622 stylus_point_get_pressure_factor (StylusPoint *instance)
4623 {
4624         if (instance == NULL)
4625                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4626                 return (double) 0;
4627
4628         return instance->GetPressureFactor ();
4629 }
4630
4631
4632 double
4633 stylus_point_get_x (StylusPoint *instance)
4634 {
4635         if (instance == NULL)
4636                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4637                 return (double) 0;
4638
4639         return instance->GetX ();
4640 }
4641
4642
4643 double
4644 stylus_point_get_y (StylusPoint *instance)
4645 {
4646         if (instance == NULL)
4647                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4648                 return (double) 0;
4649
4650         return instance->GetY ();
4651 }
4652
4653
4654 void
4655 stylus_point_set_pressure_factor (StylusPoint *instance, double factor)
4656 {
4657         if (instance == NULL)
4658                 return;
4659
4660         instance->SetPressureFactor (factor);
4661 }
4662
4663
4664 void
4665 stylus_point_set_x (StylusPoint *instance, double x)
4666 {
4667         if (instance == NULL)
4668                 return;
4669
4670         instance->SetX (x);
4671 }
4672
4673
4674 void
4675 stylus_point_set_y (StylusPoint *instance, double y)
4676 {
4677         if (instance == NULL)
4678                 return;
4679
4680         instance->SetY (y);
4681 }
4682
4683
4684 StylusPoint *
4685 stylus_point_new (void)
4686 {
4687         return new StylusPoint ();
4688 }
4689
4690
4691 /**
4692  * StylusPointCollection
4693  **/
4694 double
4695 stylus_point_collection_add_stylus_points (StylusPointCollection *instance, StylusPointCollection *stylusPointCollection)
4696 {
4697         if (instance == NULL)
4698                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4699                 return (double) 0;
4700
4701         return instance->AddStylusPoints (stylusPointCollection);
4702 }
4703
4704
4705 StylusPointCollection *
4706 stylus_point_collection_new (void)
4707 {
4708         return new StylusPointCollection ();
4709 }
4710
4711
4712 /**
4713  * Surface
4714  **/
4715 void
4716 surface_attach (Surface *instance, UIElement *toplevel)
4717 {
4718         if (instance == NULL)
4719                 return;
4720
4721         instance->Attach (toplevel);
4722 }
4723
4724
4725 Downloader *
4726 surface_create_downloader (Surface *instance)
4727 {
4728         if (instance == NULL)
4729                 return NULL;
4730
4731         return instance->CreateDownloader ();
4732 }
4733
4734
4735 void
4736 surface_emit_error (Surface *instance, int number, int code, const char *message)
4737 {
4738         if (instance == NULL)
4739                 return;
4740
4741         instance->EmitError (number, code, message);
4742 }
4743
4744
4745 Color *
4746 surface_get_background_color (Surface *instance)
4747 {
4748         if (instance == NULL)
4749                 return NULL;
4750
4751         return instance->GetBackgroundColor ();
4752 }
4753
4754
4755 UIElement *
4756 surface_get_focused_element (Surface *instance)
4757 {
4758         if (instance == NULL)
4759                 return NULL;
4760
4761         return instance->GetFocusedElement ();
4762 }
4763
4764
4765 bool
4766 surface_get_full_screen (Surface *instance)
4767 {
4768         if (instance == NULL)
4769                 return false;
4770
4771         return instance->GetFullScreen ();
4772 }
4773
4774
4775 TimeManager *
4776 surface_get_time_manager (Surface *instance)
4777 {
4778         if (instance == NULL)
4779                 return NULL;
4780
4781         return instance->GetTimeManager ();
4782 }
4783
4784
4785 UIElement *
4786 surface_get_toplevel (Surface *instance)
4787 {
4788         if (instance == NULL)
4789                 return NULL;
4790
4791         return instance->GetToplevel ();
4792 }
4793
4794
4795 MoonWindow *
4796 surface_get_window (Surface *instance)
4797 {
4798         if (instance == NULL)
4799                 return NULL;
4800
4801         return instance->GetWindow ();
4802 }
4803
4804
4805 double
4806 surface_get_zoom_factor (Surface *instance)
4807 {
4808         if (instance == NULL)
4809                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
4810                 return (double) 0;
4811
4812         return instance->GetZoomFactor ();
4813 }
4814
4815
4816 bool
4817 surface_in_main_thread (void)
4818 {
4819         return Surface::InMainThread ();
4820 }
4821
4822
4823 bool
4824 surface_is_loaded (Surface *instance)
4825 {
4826         if (instance == NULL)
4827                 return false;
4828
4829         return instance->IsLoaded ();
4830 }
4831
4832
4833 bool
4834 surface_is_user_initiated_event (Surface *instance)
4835 {
4836         if (instance == NULL)
4837                 return false;
4838
4839         return instance->IsUserInitiatedEvent ();
4840 }
4841
4842
4843 bool
4844 surface_is_version_supported (const char *version)
4845 {
4846         return Surface::IsVersionSupported (version);
4847 }
4848
4849
4850 void
4851 surface_paint (Surface *instance, cairo_t *ctx, int x, int y, int width, int height)
4852 {
4853         if (instance == NULL)
4854                 return;
4855
4856         instance->Paint (ctx, x, y, width, height);
4857 }
4858
4859
4860 void
4861 surface_resize (Surface *instance, int width, int height)
4862 {
4863         if (instance == NULL)
4864                 return;
4865
4866         instance->Resize (width, height);
4867 }
4868
4869
4870 void
4871 surface_set_full_screen (Surface *instance, bool value)
4872 {
4873         if (instance == NULL)
4874                 return;
4875
4876         instance->SetFullScreen (value);
4877 }
4878
4879
4880 Surface *
4881 surface_new (MoonWindow *window)
4882 {
4883         return new Surface (window);
4884 }
4885
4886
4887 /**
4888  * TabNavigationWalker
4889  **/
4890 bool
4891 tab_navigation_walker_focus (UIElement *element, bool forwards)
4892 {
4893         return TabNavigationWalker::Focus (element, forwards);
4894 }
4895
4896
4897 /**
4898  * TextBlock
4899  **/
4900 TextBlock *
4901 text_block_new (void)
4902 {
4903         return new TextBlock ();
4904 }
4905
4906
4907 /**
4908  * TextBox
4909  **/
4910 TextBox *
4911 text_box_new (void)
4912 {
4913         return new TextBox ();
4914 }
4915
4916
4917 /**
4918  * TextBoxBase
4919  **/
4920 void
4921 text_box_base_on_got_focus (TextBoxBase *instance, RoutedEventArgs *args)
4922 {
4923         if (instance == NULL)
4924                 return;
4925
4926         instance->OnGotFocus (args);
4927 }
4928
4929
4930 void
4931 text_box_base_on_key_down (TextBoxBase *instance, KeyEventArgs *args)
4932 {
4933         if (instance == NULL)
4934                 return;
4935
4936         instance->OnKeyDown (args);
4937 }
4938
4939
4940 void
4941 text_box_base_on_key_up (TextBoxBase *instance, KeyEventArgs *args)
4942 {
4943         if (instance == NULL)
4944                 return;
4945
4946         instance->OnKeyUp (args);
4947 }
4948
4949
4950 void
4951 text_box_base_on_lost_focus (TextBoxBase *instance, RoutedEventArgs *args)
4952 {
4953         if (instance == NULL)
4954                 return;
4955
4956         instance->OnLostFocus (args);
4957 }
4958
4959
4960 void
4961 text_box_base_on_mouse_left_button_down (TextBoxBase *instance, MouseButtonEventArgs *args)
4962 {
4963         if (instance == NULL)
4964                 return;
4965
4966         instance->OnMouseLeftButtonDown (args);
4967 }
4968
4969
4970 void
4971 text_box_base_on_mouse_left_button_up (TextBoxBase *instance, MouseButtonEventArgs *args)
4972 {
4973         if (instance == NULL)
4974                 return;
4975
4976         instance->OnMouseLeftButtonUp (args);
4977 }
4978
4979
4980 void
4981 text_box_base_on_mouse_move (TextBoxBase *instance, MouseEventArgs *args)
4982 {
4983         if (instance == NULL)
4984                 return;
4985
4986         instance->OnMouseMove (args);
4987 }
4988
4989
4990 void
4991 text_box_base_post_on_key_down (TextBoxBase *instance, KeyEventArgs *args)
4992 {
4993         if (instance == NULL)
4994                 return;
4995
4996         instance->PostOnKeyDown (args);
4997 }
4998
4999
5000 void
5001 text_box_base_select_all (TextBoxBase *instance)
5002 {
5003         if (instance == NULL)
5004                 return;
5005
5006         instance->SelectAll ();
5007 }
5008
5009
5010 bool
5011 text_box_base_select_with_error (TextBoxBase *instance, int start, int length, MoonError *error)
5012 {
5013         if (instance == NULL)
5014                 return false;
5015
5016         if (error == NULL)
5017                 g_warning ("Moonlight: Called text_box_base_select_with_error () with error == NULL.");
5018         return instance->SelectWithError (start, length, error);
5019 }
5020
5021
5022 /**
5023  * TextBoxView
5024  **/
5025 TextBoxView *
5026 text_box_view_new (void)
5027 {
5028         return new TextBoxView ();
5029 }
5030
5031
5032 /**
5033  * TextChangedEventArgs
5034  **/
5035 TextChangedEventArgs *
5036 text_changed_event_args_new (void)
5037 {
5038         return new TextChangedEventArgs ();
5039 }
5040
5041
5042 /**
5043  * TileBrush
5044  **/
5045 TileBrush *
5046 tile_brush_new (void)
5047 {
5048         return new TileBrush ();
5049 }
5050
5051
5052 /**
5053  * Timeline
5054  **/
5055 DependencyObject *
5056 timeline_get_manual_target (Timeline *instance)
5057 {
5058         if (instance == NULL)
5059                 return NULL;
5060
5061         return instance->GetManualTarget ();
5062 }
5063
5064
5065 void
5066 timeline_set_manual_target (Timeline *instance, DependencyObject *o)
5067 {
5068         if (instance == NULL)
5069                 return;
5070
5071         instance->SetManualTarget (o);
5072 }
5073
5074
5075 Timeline *
5076 timeline_new (void)
5077 {
5078         return new Timeline ();
5079 }
5080
5081
5082 /**
5083  * TimelineCollection
5084  **/
5085 TimelineCollection *
5086 timeline_collection_new (void)
5087 {
5088         return new TimelineCollection ();
5089 }
5090
5091
5092 /**
5093  * TimelineGroup
5094  **/
5095 TimelineGroup *
5096 timeline_group_new (void)
5097 {
5098         return new TimelineGroup ();
5099 }
5100
5101
5102 /**
5103  * TimelineMarker
5104  **/
5105 TimelineMarker *
5106 timeline_marker_new (void)
5107 {
5108         return new TimelineMarker ();
5109 }
5110
5111
5112 /**
5113  * TimelineMarkerCollection
5114  **/
5115 TimelineMarkerCollection *
5116 timeline_marker_collection_new (void)
5117 {
5118         return new TimelineMarkerCollection ();
5119 }
5120
5121
5122 /**
5123  * TimelineMarkerRoutedEventArgs
5124  **/
5125 TimelineMarker *
5126 timeline_marker_routed_event_args_get_marker (TimelineMarkerRoutedEventArgs *instance)
5127 {
5128         if (instance == NULL)
5129                 return NULL;
5130
5131         return instance->GetMarker ();
5132 }
5133
5134
5135 TimelineMarkerRoutedEventArgs *
5136 timeline_marker_routed_event_args_new (TimelineMarker *marker)
5137 {
5138         return new TimelineMarkerRoutedEventArgs (marker);
5139 }
5140
5141
5142 /**
5143  * TimeManager
5144  **/
5145 void
5146 time_manager_add_dispatcher_call (TimeManager *instance, TickCallHandler handler, EventObject *tick_data)
5147 {
5148         if (instance == NULL)
5149                 return;
5150
5151         instance->AddDispatcherCall (handler, tick_data);
5152 }
5153
5154
5155 void
5156 time_manager_add_tick_call (TimeManager *instance, TickCallHandler handler, EventObject *tick_data)
5157 {
5158         if (instance == NULL)
5159                 return;
5160
5161         instance->AddTickCall (handler, tick_data);
5162 }
5163
5164
5165 guint
5166 time_manager_add_timeout (TimeManager *instance, gint priority, guint ms_interval, GSourceFunc func, gpointer timeout_data)
5167 {
5168         if (instance == NULL)
5169                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5170                 return (guint) 0;
5171
5172         return instance->AddTimeout (priority, ms_interval, func, timeout_data);
5173 }
5174
5175
5176 int
5177 time_manager_get_maximum_refresh_rate (TimeManager *instance)
5178 {
5179         if (instance == NULL)
5180                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5181                 return (int) 0;
5182
5183         return instance->GetMaximumRefreshRate ();
5184 }
5185
5186
5187 void
5188 time_manager_remove_tick_call (TimeManager *instance, TickCallHandler handler, EventObject *tick_data)
5189 {
5190         if (instance == NULL)
5191                 return;
5192
5193         instance->RemoveTickCall (handler, tick_data);
5194 }
5195
5196
5197 void
5198 time_manager_remove_timeout (TimeManager *instance, guint timeout_id)
5199 {
5200         if (instance == NULL)
5201                 return;
5202
5203         instance->RemoveTimeout (timeout_id);
5204 }
5205
5206
5207 void
5208 time_manager_set_maximum_refresh_rate (TimeManager *instance, int hz)
5209 {
5210         if (instance == NULL)
5211                 return;
5212
5213         instance->SetMaximumRefreshRate (hz);
5214 }
5215
5216
5217 /**
5218  * TouchDevice
5219  **/
5220 UIElement *
5221 touch_device_get_directly_over (TouchDevice *instance)
5222 {
5223         if (instance == NULL)
5224                 return NULL;
5225
5226         return instance->GetDirectlyOver ();
5227 }
5228
5229
5230 int
5231 touch_device_get_id (TouchDevice *instance)
5232 {
5233         if (instance == NULL)
5234                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5235                 return (int) 0;
5236
5237         return instance->GetId ();
5238 }
5239
5240
5241 void
5242 touch_device_set_directly_over (TouchDevice *instance, UIElement *element)
5243 {
5244         if (instance == NULL)
5245                 return;
5246
5247         instance->SetDirectlyOver (element);
5248 }
5249
5250
5251 void
5252 touch_device_set_id (TouchDevice *instance, int id)
5253 {
5254         if (instance == NULL)
5255                 return;
5256
5257         instance->SetId (id);
5258 }
5259
5260
5261 TouchDevice *
5262 touch_device_new (void)
5263 {
5264         return new TouchDevice ();
5265 }
5266
5267
5268 /**
5269  * TouchPoint
5270  **/
5271 int
5272 touch_point_get_action (TouchPoint *instance)
5273 {
5274         if (instance == NULL)
5275                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5276                 return (TouchAction) 0;
5277
5278         return instance->GetAction ();
5279 }
5280
5281
5282 Point *
5283 touch_point_get_position (TouchPoint *instance)
5284 {
5285         if (instance == NULL)
5286                 return NULL;
5287
5288         return instance->GetPosition ();
5289 }
5290
5291
5292 Size *
5293 touch_point_get_size (TouchPoint *instance)
5294 {
5295         if (instance == NULL)
5296                 return NULL;
5297
5298         return instance->GetSize ();
5299 }
5300
5301
5302 TouchDevice *
5303 touch_point_get_touch_device (TouchPoint *instance)
5304 {
5305         if (instance == NULL)
5306                 return NULL;
5307
5308         return instance->GetTouchDevice ();
5309 }
5310
5311
5312 void
5313 touch_point_set_action (TouchPoint *instance, int action)
5314 {
5315         if (instance == NULL)
5316                 return;
5317
5318         instance->SetAction ((TouchAction) action);
5319 }
5320
5321
5322 void
5323 touch_point_set_position (TouchPoint *instance, Point *position)
5324 {
5325         if (instance == NULL)
5326                 return;
5327
5328         instance->SetPosition (position);
5329 }
5330
5331
5332 void
5333 touch_point_set_size (TouchPoint *instance, Size *size)
5334 {
5335         if (instance == NULL)
5336                 return;
5337
5338         instance->SetSize (size);
5339 }
5340
5341
5342 void
5343 touch_point_set_touch_device (TouchPoint *instance, TouchDevice *device)
5344 {
5345         if (instance == NULL)
5346                 return;
5347
5348         instance->SetTouchDevice (device);
5349 }
5350
5351
5352 TouchPoint *
5353 touch_point_new (void)
5354 {
5355         return new TouchPoint ();
5356 }
5357
5358
5359 /**
5360  * TouchPointCollection
5361  **/
5362 TouchPointCollection *
5363 touch_point_collection_new (void)
5364 {
5365         return new TouchPointCollection ();
5366 }
5367
5368
5369 /**
5370  * Transform
5371  **/
5372 Transform *
5373 transform_new (void)
5374 {
5375         return new Transform ();
5376 }
5377
5378
5379 /**
5380  * TransformCollection
5381  **/
5382 TransformCollection *
5383 transform_collection_new (void)
5384 {
5385         return new TransformCollection ();
5386 }
5387
5388
5389 /**
5390  * TransformGroup
5391  **/
5392 TransformGroup *
5393 transform_group_new (void)
5394 {
5395         return new TransformGroup ();
5396 }
5397
5398
5399 /**
5400  * TranslateTransform
5401  **/
5402 TranslateTransform *
5403 translate_transform_new (void)
5404 {
5405         return new TranslateTransform ();
5406 }
5407
5408
5409 /**
5410  * TriggerAction
5411  **/
5412 void
5413 trigger_action_fire (TriggerAction *instance)
5414 {
5415         if (instance == NULL)
5416                 return;
5417
5418         instance->Fire ();
5419 }
5420
5421
5422 TriggerAction *
5423 trigger_action_new (void)
5424 {
5425         return new TriggerAction ();
5426 }
5427
5428
5429 /**
5430  * TriggerActionCollection
5431  **/
5432 TriggerActionCollection *
5433 trigger_action_collection_new (void)
5434 {
5435         return new TriggerActionCollection ();
5436 }
5437
5438
5439 /**
5440  * TriggerBase
5441  **/
5442 TriggerBase *
5443 trigger_base_new (void)
5444 {
5445         return new TriggerBase ();
5446 }
5447
5448
5449 /**
5450  * TriggerCollection
5451  **/
5452 TriggerCollection *
5453 trigger_collection_new (void)
5454 {
5455         return new TriggerCollection ();
5456 }
5457
5458
5459 /**
5460  * Types
5461  **/
5462 Type *
5463 types_find (Types *instance, int type)
5464 {
5465         if (instance == NULL)
5466                 return NULL;
5467
5468         return instance->Find ((Type::Kind) type);
5469 }
5470
5471
5472 int
5473 types_register_type (Types *instance, const char *name, void *gc_handle, int parent, bool is_interface, bool ctor_visible, int *interfaces, int interface_count)
5474 {
5475         if (instance == NULL)
5476                 return Type::INVALID;
5477
5478         return instance->RegisterType (name, gc_handle, (Type::Kind) parent, is_interface, ctor_visible, (Type::Kind*) interfaces, interface_count);
5479 }
5480
5481
5482 Types *
5483 types_new (void)
5484 {
5485         return new Types ();
5486 }
5487
5488
5489 /**
5490  * UIElement
5491  **/
5492 void
5493 uielement_arrange (UIElement *instance, Rect finalRect)
5494 {
5495         if (instance == NULL)
5496                 return;
5497
5498         instance->Arrange (finalRect);
5499 }
5500
5501
5502 bool
5503 uielement_capture_mouse (UIElement *instance)
5504 {
5505         if (instance == NULL)
5506                 return false;
5507
5508         return instance->CaptureMouse ();
5509 }
5510
5511
5512 void
5513 uielement_element_added (UIElement *instance, UIElement *obj)
5514 {
5515         if (instance == NULL)
5516                 return;
5517
5518         instance->ElementAdded (obj);
5519 }
5520
5521
5522 void
5523 uielement_element_removed (UIElement *instance, UIElement *obj)
5524 {
5525         if (instance == NULL)
5526                 return;
5527
5528         instance->ElementRemoved (obj);
5529 }
5530
5531
5532 void
5533 uielement_find_elements_in_host_coordinates_p (UIElement *instance, Point p, HitTestCollection *uielement_list)
5534 {
5535         if (instance == NULL)
5536                 return;
5537
5538         instance->FindElementsInHostCoordinates_p (p, uielement_list);
5539 }
5540
5541
5542 void
5543 uielement_find_elements_in_host_coordinates_r (UIElement *instance, Rect p, HitTestCollection *uielement_list)
5544 {
5545         if (instance == NULL)
5546                 return;
5547
5548         instance->FindElementsInHostCoordinates_r (p, uielement_list);
5549 }
5550
5551
5552 bool
5553 uielement_focus (UIElement *instance, bool recurse)
5554 {
5555         if (instance == NULL)
5556                 return false;
5557
5558         return instance->Focus (recurse);
5559 }
5560
5561
5562 Size
5563 uielement_get_desired_size (UIElement *instance)
5564 {
5565         if (instance == NULL)
5566                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5567                 return (Size) 0;
5568
5569         return instance->GetDesiredSize ();
5570 }
5571
5572
5573 Size
5574 uielement_get_render_size (UIElement *instance)
5575 {
5576         if (instance == NULL)
5577                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5578                 return (Size) 0;
5579
5580         return instance->GetRenderSize ();
5581 }
5582
5583
5584 DependencyObject *
5585 uielement_get_subtree_object (UIElement *instance)
5586 {
5587         if (instance == NULL)
5588                 return NULL;
5589
5590         return instance->GetSubtreeObject ();
5591 }
5592
5593
5594 GeneralTransform *
5595 uielement_get_transform_to_uielement_with_error (UIElement *instance, UIElement *to_element, MoonError *error)
5596 {
5597         if (instance == NULL)
5598                 return NULL;
5599
5600         if (error == NULL)
5601                 g_warning ("Moonlight: Called uielement_get_transform_to_uielement_with_error () with error == NULL.");
5602         return instance->GetTransformToUIElementWithError (to_element, error);
5603 }
5604
5605
5606 UIElement *
5607 uielement_get_visual_parent (UIElement *instance)
5608 {
5609         if (instance == NULL)
5610                 return NULL;
5611
5612         return instance->GetVisualParent ();
5613 }
5614
5615
5616 void
5617 uielement_invalidate (UIElement *instance)
5618 {
5619         if (instance == NULL)
5620                 return;
5621
5622         instance->Invalidate ();
5623 }
5624
5625
5626 void
5627 uielement_invalidate_arrange (UIElement *instance)
5628 {
5629         if (instance == NULL)
5630                 return;
5631
5632         instance->InvalidateArrange ();
5633 }
5634
5635
5636 void
5637 uielement_invalidate_measure (UIElement *instance)
5638 {
5639         if (instance == NULL)
5640                 return;
5641
5642         instance->InvalidateMeasure ();
5643 }
5644
5645
5646 void
5647 uielement_measure (UIElement *instance, Size availableSize)
5648 {
5649         if (instance == NULL)
5650                 return;
5651
5652         instance->Measure (availableSize);
5653 }
5654
5655
5656 void
5657 uielement_release_mouse_capture (UIElement *instance)
5658 {
5659         if (instance == NULL)
5660                 return;
5661
5662         instance->ReleaseMouseCapture ();
5663 }
5664
5665
5666 void
5667 uielement_set_subtree_object (UIElement *instance, DependencyObject *value)
5668 {
5669         if (instance == NULL)
5670                 return;
5671
5672         instance->SetSubtreeObject (value);
5673 }
5674
5675
5676 void
5677 uielement_update_layout (UIElement *instance)
5678 {
5679         if (instance == NULL)
5680                 return;
5681
5682         instance->UpdateLayout ();
5683 }
5684
5685
5686 /**
5687  * UIElementCollection
5688  **/
5689 UIElementCollection *
5690 uielement_collection_new (void)
5691 {
5692         return new UIElementCollection ();
5693 }
5694
5695
5696 /**
5697  * UnmanagedMatrix
5698  **/
5699 UnmanagedMatrix *
5700 unmanaged_matrix_new (void)
5701 {
5702         return new UnmanagedMatrix ();
5703 }
5704
5705
5706 /**
5707  * UnmanagedMatrix3D
5708  **/
5709 UnmanagedMatrix3D *
5710 unmanaged_matrix3_d_new (void)
5711 {
5712         return new UnmanagedMatrix3D ();
5713 }
5714
5715
5716 /**
5717  * Uri
5718  **/
5719 bool
5720 uri_equals (const Uri *left, const Uri *right)
5721 {
5722         return Uri::Equals (left, right);
5723 }
5724
5725
5726 void
5727 uri_free (Uri *instance)
5728 {
5729         if (instance == NULL)
5730                 return;
5731
5732         instance->Free ();
5733 }
5734
5735
5736 guint
5737 uri_get_hash_code (Uri *instance)
5738 {
5739         if (instance == NULL)
5740                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5741                 return (guint) 0;
5742
5743         return instance->GetHashCode ();
5744 }
5745
5746
5747 bool
5748 uri_parse (Uri *instance, const char *uri, bool allow_trailing_sep)
5749 {
5750         if (instance == NULL)
5751                 return false;
5752
5753         return instance->Parse (uri, allow_trailing_sep);
5754 }
5755
5756
5757 /**
5758  * UserControl
5759  **/
5760 UserControl *
5761 user_control_new (void)
5762 {
5763         return new UserControl ();
5764 }
5765
5766
5767 /**
5768  * VideoBrush
5769  **/
5770 void
5771 video_brush_set_source (VideoBrush *instance, MediaElement *source)
5772 {
5773         if (instance == NULL)
5774                 return;
5775
5776         instance->SetSource (source);
5777 }
5778
5779
5780 VideoBrush *
5781 video_brush_new (void)
5782 {
5783         return new VideoBrush ();
5784 }
5785
5786
5787 /**
5788  * VideoStream
5789  **/
5790 guint32
5791 video_stream_get_height (VideoStream *instance)
5792 {
5793         if (instance == NULL)
5794                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5795                 return (guint32) 0;
5796
5797         return instance->GetHeight ();
5798 }
5799
5800
5801 guint32
5802 video_stream_get_width (VideoStream *instance)
5803 {
5804         if (instance == NULL)
5805                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5806                 return (guint32) 0;
5807
5808         return instance->GetWidth ();
5809 }
5810
5811
5812 VideoStream *
5813 video_stream_new (Media *media, int codec_id, guint32 width, guint32 height, guint64 duration, gpointer extra_data, guint32 extra_data_size)
5814 {
5815         return new VideoStream (media, codec_id, width, height, duration, extra_data, extra_data_size);
5816 }
5817
5818
5819 /**
5820  * VisualBrush
5821  **/
5822 VisualBrush *
5823 visual_brush_new (void)
5824 {
5825         return new VisualBrush ();
5826 }
5827
5828
5829 /**
5830  * WindowSettings
5831  **/
5832 WindowSettings *
5833 window_settings_new (void)
5834 {
5835         return new WindowSettings ();
5836 }
5837
5838
5839 /**
5840  * WriteableBitmap
5841  **/
5842 gpointer
5843 writeable_bitmap_initialize_from_bitmap_source (WriteableBitmap *instance, BitmapSource *source)
5844 {
5845         if (instance == NULL)
5846                 // Need to find a proper way to get the default value for the specified type and return that if instance is NULL.
5847                 return (gpointer) 0;
5848
5849         return instance->InitializeFromBitmapSource (source);
5850 }
5851
5852
5853 void
5854 writeable_bitmap_lock (WriteableBitmap *instance)
5855 {
5856         if (instance == NULL)
5857                 return;
5858
5859         instance->Lock ();
5860 }
5861
5862
5863 void
5864 writeable_bitmap_render (WriteableBitmap *instance, UIElement *element, Transform *transform)
5865 {
5866         if (instance == NULL)
5867                 return;
5868
5869         instance->Render (element, transform);
5870 }
5871
5872
5873 void
5874 writeable_bitmap_unlock (WriteableBitmap *instance)
5875 {
5876         if (instance == NULL)
5877                 return;
5878
5879         instance->Unlock ();
5880 }
5881
5882
5883 WriteableBitmap *
5884 writeable_bitmap_new (void)
5885 {
5886         return new WriteableBitmap ();
5887 }
5888
5889
5890 /**
5891  * XamlContext
5892  **/
5893 DependencyObject *
5894 xaml_context_get_template_binding_source (XamlContext *instance)
5895 {
5896         if (instance == NULL)
5897                 return NULL;
5898
5899         return instance->GetTemplateBindingSource ();
5900 }
5901
5902
5903 /**
5904  * XamlLoader
5905  **/
5906 Value *
5907 xaml_loader_create_from_file_with_error (XamlLoader *instance, const char *xaml, bool create_namescope, int *element_type, MoonError *error)
5908 {
5909         if (instance == NULL)
5910                 return NULL;
5911
5912         if (error == NULL)
5913                 g_warning ("Moonlight: Called xaml_loader_create_from_file_with_error () with error == NULL.");
5914         return instance->CreateFromFileWithError (xaml, create_namescope, (Type::Kind*) element_type, error);
5915 }
5916
5917
5918 Value *
5919 xaml_loader_create_from_string_with_error (XamlLoader *instance, const char *xaml, bool create_namescope, int *element_type, int flags, MoonError *error)
5920 {
5921         if (instance == NULL)
5922                 return NULL;
5923
5924         if (error == NULL)
5925                 g_warning ("Moonlight: Called xaml_loader_create_from_string_with_error () with error == NULL.");
5926         return instance->CreateFromStringWithError (xaml, create_namescope, (Type::Kind*) element_type, flags, error);
5927 }
5928
5929
5930 XamlContext *
5931 xaml_loader_get_context (XamlLoader *instance)
5932 {
5933         if (instance == NULL)
5934                 return NULL;
5935
5936         return instance->GetContext ();
5937 }
5938
5939
5940 Value *
5941 xaml_loader_hydrate_from_string_with_error (XamlLoader *instance, const char *xaml, Value *obj, bool create_namescope, int *element_type, int flags, MoonError *error)
5942 {
5943         if (instance == NULL)
5944                 return NULL;
5945
5946         if (error == NULL)
5947                 g_warning ("Moonlight: Called xaml_loader_hydrate_from_string_with_error () with error == NULL.");
5948         return instance->HydrateFromStringWithError (xaml, obj, create_namescope, (Type::Kind*) element_type, flags, error);
5949 }
5950
5951
5952 /**
5953  * Xap
5954  **/
5955 char *
5956 xap_unpack (const char *fname)
5957 {
5958         return Xap::Unpack (fname);
5959 }
5960
5961