static VALUE
rg_line_attributes(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return rb_ary_new3(4, INT2NUM(val.line_width),
GENUM2RVAL(val.line_style, GDK_TYPE_LINE_STYLE),
GENUM2RVAL(val.cap_style, GDK_TYPE_CAP_STYLE),
GENUM2RVAL(val.join_style, GDK_TYPE_JOIN_STYLE));
}
static VALUE
rbclt_box_layout_get_alignment (VALUE self, VALUE actor)
{
ClutterBoxLayout *layout = CLUTTER_BOX_LAYOUT (RVAL2GOBJ (self));
ClutterActor *g_actor = CLUTTER_ACTOR (RVAL2GOBJ (actor));
ClutterBoxAlignment x_align, y_align;
VALUE answer = rb_hash_new ();
clutter_box_layout_get_alignment (layout, g_actor, &x_align, &y_align);
rb_hash_aset (answer, rb_intern ("x"), GENUM2RVAL (x_align, CLUTTER_TYPE_BOX_ALIGNMENT));
rb_hash_aset (answer, rb_intern ("y"), GENUM2RVAL (y_align, CLUTTER_TYPE_BOX_ALIGNMENT));
return answer;
}
static VALUE
rg_find_window(int argc, VALUE *argv, VALUE self)
{
VALUE drag_window, x_root, y_root;
GdkWindow *dest_window;
GdkDragProtocol prot;
if (argc == 3) {
rb_scan_args(argc, argv, "30", &drag_window, &x_root, &y_root);
gdk_drag_find_window(_SELF(self),
GDK_WINDOW(RVAL2GOBJ(drag_window)),
NUM2INT(x_root), NUM2INT(y_root),
&dest_window, &prot);
} else {
VALUE screen;
rb_scan_args(argc, argv, "40", &drag_window, &screen, &x_root, &y_root);
gdk_drag_find_window_for_screen(_SELF(self),
GDK_WINDOW(RVAL2GOBJ(drag_window)),
GDK_SCREEN(RVAL2GOBJ(screen)),
NUM2INT(x_root), NUM2INT(y_root),
&dest_window, &prot);
}
return rb_ary_new3(2, GOBJ2RVAL(dest_window),
GENUM2RVAL(prot, GDK_TYPE_DRAG_PROTOCOL));
}
static VALUE
rbclt_flow_layout_get_orientation (VALUE self)
{
ClutterFlowLayout *flow_layout = CLUTTER_FLOW_LAYOUT (RVAL2GOBJ (self));
return GENUM2RVAL (clutter_flow_layout_get_orientation (flow_layout), CLUTTER_TYPE_FLOW_ORIENTATION);
}
/* Method: entry_type
* Returns: the type of the entry (see Gst::IndexEntry::Types).
*/
static VALUE
rg_entry_type (VALUE self)
{
GstIndexEntry *entry = RGST_INDEX_ENTRY (self);
return GENUM2RVAL (entry->type, GST_TYPE_INDEX_ENTRY_TYPE);
}
static VALUE
gdk_s_keyboard_grab(VALUE self, VALUE win, VALUE owner_events, VALUE time)
{
return GENUM2RVAL(gdk_keyboard_grab(GDK_WINDOW(RVAL2GOBJ(win)),
RVAL2CBOOL(owner_events), NUM2INT(time)),
GDK_TYPE_GRAB_STATUS);
}
static VALUE
rpango_find_base_dir(VALUE self, VALUE text)
{
StringValue(text);
return GENUM2RVAL(pango_find_base_dir(RSTRING_PTR(text), RSTRING_LEN(text)),
PANGO_TYPE_DIRECTION);
}
static VALUE
term_get_cursor_shape(VALUE self)
{
VteTerminalCursorShape shape;
shape = vte_terminal_get_cursor_shape(RVAL2TERM(self));
return GENUM2RVAL(shape, VTE_TYPE_TERMINAL_CURSOR_SHAPE);
}
static VALUE
term_get_cursor_blink_mode(VALUE self)
{
VteTerminalCursorBlinkMode mode;
mode = vte_terminal_get_cursor_blink_mode(RVAL2TERM(self));
return GENUM2RVAL(mode, VTE_TYPE_TERMINAL_CURSOR_BLINK_MODE);
}
static VALUE
rg_subwindow_mode(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GENUM2RVAL(val.subwindow_mode, GDK_TYPE_SUBWINDOW_MODE);
}
static VALUE
rg_fill(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GENUM2RVAL(val.fill, GDK_TYPE_FILL);
}
static VALUE
rg_function(VALUE self)
{
GdkGCValues val;
gdk_gc_get_values(_SELF(self), &val);
return GENUM2RVAL(val.function, GDK_TYPE_FUNCTION);
}
static VALUE
rg_rect_in(VALUE self, VALUE rect)
{
return GENUM2RVAL(gdk_region_rect_in(
_SELF(self),
(GdkRectangle*)RVAL2BOXED(rect, GDK_TYPE_RECTANGLE)),
GDK_TYPE_OVERLAP_TYPE);
}
static VALUE
iview_drag_dest_item(VALUE self)
{
GtkTreePath* path;
GtkIconViewDropPosition pos;
gtk_icon_view_get_drag_dest_item(_SELF(self), &path, &pos);
return rb_assoc_new(GTKTREEPATH2RVAL(path),
GENUM2RVAL(pos, GTK_TYPE_ICON_VIEW_DROP_POSITION));
}
static VALUE
rg_drag_dest_row(VALUE self)
{
GtkTreePath* path = NULL;
GtkTreeViewDropPosition pos;
gtk_tree_view_get_drag_dest_row(_SELF(self), &path, &pos);
return rb_ary_new3(2, path ? GTKTREEPATH2RVAL(path) : Qnil,
GENUM2RVAL(pos, GTK_TYPE_TREE_VIEW_DROP_POSITION));
}
static VALUE
iview_get_dest_item_at_pos(VALUE self, VALUE drag_x, VALUE drag_y)
{
GtkTreePath* path;
GtkIconViewDropPosition pos;
gboolean item_at_pos = gtk_icon_view_get_dest_item_at_pos(_SELF(self), NUM2INT(drag_x), NUM2INT(drag_y), &path, &pos);
return item_at_pos ? rb_assoc_new(GTKTREEPATH2RVAL(path),
GENUM2RVAL(pos, GTK_TYPE_ICON_VIEW_DROP_POSITION)) : Qnil;
}
static VALUE
gdk_s_pointer_grab(VALUE self, VALUE win, VALUE owner_events, VALUE event_mask, VALUE confine_to, VALUE cursor, VALUE time)
{
return GENUM2RVAL(gdk_pointer_grab(GDK_WINDOW(RVAL2GOBJ(win)),
RVAL2CBOOL(owner_events),
RVAL2GFLAGS(event_mask, GDK_TYPE_EVENT_MASK),
NIL_P(confine_to)?NULL:GDK_WINDOW(RVAL2GOBJ(confine_to)),
NIL_P(cursor)?NULL:(GdkCursor*)RVAL2BOXED(cursor, GDK_TYPE_CURSOR),
NUM2INT(time)), GDK_TYPE_GRAB_STATUS);
}
static VALUE
rg_pointer_grab(VALUE self, VALUE item, VALUE event_mask, VALUE cursor, VALUE etime)
{
return GENUM2RVAL(
goo_canvas_pointer_grab(SELF(self), RVAL2GOOCANVASITEM(item),
NUM2INT(event_mask),
(GdkCursor *)RVAL2BOXED(cursor, GDK_TYPE_CURSOR),
NIL_P(etime) ? 0 : NUM2UINT(etime)),
GDK_TYPE_GRAB_STATUS);
}
static VALUE
device_axes(VALUE self)
{
gint i;
VALUE ary = rb_ary_new();
GdkDeviceAxis* axes = _SELF(self)->axes;
for (i = 0; i < _SELF(self)->num_axes; i++){
rb_ary_push(ary, rb_ary_new3(3, GENUM2RVAL(axes[i].use, GDK_TYPE_AXIS_USE),
rb_float_new(axes[i].min), rb_float_new(axes[i].max)));
}
return ary;
}
static VALUE
rg_get_dest_row_at_pos(VALUE self, VALUE drag_x, VALUE drag_y)
{
GtkTreePath* path;
GtkTreeViewDropPosition pos;
gboolean ret;
ret = gtk_tree_view_get_dest_row_at_pos(_SELF(self),
NUM2INT(drag_x), NUM2INT(drag_y),
&path, &pos);
return ret ? rb_ary_new3(2, path ? GTKTREEPATH2RVAL(path) : Qnil,
GENUM2RVAL(pos, GTK_TYPE_TREE_VIEW_DROP_POSITION)) : Qnil;
}
static VALUE
rg_sizes(VALUE self)
{
GtkIconSize *sizes;
gint n_sizes;
VALUE result;
int n;
gtk_icon_set_get_sizes(_SELF(self), &sizes, &n_sizes);
result = rb_ary_new();
for(n=0; n<n_sizes; n++, sizes++)
rb_ary_push(result, GENUM2RVAL(*sizes, GTK_TYPE_ICON_SIZE));
return result;
}
static VALUE
rg_s_query_visual_types(G_GNUC_UNUSED VALUE self)
{
GdkVisualType *visual_types;
gint count;
VALUE ary;
int i;
gdk_query_visual_types(&visual_types, &count);
ary = rb_ary_new2(count);
for (i = 0; i < count; i++) {
rb_ary_push(ary, GENUM2RVAL((visual_types)[i], GDK_TYPE_VISUAL_TYPE));
}
return ary;
}
static VALUE
si_get_geometry(VALUE self)
{
GdkScreen* screen;
GdkRectangle area;
GtkOrientation orientation;
gboolean ret = gtk_status_icon_get_geometry(_SELF(self), &screen,
&area, &orientation);
if (ret) {
return rb_ary_new3(3, GOBJ2RVAL(screen),
BOXED2RVAL(&area, GDK_TYPE_RECTANGLE),
GENUM2RVAL(orientation, GTK_TYPE_ORIENTATION));
} else {
return rb_ary_new3(3, Qnil, Qnil, Qnil);
}
}
static VALUE
rg_query_tab_label_packing(VALUE self, VALUE child)
{
gboolean expand, fill;
GtkPackType pack_type;
VALUE ary;
gtk_notebook_query_tab_label_packing(_SELF(self),
RVAL2WIDGET(child),
&expand, &fill, &pack_type);
ary = rb_ary_new2(3);
rb_ary_push(ary, CBOOL2RVAL(expand));
rb_ary_push(ary, CBOOL2RVAL(fill));
rb_ary_push(ary, GENUM2RVAL(pack_type, GTK_TYPE_PACK_TYPE));
return ary;
}
static VALUE
rg_s_get_protocol(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE xid;
GdkDragProtocol prot;
GdkNativeWindow ret;
if (argc == 1) {
rb_scan_args(argc, argv, "10", &xid);
ret = gdk_drag_get_protocol(RVAL2GDKNATIVEWINDOW(xid), &prot);
} else {
VALUE display;
rb_scan_args(argc, argv, "20", &display, &xid);
ret = gdk_drag_get_protocol_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
RVAL2GDKNATIVEWINDOW(xid), &prot);
}
return rb_ary_new3(2, GENUM2RVAL(prot, GDK_TYPE_DRAG_PROTOCOL), GDKNATIVEWINDOW2RVAL(ret));
}
static VALUE
po_run(int argc, VALUE *argv, VALUE self)
{
VALUE action, parent, rb_result;
GtkPrintOperationResult result;
GError *error = NULL;
rb_scan_args(argc, argv, "11", &action, &parent);
result = gtk_print_operation_run(_SELF(self),
RVAL2GENUM(action, GTK_TYPE_PRINT_OPERATION_ACTION),
RVAL2GOBJ(parent), &error);
rb_result = GENUM2RVAL(result, GTK_TYPE_PRINT_OPERATION_RESULT);
if (rb_block_given_p()) {
return rb_yield(rb_result);
} else {
if (result == GTK_PRINT_OPERATION_RESULT_ERROR)
RAISE_GERROR(error);
return rb_result;
}
}
/*
* Method: wait_async { |clock, time, clock_entry| ... }
*
* Registers a block code, which will be called passing references
* to the Gst::Clock, the time (in nanoseconds) and the Gst::ClockEntry as
* parameters.
*
* Returns: a return code (see Gst::Clock::Return).
*/
static VALUE
rg_wait_async (VALUE self)
{
GstClockID id = (GstClockID) RGST_CLOCK_ENTRY (self);
if (__callback_get (id) != NULL)
rb_raise (rb_eRuntimeError,
"An asynch callback is already registred to this entry.");
else {
struct __callback *e = g_malloc (sizeof (struct __callback));
g_assert (e != NULL);
e->id = id;
e->callback = rb_block_proc ();
__callbacks = g_slist_append (__callbacks, e);
return GENUM2RVAL (INT2FIX (gst_clock_id_wait_async (id,
__callback_dispatcher,
NULL)),
GST_TYPE_CLOCK_RETURN);
}
return Qnil;
}
static VALUE
rg_get_page_type(VALUE self, VALUE page)
{
return GENUM2RVAL(gtk_assistant_get_page_type(_SELF(self), GTK_WIDGET(RVAL2GOBJ(page))), GTK_TYPE_ASSISTANT_PAGE_TYPE);
}
static VALUE
rbatkrole_s_for_name(VALUE self, VALUE name)
{
return GENUM2RVAL(atk_role_for_name(RVAL2CSTR(name)), ATK_TYPE_ROLE);
}
/* Method: type_id
* Returns: the type id of this format (see Gst::Format::Type).
*/
static VALUE
rg_type_id (VALUE self)
{
GstFormat *format = RGST_FORMAT (self);
return GENUM2RVAL (*format, GST_TYPE_FORMAT);
}
