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