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

/* Convenience API */static VALUErb_rsvg_pixbuf_from_file(VALUE self, VALUE file_name){    VALUE rb_pixbuf;    GdkPixbuf *pixbuf;    GError *error = NULL;    pixbuf = rsvg_pixbuf_from_file(RVAL2CSTR(file_name), &error);    if (error) RAISE_GERROR(error);    rb_pixbuf = GOBJ2RVAL(pixbuf);    g_object_unref(pixbuf);    return rb_pixbuf;}

/* * Gtk::Settings.install_property(...) do |spec, str| *   #parse str *   new_val = ....   # parse value from string. *   new_val          # return new_val or nil if you can't convert the value. * end */static gbooleanrc_property_parser(const GParamSpec *pspec, const GString *rc_string, GValue *property_value){    VALUE spec = GOBJ2RVAL((gpointer)pspec);    VALUE func = rb_hash_aref(prop_func_table, spec);    VALUE ret = rb_funcall(func, id_call, 2, spec, CSTR2RVAL(rc_string->str));    if (NIL_P(ret)) {        return FALSE;    } else if (RVAL2CBOOL(ret)){        rbgobj_rvalue_to_gvalue(ret, property_value);        return TRUE;    } else {        rb_raise(rb_eArgError, "Gtk::Settings#install_property() block should return new value or nil");    }}

static gbooleanterm_is_selected_cb(VteTerminal *terminal, glong column, glong row,                    gpointer data){    gboolean result = TRUE;    VALUE callback = (VALUE)data;    if (!NIL_P(callback)) {        VALUE rb_result;        rb_result = rb_funcall(callback, id_call, 3, GOBJ2RVAL(terminal),                               LONG2NUM(column), LONG2NUM(row));        result = RVAL2CBOOL(rb_result);    }    return result;}

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 voidmenu_pos_func(GtkMenu *menu, gint *px, gint *py, gboolean *push_in, gpointer data){    VALUE arr = rb_funcall((VALUE)data, id_call, 4, GOBJ2RVAL(menu),                            INT2FIX(*px), INT2FIX(*py),                            CBOOL2RVAL(*push_in));    if (TYPE(arr) == T_ARRAY && (RARRAY_LEN(arr) == 2 || RARRAY_LEN(arr) == 3)){        *px = NUM2INT(RARRAY_PTR(arr)[0]);        *py = NUM2INT(RARRAY_PTR(arr)[1]);        if (RARRAY_LEN(arr) == 3)            *push_in = RVAL2CBOOL(RARRAY_PTR(arr)[2]);    } else {        rb_raise(rb_eArgError, "block should return [x, y, push_in]");     } }

static gbooleaneach_printer(GtkPrinter *printer, gpointer data){    VALUE result;    VALUE argv[1];    struct callback_arg arg;    argv[0] = GOBJ2RVAL(printer);    arg.callback = (VALUE)data;    arg.argc = 1;    arg.argv = argv;    result = G_PROTECT_CALLBACK(invoke_callback, &arg);    return NIL_P(rb_errinfo()) ? TRUE : RVAL2CBOOL(result);}

static VALUErg_get_path_at_pos(VALUE self, VALUE x, VALUE y){    GtkTreePath* path;    GtkTreeViewColumn* column;    gint cell_x, cell_y;    gboolean ret;    ret = gtk_tree_view_get_path_at_pos(_SELF(self),                                         NUM2INT(x), NUM2INT(y),                                        &path, &column, &cell_x, &cell_y);    return ret ? rb_ary_new3(4,                              path ? GTKTREEPATH2RVAL(path) : Qnil,                             column ? GOBJ2RVAL(column) : Qnil,                             INT2NUM(cell_x), INT2NUM(cell_y)) : Qnil;}

static VALUEasyncinitable_initialize_finish(VALUE self, VALUE result){        GError *error = NULL;        GObject *object;        VALUE rbobject;        object = g_async_initable_new_finish(_SELF(self),                                             RVAL2GASYNCRESULT(result),                                             &error);        if (object == NULL)                rbgio_raise_error(error);        rbobject = GOBJ2RVAL(object);        g_object_unref(object);        return rbobject;}

static VALUEsignal_rows_reordered_func(G_GNUC_UNUSED guint num, const GValue *values){    GtkTreeModel* model = g_value_get_object(&values[0]);    GtkTreePath* path = g_value_get_boxed(&values[1]);    GtkTreeIter* iter = g_value_get_boxed(&values[2]);    gint* new_orders = (gint*)g_value_get_pointer(&values[3]);    gint len = gtk_tree_model_iter_n_children(model, iter);    VALUE orders = Qnil;    int i;    iter->user_data3 = model;    orders = rb_ary_new2(len);    for (i = 0; i < len; i++, new_orders++) {        rb_ary_push(orders, INT2NUM(*new_orders));    }    return rb_ary_new3(4, GOBJ2RVAL(model), GTKTREEPATH2RVAL(path), GTKTREEITER2RVAL(iter), orders);}

static VALUErg_s_pixbuf_from_file_at_zoom(G_GNUC_UNUSED VALUE self, VALUE file_name,                                 VALUE x_zoom, VALUE y_zoom){    VALUE rb_pixbuf;    GdkPixbuf *pixbuf;    GError *error = NULL;    pixbuf = rsvg_pixbuf_from_file_at_zoom(RVAL2CSTR(file_name),                                           NUM2DBL(x_zoom),                                           NUM2DBL(y_zoom),                                           &error);    if (error) RAISE_GERROR(error);    rb_pixbuf = GOBJ2RVAL(pixbuf);    g_object_unref(pixbuf);    return rb_pixbuf;}

static VALUErg_s_pixbuf_from_file_at_size(G_GNUC_UNUSED VALUE self, VALUE file_name,                                 VALUE width, VALUE height){    VALUE rb_pixbuf;    GdkPixbuf *pixbuf;    GError *error = NULL;    pixbuf = rsvg_pixbuf_from_file_at_size(RVAL2CSTR(file_name),                                           NUM2INT(width),                                           NUM2INT(height),                                           &error);    if (error) RAISE_GERROR(error);    rb_pixbuf = GOBJ2RVAL(pixbuf);    g_object_unref(pixbuf);    return rb_pixbuf;}

static VALUErg_each(VALUE self){    PopplerDocument *document;    int i, n_pages;    document = RVAL2DOC(self);    n_pages = poppler_document_get_n_pages(document);    for (i = 0; i < n_pages; i++) {        PopplerPage *page;        VALUE rb_page;        page = poppler_document_get_page(document, i);        rb_page = GOBJ2RVAL(page);        if (page)            g_object_unref(page);        rb_yield(rb_page);    }    return self;}

static VALUErg_open_signal_func(G_GNUC_UNUSED guint num, const GValue *values){    VALUE rb_files;    GFile **files;    gint i, n_files;    files = g_value_get_pointer(&(values[1]));    n_files = g_value_get_int(&(values[2]));    rb_files = rb_ary_new2(n_files);    for (i = 0; i < n_files; i++) {        GFile *file = files[i];        rb_ary_push(rb_files, GOBJ2RVAL(file));    }    return rb_ary_new3(3,                       GVAL2RVAL(&values[0]),                       rb_files,                       GVAL2RVAL(&values[3]));}

static VALUErb_rsvg_pixbuf_from_file_at_max_size_ex(VALUE self, VALUE file_name,                                        VALUE max_width, VALUE max_height){    VALUE rb_pixbuf;    GdkPixbuf *pixbuf;    GError *error = NULL;    pixbuf = rsvg_pixbuf_from_file_at_max_size_ex(_SELF(self),             RVAL2CSTR(file_name),             NUM2INT(max_width),             NUM2INT(max_height),             &error);    if (error) RAISE_GERROR(error);    rb_pixbuf = GOBJ2RVAL(pixbuf);    g_object_unref(pixbuf);    return rb_pixbuf;}

static VALUErg_s_open(G_GNUC_UNUSED VALUE self, VALUE display_name){    GdkDisplay* gdisplay = gdk_display_open(RVAL2CSTR(display_name));    if (! gdisplay) {        rb_raise(rb_eRuntimeError, "The display `%s' could not be opened.",                  RVAL2CSTR(display_name));    } else {        VALUE display;        g_object_ref(gdisplay);        display = GOBJ2RVAL(gdisplay);        if (rb_block_given_p()) {            rb_ensure(rb_yield, display, rg_close, display);            return Qnil;        } else {            return display;        }    }}

static VALUErg_families(VALUE self){    int n_families;    PangoFontFamily** families;    int i;    VALUE result;    pango_font_map_list_families(_SELF(self),                                 &families,                                 &n_families);    result = rb_ary_new2(n_families);    for (i = 0; i < n_families; i++)      rb_ary_store(result, i, GOBJ2RVAL(families[i]));    g_free(families);    return result;}

/* * Class method: make(factory_name, element_name) * factory_name: a name of an existing factory. * element_name: a name which will be attributed to the element. * * Creates a new Gst::Element of the type defined by the given element factory. * * If element name is ommited (or nil), then the element will receive a guaranteed  * unique name, consisting of the element factory name and a number.  * If name is given, it will be given the name supplied. * * 	# Creates a 'mad' GStreamer element, named 'foo': * 	elem1 = Gst::ElementFactory.make("mad", "foo") *	   * 	# This line does exactly the same thing: * 	elem2 = Gst::ElementFactory.find("mad").create("foo") * * Returns: a newly created object based on Gst::Element. */static VALUErb_gst_elementfactory_make(int argc, VALUE *argv, VALUE self){    GstElement *element;    VALUE fname, ename;    VALUE ret;    rb_scan_args(argc, argv, "11", &fname, &ename);    element = gst_element_factory_make(RVAL2CSTR(fname),				       RVAL2CSTR_ACCEPT_NIL(ename));    if (element == NULL)        return Qnil;    /* This add another ref to the element, but it was already ours so     * unref it again */    ret = GOBJ2RVAL(element);    GOBJ2RVAL_UNREF(element);    return ret;}

// FIXME: use rb_protectstatic voidset_prop_func(GObject* object,              guint property_id,              const GValue* value,              GParamSpec* pspec){    ID ruby_setter = (ID)g_param_spec_get_qdata(pspec, q_ruby_setter);    if (!ruby_setter) {        gchar* name = g_strconcat(g_param_spec_get_name(pspec), "=", NULL);        gchar* p;        for (p = name; *p; p++) {          if (*p == '-')            *p = '_';        }        ruby_setter = rb_intern(name);        g_param_spec_set_qdata(pspec, q_ruby_setter, (gpointer)ruby_setter);        g_free(name);    }    rb_funcall(GOBJ2RVAL(object), ruby_setter, 1, GVAL2RVAL(value));}

static VALUErg_m_new(int argc, VALUE *argv, VALUE self){        const RGObjClassInfo* info;        VALUE cancellable, parameters;        GObject *object;        VALUE result;        rb_scan_args(argc, argv, "02", &cancellable, &parameters);        info = CLASS2CINFO(self);        if (info->klass != self)                rb_raise(rb_eTypeError,                         "%s: class not registered with GLib",                         rb_class2name(self));        object = rbgio_ginitable_new(info->gtype, parameters, cancellable);        result = GOBJ2RVAL(object);        g_object_unref(object);        return result;}

static VALUErg_s_new_bang(int argc, VALUE *argv, VALUE self){    const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);    VALUE params_hash;    GObject* gobj;    VALUE result;    rb_scan_args(argc, argv, "01", &params_hash);    if (!NIL_P(params_hash))        Check_Type(params_hash, RUBY_T_HASH);    if (cinfo->klass != self)        rb_raise(rb_eTypeError, "%s isn't registered class",                 rb_class2name(self));    gobj = rbgobj_gobject_new(cinfo->gtype, params_hash);    result = GOBJ2RVAL(gobj);    g_object_unref(gobj);    return result;}

// FIXME: use rb_protectstatic voidget_prop_func(GObject* object,              guint property_id,              GValue* value,              GParamSpec* pspec){    ID ruby_getter = (ID)g_param_spec_get_qdata(pspec, q_ruby_getter);    if (!ruby_getter) {        gchar* name = g_strdup(g_param_spec_get_name(pspec));        gchar* p;        for (p = name; *p; p++) {          if (*p == '-')            *p = '_';        }        ruby_getter = rb_intern(name);        g_param_spec_set_qdata(pspec, q_ruby_getter, (gpointer)ruby_getter);        g_free(name);    }    {        VALUE ret = rb_funcall(GOBJ2RVAL(object), ruby_getter, 0);        rbgobj_rvalue_to_gvalue(ret, value);    }}

static VALUErg_get_page(VALUE self, VALUE index_or_label){    VALUE rb_page;    PopplerPage *page;    if (RVAL2CBOOL(rb_obj_is_kind_of(index_or_label, rb_cInteger))) {        page = poppler_document_get_page(RVAL2DOC(self),                                         NUM2INT(index_or_label));    } else if (RVAL2CBOOL(rb_obj_is_kind_of(index_or_label, rb_cString))) {        page = poppler_document_get_page_by_label(RVAL2DOC(self),                                                  RVAL2CSTR(index_or_label));    } else {        VALUE inspect;        inspect = rb_inspect(index_or_label);        rb_raise(rb_eArgError, "%s must be Integer or String",                 RVAL2CSTR(inspect));    }    rb_page = GOBJ2RVAL(page);    if (page)        g_object_unref(page);    return rb_page;}

VALUErbgtk_make_clipboard(GtkClipboard *gobj){    return GOBJ2RVAL(gobj);}

static VALUErg_wait_for_image(VALUE self){    GdkPixbuf* pixbuf = gtk_clipboard_wait_for_image(_SELF(self));    return GOBJ2RVAL(pixbuf);}

static voidclipboard_image_received_func(GtkClipboard *clipboard, GdkPixbuf *pixbuf, gpointer func){    rb_funcall((VALUE)func, id_call, 2, CLIPBOARD2RVAL(clipboard),               GOBJ2RVAL(pixbuf));}

static VALUErg_xor(VALUE self, VALUE compare_set){    return GOBJ2RVAL(atk_state_set_xor_sets(_SELF(self), _SELF(compare_set)));}

static VALUEget_source(VALUE self){    return GOBJ2RVAL(GST_MESSAGE_SRC(SELF(self)));}

static VALUErg_get_nth_page(VALUE self, VALUE page_num){    return GOBJ2RVAL(gtk_assistant_get_nth_page(_SELF(self), NUM2INT(page_num)));}

static VALUErg_get_page_side_image(VALUE self, VALUE page){    return GOBJ2RVAL(gtk_assistant_get_page_side_image(_SELF(self), GTK_WIDGET(RVAL2GOBJ(page))));}

static VALUErg_image(VALUE self){    return GOBJ2RVAL(gdk_cursor_get_image(RVAL2GDKCURSOR(self)));}