static VALUE rg_m_sync(VALUE self, VALUE working_directory, VALUE argv, VALUE envp, VALUE flags) { GError *err = NULL; gboolean ret; VALUE func = Qnil; gchar** gargv; gchar** genvp; gchar *standard_output = NULL, *standard_error = NULL; gint exit_status; VALUE std_out, std_err; if (rb_block_given_p()) { func = rb_block_proc(); G_RELATIVE(self, func); } gargv = (gchar **)RVAL2STRV(argv); genvp = (gchar **)RVAL2STRV_ACCEPT_NIL(envp); ret = g_spawn_sync(NIL_P(working_directory) ? NULL : RVAL2CSTR(working_directory), gargv, genvp, NUM2INT(flags), (GSpawnChildSetupFunc)child_setup, (gpointer)func, &standard_output, &standard_error, &exit_status, &err); g_free(gargv); g_free(genvp); if (!ret) RAISE_GERROR(err); if (standard_output) { std_out = CSTR2RVAL(standard_output); g_free(standard_output); } else { std_out = Qnil; standard_output = NULL; } if (standard_error) { std_err = CSTR2RVAL(standard_error); g_free(standard_error); standard_error = NULL; } else { std_err = Qnil; } if (! ret) RAISE_GERROR(err); return rb_ary_new3(3, std_out, std_err, INT2FIX(exit_status)); }
static VALUE rbclt_layout_manager_child_set_property (VALUE self, VALUE container, VALUE actor, VALUE property, VALUE value) { ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (RVAL2GOBJ (self)); ClutterContainer *g_container = CLUTTER_CONTAINER (RVAL2GOBJ (container)); ClutterActor *g_actor = CLUTTER_ACTOR (RVAL2GOBJ (actor)); GValue g_value; g_value_init (&g_value, RVAL2GTYPE (value)); rbgobj_rvalue_to_gvalue (value, &g_value); clutter_layout_manager_child_set_property (manager, g_container, g_actor, RVAL2CSTR (property), &g_value); g_value_unset (&g_value); return Qnil; }
static VALUE rb_rsvg_handle_new_from_data(VALUE self, VALUE data) { GError *error = NULL; RsvgHandle *handle; handle = rsvg_handle_new_from_data((const guint8 *)RVAL2CSTR(data), RSTRING_LEN(data), &error); if (error) RAISE_GERROR(error); return GOBJ2RVAL(handle); }
static VALUE rb_rsvg_handle_new_from_file(VALUE self, VALUE file) { GError *error = NULL; RsvgHandle *handle; handle = rsvg_handle_new_from_file((const gchar *)RVAL2CSTR(file), &error); if (error) RAISE_GERROR(error); return GOBJ2RVAL(handle); }
static VALUE rg_render_icon(int argc, VALUE *argv, VALUE self) { VALUE style, direction, state, size, widget, detail; rb_scan_args(argc, argv, "42", &style, &direction, &state, &size, &widget, &detail); return GOBJ2RVAL(gtk_icon_set_render_icon(_SELF(self), RVAL2GOBJ(style), RVAL2GENUM(direction, GTK_TYPE_TEXT_DIRECTION), RVAL2GENUM(state, GTK_TYPE_STATE_TYPE), RVAL2GENUM(size, GTK_TYPE_ICON_SIZE), NIL_P(widget) ? NULL : RVAL2GOBJ(widget), NIL_P(detail) ? NULL : RVAL2CSTR(detail))); }
static VALUE style_lookup_icon_set(VALUE self, VALUE stock_id) { const gchar *id; GtkIconSet *ret; if (TYPE(stock_id) == T_STRING) { id = RVAL2CSTR(stock_id); } else { id = rb_id2name(SYM2ID(stock_id)); } ret = gtk_style_lookup_icon_set(_SELF(self), id); return BOXED2RVAL(ret, GTK_TYPE_ICON_SET); }
static VALUE fileattributeinfolist_add(int argc, VALUE *argv, VALUE self) { VALUE name, type, flags; rb_scan_args(argc, argv, "21", &name, &type, &flags); g_file_attribute_info_list_add(_SELF(self), RVAL2CSTR(name), RVAL2GFILEATTRIBUTETYPE(type), RVAL2GFILEATTRIBUTEINFOFLAGSDEFAULT(flags)); return self; }
static VALUE rg_save(VALUE self, VALUE uri) { gboolean result; GError *error = NULL; uri = rb_funcall(self, id_ensure_uri, 1, uri); result = poppler_document_save(RVAL2DOC(self), RVAL2CSTR(uri), &error); if (error) RAISE_GERROR(error); return CBOOL2RVAL(result); }
static VALUE rg_s_notify_startup_complete(int argc, VALUE *argv, VALUE self) { VALUE startup_id; rb_scan_args(argc, argv, "01", &startup_id); if (NIL_P(startup_id)) { gdk_notify_startup_complete(); } else { gdk_notify_startup_complete_with_id(RVAL2CSTR(startup_id)); } return self; }
static VALUE appinfo_launch_default_for_uri(int argc, VALUE *argv, VALUE self) { VALUE uri, launch_context; GError *error; rb_scan_args(argc, argv, "11", &uri, &launch_context); if (!g_app_info_launch_default_for_uri(RVAL2CSTR(uri), RVAL2GAPPLAUNCHCONTEXT(launch_context), &error)) rbgio_raise_error(error); return self; }
/* Internal use only */ static VALUE ioc_set_line_term(VALUE args) { VALUE self = RARRAY_PTR(args)[0]; VALUE doit = RARRAY_PTR(args)[1]; VALUE line_term = RARRAY_PTR(args)[2]; if (doit == Qtrue){ StringValue(line_term); g_io_channel_set_line_term(_SELF(self), RVAL2CSTR(line_term), RSTRING_LEN(line_term)); } return self; }
static void in_callback_argument_from_ruby(RBGIArgMetadata *metadata, GArray *in_args) { gpointer callback; GIArgInfo *arg_info; GIArgument *callback_argument; arg_info = &(metadata->arg_info); callback = find_callback_function(arg_info); if (!callback) { GITypeInfo type_info; GIBaseInfo *interface_info; VALUE rb_type_name; g_arg_info_load_type(arg_info, &type_info); interface_info = g_type_info_get_interface(&type_info); rb_type_name = CSTR2RVAL(g_base_info_get_name(interface_info)); g_base_info_unref(interface_info); rb_raise(rb_eNotImpError, "TODO: <%s>(%s) callback is not supported yet.", RVAL2CSTR(rb_type_name), g_base_info_get_name(arg_info)); } callback_argument = &(g_array_index(in_args, GIArgument, metadata->in_arg_index)); callback_argument->v_pointer = callback; if (metadata->closure_in_arg_index != -1) { RBGICallbackData *callback_data; GIArgument *closure_argument; callback_data = ALLOC(RBGICallbackData); callback_data->metadata = metadata; callback_data->rb_callback = rb_block_proc(); callback_data_guard_from_gc(callback_data); closure_argument = &(g_array_index(in_args, GIArgument, metadata->closure_in_arg_index)); closure_argument->v_pointer = callback_data; } if (metadata->destroy_in_arg_index != -1) { GIArgument *destroy_argument; destroy_argument = &(g_array_index(in_args, GIArgument, metadata->destroy_in_arg_index)); destroy_argument->v_pointer = destroy_notify; } }
static VALUE fileattributematcher_enumerate_namespace(VALUE self, VALUE ns) { const char *match; gboolean matches_all = g_file_attribute_matcher_enumerate_namespace(_SELF(self), RVAL2CSTR(ns)); if (!rb_block_given_p()) return CBOOL2RVAL(matches_all); while ((match = g_file_attribute_matcher_enumerate_next(_SELF(self))) != NULL) rb_yield(CSTR2RVAL(match)); return self; }
static VALUE rg_fork_command(int argc, VALUE *argv, VALUE self) { VALUE rb_command, rb_command_argv, rb_envv, rb_directory; VALUE lastlog, utmp, wtmp; char *command; char **command_argv; char **envv; char *directory; pid_t pid; rb_scan_args(argc, argv, "07", &rb_command, &rb_command_argv, &rb_envv, &rb_directory, &lastlog, &utmp, &wtmp); #if VTE_CHECK_VERSION(0, 26, 0) if (argc == 0 || TYPE(rb_command) == T_HASH) return fork_command_full(1, &rb_command, self); rb_warn("'fork_commad(command, argv, envv, directory, lastlog, utmp, wtmp)' style" " has been deprecated since version 0.26." " Use 'fork_commad(options = {})' style."); #endif command = NIL_P(rb_command) ? NULL : RVAL2CSTR(rb_command); command_argv = rval2cstrary(rb_command_argv); envv = rval2cstrary(rb_envv); directory = NIL_P(rb_directory) ? NULL : RVAL2CSTR(rb_directory); pid = vte_terminal_fork_command(RVAL2TERM(self), command, command_argv, envv, directory, NIL_P(lastlog) ? TRUE : RVAL2CBOOL(lastlog), NIL_P(utmp) ? TRUE : RVAL2CBOOL(utmp), NIL_P(wtmp) ? TRUE : RVAL2CBOOL(wtmp)); free_cstrary(command_argv); free_cstrary(envv); return INT2NUM(pid); }
static VALUE put_value(int argc, VALUE *argv, VALUE self) { VALUE value, cancellable; gboolean success; GError *error = NULL; rb_scan_args(argc, argv, "11", &value, &cancellable); /* TODO: How do we convert from a Number to uint64 through byte in a * reliable manner? Is it even sane to do so? */ switch (TYPE(value)) { case T_STRING: success = g_data_output_stream_put_string(_SELF(self), RVAL2CSTR(value), cancellable, &error); break; if (!success) rbgio_raise_io_error(error); return self; } #endif void Init_gdataoutputstream(VALUE glib) { VALUE dataoutputstream = G_DEF_CLASS(G_TYPE_DATA_OUTPUT_STREAM, "DataOutputStream", glib); rb_define_method(dataoutputstream, "initialize", stream_initialize, -1); rb_define_method(dataoutputstream, "byte_order", stream_byte_order, 0); rb_define_method(dataoutputstream, "set_byte_order", stream_set_byte_order, 1); G_DEF_SETTER(dataoutputstream, "byte_order"); rb_define_method(dataoutputstream, "put_byte", stream_put_byte, -1); rb_define_method(dataoutputstream, "put_int16", stream_put_int16, -1); rb_define_method(dataoutputstream, "put_uint16", stream_put_uint16, -1); rb_define_method(dataoutputstream, "put_int32", stream_put_int32, -1); rb_define_method(dataoutputstream, "put_uint32", stream_put_uint32, -1); rb_define_method(dataoutputstream, "put_int64", stream_put_int64, -1); rb_define_method(dataoutputstream, "put_uint64", stream_put_uint64, -1); rb_define_method(dataoutputstream, "put_string", stream_put_string, -1); rb_define_alias(dataoutputstream, "<<", "put_string"); rb_define_alias(dataoutputstream, "write", "put_string"); /* TODO: Should we add #put_value/#put? */ }
/* Convenience API */ static VALUE rg_s_pixbuf_from_file(G_GNUC_UNUSED 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; }
static VALUE rg_add_attribute(VALUE self, VALUE cell, VALUE attribute, VALUE column) { const gchar *name; if (SYMBOL_P(attribute)) { name = rb_id2name(SYM2ID(attribute)); } else { name = RVAL2CSTR(attribute); } gtk_cell_layout_add_attribute(_SELF(self), RVAL2RENDERER(cell), name, NUM2INT(column)); return self; }
static VALUE rg_get_logical_widths(VALUE self, VALUE rbtext, VALUE rbembedding_level) { PangoGlyphString *glyphs = _SELF(self); const char *text = RVAL2CSTR(rbtext); long length = RSTRING_LEN(rbtext); int embedding_level = NUM2INT(rbembedding_level); glong n = g_utf8_strlen(text, length); int *logical_widths = g_new(int, n); pango_glyph_string_get_logical_widths(glyphs, text, length, embedding_level, logical_widths); return GINTS2RVAL_FREE(logical_widths, n); }
static VALUE it_load_icon(VALUE self, VALUE icon_name, VALUE size, VALUE flags) { GError *error = NULL; GdkPixbuf *pixbuf; pixbuf = gtk_icon_theme_load_icon(_SELF(self), RVAL2CSTR(icon_name), NUM2INT(size), RVAL2ICON_LOOKUP_FLAGS(flags), &error); if (!pixbuf) RAISE_GERROR(error); return GOBJ2RVAL(pixbuf); }
static VALUE bf_load_from_data_dirs(VALUE self, VALUE file) { GError* error = NULL; gboolean ret; gchar* full_path; ret = g_bookmark_file_load_from_data_dirs(_SELF(self), (const gchar*)RVAL2CSTR(file), &full_path, &error); if (! ret) RAISE_GERROR(error); return full_path ? CSTR2RVAL(full_path) : Qnil; }
static VALUE rg_lookup_by_name(VALUE self, VALUE hostname, VALUE cancellable) { GError *error = NULL; GList *addresses; addresses = g_resolver_lookup_by_name(_SELF(self), RVAL2CSTR(hostname), RVAL2GCANCELLABLE(cancellable), &error); if (addresses == NULL) rbgio_raise_error(error); return GLIST2ARY_UNREF_FREE(addresses); }
static VALUE encode_change_from (int argc, VALUE *argv, VALUE self) { VALUE from, parameters; const gchar *packet; gsize packet_size; rb_scan_args(argc, argv, "11", &from, ¶meters); milter_reply_encoder_encode_change_from(SELF(self), &packet, &packet_size, RVAL2CSTR(from), RVAL2CSTR_ACCEPT_NIL(parameters)); return CSTR2RVAL_SIZE(packet, packet_size); }
static VALUE rg_expand_references(VALUE self, VALUE rb_string) { const gchar *string = RVAL2CSTR(rb_string); gchar *expanded_string = NULL; GError *error = NULL; expanded_string = g_match_info_expand_references(_SELF(self), string, &error); if (error) RAISE_GERROR(error); return CSTR2RVAL_FREE(expanded_string); }
static VALUE rg_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; }
static VALUE encode_add_recipient (int argc, VALUE *argv, VALUE self) { VALUE to, parameters; const gchar *packet; gsize packet_size; rb_scan_args(argc, argv, "11", &to, ¶meters); milter_reply_encoder_encode_add_recipient(SELF(self), &packet, &packet_size, RVAL2CSTR(to), RVAL2CSTR_ACCEPT_NIL(parameters)); return CSTR2RVAL_SIZE(packet, packet_size); }
static VALUE rb_rsvg_handle_render_cairo(int argc, VALUE *argv, VALUE self) { VALUE cr, id; rb_scan_args(argc, argv, "11", &cr, &id); if (NIL_P(id)) { rsvg_handle_render_cairo( _SELF(self), RVAL2CRCONTEXT(cr)); } else { rsvg_handle_render_cairo_sub( _SELF(self), RVAL2CRCONTEXT(cr), (const char *)RVAL2CSTR(id)); } return Qnil; }
static VALUE rg_match_set_cursor(VALUE self, VALUE tag, VALUE cursor) { if (NIL_P(cursor) || RVAL2GTYPE(cursor) == GDK_TYPE_CURSOR) { vte_terminal_match_set_cursor(RVAL2TERM(self), NUM2INT(tag), RVAL2GOBJ(cursor)); } else if (RVAL2GTYPE(cursor) == GDK_TYPE_CURSOR_TYPE) { vte_terminal_match_set_cursor_type(RVAL2TERM(self), NUM2INT(tag), RVAL2CT(cursor)); #if VTE_CHECK_VERSION(0, 17, 1) } else { vte_terminal_match_set_cursor_name(_SELF(self), NUM2INT(tag), RVAL2CSTR(cursor)); #endif } return self; }
static VALUE rg_s_have_reference_p(G_GNUC_UNUSED VALUE self, VALUE rb_replacement) { const gchar *replacement; gboolean has_references; GError *error = NULL; replacement = RVAL2CSTR(rb_replacement); g_regex_check_replacement(replacement, &has_references, &error); if (error) RAISE_GERROR(error); return CBOOL2RVAL(has_references); }
/* data should be [self, data] */ static gchar * comp_func(gpointer compdata) { VALUE ret; VALUE self = RARRAY_PTR((VALUE)compdata)[0]; VALUE data = RARRAY_PTR((VALUE)compdata)[1]; VALUE func = rb_ivar_get(self, id_compfunc); if (NIL_P(func)){ ret = rb_funcall(data, id_to_s, 0); } else { ret = rb_funcall(func, id_call, 1, data); } return (gchar *)RVAL2CSTR(ret); }
/* * Method: find_feature(feature_name, feature_type) * feature_name: a feature name. * feature_type: a feature type. * * Finds the plugin feature with the given name and type in the registry. * * Valid features types are Gst::AutoplugFactory, Gst::ElementFactory, * Gst::IndexFactory, Gst::SchedulerFactory and Gst::TypeFactory. * * Returns: a reference to a Gst::PluginFeature on success, or nil if the * named plugin feature is not found. */ static VALUE rb_gst_registry_find_feature(VALUE self, VALUE name, VALUE type) { GstPluginFeature *feature; GType gtype; gtype = CLASS2GTYPE (type); if (!is_valid_pluginfeature_type (gtype)) rb_raise (rb_eArgError, "Invalid feature type."); feature = gst_registry_find_feature (RGST_REGISTRY (self), RVAL2CSTR (name), gtype); return feature != NULL ? instanciate_pluginfeature (feature) : Qnil; }