static SeedValue value_from_ffi_type (SeedContext ctx, GType otype, GArgument *value, SeedException *exception) { switch (g_type_fundamental (otype)) { case G_TYPE_INT: return seed_value_from_int (ctx, value->v_int, exception); break; case G_TYPE_FLOAT: return seed_value_from_float (ctx, value->v_float, exception); break; case G_TYPE_DOUBLE: return seed_value_from_double (ctx, value->v_double, exception); break; case G_TYPE_BOOLEAN: return seed_value_from_boolean (ctx, value->v_boolean, exception); break; case G_TYPE_STRING: return seed_value_from_string (ctx, value->v_pointer, exception); break; case G_TYPE_CHAR: return seed_value_from_char (ctx, value->v_int, exception); break; case G_TYPE_UCHAR: return seed_value_from_uchar (ctx, value->v_uint, exception); break; case G_TYPE_UINT: return seed_value_from_uint (ctx, value->v_uint, exception); break; case G_TYPE_POINTER: return seed_make_pointer (ctx, value->v_pointer); break; case G_TYPE_LONG: return seed_value_from_long (ctx, value->v_long, exception); break; case G_TYPE_ULONG: return seed_value_from_ulong (ctx, value->v_ulong, exception); break; case G_TYPE_INT64: return seed_value_from_int64 (ctx, value->v_int64, exception); break; case G_TYPE_UINT64: return seed_value_from_uint64 (ctx, value->v_uint64, exception); break; case G_TYPE_NONE: return seed_make_null (ctx); default: g_warning ("Unsupported fundamental type in value_from_ffi_type: %s", g_type_name(g_type_fundamental (otype))); return seed_make_null (ctx); } }
static void g_value_from_ffi_value (GValue *gvalue, const GIArgument *value) { switch (g_type_fundamental (G_VALUE_TYPE (gvalue))) { case G_TYPE_INT: g_value_set_int (gvalue, (gint)value->v_long); break; case G_TYPE_FLOAT: g_value_set_float (gvalue, (gfloat)value->v_float); break; case G_TYPE_DOUBLE: g_value_set_double (gvalue, (gdouble)value->v_double); break; case G_TYPE_BOOLEAN: g_value_set_boolean (gvalue, (gboolean)value->v_long); break; case G_TYPE_STRING: g_value_set_string (gvalue, (gchar*)value->v_pointer); break; case G_TYPE_CHAR: g_value_set_char (gvalue, (gchar)value->v_long); break; case G_TYPE_UCHAR: g_value_set_uchar (gvalue, (guchar)value->v_ulong); break; case G_TYPE_UINT: g_value_set_uint (gvalue, (guint)value->v_ulong); break; case G_TYPE_POINTER: g_value_set_pointer (gvalue, (gpointer)value->v_pointer); break; case G_TYPE_LONG: g_value_set_long (gvalue, (glong)value->v_long); break; case G_TYPE_ULONG: g_value_set_ulong (gvalue, (gulong)value->v_ulong); break; case G_TYPE_INT64: g_value_set_int64 (gvalue, (gint64)value->v_int64); break; case G_TYPE_UINT64: g_value_set_uint64 (gvalue, (guint64)value->v_uint64); break; case G_TYPE_BOXED: g_value_set_boxed (gvalue, (gpointer)value->v_pointer); break; default: g_warning ("Unsupported fundamental type: %s", g_type_name (g_type_fundamental (G_VALUE_TYPE (gvalue)))); } }
/** * _gtk_css_style_parse_value: * @value: the value to parse into. Must be a valid initialized #GValue * @parser: the parser to parse from * * This is the generic parsing function used for CSS values. If the * function fails to parse a value, it will emit an error on @parser, * return %FALSE and not touch @value. * * Returns: %TRUE if parsing succeeded. **/ gboolean _gtk_css_style_funcs_parse_value (GValue *value, GtkCssParser *parser) { GtkStyleParseFunc func; g_return_val_if_fail (value != NULL, FALSE); g_return_val_if_fail (parser != NULL, FALSE); gtk_css_style_funcs_init (); func = g_hash_table_lookup (parse_funcs, GSIZE_TO_POINTER (G_VALUE_TYPE (value))); if (func == NULL) func = g_hash_table_lookup (parse_funcs, GSIZE_TO_POINTER (g_type_fundamental (G_VALUE_TYPE (value)))); if (func == NULL) { _gtk_css_parser_error (parser, "Cannot convert to type '%s'", g_type_name (G_VALUE_TYPE (value))); return FALSE; } return (*func) (parser, value); }
static ffi_type * value_to_ffi_type (const GValue *gvalue, gpointer *value) { ffi_type *rettype = NULL; GType type = g_type_fundamental (G_VALUE_TYPE (gvalue)); g_assert (type != G_TYPE_INVALID); switch (type) { case G_TYPE_BOOLEAN: case G_TYPE_CHAR: case G_TYPE_INT: rettype = &ffi_type_sint; *value = (gpointer)&(gvalue->data[0].v_int); break; case G_TYPE_UCHAR: case G_TYPE_UINT: rettype = &ffi_type_uint; *value = (gpointer)&(gvalue->data[0].v_uint); break; case G_TYPE_STRING: case G_TYPE_OBJECT: case G_TYPE_BOXED: case G_TYPE_POINTER: rettype = &ffi_type_pointer; *value = (gpointer)&(gvalue->data[0].v_pointer); break; case G_TYPE_FLOAT: rettype = &ffi_type_float; *value = (gpointer)&(gvalue->data[0].v_float); break; case G_TYPE_DOUBLE: rettype = &ffi_type_double; *value = (gpointer)&(gvalue->data[0].v_double); break; case G_TYPE_LONG: rettype = &ffi_type_slong; *value = (gpointer)&(gvalue->data[0].v_long); break; case G_TYPE_ULONG: rettype = &ffi_type_ulong; *value = (gpointer)&(gvalue->data[0].v_ulong); break; case G_TYPE_INT64: rettype = &ffi_type_sint64; *value = (gpointer)&(gvalue->data[0].v_int64); break; case G_TYPE_UINT64: rettype = &ffi_type_uint64; *value = (gpointer)&(gvalue->data[0].v_uint64); break; default: rettype = &ffi_type_pointer; *value = NULL; g_warning ("Unsupported fundamental type: %s", g_type_name (type)); break; } return rettype; }
static ffi_type * return_type_to_ffi_type (GType otype) { GType type = g_type_fundamental (otype); g_assert (type != G_TYPE_INVALID); switch (type) { case G_TYPE_BOOLEAN: case G_TYPE_CHAR: case G_TYPE_INT: return &ffi_type_sint; break; case G_TYPE_UCHAR: case G_TYPE_UINT: return &ffi_type_uint; break; case G_TYPE_STRING: return &ffi_type_pointer; break; case G_TYPE_OBJECT: // case G_TYPE_BOXED: case G_TYPE_POINTER: return &ffi_type_pointer; break; case G_TYPE_FLOAT: return &ffi_type_float; break; case G_TYPE_DOUBLE: return &ffi_type_double; break; case G_TYPE_LONG: return &ffi_type_slong; break; case G_TYPE_ULONG: return &ffi_type_ulong; break; case G_TYPE_INT64: return &ffi_type_sint64; break; case G_TYPE_UINT64: return &ffi_type_uint64; break; default: g_warning ("Unsupported fundamental out type: %s", g_type_name (type)); return &ffi_type_pointer; break; } }
char * _gtk_css_value_to_string (const GValue *value) { ToStringFunc func; css_string_funcs_init (); func = g_hash_table_lookup (to_string_funcs, GSIZE_TO_POINTER (G_VALUE_TYPE (value))); if (func == NULL) func = g_hash_table_lookup (to_string_funcs, GSIZE_TO_POINTER (g_type_fundamental (G_VALUE_TYPE (value)))); if (func) return func (value); return g_strdup_value_contents (value); }
/** * _gtk_css_style_print_value: * @value: an initialized GValue returned from _gtk_css_style_parse() * @string: the string to print into * * Prints @value into @string as a CSS value. If @value is not a * valid value, a random string will be printed instead. **/ void _gtk_css_style_funcs_print_value (const GValue *value, GString *string) { GtkStylePrintFunc func; gtk_css_style_funcs_init (); func = g_hash_table_lookup (print_funcs, GSIZE_TO_POINTER (G_VALUE_TYPE (value))); if (func == NULL) func = g_hash_table_lookup (print_funcs, GSIZE_TO_POINTER (g_type_fundamental (G_VALUE_TYPE (value)))); if (func == NULL) { char *s = g_strdup_value_contents (value); g_string_append (string, s); g_free (s); return; } func (value, string); }
static PyObject * _wrap_g_type_wrapper__get_fundamental(PyGTypeWrapper *self, void *closure) { return pyg_type_wrapper_new(g_type_fundamental(self->type)); }
static ffi_type * gtype_to_ffi_type (SeedContext ctx, SeedValue value, GType otype, GArgument *garg, gpointer *arg, SeedException *exception) { ffi_type *return_type; GType type = g_type_fundamental (otype); g_assert (type != G_TYPE_INVALID); switch (type) { case G_TYPE_BOOLEAN: case G_TYPE_CHAR: case G_TYPE_INT: return_type = &ffi_type_sint; garg->v_int = seed_value_to_int (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_UCHAR: case G_TYPE_UINT: return_type = &ffi_type_uint; garg->v_uint = seed_value_to_uint (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_STRING: return_type = &ffi_type_pointer; garg->v_pointer = seed_value_to_string (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_OBJECT: // case G_TYPE_BOXED: case G_TYPE_POINTER: return_type = &ffi_type_pointer; garg->v_pointer = seed_pointer_get_pointer (ctx, value); *arg = (gpointer)garg; break; case G_TYPE_FLOAT: return_type = &ffi_type_float; garg->v_float = seed_value_to_float (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_DOUBLE: return_type = &ffi_type_double; garg->v_double = seed_value_to_double (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_LONG: return_type = &ffi_type_slong; garg->v_uint = seed_value_to_uint (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_ULONG: return_type = &ffi_type_ulong; garg->v_ulong = seed_value_to_ulong (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_INT64: return_type = &ffi_type_sint64; garg->v_int64 = seed_value_to_int64 (ctx, value, exception); *arg = (gpointer)garg; break; case G_TYPE_UINT64: return_type = &ffi_type_uint64; garg->v_uint64 = seed_value_to_uint64 (ctx, value, exception); *arg = (gpointer)garg; break; default: g_warning ("Unsupported fundamental in type: %s", g_type_name (type)); return_type = &ffi_type_pointer; garg->v_pointer = NULL; *arg = (garg->v_pointer); break; } return return_type; }