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