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