← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rgtk2/trusty

« back to all changes in this revision

Viewing changes to src/gdkFuncs.c

  • Committer: Bazaar Package Importer
  • Author(s): Dirk Eddelbuettel
  • Date: 2010-11-03 11:35:46 UTC
  • mfrom: (1.3.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20101103113546-a7fi7jdxdebp0tw1
Tags: 2.20.1-1
* New upstream release

* debian/control: Set (Build-)Depends: to current R version
* debian/control: Set Standards-Version: to current version 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gdkFuncs.c
9359
9359
}
9360
9360
 
9361
9361
 
 
9362
USER_OBJECT_
 
9363
S_gdk_app_launch_context_get_type(void)
 
9364
{
 
9365
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9366
#if GDK_CHECK_VERSION(2, 14, 0)
 
9367
 
 
9368
  GType ans;
 
9369
 
 
9370
  ans = gdk_app_launch_context_get_type();
 
9371
 
 
9372
  _result = asRGType(ans);
 
9373
#else
 
9374
  error("gdk_app_launch_context_get_type exists only in Gdk >= 2.14.0");
 
9375
#endif
 
9376
 
 
9377
  return(_result);
 
9378
}
 
9379
 
 
9380
 
 
9381
USER_OBJECT_
 
9382
S_gdk_app_launch_context_new(void)
 
9383
{
 
9384
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9385
#if GDK_CHECK_VERSION(2, 14, 0)
 
9386
 
 
9387
  GdkAppLaunchContext* ans;
 
9388
 
 
9389
  ans = gdk_app_launch_context_new();
 
9390
 
 
9391
  _result = toRPointerWithFinalizer(ans, "GdkAppLaunchContext", (RPointerFinalizer) g_object_unref);
 
9392
#else
 
9393
  error("gdk_app_launch_context_new exists only in Gdk >= 2.14.0");
 
9394
#endif
 
9395
 
 
9396
  return(_result);
 
9397
}
 
9398
 
 
9399
 
 
9400
USER_OBJECT_
 
9401
S_gdk_app_launch_context_set_display(USER_OBJECT_ s_object, USER_OBJECT_ s_display)
 
9402
{
 
9403
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9404
#if GDK_CHECK_VERSION(2, 14, 0)
 
9405
  GdkAppLaunchContext* object = GDK_APP_LAUNCH_CONTEXT(getPtrValue(s_object));
 
9406
  GdkDisplay* display = GDK_DISPLAY_OBJECT(getPtrValue(s_display));
 
9407
 
 
9408
 
 
9409
  gdk_app_launch_context_set_display(object, display);
 
9410
 
 
9411
#else
 
9412
  error("gdk_app_launch_context_set_display exists only in Gdk >= 2.14.0");
 
9413
#endif
 
9414
 
 
9415
  return(_result);
 
9416
}
 
9417
 
 
9418
 
 
9419
USER_OBJECT_
 
9420
S_gdk_app_launch_context_set_screen(USER_OBJECT_ s_object, USER_OBJECT_ s_screen)
 
9421
{
 
9422
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9423
#if GDK_CHECK_VERSION(2, 14, 0)
 
9424
  GdkAppLaunchContext* object = GDK_APP_LAUNCH_CONTEXT(getPtrValue(s_object));
 
9425
  GdkScreen* screen = GDK_SCREEN(getPtrValue(s_screen));
 
9426
 
 
9427
 
 
9428
  gdk_app_launch_context_set_screen(object, screen);
 
9429
 
 
9430
#else
 
9431
  error("gdk_app_launch_context_set_screen exists only in Gdk >= 2.14.0");
 
9432
#endif
 
9433
 
 
9434
  return(_result);
 
9435
}
 
9436
 
 
9437
 
 
9438
USER_OBJECT_
 
9439
S_gdk_app_launch_context_set_desktop(USER_OBJECT_ s_object, USER_OBJECT_ s_desktop)
 
9440
{
 
9441
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9442
#if GDK_CHECK_VERSION(2, 14, 0)
 
9443
  GdkAppLaunchContext* object = GDK_APP_LAUNCH_CONTEXT(getPtrValue(s_object));
 
9444
  gint desktop = ((gint)asCInteger(s_desktop));
 
9445
 
 
9446
 
 
9447
  gdk_app_launch_context_set_desktop(object, desktop);
 
9448
 
 
9449
#else
 
9450
  error("gdk_app_launch_context_set_desktop exists only in Gdk >= 2.14.0");
 
9451
#endif
 
9452
 
 
9453
  return(_result);
 
9454
}
 
9455
 
 
9456
 
 
9457
USER_OBJECT_
 
9458
S_gdk_app_launch_context_set_timestamp(USER_OBJECT_ s_object, USER_OBJECT_ s_timestamp)
 
9459
{
 
9460
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9461
#if GDK_CHECK_VERSION(2, 14, 0)
 
9462
  GdkAppLaunchContext* object = GDK_APP_LAUNCH_CONTEXT(getPtrValue(s_object));
 
9463
  guint32 timestamp = ((guint32)asCNumeric(s_timestamp));
 
9464
 
 
9465
 
 
9466
  gdk_app_launch_context_set_timestamp(object, timestamp);
 
9467
 
 
9468
#else
 
9469
  error("gdk_app_launch_context_set_timestamp exists only in Gdk >= 2.14.0");
 
9470
#endif
 
9471
 
 
9472
  return(_result);
 
9473
}
 
9474
 
 
9475
 
 
9476
USER_OBJECT_
 
9477
S_gdk_app_launch_context_set_icon(USER_OBJECT_ s_object, USER_OBJECT_ s_icon)
 
9478
{
 
9479
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9480
#if GDK_CHECK_VERSION(2, 14, 0)
 
9481
  GdkAppLaunchContext* object = GDK_APP_LAUNCH_CONTEXT(getPtrValue(s_object));
 
9482
  GIcon* icon = GET_LENGTH(s_icon) == 0 ? NULL : G_ICON(getPtrValue(s_icon));
 
9483
 
 
9484
 
 
9485
  gdk_app_launch_context_set_icon(object, icon);
 
9486
 
 
9487
#else
 
9488
  error("gdk_app_launch_context_set_icon exists only in Gdk >= 2.14.0");
 
9489
#endif
 
9490
 
 
9491
  return(_result);
 
9492
}
 
9493
 
 
9494
 
 
9495
USER_OBJECT_
 
9496
S_gdk_app_launch_context_set_icon_name(USER_OBJECT_ s_object, USER_OBJECT_ s_icon_name)
 
9497
{
 
9498
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9499
#if GDK_CHECK_VERSION(2, 14, 0)
 
9500
  GdkAppLaunchContext* object = GDK_APP_LAUNCH_CONTEXT(getPtrValue(s_object));
 
9501
  const char* icon_name = GET_LENGTH(s_icon_name) == 0 ? NULL : ((const char*)asCString(s_icon_name));
 
9502
 
 
9503
 
 
9504
  gdk_app_launch_context_set_icon_name(object, icon_name);
 
9505
 
 
9506
#else
 
9507
  error("gdk_app_launch_context_set_icon_name exists only in Gdk >= 2.14.0");
 
9508
#endif
 
9509
 
 
9510
  return(_result);
 
9511
}
 
9512
 
 
9513
 
 
9514
USER_OBJECT_
 
9515
S_gdk_screen_get_monitor_width_mm(USER_OBJECT_ s_object, USER_OBJECT_ s_monitor_num)
 
9516
{
 
9517
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9518
#if GDK_CHECK_VERSION(2, 14, 0)
 
9519
  GdkScreen* object = GDK_SCREEN(getPtrValue(s_object));
 
9520
  gint monitor_num = ((gint)asCInteger(s_monitor_num));
 
9521
 
 
9522
  gint ans;
 
9523
 
 
9524
  ans = gdk_screen_get_monitor_width_mm(object, monitor_num);
 
9525
 
 
9526
  _result = asRInteger(ans);
 
9527
#else
 
9528
  error("gdk_screen_get_monitor_width_mm exists only in Gdk >= 2.14.0");
 
9529
#endif
 
9530
 
 
9531
  return(_result);
 
9532
}
 
9533
 
 
9534
 
 
9535
USER_OBJECT_
 
9536
S_gdk_screen_get_monitor_height_mm(USER_OBJECT_ s_object, USER_OBJECT_ s_monitor_num)
 
9537
{
 
9538
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9539
#if GDK_CHECK_VERSION(2, 14, 0)
 
9540
  GdkScreen* object = GDK_SCREEN(getPtrValue(s_object));
 
9541
  gint monitor_num = ((gint)asCInteger(s_monitor_num));
 
9542
 
 
9543
  gint ans;
 
9544
 
 
9545
  ans = gdk_screen_get_monitor_height_mm(object, monitor_num);
 
9546
 
 
9547
  _result = asRInteger(ans);
 
9548
#else
 
9549
  error("gdk_screen_get_monitor_height_mm exists only in Gdk >= 2.14.0");
 
9550
#endif
 
9551
 
 
9552
  return(_result);
 
9553
}
 
9554
 
 
9555
 
 
9556
USER_OBJECT_
 
9557
S_gdk_screen_get_monitor_plug_name(USER_OBJECT_ s_object, USER_OBJECT_ s_monitor_num)
 
9558
{
 
9559
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9560
#if GDK_CHECK_VERSION(2, 14, 0)
 
9561
  GdkScreen* object = GDK_SCREEN(getPtrValue(s_object));
 
9562
  gint monitor_num = ((gint)asCInteger(s_monitor_num));
 
9563
 
 
9564
  gchar* ans;
 
9565
 
 
9566
  ans = gdk_screen_get_monitor_plug_name(object, monitor_num);
 
9567
 
 
9568
  _result = asRString(ans);
 
9569
    CLEANUP(g_free, ans);;
 
9570
#else
 
9571
  error("gdk_screen_get_monitor_plug_name exists only in Gdk >= 2.14.0");
 
9572
#endif
 
9573
 
 
9574
  return(_result);
 
9575
}
 
9576
 
 
9577
 
 
9578
USER_OBJECT_
 
9579
S_gdk_window_redirect_to_drawable(USER_OBJECT_ s_object, USER_OBJECT_ s_drawable, USER_OBJECT_ s_src_x, USER_OBJECT_ s_src_y, USER_OBJECT_ s_dest_x, USER_OBJECT_ s_dest_y, USER_OBJECT_ s_width, USER_OBJECT_ s_height)
 
9580
{
 
9581
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9582
#if GDK_CHECK_VERSION(2, 14, 0)
 
9583
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9584
  GdkDrawable* drawable = GDK_DRAWABLE(getPtrValue(s_drawable));
 
9585
  gint src_x = ((gint)asCInteger(s_src_x));
 
9586
  gint src_y = ((gint)asCInteger(s_src_y));
 
9587
  gint dest_x = ((gint)asCInteger(s_dest_x));
 
9588
  gint dest_y = ((gint)asCInteger(s_dest_y));
 
9589
  gint width = ((gint)asCInteger(s_width));
 
9590
  gint height = ((gint)asCInteger(s_height));
 
9591
 
 
9592
 
 
9593
  gdk_window_redirect_to_drawable(object, drawable, src_x, src_y, dest_x, dest_y, width, height);
 
9594
 
 
9595
#else
 
9596
  error("gdk_window_redirect_to_drawable exists only in Gdk >= 2.14.0");
 
9597
#endif
 
9598
 
 
9599
  return(_result);
 
9600
}
 
9601
 
 
9602
 
 
9603
USER_OBJECT_
 
9604
S_gdk_window_remove_redirection(USER_OBJECT_ s_object)
 
9605
{
 
9606
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9607
#if GDK_CHECK_VERSION(2, 14, 0)
 
9608
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9609
 
 
9610
 
 
9611
  gdk_window_remove_redirection(object);
 
9612
 
 
9613
#else
 
9614
  error("gdk_window_remove_redirection exists only in Gdk >= 2.14.0");
 
9615
#endif
 
9616
 
 
9617
  return(_result);
 
9618
}
 
9619
 
 
9620
 
 
9621
USER_OBJECT_
 
9622
S_gdk_pixbuf_new_from_stream(USER_OBJECT_ s_stream, USER_OBJECT_ s_cancellable)
 
9623
{
 
9624
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9625
#if GDK_CHECK_VERSION(2, 14, 0)
 
9626
  GInputStream* stream = G_INPUT_STREAM(getPtrValue(s_stream));
 
9627
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL : G_CANCELLABLE(getPtrValue(s_cancellable));
 
9628
 
 
9629
  GdkPixbuf* ans;
 
9630
  GError* error = NULL;
 
9631
 
 
9632
  ans = gdk_pixbuf_new_from_stream(stream, cancellable, &error);
 
9633
 
 
9634
  _result = toRPointerWithFinalizer(ans, "GdkPixbuf", (RPointerFinalizer) g_object_unref);
 
9635
 
 
9636
  _result = retByVal(_result, "error", asRGError(error), NULL);
 
9637
    CLEANUP(g_error_free, error);;
 
9638
#else
 
9639
  error("gdk_pixbuf_new_from_stream exists only in Gdk >= 2.14.0");
 
9640
#endif
 
9641
 
 
9642
  return(_result);
 
9643
}
 
9644
 
 
9645
 
 
9646
USER_OBJECT_
 
9647
S_gdk_pixbuf_new_from_stream_at_scale(USER_OBJECT_ s_stream, USER_OBJECT_ s_width, USER_OBJECT_ s_height, USER_OBJECT_ s_preserve_aspect_ratio, USER_OBJECT_ s_cancellable)
 
9648
{
 
9649
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9650
#if GDK_CHECK_VERSION(2, 14, 0)
 
9651
  GInputStream* stream = G_INPUT_STREAM(getPtrValue(s_stream));
 
9652
  gint width = ((gint)asCInteger(s_width));
 
9653
  gint height = ((gint)asCInteger(s_height));
 
9654
  gboolean preserve_aspect_ratio = ((gboolean)asCLogical(s_preserve_aspect_ratio));
 
9655
  GCancellable* cancellable = GET_LENGTH(s_cancellable) == 0 ? NULL : G_CANCELLABLE(getPtrValue(s_cancellable));
 
9656
 
 
9657
  GdkPixbuf* ans;
 
9658
  GError* error = NULL;
 
9659
 
 
9660
  ans = gdk_pixbuf_new_from_stream_at_scale(stream, width, height, preserve_aspect_ratio, cancellable, &error);
 
9661
 
 
9662
  _result = toRPointerWithFinalizer(ans, "GdkPixbuf", (RPointerFinalizer) g_object_unref);
 
9663
 
 
9664
  _result = retByVal(_result, "error", asRGError(error), NULL);
 
9665
    CLEANUP(g_error_free, error);;
 
9666
#else
 
9667
  error("gdk_pixbuf_new_from_stream_at_scale exists only in Gdk >= 2.14.0");
 
9668
#endif
 
9669
 
 
9670
  return(_result);
 
9671
}
 
9672
 
 
9673
 
 
9674
USER_OBJECT_
 
9675
S_gdk_test_render_sync(USER_OBJECT_ s_window)
 
9676
{
 
9677
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9678
#if GDK_CHECK_VERSION(2, 14, 0)
 
9679
  GdkWindow* window = GDK_WINDOW(getPtrValue(s_window));
 
9680
 
 
9681
 
 
9682
  gdk_test_render_sync(window);
 
9683
 
 
9684
#else
 
9685
  error("gdk_test_render_sync exists only in Gdk >= 2.14.0");
 
9686
#endif
 
9687
 
 
9688
  return(_result);
 
9689
}
 
9690
 
 
9691
 
 
9692
USER_OBJECT_
 
9693
S_gdk_test_simulate_key(USER_OBJECT_ s_window, USER_OBJECT_ s_x, USER_OBJECT_ s_y, USER_OBJECT_ s_keyval, USER_OBJECT_ s_modifiers, USER_OBJECT_ s_key_pressrelease)
 
9694
{
 
9695
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9696
#if GDK_CHECK_VERSION(2, 14, 0)
 
9697
  GdkWindow* window = GDK_WINDOW(getPtrValue(s_window));
 
9698
  gint x = ((gint)asCInteger(s_x));
 
9699
  gint y = ((gint)asCInteger(s_y));
 
9700
  guint keyval = ((guint)asCNumeric(s_keyval));
 
9701
  GdkModifierType modifiers = ((GdkModifierType)asCFlag(s_modifiers, GDK_TYPE_MODIFIER_TYPE));
 
9702
  GdkEventType key_pressrelease = ((GdkEventType)asCEnum(s_key_pressrelease, GDK_TYPE_EVENT_TYPE));
 
9703
 
 
9704
  gboolean ans;
 
9705
 
 
9706
  ans = gdk_test_simulate_key(window, x, y, keyval, modifiers, key_pressrelease);
 
9707
 
 
9708
  _result = asRLogical(ans);
 
9709
#else
 
9710
  error("gdk_test_simulate_key exists only in Gdk >= 2.14.0");
 
9711
#endif
 
9712
 
 
9713
  return(_result);
 
9714
}
 
9715
 
 
9716
 
 
9717
USER_OBJECT_
 
9718
S_gdk_test_simulate_button(USER_OBJECT_ s_window, USER_OBJECT_ s_x, USER_OBJECT_ s_y, USER_OBJECT_ s_button, USER_OBJECT_ s_modifiers, USER_OBJECT_ s_button_pressrelease)
 
9719
{
 
9720
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9721
#if GDK_CHECK_VERSION(2, 14, 0)
 
9722
  GdkWindow* window = GDK_WINDOW(getPtrValue(s_window));
 
9723
  gint x = ((gint)asCInteger(s_x));
 
9724
  gint y = ((gint)asCInteger(s_y));
 
9725
  guint button = ((guint)asCNumeric(s_button));
 
9726
  GdkModifierType modifiers = ((GdkModifierType)asCFlag(s_modifiers, GDK_TYPE_MODIFIER_TYPE));
 
9727
  GdkEventType button_pressrelease = ((GdkEventType)asCEnum(s_button_pressrelease, GDK_TYPE_EVENT_TYPE));
 
9728
 
 
9729
  gboolean ans;
 
9730
 
 
9731
  ans = gdk_test_simulate_button(window, x, y, button, modifiers, button_pressrelease);
 
9732
 
 
9733
  _result = asRLogical(ans);
 
9734
#else
 
9735
  error("gdk_test_simulate_button exists only in Gdk >= 2.14.0");
 
9736
#endif
 
9737
 
 
9738
  return(_result);
 
9739
}
 
9740
 
 
9741
 
 
9742
USER_OBJECT_
 
9743
S_gdk_pixbuf_save_to_stream(USER_OBJECT_ s_object, USER_OBJECT_ s_stream, USER_OBJECT_ s_type, USER_OBJECT_ s_cancellable)
 
9744
{
 
9745
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9746
#if GDK_CHECK_VERSION(2, 14, 0)
 
9747
  GdkPixbuf* object = GDK_PIXBUF(getPtrValue(s_object));
 
9748
  GOutputStream* stream = G_OUTPUT_STREAM(getPtrValue(s_stream));
 
9749
  const char* type = ((const char*)asCString(s_type));
 
9750
  GCancellable* cancellable = G_CANCELLABLE(getPtrValue(s_cancellable));
 
9751
 
 
9752
  gboolean ans;
 
9753
  GError* error = NULL;
 
9754
 
 
9755
  ans = gdk_pixbuf_save_to_stream(object, stream, type, cancellable, &error);
 
9756
 
 
9757
  _result = asRLogical(ans);
 
9758
 
 
9759
  _result = retByVal(_result, "error", asRGError(error), NULL);
 
9760
    CLEANUP(g_error_free, error);;
 
9761
#else
 
9762
  error("gdk_pixbuf_save_to_stream exists only in Gdk >= 2.14.0");
 
9763
#endif
 
9764
 
 
9765
  return(_result);
 
9766
}
 
9767
 
 
9768
 
 
9769
USER_OBJECT_
 
9770
S_gdk_keymap_get_caps_lock_state(USER_OBJECT_ s_object)
 
9771
{
 
9772
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9773
#if GDK_CHECK_VERSION(2, 16, 0)
 
9774
  GdkKeymap* object = GDK_KEYMAP(getPtrValue(s_object));
 
9775
 
 
9776
  gboolean ans;
 
9777
 
 
9778
  ans = gdk_keymap_get_caps_lock_state(object);
 
9779
 
 
9780
  _result = asRLogical(ans);
 
9781
#else
 
9782
  error("gdk_keymap_get_caps_lock_state exists only in Gdk >= 2.16.0");
 
9783
#endif
 
9784
 
 
9785
  return(_result);
 
9786
}
 
9787
 
 
9788
 
 
9789
USER_OBJECT_
 
9790
S_gdk_cairo_reset_clip(USER_OBJECT_ s_cr, USER_OBJECT_ s_drawable)
 
9791
{
 
9792
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9793
#if GDK_CHECK_VERSION(2, 18, 0)
 
9794
  cairo_t* cr = ((cairo_t*)getPtrValue(s_cr));
 
9795
  GdkDrawable* drawable = GDK_DRAWABLE(getPtrValue(s_drawable));
 
9796
 
 
9797
 
 
9798
  gdk_cairo_reset_clip(cr, drawable);
 
9799
 
 
9800
#else
 
9801
  error("gdk_cairo_reset_clip exists only in Gdk >= 2.18.0");
 
9802
#endif
 
9803
 
 
9804
  return(_result);
 
9805
}
 
9806
 
 
9807
 
 
9808
USER_OBJECT_
 
9809
S_gdk_offscreen_window_get_pixmap(USER_OBJECT_ s_window)
 
9810
{
 
9811
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9812
#if GDK_CHECK_VERSION(2, 18, 0)
 
9813
  GdkWindow* window = GDK_WINDOW(getPtrValue(s_window));
 
9814
 
 
9815
  GdkPixmap* ans;
 
9816
 
 
9817
  ans = gdk_offscreen_window_get_pixmap(window);
 
9818
 
 
9819
  _result = toRPointerWithRef(ans, "GdkPixmap");
 
9820
#else
 
9821
  error("gdk_offscreen_window_get_pixmap exists only in Gdk >= 2.18.0");
 
9822
#endif
 
9823
 
 
9824
  return(_result);
 
9825
}
 
9826
 
 
9827
 
 
9828
USER_OBJECT_
 
9829
S_gdk_offscreen_window_set_embedder(USER_OBJECT_ s_window, USER_OBJECT_ s_embedder)
 
9830
{
 
9831
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9832
#if GDK_CHECK_VERSION(2, 18, 0)
 
9833
  GdkWindow* window = GDK_WINDOW(getPtrValue(s_window));
 
9834
  GdkWindow* embedder = GDK_WINDOW(getPtrValue(s_embedder));
 
9835
 
 
9836
 
 
9837
  gdk_offscreen_window_set_embedder(window, embedder);
 
9838
 
 
9839
#else
 
9840
  error("gdk_offscreen_window_set_embedder exists only in Gdk >= 2.18.0");
 
9841
#endif
 
9842
 
 
9843
  return(_result);
 
9844
}
 
9845
 
 
9846
 
 
9847
USER_OBJECT_
 
9848
S_gdk_offscreen_window_get_embedder(USER_OBJECT_ s_window)
 
9849
{
 
9850
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9851
#if GDK_CHECK_VERSION(2, 18, 0)
 
9852
  GdkWindow* window = GDK_WINDOW(getPtrValue(s_window));
 
9853
 
 
9854
  GdkWindow* ans;
 
9855
 
 
9856
  ans = gdk_offscreen_window_get_embedder(window);
 
9857
 
 
9858
  _result = toRPointerWithRef(ans, "GdkWindow");
 
9859
#else
 
9860
  error("gdk_offscreen_window_get_embedder exists only in Gdk >= 2.18.0");
 
9861
#endif
 
9862
 
 
9863
  return(_result);
 
9864
}
 
9865
 
 
9866
 
 
9867
USER_OBJECT_
 
9868
S_gdk_region_rect_equal(USER_OBJECT_ s_object, USER_OBJECT_ s_rectangle)
 
9869
{
 
9870
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9871
#if GDK_CHECK_VERSION(2, 18, 0)
 
9872
  GdkRegion* object = ((GdkRegion*)getPtrValue(s_object));
 
9873
  const GdkRectangle* rectangle = asCGdkRectangle(s_rectangle);
 
9874
 
 
9875
  gboolean ans;
 
9876
 
 
9877
  ans = gdk_region_rect_equal(object, rectangle);
 
9878
 
 
9879
  _result = asRLogical(ans);
 
9880
#else
 
9881
  error("gdk_region_rect_equal exists only in Gdk >= 2.18.0");
 
9882
#endif
 
9883
 
 
9884
  return(_result);
 
9885
}
 
9886
 
 
9887
 
 
9888
USER_OBJECT_
 
9889
S_gdk_window_ensure_native(USER_OBJECT_ s_object)
 
9890
{
 
9891
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9892
#if GDK_CHECK_VERSION(2, 18, 0)
 
9893
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9894
 
 
9895
  gboolean ans;
 
9896
 
 
9897
  ans = gdk_window_ensure_native(object);
 
9898
 
 
9899
  _result = asRLogical(ans);
 
9900
#else
 
9901
  error("gdk_window_ensure_native exists only in Gdk >= 2.18.0");
 
9902
#endif
 
9903
 
 
9904
  return(_result);
 
9905
}
 
9906
 
 
9907
 
 
9908
USER_OBJECT_
 
9909
S_gdk_window_flush(USER_OBJECT_ s_object)
 
9910
{
 
9911
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9912
#if GDK_CHECK_VERSION(2, 18, 0)
 
9913
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9914
 
 
9915
 
 
9916
  gdk_window_flush(object);
 
9917
 
 
9918
#else
 
9919
  error("gdk_window_flush exists only in Gdk >= 2.18.0");
 
9920
#endif
 
9921
 
 
9922
  return(_result);
 
9923
}
 
9924
 
 
9925
 
 
9926
USER_OBJECT_
 
9927
S_gdk_window_geometry_changed(USER_OBJECT_ s_object)
 
9928
{
 
9929
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9930
#if GDK_CHECK_VERSION(2, 18, 0)
 
9931
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9932
 
 
9933
 
 
9934
  gdk_window_geometry_changed(object);
 
9935
 
 
9936
#else
 
9937
  error("gdk_window_geometry_changed exists only in Gdk >= 2.18.0");
 
9938
#endif
 
9939
 
 
9940
  return(_result);
 
9941
}
 
9942
 
 
9943
 
 
9944
USER_OBJECT_
 
9945
S_gdk_window_get_cursor(USER_OBJECT_ s_object)
 
9946
{
 
9947
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9948
#if GDK_CHECK_VERSION(2, 18, 0)
 
9949
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9950
 
 
9951
  GdkCursor* ans;
 
9952
 
 
9953
  ans = gdk_window_get_cursor(object);
 
9954
 
 
9955
  _result = toRPointerWithFinalizer(ans ? gdk_cursor_ref(ans) : NULL, "GdkCursor", (RPointerFinalizer) gdk_cursor_unref);
 
9956
#else
 
9957
  error("gdk_window_get_cursor exists only in Gdk >= 2.18.0");
 
9958
#endif
 
9959
 
 
9960
  return(_result);
 
9961
}
 
9962
 
 
9963
 
 
9964
USER_OBJECT_
 
9965
S_gdk_window_restack(USER_OBJECT_ s_object, USER_OBJECT_ s_sibling, USER_OBJECT_ s_above)
 
9966
{
 
9967
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9968
#if GDK_CHECK_VERSION(2, 18, 0)
 
9969
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9970
  GdkWindow* sibling = GDK_WINDOW(getPtrValue(s_sibling));
 
9971
  gboolean above = ((gboolean)asCLogical(s_above));
 
9972
 
 
9973
 
 
9974
  gdk_window_restack(object, sibling, above);
 
9975
 
 
9976
#else
 
9977
  error("gdk_window_restack exists only in Gdk >= 2.18.0");
 
9978
#endif
 
9979
 
 
9980
  return(_result);
 
9981
}
 
9982
 
 
9983
 
 
9984
USER_OBJECT_
 
9985
S_gdk_window_is_destroyed(USER_OBJECT_ s_object)
 
9986
{
 
9987
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
9988
#if GDK_CHECK_VERSION(2, 18, 0)
 
9989
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
9990
 
 
9991
  gboolean ans;
 
9992
 
 
9993
  ans = gdk_window_is_destroyed(object);
 
9994
 
 
9995
  _result = asRLogical(ans);
 
9996
#else
 
9997
  error("gdk_window_is_destroyed exists only in Gdk >= 2.18.0");
 
9998
#endif
 
9999
 
 
10000
  return(_result);
 
10001
}
 
10002
 
 
10003
 
 
10004
USER_OBJECT_
 
10005
S_gdk_window_get_root_coords(USER_OBJECT_ s_object, USER_OBJECT_ s_x, USER_OBJECT_ s_y)
 
10006
{
 
10007
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
10008
#if GDK_CHECK_VERSION(2, 18, 0)
 
10009
  GdkWindow* object = GDK_WINDOW(getPtrValue(s_object));
 
10010
  gint x = ((gint)asCInteger(s_x));
 
10011
  gint y = ((gint)asCInteger(s_y));
 
10012
 
 
10013
  gint root_x;
 
10014
  gint root_y;
 
10015
 
 
10016
  gdk_window_get_root_coords(object, x, y, &root_x, &root_y);
 
10017
 
 
10018
 
 
10019
  _result = retByVal(_result, "root.x", asRInteger(root_x), "root.y", asRInteger(root_y), NULL);
 
10020
  ;
 
10021
  ;
 
10022
#else
 
10023
  error("gdk_window_get_root_coords exists only in Gdk >= 2.18.0");
 
10024
#endif
 
10025
 
 
10026
  return(_result);
 
10027
}
 
10028
 
 
10029
 
 
10030
USER_OBJECT_
 
10031
S_gdk_pixbuf_simple_anim_set_loop(USER_OBJECT_ s_object, USER_OBJECT_ s_loop)
 
10032
{
 
10033
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
10034
#if GDK_CHECK_VERSION(2, 18, 0)
 
10035
  GdkPixbufSimpleAnim* object = GDK_PIXBUF_SIMPLE_ANIM(getPtrValue(s_object));
 
10036
  gboolean loop = ((gboolean)asCLogical(s_loop));
 
10037
 
 
10038
 
 
10039
  gdk_pixbuf_simple_anim_set_loop(object, loop);
 
10040
 
 
10041
#else
 
10042
  error("gdk_pixbuf_simple_anim_set_loop exists only in Gdk >= 2.18.0");
 
10043
#endif
 
10044
 
 
10045
  return(_result);
 
10046
}
 
10047
 
 
10048
 
 
10049
USER_OBJECT_
 
10050
S_gdk_pixbuf_simple_anim_get_loop(USER_OBJECT_ s_object)
 
10051
{
 
10052
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
10053
#if GDK_CHECK_VERSION(2, 18, 0)
 
10054
  GdkPixbufSimpleAnim* object = GDK_PIXBUF_SIMPLE_ANIM(getPtrValue(s_object));
 
10055
 
 
10056
  gboolean ans;
 
10057
 
 
10058
  ans = gdk_pixbuf_simple_anim_get_loop(object);
 
10059
 
 
10060
  _result = asRLogical(ans);
 
10061
#else
 
10062
  error("gdk_pixbuf_simple_anim_get_loop exists only in Gdk >= 2.18.0");
 
10063
#endif
 
10064
 
 
10065
  return(_result);
 
10066
}
 
10067
 
 
10068
 
 
10069
USER_OBJECT_
 
10070
S_gdk_keymap_add_virtual_modifiers(USER_OBJECT_ s_object)
 
10071
{
 
10072
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
10073
#if GDK_CHECK_VERSION(2, 20, 0)
 
10074
  GdkKeymap* object = GDK_KEYMAP(getPtrValue(s_object));
 
10075
 
 
10076
  GdkModifierType state;
 
10077
 
 
10078
  gdk_keymap_add_virtual_modifiers(object, &state);
 
10079
 
 
10080
 
 
10081
  _result = retByVal(_result, "state", asRFlag(state, GDK_TYPE_MODIFIER_TYPE), NULL);
 
10082
  ;
 
10083
#else
 
10084
  error("gdk_keymap_add_virtual_modifiers exists only in Gdk >= 2.20.0");
 
10085
#endif
 
10086
 
 
10087
  return(_result);
 
10088
}
 
10089
 
 
10090
 
 
10091
USER_OBJECT_
 
10092
S_gdk_keymap_map_virtual_modifiers(USER_OBJECT_ s_object)
 
10093
{
 
10094
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
10095
#if GDK_CHECK_VERSION(2, 20, 0)
 
10096
  GdkKeymap* object = GDK_KEYMAP(getPtrValue(s_object));
 
10097
 
 
10098
  gboolean ans;
 
10099
  GdkModifierType state;
 
10100
 
 
10101
  ans = gdk_keymap_map_virtual_modifiers(object, &state);
 
10102
 
 
10103
  _result = asRLogical(ans);
 
10104
 
 
10105
  _result = retByVal(_result, "state", asRFlag(state, GDK_TYPE_MODIFIER_TYPE), NULL);
 
10106
  ;
 
10107
#else
 
10108
  error("gdk_keymap_map_virtual_modifiers exists only in Gdk >= 2.20.0");
 
10109
#endif
 
10110
 
 
10111
  return(_result);
 
10112
}
 
10113
 
 
10114
 
 
10115
USER_OBJECT_
 
10116
S_gdk_screen_get_primary_monitor(USER_OBJECT_ s_object)
 
10117
{
 
10118
  USER_OBJECT_ _result = NULL_USER_OBJECT;
 
10119
#if GDK_CHECK_VERSION(2, 20, 0)
 
10120
  GdkScreen* object = GDK_SCREEN(getPtrValue(s_object));
 
10121
 
 
10122
  gint ans;
 
10123
 
 
10124
  ans = gdk_screen_get_primary_monitor(object);
 
10125
 
 
10126
  _result = asRInteger(ans);
 
10127
#else
 
10128
  error("gdk_screen_get_primary_monitor exists only in Gdk >= 2.20.0");
 
10129
#endif
 
10130
 
 
10131
  return(_result);
 
10132
}
 
10133
 
 
10134