static VALUE
rbglib_m_filename_from_uri(G_GNUC_UNUSED VALUE self, VALUE str)
{
GError *err = NULL;
VALUE s;
gchar* filename;
char* hostname;
filename = g_filename_from_uri(StringValuePtr(str), &hostname, &err);
if (err)
RAISE_GERROR(err);
s = rb_ary_new3(2, rb_str_new2(filename),
hostname ? rb_str_new2(hostname) : Qnil);
g_free(filename);
g_free(hostname);
return s;
}
static VALUE
rg_initialize(VALUE self, VALUE flags_or_fd)
{
VtePty *pty = NULL;
GError *error = NULL;
if (TYPE(flags_or_fd) == T_FIXNUM) {
pty = vte_pty_new_foreign(NUM2INT(flags_or_fd), &error);
} else {
pty = vte_pty_new(RVAL2VTEPTYFLAGS(flags_or_fd), &error);
}
if (error)
RAISE_GERROR(error);
G_INITIALIZE(self, pty);
return Qnil;
}
static VALUE
rbglib_m_filename_to_utf8(G_GNUC_UNUSED VALUE self, VALUE str)
{
GError *err = NULL;
VALUE s = Qnil;
gchar* ret;
gsize written;
StringValue(str);
ret = g_filename_to_utf8(RSTRING_PTR(str), RSTRING_LEN(str),
NULL, &written, &err);
if (err != NULL)
RAISE_GERROR(err);
s = rb_str_new(ret, written);
g_free(ret);
return s;
}
static VALUE
rbclt_script_load_from_data (VALUE self, VALUE data)
{
ClutterScript *script = CLUTTER_SCRIPT (RVAL2GOBJ (self));
guint merge_id;
GError *error = NULL;
StringValuePtr (data);
merge_id = clutter_script_load_from_data (script,
RSTRING (data)->ptr,
RSTRING (data)->len,
&error);
if (error)
RAISE_GERROR (error);
return UINT2NUM (merge_id);
}
static VALUE
rg_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 VALUE
rbglib_m_convert(G_GNUC_UNUSED VALUE self, VALUE str, VALUE to, VALUE from)
{
GError *err = NULL;
gchar* ret;
gsize written;
VALUE s = Qnil;
StringValue(str);
ret = g_convert(RSTRING_PTR(str), RSTRING_LEN(str),
StringValuePtr(to), StringValuePtr(from),
NULL, &written, &err);
if (err != NULL)
RAISE_GERROR(err);
s = rb_str_new(ret, written);
g_free(ret);
return s;
}
static VALUE
rbglib_m_filename_to_uri(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE filename, hostname, s;
GError *err = NULL;
gchar* ret;
rb_scan_args(argc, argv, "11", &filename, &hostname);
ret = g_filename_to_uri(StringValuePtr(filename),
NIL_P(hostname) ? NULL : StringValuePtr(hostname),
&err);
if (err)
RAISE_GERROR(err);
s = rb_str_new2(ret);
g_free(ret);
return s;
}
static VALUE
rg_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 VALUE
rg_split(gint argc, VALUE *argv, VALUE self)
{
VALUE rb_string, rb_start_position, rb_match_options, rb_max_tokens, rb_options;
GError *error = NULL;
gchar **strings;
const gchar *string;
gssize string_len = -1;
gint start_position = 0;
GRegexMatchFlags match_options = 0;
gint max_tokens = 0;
rb_scan_args(argc, argv, "11", &rb_string, &rb_options);
rbg_scan_options(rb_options,
"start_position", &rb_start_position,
"match_options", &rb_match_options,
"max_tokens", &rb_max_tokens,
NULL);
string = RVAL2CSTR(rb_string);
string_len = RSTRING_LEN(rb_string);
if (!NIL_P(rb_start_position))
start_position = NUM2INT(rb_start_position);
if (!NIL_P(rb_match_options))
match_options = RVAL2GREGEXMATCHOPTIONSFLAGS(rb_match_options);
if (!NIL_P(rb_max_tokens))
max_tokens = NUM2INT(rb_max_tokens);
strings = g_regex_split_full(_SELF(self),
string,
string_len,
start_position,
match_options,
max_tokens,
&error);
if (error)
RAISE_GERROR(error);
return STRV2RVAL_FREE(strings);
}
static VALUE
rb_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 VALUE
shell_parse(VALUE self, VALUE command_line)
{
gint argc, i;
gchar** argv;
GError* err = NULL;
VALUE ary;
gboolean ret = g_shell_parse_argv(RVAL2CSTR(command_line),
&argc, &argv, &err);
if (! ret) RAISE_GERROR(err);
ary = rb_ary_new();
for (i = 0; i < argc; i++) {
rb_ary_push(ary, CSTR2RVAL(argv[i]));
}
g_strfreev (argv);
return ary;
}
static VALUE
rb_rsvg_handle_close(VALUE self)
{
gboolean result;
GError *error = NULL;
if (RVAL2CBOOL(rb_ivar_get(self, id_closed))) {
return Qnil;
}
result = rsvg_handle_close(_SELF(self), &error);
if (result) {
rb_ivar_set(self, id_closed, Qtrue);
} else {
RAISE_GERROR(error);
}
return CBOOL2RVAL(result);
}
static VALUE
rg_write_contents(int argc, VALUE *argv, VALUE self)
{
VALUE stream, flags, rb_cancellable;
GCancellable *cancellable;
gboolean result;
GError *error = NULL;
rb_scan_args(argc, argv, "21", &stream, &flags, &rb_cancellable);
cancellable = NIL_P(rb_cancellable) ? NULL : RVAL2GCANCELLABLE(rb_cancellable);
result = vte_terminal_write_contents(_SELF(self),
RVAL2GOUTPUTSTREAM(stream),
RVAL2VTETERMINALWRITEFLAGS(flags),
cancellable,
&error);
if (error)
RAISE_GERROR(error);
return CBOOL2RVAL(result);
}
static VALUE
rg_s_to_utf8(G_GNUC_UNUSED VALUE self, VALUE rb_utf16)
{
VALUE result;
gchar *utf8;
gunichar2 *utf16;
glong len, items_written;
GError *error = NULL;
utf16 = (gunichar2 *)(void *)StringValueCStr(rb_utf16);
len = RSTRING_LEN(rb_utf16) / sizeof(*utf16);
utf8 = g_utf16_to_utf8(utf16, len, NULL, &items_written, &error);
if (error)
RAISE_GERROR(error);
result = CSTR2RVAL_LEN(utf8, items_written * sizeof(*utf8));
g_free(utf8);
return result;
}
static VALUE
rg_write_contents(int argc, VALUE *argv, VALUE self)
{
VALUE stream, flags, rb_cancellable;
GCancellable *cancellable;
gboolean result;
GError *error = NULL;
rb_scan_args(argc, argv, "21", &stream, &flags, &rb_cancellable);
cancellable = NIL_P(rb_cancellable) ? NULL : RVAL2GOBJ(rb_cancellable);
result = vte_terminal_write_contents(_SELF(self),
RVAL2GOBJ(stream),
RVAL2GENUM(flags, VTE_TYPE_TERMINAL_WRITE_FLAGS),
cancellable,
&error);
if (error)
RAISE_GERROR(error);
return CBOOL2RVAL(result);
}
static VALUE
bf_get_applications(VALUE self, VALUE uri)
{
gsize length;
VALUE ary;
gint i;
GError* error = NULL;
gchar** ret = g_bookmark_file_get_applications(_SELF(self),
(const gchar *)RVAL2CSTR(uri),
&length, &error);
if (error) RAISE_GERROR(error);
ary = rb_ary_new();
for(i = 0; i < length; i++){
rb_ary_push(ary, CSTR2RVAL(ret[i]));
}
g_strfreev(ret);
return ary;
}
void
rbgio_raise_error(GError *error)
{
VALUE domain_error, rberror;
domain_error = rb_hash_aref(s_errors, UINT2NUM(error->domain));
if (NIL_P(domain_error))
RAISE_GERROR(error);
rberror = rb_hash_aref(rb_ivar_get(domain_error, s_id_errors),
INT2NUM(error->code));
if (NIL_P(rberror)) {
VALUE enum_name = rb_ivar_get(domain_error, s_id_enum_name);
rb_raise(rb_eNotImpError,
"%s contains error codes that have not been implemented: %d",
RVAL2CSTR(enum_name), error->code);
}
rb_raise(rberror, "%s", error->message);
}
static VALUE
rg_s_to_utf8(G_GNUC_UNUSED VALUE self, VALUE rb_ucs4)
{
VALUE result;
gunichar *ucs4;
gchar *utf8;
glong len, items_written;
GError *error = NULL;
ucs4 = (gunichar *)StringValuePtr(rb_ucs4);
len = RSTRING_LEN(rb_ucs4) / sizeof(*ucs4);
utf8 = g_ucs4_to_utf8(ucs4, len, NULL, &items_written, &error);
if (error)
RAISE_GERROR(error);
result = CSTR2RVAL_LEN(utf8, items_written);
g_free(utf8);
return result;
}
static VALUE
rg_add_ui(int argc, VALUE *argv, VALUE self)
{
GError* error = NULL;
guint ret;
VALUE buffer;
if (argc == 1) {
VALUE buffer_or_filename;
rb_scan_args(argc, argv, "10", &buffer_or_filename);
StringValue(buffer_or_filename);
buffer = rb_funcall(buffer_or_filename, rb_intern("include?"), 1, CSTR2RVAL("<ui>"));
if (RVAL2CBOOL(buffer)){
StringValue(buffer_or_filename);
ret = gtk_ui_manager_add_ui_from_string(_SELF(self),
RSTRING_PTR(buffer_or_filename),
RSTRING_LEN(buffer_or_filename),
&error);
} else {
ret = gtk_ui_manager_add_ui_from_file(_SELF(self), RVAL2CSTR(buffer_or_filename),
&error);
}
} else {
VALUE merge_id, path, name, action, type, top;
rb_scan_args(argc, argv, "60", &merge_id, &path, &name, &action, &type, &top);
ret = NUM2UINT(merge_id);
gtk_ui_manager_add_ui(_SELF(self), ret, RVAL2CSTR(path),
RVAL2CSTR(name), RVAL2CSTR(action),
RVAL2GFLAGS(type, GTK_TYPE_UI_MANAGER_ITEM_TYPE),
RVAL2CBOOL(top));
}
if (ret == 0) RAISE_GERROR(error);
return UINT2NUM(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;
}
}
/* This method is from rbpangoattribute.c */
static VALUE
rg_s_parse_markup(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE markup_text, accel_marker;
PangoAttrList *pattr_list;
gchar* gtext;
gunichar accel_char;
GError *error = NULL;
gboolean ret;
char c;
VALUE text = Qnil;
VALUE attr_list = Qnil;
rb_scan_args(argc, argv, "11", &markup_text, &accel_marker);
if (NIL_P(markup_text)) rb_raise(rb_eRuntimeError, "1st argument can't accept nil");
StringValue(markup_text);
ret = pango_parse_markup(RSTRING_PTR(markup_text),
RSTRING_LEN(markup_text),
NIL_P(accel_marker) ? 0 : NUM2CHR(accel_marker),
&pattr_list, >ext, &accel_char, &error);
if (!ret) RAISE_GERROR(error);
if (pattr_list){
attr_list = PANGOATTRLIST2RVAL(pattr_list);
pango_attr_list_unref(pattr_list);
}
c = (char)accel_char;
if (text){
text = CSTR2RVAL(gtext);
g_free(gtext);
}
return rb_ary_new3(3, attr_list, text,
accel_char ? rb_str_new(&c, 1) : Qnil);
}
static VALUE
rg_m_command_line_sync(G_GNUC_UNUSED VALUE self, VALUE str)
{
GError *err = NULL;
const gchar *command_line;
gchar *standard_output = NULL, *standard_error = NULL;
gint exit_status;
VALUE std_out, std_err;
gboolean ret;
command_line = RVAL2CSTR(str);
ret = g_spawn_command_line_sync(command_line,
&standard_output,
&standard_error,
&exit_status,
&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
parse_spec (VALUE self, VALUE spec)
{
gint domain;
struct sockaddr *address;
socklen_t address_size;
VALUE rb_address;
GError *error = NULL;
if (!milter_connection_parse_spec(RVAL2CSTR(spec),
&domain, &address, &address_size,
&error))
RAISE_GERROR(error);
switch (address->sa_family) {
case AF_INET:
{
struct sockaddr_in *address_in = (struct sockaddr_in *)address;
gchar ip_address[INET_ADDRSTRLEN];
guint16 port;
gboolean success;
success = (NULL != inet_ntop(AF_INET, &(address_in->sin_addr),
ip_address, sizeof(ip_address)));
port = ntohs(address_in->sin_port);
g_free(address);
if (!success)
rb_sys_fail("failed to convert IP address to string");
rb_address = rb_funcall(rb_cMilterSocketAddressIPv4,
id_new,
2,
CSTR2RVAL(ip_address),
UINT2NUM(port));
}
break;
case AF_INET6:
{
struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *)address;
gchar ipv6_address[INET6_ADDRSTRLEN];
guint16 port;
gboolean success;
success = (NULL != inet_ntop(AF_INET6, &(address_in6->sin6_addr),
ipv6_address, sizeof(ipv6_address)));
port = ntohs(address_in6->sin6_port);
g_free(address);
if (!success)
rb_sys_fail("failed to convert IPv6 address to string");
rb_address = rb_funcall(rb_cMilterSocketAddressIPv6,
id_new,
2,
CSTR2RVAL(ipv6_address),
UINT2NUM(port));
}
break;
case AF_UNIX:
{
struct sockaddr_un *address_un = (struct sockaddr_un *)address;
VALUE rb_path;
rb_path = CSTR2RVAL(address_un->sun_path);
g_free(address);
rb_address = rb_funcall(rb_cMilterSocketAddressUnix,
id_new,
1,
rb_path);
}
break;
case AF_UNSPEC:
g_free(address);
rb_address = rb_funcall(rb_cMilterSocketAddressUnknown, id_new, 0);
break;
default:
rb_address = rb_str_new((gchar *)address, address_size);
g_free(address);
break;
}
return rb_address;
}
static VALUE
rg_replace(gint argc, VALUE *argv, VALUE self)
{
VALUE rb_string;
VALUE rb_replacement;
VALUE rb_options;
VALUE rb_start_position;
VALUE rb_match_options;
VALUE rb_literal;
GError *error = NULL;
gchar *modified_string;
const gchar *string;
const gchar *replacement;
gssize string_len = -1;
gint start_position = 0;
GRegexMatchFlags match_options = 0;
if (rb_block_given_p()) {
RGRegexEvalCallbackData data;
rb_scan_args(argc, argv, "11", &rb_string, &rb_options);
rbg_scan_options(rb_options,
"start_position", &rb_start_position,
"match_options", &rb_match_options,
NULL);
string = RVAL2CSTR(rb_string);
string_len = RSTRING_LEN(rb_string);
if (!NIL_P(rb_start_position))
start_position = NUM2INT(rb_start_position);
if (!NIL_P(rb_match_options))
match_options = RVAL2GREGEXMATCHOPTIONSFLAGS(rb_match_options);
data.callback = rb_block_proc();
data.status = 0;
modified_string = g_regex_replace_eval(_SELF(self),
string,
string_len,
start_position,
match_options,
rg_regex_eval_callback,
&data,
&error);
if (!(data.status == 0 || data.status == RUBY_TAG_BREAK)) {
if (error)
g_error_free(error);
g_free(modified_string);
rb_jump_tag(data.status);
}
} else {
rb_scan_args(argc, argv, "21", &rb_string, &rb_replacement, &rb_options);
rbg_scan_options(rb_options,
"start_position", &rb_start_position,
"match_options", &rb_match_options,
"literal", &rb_literal,
NULL);
string = RVAL2CSTR(rb_string);
string_len = RSTRING_LEN(rb_string);
replacement = RVAL2CSTR(rb_replacement);
if (!NIL_P(rb_start_position))
start_position = NUM2INT(rb_start_position);
if (!NIL_P(rb_match_options))
match_options = RVAL2GREGEXMATCHOPTIONSFLAGS(rb_match_options);
if (RVAL2CBOOL(rb_literal)) {
modified_string = g_regex_replace_literal(_SELF(self),
string,
string_len,
start_position,
replacement,
match_options,
&error);
} else {
modified_string = g_regex_replace(_SELF(self),
string,
string_len,
start_position,
replacement,
match_options,
&error);
}
}
if (error)
RAISE_GERROR(error);
return CSTR2RVAL_FREE(modified_string);
}
