自学教程：C++ GENUM2RVAL函数代码示例

static VALUErg_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 VALUErbclt_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 VALUErg_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 VALUErbclt_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 VALUErg_entry_type (VALUE self){    GstIndexEntry *entry = RGST_INDEX_ENTRY (self);    return GENUM2RVAL (entry->type, GST_TYPE_INDEX_ENTRY_TYPE);}

static VALUEgdk_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 VALUErpango_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 VALUEterm_get_cursor_shape(VALUE self){    VteTerminalCursorShape shape;    shape = vte_terminal_get_cursor_shape(RVAL2TERM(self));    return GENUM2RVAL(shape, VTE_TYPE_TERMINAL_CURSOR_SHAPE);}

static VALUEterm_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 VALUErg_subwindow_mode(VALUE self){    GdkGCValues val;    gdk_gc_get_values(_SELF(self), &val);    return GENUM2RVAL(val.subwindow_mode, GDK_TYPE_SUBWINDOW_MODE);}

static VALUErg_fill(VALUE self){    GdkGCValues val;    gdk_gc_get_values(_SELF(self), &val);    return GENUM2RVAL(val.fill, GDK_TYPE_FILL);}

static VALUErg_function(VALUE self){    GdkGCValues val;    gdk_gc_get_values(_SELF(self), &val);    return GENUM2RVAL(val.function, GDK_TYPE_FUNCTION);}

static VALUErg_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 VALUEiview_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 VALUErg_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 VALUEiview_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 VALUEgdk_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 VALUErg_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 VALUEdevice_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 VALUErg_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 VALUErg_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 VALUErg_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 VALUEsi_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 VALUErg_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 VALUErg_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 VALUEpo_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 VALUErg_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 VALUErg_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 VALUErbatkrole_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 VALUErg_type_id (VALUE self){    GstFormat *format = RGST_FORMAT (self);    return GENUM2RVAL (*format, GST_TYPE_FORMAT);}