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;
}
