src/cbinding.cpp

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