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