PyObject * pygi_get_property_value_real (PyGObject *instance, const gchar *attr_name) { GType g_type; GIPropertyInfo *property_info = NULL; char *property_name = g_strdup (attr_name); GParamSpec *pspec = NULL; GValue value = { 0, }; GIArgument arg = { 0, }; PyObject *py_value = NULL; GITypeInfo *type_info = NULL; GITransfer transfer; canonicalize_key (property_name); g_type = pyg_type_from_object ((PyObject *)instance); property_info = _pygi_lookup_property_from_g_type (g_type, property_name); if (property_info == NULL) goto out; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (instance->obj), attr_name); if (pspec == NULL) goto out; g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_object_get_property (instance->obj, attr_name, &value); type_info = g_property_info_get_type (property_info); transfer = g_property_info_get_ownership_transfer (property_info); GITypeTag type_tag = g_type_info_get_tag (type_info); switch (type_tag) { case GI_TYPE_TAG_BOOLEAN: arg.v_boolean = g_value_get_boolean (&value); break; case GI_TYPE_TAG_INT8: arg.v_int8 = g_value_get_schar (&value); break; case GI_TYPE_TAG_INT16: case GI_TYPE_TAG_INT32: if (G_VALUE_HOLDS_LONG (&value)) arg.v_long = g_value_get_long (&value); else arg.v_int = g_value_get_int (&value); break; case GI_TYPE_TAG_INT64: if (G_VALUE_HOLDS_LONG (&value)) arg.v_long = g_value_get_long (&value); else arg.v_int64 = g_value_get_int64 (&value); break; case GI_TYPE_TAG_UINT8: arg.v_uint8 = g_value_get_uchar (&value); break; case GI_TYPE_TAG_UINT16: case GI_TYPE_TAG_UINT32: if (G_VALUE_HOLDS_ULONG (&value)) arg.v_ulong = g_value_get_ulong (&value); else arg.v_uint = g_value_get_uint (&value); break; case GI_TYPE_TAG_UINT64: if (G_VALUE_HOLDS_ULONG (&value)) arg.v_ulong = g_value_get_ulong (&value); else arg.v_uint64 = g_value_get_uint64 (&value); break; case GI_TYPE_TAG_FLOAT: arg.v_float = g_value_get_float (&value); break; case GI_TYPE_TAG_DOUBLE: arg.v_double = g_value_get_double (&value); break; case GI_TYPE_TAG_GTYPE: arg.v_size = g_value_get_gtype (&value); break; case GI_TYPE_TAG_UTF8: case GI_TYPE_TAG_FILENAME: arg.v_string = g_value_dup_string (&value); break; case GI_TYPE_TAG_INTERFACE: { GIBaseInfo *info; GIInfoType info_type; GType type; info = g_type_info_get_interface (type_info); type = g_registered_type_info_get_g_type (info); info_type = g_base_info_get_type (info); g_base_info_unref (info); switch (info_type) { case GI_INFO_TYPE_ENUM: arg.v_int32 = g_value_get_enum (&value); break; case GI_INFO_TYPE_INTERFACE: case GI_INFO_TYPE_OBJECT: arg.v_pointer = g_value_get_object (&value); break; case GI_INFO_TYPE_BOXED: case GI_INFO_TYPE_STRUCT: case GI_INFO_TYPE_UNION: if (g_type_is_a (type, G_TYPE_BOXED)) { arg.v_pointer = g_value_get_boxed (&value); } else if (g_type_is_a (type, G_TYPE_POINTER)) { arg.v_pointer = g_value_get_pointer (&value); } else { PyErr_Format (PyExc_NotImplementedError, "Retrieving properties of type '%s' is not implemented", g_type_name (type)); } break; default: PyErr_Format (PyExc_NotImplementedError, "Retrieving properties of type '%s' is not implemented", g_type_name (type)); goto out; } break; } case GI_TYPE_TAG_GHASH: arg.v_pointer = g_value_get_boxed (&value); break; case GI_TYPE_TAG_GLIST: arg.v_pointer = g_value_get_pointer (&value); break; case GI_TYPE_TAG_ARRAY: { gchar** strings; GArray *arg_items; int i; strings = g_value_get_boxed (&value); if (strings == NULL) arg.v_pointer = NULL; else { arg_items = g_array_sized_new (TRUE, TRUE, sizeof (GIArgument), g_strv_length (strings)); g_array_set_size (arg_items, g_strv_length (strings)); for (i = 0; strings[i] != NULL; ++i) { g_array_index (arg_items, GIArgument, i).v_string = strings[i]; } arg.v_pointer = arg_items; } break; } default: PyErr_Format (PyExc_NotImplementedError, "Retrieving properties of type %s is not implemented", g_type_tag_to_string (g_type_info_get_tag (type_info))); goto out; } py_value = _pygi_argument_to_object (&arg, type_info, transfer); out: g_free (property_name); if (property_info != NULL) g_base_info_unref (property_info); if (type_info != NULL) g_base_info_unref (type_info); return py_value; }
static void gst_motion_cells_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMotioncells *filter = gst_motion_cells (object); //variables for overlay regions setup gchar **strs, **colorstr, **motioncellsstr, **motionmaskcellsstr; int i, ux, uy, lx, ly; int r, g, b; int cellscolorscnt = 0; int linidx, colidx, masklinidx, maskcolidx; int tmpux = -1; int tmpuy = -1; int tmplx = -1; int tmply = -1; GstStateChangeReturn ret; g_mutex_lock (filter->propset_mutex); switch (prop_id) { case PROP_GRID_X: ret = gst_element_get_state (GST_ELEMENT (filter), &filter->state, NULL, 250 * GST_NSECOND); filter->gridx = g_value_get_int (value); if (filter->prevgridx != filter->gridx && ret == GST_STATE_CHANGE_SUCCESS && filter->state == GST_STATE_PLAYING) { filter->changed_gridx = true; } filter->prevgridx = filter->gridx; break; case PROP_GRID_Y: ret = gst_element_get_state (GST_ELEMENT (filter), &filter->state, NULL, 250 * GST_NSECOND); filter->gridy = g_value_get_int (value); if (filter->prevgridy != filter->gridy && ret == GST_STATE_CHANGE_SUCCESS && filter->state == GST_STATE_PLAYING) { filter->changed_gridy = true; } filter->prevgridy = filter->gridy; break; case PROP_GAP: filter->gap = g_value_get_int (value); break; case PROP_POSTNOMOTION: filter->postnomotion = g_value_get_int (value); break; case PROP_MINIMUNMOTIONFRAMES: filter->minimum_motion_frames = g_value_get_int (value); break; case PROP_SENSITIVITY: filter->sensitivity = g_value_get_double (value); break; case PROP_THRESHOLD: filter->threshold = g_value_get_double (value); break; case PROP_DISPLAY: filter->display = g_value_get_boolean (value); break; case PROP_POSTALLMOTION: filter->postallmotion = g_value_get_boolean (value); break; case PROP_USEALPHA: filter->usealpha = g_value_get_boolean (value); break; case PROP_CALCULATEMOTION: filter->calculate_motion = g_value_get_boolean (value); break; case PROP_DATE: ret = gst_element_get_state (GST_ELEMENT (filter), &filter->state, NULL, 250 * GST_NSECOND); if (ret == GST_STATE_CHANGE_SUCCESS && filter->state == GST_STATE_PLAYING) { filter->changed_startime = true; } filter->starttime = g_value_get_long (value); break; case PROP_DATAFILE: GFREE (filter->cur_datafile); GFREE (filter->basename_datafile); filter->basename_datafile = g_value_dup_string (value); if (strlen (filter->basename_datafile) == 0) { filter->cur_datafile = g_strdup (NULL); break; } filter->cur_datafile = g_strdup_printf ("%s-0.%s", filter->basename_datafile, filter->datafile_extension); if (g_strcmp0 (filter->prev_datafile, filter->basename_datafile) != 0) { filter->changed_datafile = TRUE; filter->sent_init_error_msg = FALSE; filter->sent_save_error_msg = FALSE; filter->datafileidx = 0; motion_cells_free_resources (filter->id); } else { filter->changed_datafile = FALSE; } GFREE (filter->prev_datafile); filter->prev_datafile = g_strdup (filter->basename_datafile); break; case PROP_DATAFILE_EXT: GFREE (filter->datafile_extension); filter->datafile_extension = g_value_dup_string (value); break; case PROP_MOTIONMASKCOORD: strs = g_strsplit (g_value_get_string (value), ",", 255); GFREE (filter->motionmaskcoords); //setting number of regions for (filter->motionmaskcoord_count = 0; strs[filter->motionmaskcoord_count] != NULL; ++filter->motionmaskcoord_count); if (filter->motionmaskcoord_count > 0) { sscanf (strs[0], "%d:%d:%d:%d", &tmpux, &tmpuy, &tmplx, &tmply); if (tmpux > -1 && tmpuy > -1 && tmplx > -1 && tmply > -1) { filter->motionmaskcoords = g_new0 (motionmaskcoordrect, filter->motionmaskcoord_count); for (i = 0; i < filter->motionmaskcoord_count; ++i) { sscanf (strs[i], "%d:%d:%d:%d", &ux, &uy, &lx, &ly); ux = CLAMP (ux, 0, filter->width - 1); uy = CLAMP (uy, 0, filter->height - 1); lx = CLAMP (lx, 0, filter->width - 1); ly = CLAMP (ly, 0, filter->height - 1); filter->motionmaskcoords[i].upper_left_x = ux; filter->motionmaskcoords[i].upper_left_y = uy; filter->motionmaskcoords[i].lower_right_x = lx; filter->motionmaskcoords[i].lower_right_y = ly; } } else { filter->motionmaskcoord_count = 0; } } if (strs) g_strfreev (strs); tmpux = -1; tmpuy = -1; tmplx = -1; tmply = -1; break; case PROP_MOTIONMASKCELLSPOS: motionmaskcellsstr = g_strsplit (g_value_get_string (value), ",", 255); GFREE (filter->motionmaskcellsidx); //setting number of regions for (filter->motionmaskcells_count = 0; motionmaskcellsstr[filter->motionmaskcells_count] != NULL; ++filter->motionmaskcells_count); if (filter->motionmaskcells_count > 0) { sscanf (motionmaskcellsstr[0], "%d:%d", &tmpux, &tmpuy); if (tmpux > -1 && tmpuy > -1) { filter->motionmaskcellsidx = g_new0 (motioncellidx, filter->motionmaskcells_count); for (i = 0; i < filter->motionmaskcells_count; ++i) { sscanf (motionmaskcellsstr[i], "%d:%d", &masklinidx, &maskcolidx); filter->motionmaskcellsidx[i].lineidx = masklinidx; filter->motionmaskcellsidx[i].columnidx = maskcolidx; } } else { filter->motionmaskcells_count = 0; } } if (motionmaskcellsstr) g_strfreev (motionmaskcellsstr); tmpux = -1; tmpuy = -1; tmplx = -1; tmply = -1; break; case PROP_CELLSCOLOR: colorstr = g_strsplit (g_value_get_string (value), ",", 255); for (cellscolorscnt = 0; colorstr[cellscolorscnt] != NULL; ++cellscolorscnt); if (cellscolorscnt == 3) { sscanf (colorstr[0], "%d", &r); sscanf (colorstr[1], "%d", &g); sscanf (colorstr[2], "%d", &b); //check right RGB color format r = CLAMP (r, 1, 255); g = CLAMP (g, 1, 255); b = CLAMP (b, 1, 255); filter->motioncellscolor->R_channel_value = r; filter->motioncellscolor->G_channel_value = g; filter->motioncellscolor->B_channel_value = b; } if (colorstr) g_strfreev (colorstr); break; case PROP_MOTIONCELLSIDX: motioncellsstr = g_strsplit (g_value_get_string (value), ",", 255); //setting number of regions for (filter->motioncells_count = 0; motioncellsstr[filter->motioncells_count] != NULL; ++filter->motioncells_count); if (filter->motioncells_count > 0) { sscanf (motioncellsstr[0], "%d:%d", &tmpux, &tmpuy); if (tmpux > -1 && tmpuy > -1) { GFREE (filter->motioncellsidx); filter->motioncellsidx = g_new0 (motioncellidx, filter->motioncells_count); for (i = 0; i < filter->motioncells_count; ++i) { sscanf (motioncellsstr[i], "%d:%d", &linidx, &colidx); filter->motioncellsidx[i].lineidx = linidx; filter->motioncellsidx[i].columnidx = colidx; } } else { filter->motioncells_count = 0; } } if (motioncellsstr) g_strfreev (motioncellsstr); tmpux = -1; tmpuy = -1; tmplx = -1; tmply = -1; break; case PROP_MOTIONCELLTHICKNESS: filter->thickness = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } g_mutex_unlock (filter->propset_mutex); }
void _gtk_tree_data_list_value_to_node (GtkTreeDataList *list, GValue *value) { switch (get_fundamental_type (G_VALUE_TYPE (value))) { case G_TYPE_BOOLEAN: list->data.v_int = g_value_get_boolean (value); break; case G_TYPE_CHAR: list->data.v_char = g_value_get_schar (value); break; case G_TYPE_UCHAR: list->data.v_uchar = g_value_get_uchar (value); break; case G_TYPE_INT: list->data.v_int = g_value_get_int (value); break; case G_TYPE_UINT: list->data.v_uint = g_value_get_uint (value); break; case G_TYPE_LONG: list->data.v_long = g_value_get_long (value); break; case G_TYPE_ULONG: list->data.v_ulong = g_value_get_ulong (value); break; case G_TYPE_INT64: list->data.v_int64 = g_value_get_int64 (value); break; case G_TYPE_UINT64: list->data.v_uint64 = g_value_get_uint64 (value); break; case G_TYPE_ENUM: list->data.v_int = g_value_get_enum (value); break; case G_TYPE_FLAGS: list->data.v_uint = g_value_get_flags (value); break; case G_TYPE_POINTER: list->data.v_pointer = g_value_get_pointer (value); break; case G_TYPE_FLOAT: list->data.v_float = g_value_get_float (value); break; case G_TYPE_DOUBLE: list->data.v_double = g_value_get_double (value); break; case G_TYPE_STRING: g_free (list->data.v_pointer); list->data.v_pointer = g_value_dup_string (value); break; case G_TYPE_OBJECT: if (list->data.v_pointer) g_object_unref (list->data.v_pointer); list->data.v_pointer = g_value_dup_object (value); break; case G_TYPE_BOXED: if (list->data.v_pointer) g_boxed_free (G_VALUE_TYPE (value), list->data.v_pointer); list->data.v_pointer = g_value_dup_boxed (value); break; case G_TYPE_VARIANT: if (list->data.v_pointer) g_variant_unref (list->data.v_pointer); list->data.v_pointer = g_value_dup_variant (value); break; default: g_warning ("%s: Unsupported type (%s) stored.", G_STRLOC, g_type_name (G_VALUE_TYPE (value))); break; } }
void test_set_value_from_string() { GValue val = { 0, }; xmlfile = "gstutils_test_set_value_from_string"; std_log(LOG_FILENAME_LINE, "Test Started gstutils_test_set_value_from_string"); /* g_return_if_fail */ ASSERT_CRITICAL (gst_util_set_value_from_string (NULL, "xyz")); g_value_init (&val, G_TYPE_STRING); ASSERT_CRITICAL (gst_util_set_value_from_string (&val, NULL)); g_value_unset (&val); /* string => string */ g_value_init (&val, G_TYPE_STRING); gst_util_set_value_from_string (&val, "Y00"); fail_unless (g_value_get_string (&val) != NULL); fail_unless_equals_string (g_value_get_string (&val), "Y00"); g_value_unset (&val); /* string => int */ g_value_init (&val, G_TYPE_INT); gst_util_set_value_from_string (&val, "987654321"); fail_unless (g_value_get_int (&val) == 987654321); g_value_unset (&val); g_value_init (&val, G_TYPE_INT); ASSERT_CRITICAL (gst_util_set_value_from_string (&val, "xyz")); g_value_unset (&val); /* string => uint */ g_value_init (&val, G_TYPE_UINT); gst_util_set_value_from_string (&val, "987654321"); fail_unless (g_value_get_uint (&val) == 987654321); g_value_unset (&val); /* CHECKME: is this really desired behaviour? (tpm) */ g_value_init (&val, G_TYPE_UINT); gst_util_set_value_from_string (&val, "-999"); fail_unless (g_value_get_uint (&val) == ((guint) 0 - (guint) 999)); g_value_unset (&val); g_value_init (&val, G_TYPE_UINT); ASSERT_CRITICAL (gst_util_set_value_from_string (&val, "xyz")); g_value_unset (&val); /* string => long */ g_value_init (&val, G_TYPE_LONG); gst_util_set_value_from_string (&val, "987654321"); fail_unless (g_value_get_long (&val) == 987654321); g_value_unset (&val); g_value_init (&val, G_TYPE_LONG); ASSERT_CRITICAL (gst_util_set_value_from_string (&val, "xyz")); g_value_unset (&val); /* string => ulong */ g_value_init (&val, G_TYPE_ULONG); gst_util_set_value_from_string (&val, "987654321"); fail_unless (g_value_get_ulong (&val) == 987654321); g_value_unset (&val); /* CHECKME: is this really desired behaviour? (tpm) */ g_value_init (&val, G_TYPE_ULONG); gst_util_set_value_from_string (&val, "-999"); fail_unless (g_value_get_ulong (&val) == ((gulong) 0 - (gulong) 999)); g_value_unset (&val); g_value_init (&val, G_TYPE_ULONG); ASSERT_CRITICAL (gst_util_set_value_from_string (&val, "xyz")); g_value_unset (&val); /* string => boolean */ g_value_init (&val, G_TYPE_BOOLEAN); gst_util_set_value_from_string (&val, "true"); fail_unless_equals_int (g_value_get_boolean (&val), TRUE); g_value_unset (&val); g_value_init (&val, G_TYPE_BOOLEAN); gst_util_set_value_from_string (&val, "TRUE"); fail_unless_equals_int (g_value_get_boolean (&val), TRUE); g_value_unset (&val); g_value_init (&val, G_TYPE_BOOLEAN); gst_util_set_value_from_string (&val, "false"); fail_unless_equals_int (g_value_get_boolean (&val), FALSE); g_value_unset (&val); g_value_init (&val, G_TYPE_BOOLEAN); gst_util_set_value_from_string (&val, "FALSE"); fail_unless_equals_int (g_value_get_boolean (&val), FALSE); g_value_unset (&val); g_value_init (&val, G_TYPE_BOOLEAN); gst_util_set_value_from_string (&val, "bleh"); fail_unless_equals_int (g_value_get_boolean (&val), FALSE); g_value_unset (&val); #if 0 /* string => float (yay, localisation issues involved) */ g_value_init (&val, G_TYPE_FLOAT); gst_util_set_value_from_string (&val, "987.654"); fail_unless (g_value_get_float (&val) >= 987.653 && g_value_get_float (&val) <= 987.655); g_value_unset (&val); g_value_init (&val, G_TYPE_FLOAT); gst_util_set_value_from_string (&val, "987,654"); fail_unless (g_value_get_float (&val) >= 987.653 && g_value_get_float (&val) <= 987.655); g_value_unset (&val); /* string => double (yay, localisation issues involved) */ g_value_init (&val, G_TYPE_DOUBLE); gst_util_set_value_from_string (&val, "987.654"); fail_unless (g_value_get_double (&val) >= 987.653 && g_value_get_double (&val) <= 987.655); g_value_unset (&val); g_value_init (&val, G_TYPE_DOUBLE); gst_util_set_value_from_string (&val, "987,654"); fail_unless (g_value_get_double (&val) >= 987.653 && g_value_get_double (&val) <= 987.655); g_value_unset (&val); #endif std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); }
VALUE rbgobj_gvalue_to_rvalue(const GValue* value) { GType type, fundamental_type; VALUE rvalue; if (!value) return Qnil; type = G_VALUE_TYPE(value); if (rbgobj_convert_gvalue2rvalue(type, value, &rvalue)) return rvalue; fundamental_type = G_TYPE_FUNDAMENTAL(type); switch (fundamental_type) { case G_TYPE_NONE: return Qnil; case G_TYPE_CHAR: return CHR2FIX(g_value_get_char(value)); case G_TYPE_UCHAR: return INT2FIX(g_value_get_uchar(value)); case G_TYPE_BOOLEAN: return CBOOL2RVAL(g_value_get_boolean(value)); case G_TYPE_INT: return INT2NUM(g_value_get_int(value)); case G_TYPE_UINT: return UINT2NUM(g_value_get_uint(value)); case G_TYPE_LONG: return LONG2NUM(g_value_get_long(value)); case G_TYPE_ULONG: return ULONG2NUM(g_value_get_ulong(value)); case G_TYPE_INT64: return rbglib_int64_to_num(g_value_get_int64(value)); case G_TYPE_UINT64: return rbglib_uint64_to_num(g_value_get_uint64(value)); case G_TYPE_FLOAT: return rb_float_new(g_value_get_float(value)); case G_TYPE_DOUBLE: return rb_float_new(g_value_get_double(value)); case G_TYPE_STRING: return CSTR2RVAL(g_value_get_string(value)); case G_TYPE_ENUM: return rbgobj_make_enum(g_value_get_enum(value), type); case G_TYPE_FLAGS: return rbgobj_make_flags(g_value_get_flags(value), type); case G_TYPE_OBJECT: case G_TYPE_INTERFACE: { GObject* gobj = g_value_get_object(value); return gobj ? GOBJ2RVAL(gobj) : Qnil; } case G_TYPE_PARAM: { GParamSpec* pspec = g_value_get_param(value); return pspec ? rbgobj_ruby_object_from_instance(pspec) : Qnil; } case G_TYPE_POINTER: { gpointer ptr = g_value_get_pointer(value); if (!ptr) return Qnil; else return rbgobj_ptr_new(type, ptr); } case G_TYPE_BOXED: { GType gtype; for (gtype = type; gtype != G_TYPE_INVALID; gtype = g_type_parent(gtype)) { GValueToRValueFunc func = g_type_get_qdata(gtype, qGValueToRValueFunc); if (!func) continue; return func(value); } } default: if (!rbgobj_convert_gvalue2rvalue(fundamental_type, value, &rvalue)) { GValueToRValueFunc func; func = g_type_get_qdata(type, qGValueToRValueFunc); if (!func) { g_warning("rbgobj_gvalue_to_rvalue: unsupported type: %s\n", g_type_name(type)); } else { rvalue = func(value); } } return rvalue; } }
static void psppire_data_editor_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { int i; PsppireDataEditor *de = PSPPIRE_DATA_EDITOR (object); switch (prop_id) { case PROP_SPLIT_WINDOW: psppire_data_editor_split_window (de, g_value_get_boolean (value)); break; case PROP_DATA_WINDOW: de->data_window = g_value_get_pointer (value); g_object_ref (de->data_window); break; case PROP_DATA_STORE: if ( de->data_store) g_object_unref (de->data_store); de->data_store = g_value_get_pointer (value); g_object_ref (de->data_store); for (i = 0 ; i < 4 ; ++i ) { g_object_set (de->data_sheet[i], "model", de->data_store, NULL); g_signal_connect_swapped (de->data_store->dict, "filter-changed", G_CALLBACK (gtk_widget_queue_draw), de->data_sheet[i]); } g_signal_connect (de->data_store->dict, "backend-changed", G_CALLBACK (new_variables_callback), de); g_signal_connect (de->data_store->dict, "variable-inserted", G_CALLBACK (insert_variable_callback), de); g_signal_connect (de->data_store->dict, "variable-deleted", G_CALLBACK (delete_variable_callback), de); g_signal_connect (de->data_store->dict, "variable-display-width-changed", G_CALLBACK (rewidth_variable_callback), de); g_signal_connect (de->data_store, "backend-changed", G_CALLBACK (new_data_callback), de); g_signal_connect (de->data_store, "case-inserted", G_CALLBACK (case_inserted_callback), de); g_signal_connect (de->data_store, "cases-deleted", G_CALLBACK (cases_deleted_callback), de); break; case PROP_VAR_STORE: if ( de->var_store) g_object_unref (de->var_store); de->var_store = g_value_get_pointer (value); g_object_ref (de->var_store); g_object_set (de->var_sheet, "model", de->var_store, NULL); break; case PROP_VS_ROW_MENU: { GObject *menu = g_value_get_object (value); g_signal_connect (de->var_sheet, "button-event-row", G_CALLBACK (popup_variable_row_menu), menu); } break; case PROP_DS_COLUMN_MENU: { GObject *menu = g_value_get_object (value); g_signal_connect (de->data_sheet[0], "button-event-column", G_CALLBACK (popup_variable_column_menu), menu); } break; case PROP_DS_ROW_MENU: { GObject *menu = g_value_get_object (value); g_signal_connect (de->data_sheet[0], "button-event-row", G_CALLBACK (popup_cases_menu), menu); } break; case PROP_CURRENT_VAR: { gint row, col; gint var = g_value_get_long (value); switch (gtk_notebook_get_current_page (GTK_NOTEBOOK (object))) { case PSPPIRE_DATA_EDITOR_DATA_VIEW: psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &col); psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), row, var); psppire_sheet_moveto (PSPPIRE_SHEET (de->data_sheet[0]), -1, var, 0.5, 0.5); break; case PSPPIRE_DATA_EDITOR_VARIABLE_VIEW: psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->var_sheet), &row, &col); psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->var_sheet), var, col); psppire_sheet_moveto (PSPPIRE_SHEET (de->var_sheet), var, -1, 0.5, 0.5); break; default: g_assert_not_reached (); break; }; } break; case PROP_CURRENT_CASE: { gint row, col; gint case_num = g_value_get_long (value); psppire_sheet_get_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), &row, &col); psppire_sheet_set_active_cell (PSPPIRE_SHEET (de->data_sheet[0]), case_num, col); psppire_sheet_moveto (PSPPIRE_SHEET (de->data_sheet[0]), case_num, -1, 0.5, 0.5); } break; case PROP_VALUE_LABELS: { psppire_data_store_show_labels (de->data_store, g_value_get_boolean (value)); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; }; }
JsonNode * json_serialize_pspec (const GValue *real_value, GParamSpec *pspec) { JsonNode *retval = NULL; JsonNodeType node_type; switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (real_value))) { /* JSON native types */ case G_TYPE_INT64: retval = json_node_init_int (json_node_alloc (), g_value_get_int64 (real_value)); break; case G_TYPE_BOOLEAN: retval = json_node_init_boolean (json_node_alloc (), g_value_get_boolean (real_value)); break; case G_TYPE_DOUBLE: retval = json_node_init_double (json_node_alloc (), g_value_get_double (real_value)); break; case G_TYPE_STRING: retval = json_node_init_string (json_node_alloc (), g_value_get_string (real_value)); break; /* auto-promoted types */ case G_TYPE_INT: retval = json_node_init_int (json_node_alloc (), g_value_get_int (real_value)); break; case G_TYPE_UINT: retval = json_node_init_int (json_node_alloc (), g_value_get_uint (real_value)); break; case G_TYPE_LONG: retval = json_node_init_int (json_node_alloc (), g_value_get_long (real_value)); break; case G_TYPE_ULONG: retval = json_node_init_int (json_node_alloc (), g_value_get_ulong (real_value)); break; case G_TYPE_UINT64: retval = json_node_init_int (json_node_alloc (), g_value_get_uint64 (real_value)); break; case G_TYPE_FLOAT: retval = json_node_init_double (json_node_alloc (), g_value_get_float (real_value)); break; case G_TYPE_CHAR: retval = json_node_alloc (); json_node_init_int (retval, g_value_get_schar (real_value)); break; case G_TYPE_UCHAR: retval = json_node_init_int (json_node_alloc (), g_value_get_uchar (real_value)); break; case G_TYPE_ENUM: retval = json_node_init_int (json_node_alloc (), g_value_get_enum (real_value)); break; case G_TYPE_FLAGS: retval = json_node_init_int (json_node_alloc (), g_value_get_flags (real_value)); break; /* complex types */ case G_TYPE_BOXED: if (G_VALUE_HOLDS (real_value, G_TYPE_STRV)) { gchar **strv = g_value_get_boxed (real_value); gint i, strv_len; JsonArray *array; strv_len = g_strv_length (strv); array = json_array_sized_new (strv_len); for (i = 0; i < strv_len; i++) { JsonNode *str = json_node_new (JSON_NODE_VALUE); json_node_set_string (str, strv[i]); json_array_add_element (array, str); } retval = json_node_init_array (json_node_alloc (), array); json_array_unref (array); } else if (json_boxed_can_serialize (G_VALUE_TYPE (real_value), &node_type)) { gpointer boxed = g_value_get_boxed (real_value); retval = json_boxed_serialize (G_VALUE_TYPE (real_value), boxed); } else g_warning ("Boxed type '%s' is not handled by JSON-GLib", g_type_name (G_VALUE_TYPE (real_value))); break; case G_TYPE_OBJECT: { GObject *object = g_value_get_object (real_value); retval = json_node_alloc (); if (object != NULL) { json_node_init (retval, JSON_NODE_OBJECT); json_node_take_object (retval, json_gobject_dump (object)); } else json_node_init_null (retval); } break; case G_TYPE_NONE: retval = json_node_new (JSON_NODE_NULL); break; default: g_warning ("Unsupported type `%s'", g_type_name (G_VALUE_TYPE (real_value))); break; } return retval; }
QT_BEGIN_NAMESPACE //internal static void addTagToMap(const GstTagList *list, const gchar *tag, gpointer user_data) { QMap<QByteArray, QVariant> *map = reinterpret_cast<QMap<QByteArray, QVariant>* >(user_data); GValue val; val.g_type = 0; gst_tag_list_copy_value(&val,list,tag); switch( G_VALUE_TYPE(&val) ) { case G_TYPE_STRING: { const gchar *str_value = g_value_get_string(&val); map->insert(QByteArray(tag), QString::fromUtf8(str_value)); break; } case G_TYPE_INT: map->insert(QByteArray(tag), g_value_get_int(&val)); break; case G_TYPE_UINT: map->insert(QByteArray(tag), g_value_get_uint(&val)); break; case G_TYPE_LONG: map->insert(QByteArray(tag), qint64(g_value_get_long(&val))); break; case G_TYPE_BOOLEAN: map->insert(QByteArray(tag), g_value_get_boolean(&val)); break; case G_TYPE_CHAR: #if GLIB_CHECK_VERSION(2,32,0) map->insert(QByteArray(tag), g_value_get_schar(&val)); #else map->insert(QByteArray(tag), g_value_get_char(&val)); #endif break; case G_TYPE_DOUBLE: map->insert(QByteArray(tag), g_value_get_double(&val)); break; default: // GST_TYPE_DATE is a function, not a constant, so pull it out of the switch #if GST_CHECK_VERSION(1,0,0) if (G_VALUE_TYPE(&val) == G_TYPE_DATE) { const GDate *date = (const GDate *)g_value_get_boxed(&val); #else if (G_VALUE_TYPE(&val) == GST_TYPE_DATE) { const GDate *date = gst_value_get_date(&val); #endif if (g_date_valid(date)) { int year = g_date_get_year(date); int month = g_date_get_month(date); int day = g_date_get_day(date); map->insert(QByteArray(tag), QDate(year,month,day)); if (!map->contains("year")) map->insert("year", year); } } else if (G_VALUE_TYPE(&val) == GST_TYPE_FRACTION) { int nom = gst_value_get_fraction_numerator(&val); int denom = gst_value_get_fraction_denominator(&val); if (denom > 0) { map->insert(QByteArray(tag), double(nom)/denom); } } break; } g_value_unset(&val); } /*! Convert GstTagList structure to QMap<QByteArray, QVariant>. Mapping to int, bool, char, string, fractions and date are supported. Fraction values are converted to doubles. */ QMap<QByteArray, QVariant> QGstUtils::gstTagListToMap(const GstTagList *tags) { QMap<QByteArray, QVariant> res; gst_tag_list_foreach(tags, addTagToMap, &res); return res; }
static int get_field(OhmFact *fact, fsif_fldtype_t type,char *name,void *vptr) { GValue *gv; if (!fact || !name || !(gv = ohm_fact_get(fact, name))) { OHM_ERROR("resource: [%s] Cant find field %s", __FUNCTION__, name?name:"<null>"); goto return_empty_value; } switch (type) { case fldtype_string: if (G_VALUE_TYPE(gv) != G_TYPE_STRING) goto type_mismatch; else *(const char **)vptr = g_value_get_string(gv); break; case fldtype_integer: switch (G_VALUE_TYPE(gv)) { case G_TYPE_LONG: *(long *)vptr = g_value_get_long(gv); break; case G_TYPE_INT: *(long *)vptr = g_value_get_int(gv); break; default: goto type_mismatch; } break; case fldtype_unsignd: if (G_VALUE_TYPE(gv) != G_TYPE_ULONG) goto type_mismatch; else *(unsigned long *)vptr = g_value_get_ulong(gv); break; case fldtype_floating: if (G_VALUE_TYPE(gv) != G_TYPE_DOUBLE) goto type_mismatch; else *(double *)vptr = g_value_get_double(gv); break; case fldtype_time: if (G_VALUE_TYPE(gv) != G_TYPE_UINT64) goto type_mismatch; else *(time_t *)vptr = g_value_get_uint64(gv); break; default: break; } return TRUE; type_mismatch: OHM_ERROR("resource: [%s] Type mismatch when fetching field '%s'", __FUNCTION__,name); return_empty_value: switch (type) { case fldtype_string: *(char **)vptr = NULL; break; case fldtype_integer: *(long *)vptr = 0; break; case fldtype_unsignd: *(unsigned long *)vptr = 0; break; case fldtype_floating: *(double *)vptr = 0.0; break; case fldtype_time: *(unsigned long long *)vptr = 0ULL; break; default: break; } return FALSE; }
int main(int argc, char **argv) { struct _vte_matcher *matcher = NULL; GArray *array; unsigned int i, j; int l; unsigned char buf[4096]; GValue *value; int infile; struct _vte_iso2022_state *subst; const char *tmp; GValueArray *values; _vte_debug_init(); if (argc < 1) { g_print("usage: %s [file]\n", argv[0]); return 1; } if ((argc > 1) && (strcmp(argv[1], "-") != 0)) { infile = open (argv[1], O_RDONLY); if (infile == -1) { g_print("error opening %s: %s\n", argv[1], strerror(errno)); exit(1); } } else { infile = 1; } g_type_init(); array = g_array_new(FALSE, FALSE, sizeof(gunichar)); matcher = _vte_matcher_new(); subst = _vte_iso2022_state_new(NULL, VTE_ISO2022_DEFAULT_UTF8_AMBIGUOUS_WIDTH, NULL, NULL); for (;;) { l = read (infile, buf, sizeof (buf)); if (!l) break; if (l == -1) { if (errno == EAGAIN) continue; exit (1); } g_array_set_size (array, 0); _vte_iso2022_process(subst, buf, (unsigned int) l, array); i = 0; while (i <= array->len) { tmp = NULL; values = NULL; for (j = 1; j < (array->len - i); j++) { _vte_matcher_match(matcher, &g_array_index(array, gunichar, i), j, &tmp, NULL, &values); if ((tmp == NULL) || (strlen(tmp) > 0)) { break; } } if (i + j == array->len) { break; } if (tmp == NULL) { gunichar c; c = g_array_index(array, gunichar, i); if (VTE_ISO2022_HAS_ENCODED_WIDTH(c)) { c &= ~VTE_ISO2022_ENCODED_WIDTH_MASK; } if (c < 32) { g_print("`^%c'\n", c + 64); } else if (c < 127) { g_print("`%c'\n", c); } else { g_print("`0x%x'\n", c); } i++; continue; } l = j; g_print("%s(", tmp); for (j = 0; (values != NULL) && (j < values->n_values); j++) { if (j > 0) { g_print(", "); } value = g_value_array_get_nth(values, j); if (G_VALUE_HOLDS_LONG(value)) { g_print("%ld", g_value_get_long(value)); } if (G_VALUE_HOLDS_STRING(value)) { g_print("`%s'", g_value_get_string(value)); } if (G_VALUE_HOLDS_POINTER(value)) { g_print("`%ls'", (wchar_t*) g_value_get_pointer(value)); } } if (values != NULL) { _vte_matcher_free_params_array(matcher, values); } g_print(")\n"); i += l; } } g_print("End of data.\n"); close (infile); _vte_iso2022_state_free(subst); g_array_free(array, TRUE); _vte_matcher_free(matcher); return 0; }
DECLARE_TO_XML (long) { char buf[256]; g_snprintf (buf, sizeof (buf), "%ld", g_value_get_long (value)); return gsk_xml_node_new_text_c (buf); }
int rb_gvalue_compare (GValue *a, GValue *b) { int retval; const char *stra, *strb; if (G_VALUE_TYPE (a) != G_VALUE_TYPE (b)) return -1; switch (G_VALUE_TYPE (a)) { case G_TYPE_BOOLEAN: if (g_value_get_int (a) < g_value_get_int (b)) retval = -1; else if (g_value_get_int (a) == g_value_get_int (b)) retval = 0; else retval = 1; break; case G_TYPE_CHAR: if (g_value_get_char (a) < g_value_get_char (b)) retval = -1; else if (g_value_get_char (a) == g_value_get_char (b)) retval = 0; else retval = 1; break; case G_TYPE_UCHAR: if (g_value_get_uchar (a) < g_value_get_uchar (b)) retval = -1; else if (g_value_get_uchar (a) == g_value_get_uchar (b)) retval = 0; else retval = 1; break; case G_TYPE_INT: if (g_value_get_int (a) < g_value_get_int (b)) retval = -1; else if (g_value_get_int (a) == g_value_get_int (b)) retval = 0; else retval = 1; break; case G_TYPE_UINT: if (g_value_get_uint (a) < g_value_get_uint (b)) retval = -1; else if (g_value_get_uint (a) == g_value_get_uint (b)) retval = 0; else retval = 1; break; case G_TYPE_LONG: if (g_value_get_long (a) < g_value_get_long (b)) retval = -1; else if (g_value_get_long (a) == g_value_get_long (b)) retval = 0; else retval = 1; break; case G_TYPE_ULONG: if (g_value_get_ulong (a) < g_value_get_ulong (b)) retval = -1; else if (g_value_get_ulong (a) == g_value_get_ulong (b)) retval = 0; else retval = 1; break; case G_TYPE_INT64: if (g_value_get_int64 (a) < g_value_get_int64 (b)) retval = -1; else if (g_value_get_int64 (a) == g_value_get_int64 (b)) retval = 0; else retval = 1; break; case G_TYPE_UINT64: if (g_value_get_uint64 (a) < g_value_get_uint64 (b)) retval = -1; else if (g_value_get_uint64 (a) == g_value_get_uint64 (b)) retval = 0; else retval = 1; break; case G_TYPE_ENUM: /* this is somewhat bogus. */ if (g_value_get_enum (a) < g_value_get_enum (b)) retval = -1; else if (g_value_get_enum (a) == g_value_get_enum (b)) retval = 0; else retval = 1; break; case G_TYPE_FLAGS: /* this is even more bogus. */ if (g_value_get_flags (a) < g_value_get_flags (b)) retval = -1; else if (g_value_get_flags (a) == g_value_get_flags (b)) retval = 0; else retval = 1; break; case G_TYPE_FLOAT: if (g_value_get_float (a) < g_value_get_float (b)) retval = -1; else if (g_value_get_float (a) == g_value_get_float (b)) retval = 0; else retval = 1; break; case G_TYPE_DOUBLE: if (g_value_get_double (a) < g_value_get_double (b)) retval = -1; else if (g_value_get_double (a) == g_value_get_double (b)) retval = 0; else retval = 1; break; case G_TYPE_STRING: stra = g_value_get_string (a); strb = g_value_get_string (b); if (stra == NULL) stra = ""; if (strb == NULL) strb = ""; retval = g_utf8_collate (stra, strb); break; case G_TYPE_POINTER: retval = (g_value_get_pointer (a) != g_value_get_pointer (b)); break; case G_TYPE_BOXED: retval = (g_value_get_boxed (a) != g_value_get_boxed (b)); break; case G_TYPE_OBJECT: retval = (g_value_get_object (a) != g_value_get_object (b)); break; default: g_assert_not_reached (); retval = 0; break; } return retval; }
/** * pyg_value_as_pyobject: * @value: the GValue object. * @copy_boxed: true if boxed values should be copied. * * This function creates/returns a Python wrapper object that * represents the GValue passed as an argument. * * Returns: a PyObject representing the value. */ PyObject * pyg_value_as_pyobject(const GValue *value, gboolean copy_boxed) { gchar buf[128]; switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INTERFACE: if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) return pygobject_new(g_value_get_object(value)); else break; case G_TYPE_CHAR: { gint8 val = g_value_get_char(value); return PYGLIB_PyUnicode_FromStringAndSize((char *)&val, 1); } case G_TYPE_UCHAR: { guint8 val = g_value_get_uchar(value); return PYGLIB_PyBytes_FromStringAndSize((char *)&val, 1); } case G_TYPE_BOOLEAN: { return PyBool_FromLong(g_value_get_boolean(value)); } case G_TYPE_INT: return PYGLIB_PyLong_FromLong(g_value_get_int(value)); case G_TYPE_UINT: { /* in Python, the Int object is backed by a long. If a long can hold the whole value of an unsigned int, use an Int. Otherwise, use a Long object to avoid overflow. This matches the ULongArg behavior in codegen/argtypes.h */ #if (G_MAXUINT <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) g_value_get_uint(value)); #else return PyLong_FromUnsignedLong((gulong) g_value_get_uint(value)); #endif } case G_TYPE_LONG: return PYGLIB_PyLong_FromLong(g_value_get_long(value)); case G_TYPE_ULONG: { gulong val = g_value_get_ulong(value); if (val <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) val); else return PyLong_FromUnsignedLong(val); } case G_TYPE_INT64: { gint64 val = g_value_get_int64(value); if (G_MINLONG <= val && val <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) val); else return PyLong_FromLongLong(val); } case G_TYPE_UINT64: { guint64 val = g_value_get_uint64(value); if (val <= G_MAXLONG) return PYGLIB_PyLong_FromLong((glong) val); else return PyLong_FromUnsignedLongLong(val); } case G_TYPE_ENUM: return pyg_enum_from_gtype(G_VALUE_TYPE(value), g_value_get_enum(value)); case G_TYPE_FLAGS: return pyg_flags_from_gtype(G_VALUE_TYPE(value), g_value_get_flags(value)); case G_TYPE_FLOAT: return PyFloat_FromDouble(g_value_get_float(value)); case G_TYPE_DOUBLE: return PyFloat_FromDouble(g_value_get_double(value)); case G_TYPE_STRING: { const gchar *str = g_value_get_string(value); if (str) return PYGLIB_PyUnicode_FromString(str); Py_INCREF(Py_None); return Py_None; } case G_TYPE_POINTER: return pyg_pointer_new(G_VALUE_TYPE(value), g_value_get_pointer(value)); case G_TYPE_BOXED: { PyGTypeMarshal *bm; if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) { PyObject *ret = (PyObject *)g_value_dup_boxed(value); if (ret == NULL) { Py_INCREF(Py_None); return Py_None; } return ret; } else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) { GValue *n_value = g_value_get_boxed (value); return pyg_value_as_pyobject(n_value, copy_boxed); } else if (G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY)) { GValueArray *array = (GValueArray *) g_value_get_boxed(value); PyObject *ret = PyList_New(array->n_values); int i; for (i = 0; i < array->n_values; ++i) PyList_SET_ITEM(ret, i, pyg_value_as_pyobject (array->values + i, copy_boxed)); return ret; } else if (G_VALUE_HOLDS(value, G_TYPE_GSTRING)) { GString *string = (GString *) g_value_get_boxed(value); PyObject *ret = PYGLIB_PyUnicode_FromStringAndSize(string->str, string->len); return ret; } bm = pyg_type_lookup(G_VALUE_TYPE(value)); if (bm) { return bm->fromvalue(value); } else { if (copy_boxed) return pyg_boxed_new(G_VALUE_TYPE(value), g_value_get_boxed(value), TRUE, TRUE); else return pyg_boxed_new(G_VALUE_TYPE(value), g_value_get_boxed(value),FALSE,FALSE); } } case G_TYPE_PARAM: return pyg_param_spec_new(g_value_get_param(value)); case G_TYPE_OBJECT: return pygobject_new(g_value_get_object(value)); default: { PyGTypeMarshal *bm; if ((bm = pyg_type_lookup(G_VALUE_TYPE(value)))) return bm->fromvalue(value); break; } } g_snprintf(buf, sizeof(buf), "unknown type %s", g_type_name(G_VALUE_TYPE(value))); PyErr_SetString(PyExc_TypeError, buf); return NULL; }
static void print_element_properties_info (GstElement * element) { GParamSpec **property_specs; guint num_properties, i; gboolean readable; gboolean first_flag; property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (element), &num_properties); n_print ("\n"); n_print ("Element Properties:\n"); for (i = 0; i < num_properties; i++) { GValue value = { 0, }; GParamSpec *param = property_specs[i]; readable = FALSE; g_value_init (&value, param->value_type); n_print (" %-20s: %s\n", g_param_spec_get_name (param), g_param_spec_get_blurb (param)); first_flag = TRUE; n_print ("%-23.23s flags: ", ""); if (param->flags & G_PARAM_READABLE) { g_object_get_property (G_OBJECT (element), param->name, &value); readable = TRUE; if (!first_flag) g_print (", "); else first_flag = FALSE; g_print (_("readable")); } if (param->flags & G_PARAM_WRITABLE) { if (!first_flag) g_print (", "); else first_flag = FALSE; g_print (_("writable")); } if (param->flags & GST_PARAM_CONTROLLABLE) { if (!first_flag) g_print (", "); else first_flag = FALSE; g_print (_("controllable")); } n_print ("\n"); switch (G_VALUE_TYPE (&value)) { case G_TYPE_STRING: { GParamSpecString *pstring = G_PARAM_SPEC_STRING (param); n_print ("%-23.23s String. ", ""); if (pstring->default_value == NULL) g_print ("Default: null "); else g_print ("Default: \"%s\" ", pstring->default_value); if (readable) { const char *string_val = g_value_get_string (&value); if (string_val == NULL) g_print ("Current: null"); else g_print ("Current: \"%s\"", string_val); } break; } case G_TYPE_BOOLEAN: { GParamSpecBoolean *pboolean = G_PARAM_SPEC_BOOLEAN (param); n_print ("%-23.23s Boolean. ", ""); g_print ("Default: %s ", (pboolean->default_value ? "true" : "false")); if (readable) g_print ("Current: %s", (g_value_get_boolean (&value) ? "true" : "false")); break; } case G_TYPE_ULONG: { GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param); n_print ("%-23.23s Unsigned Long. ", ""); g_print ("Range: %lu - %lu Default: %lu ", pulong->minimum, pulong->maximum, pulong->default_value); if (readable) g_print ("Current: %lu", g_value_get_ulong (&value)); break; } case G_TYPE_LONG: { GParamSpecLong *plong = G_PARAM_SPEC_LONG (param); n_print ("%-23.23s Long. ", ""); g_print ("Range: %ld - %ld Default: %ld ", plong->minimum, plong->maximum, plong->default_value); if (readable) g_print ("Current: %ld", g_value_get_long (&value)); break; } case G_TYPE_UINT: { GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param); n_print ("%-23.23s Unsigned Integer. ", ""); g_print ("Range: %u - %u Default: %u ", puint->minimum, puint->maximum, puint->default_value); if (readable) g_print ("Current: %u", g_value_get_uint (&value)); break; } case G_TYPE_INT: { GParamSpecInt *pint = G_PARAM_SPEC_INT (param); n_print ("%-23.23s Integer. ", ""); g_print ("Range: %d - %d Default: %d ", pint->minimum, pint->maximum, pint->default_value); if (readable) g_print ("Current: %d", g_value_get_int (&value)); break; } case G_TYPE_UINT64: { GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param); n_print ("%-23.23s Unsigned Integer64. ", ""); g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT " Default: %" G_GUINT64_FORMAT " ", puint64->minimum, puint64->maximum, puint64->default_value); if (readable) g_print ("Current: %" G_GUINT64_FORMAT, g_value_get_uint64 (&value)); break; } case G_TYPE_INT64: { GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param); n_print ("%-23.23s Integer64. ", ""); g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT " Default: %" G_GINT64_FORMAT " ", pint64->minimum, pint64->maximum, pint64->default_value); if (readable) g_print ("Current: %" G_GINT64_FORMAT, g_value_get_int64 (&value)); break; } case G_TYPE_FLOAT: { GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param); n_print ("%-23.23s Float. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pfloat->minimum, pfloat->maximum, pfloat->default_value); if (readable) g_print ("Current: %15.7g", g_value_get_float (&value)); break; } case G_TYPE_DOUBLE: { GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param); n_print ("%-23.23s Double. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pdouble->minimum, pdouble->maximum, pdouble->default_value); if (readable) g_print ("Current: %15.7g", g_value_get_double (&value)); break; } default: if (param->value_type == GST_TYPE_CAPS) { const GstCaps *caps = gst_value_get_caps (&value); if (!caps) n_print ("%-23.23s Caps (NULL)", ""); else { print_caps (caps, " "); } } else if (G_IS_PARAM_SPEC_ENUM (param)) { GParamSpecEnum *penum = G_PARAM_SPEC_ENUM (param); GEnumValue *values; guint j = 0; gint enum_value; const gchar *def_val_nick = "", *cur_val_nick = ""; values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values; enum_value = g_value_get_enum (&value); while (values[j].value_name) { if (values[j].value == enum_value) cur_val_nick = values[j].value_nick; if (values[j].value == penum->default_value) def_val_nick = values[j].value_nick; j++; } n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\" Current: %d, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), penum->default_value, def_val_nick, enum_value, cur_val_nick); j = 0; while (values[j].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (%d): %-16s - %s", "", values[j].value, values[j].value_nick, values[j].value_name); j++; } /* g_type_class_unref (ec); */ } else if (G_IS_PARAM_SPEC_FLAGS (param)) { GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param); GFlagsValue *values; guint j = 0; gint flags_value; GString *cur_flags = NULL, *def_flags = NULL; values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values; flags_value = g_value_get_flags (&value); while (values[j].value_name) { if (values[j].value & flags_value) { if (cur_flags) { g_string_append_printf (cur_flags, " | %s", values[j].value_nick); } else { cur_flags = g_string_new (values[j].value_nick); } } if (values[j].value & pflags->default_value) { if (def_flags) { g_string_append_printf (def_flags, " | %s", values[j].value_nick); } else { def_flags = g_string_new (values[j].value_nick); } } j++; } n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\" Current: 0x%08x, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), pflags->default_value, (def_flags ? def_flags->str : "(none)"), flags_value, (cur_flags ? cur_flags->str : "(none)")); j = 0; while (values[j].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (0x%08x): %-16s - %s", "", values[j].value, values[j].value_nick, values[j].value_name); j++; } if (cur_flags) g_string_free (cur_flags, TRUE); if (def_flags) g_string_free (def_flags, TRUE); } else if (G_IS_PARAM_SPEC_OBJECT (param)) { n_print ("%-23.23s Object of type \"%s\"", "", g_type_name (param->value_type)); } else if (G_IS_PARAM_SPEC_BOXED (param)) { n_print ("%-23.23s Boxed pointer of type \"%s\"", "", g_type_name (param->value_type)); } else if (G_IS_PARAM_SPEC_POINTER (param)) { if (param->value_type != G_TYPE_POINTER) { n_print ("%-23.23s Pointer of type \"%s\".", "", g_type_name (param->value_type)); } else { n_print ("%-23.23s Pointer.", ""); } } else if (param->value_type == G_TYPE_VALUE_ARRAY) { GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param); if (pvarray->element_spec) { n_print ("%-23.23s Array of GValues of type \"%s\"", "", g_type_name (pvarray->element_spec->value_type)); } else { n_print ("%-23.23s Array of GValues", ""); } } else if (GST_IS_PARAM_SPEC_FRACTION (param)) { GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param); n_print ("%-23.23s Fraction. ", ""); g_print ("Range: %d/%d - %d/%d Default: %d/%d ", pfraction->min_num, pfraction->min_den, pfraction->max_num, pfraction->max_den, pfraction->def_num, pfraction->def_den); if (readable) g_print ("Current: %d/%d", gst_value_get_fraction_numerator (&value), gst_value_get_fraction_denominator (&value)); } else if (GST_IS_PARAM_SPEC_MINI_OBJECT (param)) { n_print ("%-23.23s MiniObject of type \"%s\"", "", g_type_name (param->value_type)); } else { n_print ("%-23.23s Unknown type %ld \"%s\"", "", param->value_type, g_type_name (param->value_type)); } break; } if (!readable) g_print (" Write only\n"); else g_print ("\n"); g_value_reset (&value); } if (num_properties == 0) n_print (" none\n"); g_free (property_specs); }
static void test_collection (void) { GValue value = { 0, }; gchar *error; g_value_init (&value, G_TYPE_CHAR); error = collect (&value, 'c'); g_assert (error == NULL); g_assert (g_value_get_char (&value) == 'c'); g_value_unset (&value); g_value_init (&value, G_TYPE_UCHAR); error = collect (&value, 129); g_assert (error == NULL); g_assert (g_value_get_uchar (&value) == 129); g_value_unset (&value); g_value_init (&value, G_TYPE_BOOLEAN); error = collect (&value, TRUE); g_assert (error == NULL); g_assert (g_value_get_boolean (&value) == TRUE); g_value_unset (&value); g_value_init (&value, G_TYPE_INT); error = collect (&value, G_MAXINT); g_assert (error == NULL); g_assert (g_value_get_int (&value) == G_MAXINT); g_value_unset (&value); g_value_init (&value, G_TYPE_UINT); error = collect (&value, G_MAXUINT); g_assert (error == NULL); g_assert (g_value_get_uint (&value) == G_MAXUINT); g_value_unset (&value); g_value_init (&value, G_TYPE_LONG); error = collect (&value, G_MAXLONG); g_assert (error == NULL); g_assert (g_value_get_long (&value) == G_MAXLONG); g_value_unset (&value); g_value_init (&value, G_TYPE_ULONG); error = collect (&value, G_MAXULONG); g_assert (error == NULL); g_assert (g_value_get_ulong (&value) == G_MAXULONG); g_value_unset (&value); g_value_init (&value, G_TYPE_INT64); error = collect (&value, G_MAXINT64); g_assert (error == NULL); g_assert (g_value_get_int64 (&value) == G_MAXINT64); g_value_unset (&value); g_value_init (&value, G_TYPE_UINT64); error = collect (&value, G_MAXUINT64); g_assert (error == NULL); g_assert (g_value_get_uint64 (&value) == G_MAXUINT64); g_value_unset (&value); g_value_init (&value, G_TYPE_FLOAT); error = collect (&value, G_MAXFLOAT); g_assert (error == NULL); g_assert (g_value_get_float (&value) == G_MAXFLOAT); g_value_unset (&value); g_value_init (&value, G_TYPE_DOUBLE); error = collect (&value, G_MAXDOUBLE); g_assert (error == NULL); g_assert (g_value_get_double (&value) == G_MAXDOUBLE); g_value_unset (&value); g_value_init (&value, G_TYPE_STRING); error = collect (&value, "string ?"); g_assert (error == NULL); g_assert (strcmp (g_value_get_string (&value), "string ?") == 0); g_value_unset (&value); g_value_init (&value, G_TYPE_GTYPE); error = collect (&value, G_TYPE_BOXED); g_assert (error == NULL); g_assert (g_value_get_gtype (&value) == G_TYPE_BOXED); }
static void updated_cb(void *data,OhmFact *fact,GQuark fldquark,gpointer value) { (void)data; GValue *gval = (GValue *)value; char *name; watch_fact_t *wfact; watch_entry_t *wentry; fsif_field_t fld; char valb[256]; char *valstr; if (fact == NULL) { OHM_ERROR("resource: %s() called with null fact pointer",__FUNCTION__); return; } name = (char *)ohm_structure_get_name(OHM_STRUCTURE(fact)); if (value != NULL && (wfact = find_watch(name, watch_update)) != NULL) { for (wentry = wfact->entries; wentry != NULL; wentry = wentry->next){ fld.name = (char *)g_quark_to_string(fldquark); if (matching_entry(fact, wentry->selist) && (!wentry->fldname || !strcmp(fld.name, wentry->fldname))) { switch (G_VALUE_TYPE(gval)) { case G_TYPE_STRING: fld.type = fldtype_string; fld.value.string = (char *)g_value_get_string(gval); break; case G_TYPE_LONG: fld.type = fldtype_integer; fld.value.integer = g_value_get_long(gval); break; case G_TYPE_INT: fld.type = fldtype_integer; fld.value.integer = g_value_get_int(gval); break; case G_TYPE_ULONG: fld.type = fldtype_unsignd; fld.value.unsignd = g_value_get_ulong(gval); break; case G_TYPE_DOUBLE: fld.type = fldtype_floating; fld.value.floating = g_value_get_double(gval); break; case G_TYPE_UINT64: fld.type = fldtype_time; fld.value.time = g_value_get_uint64(gval); break; default: OHM_ERROR("resource: [%s] Unsupported data type (%d) " "for field '%s'", __FUNCTION__, G_VALUE_TYPE(gval), fld.name); return; } valstr = print_value(fld.type, (void *)&fld.value, valb, sizeof(valb)); OHM_DEBUG(DBG_FS, "field watch point: field '%s:%s' " "changed to '%s'", name, fld.name, valstr); wentry->callback.field_watch(fact, name, &fld,wentry->usrdata); return; } /* if matching_entry */ } /* for */ } /* if find_watch */ }
static gint _gvalues_compare_fixed (const GValue *value1, const GValue *value2) { int ret = 0; switch (G_VALUE_TYPE (value1)) { case G_TYPE_CHAR: { gchar val1 = g_value_get_schar (value1); gchar val2 = g_value_get_schar (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_UCHAR: { guchar val1 = g_value_get_uchar (value1); guchar val2 = g_value_get_uchar (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_BOOLEAN: { gboolean val1 = g_value_get_boolean (value1); gboolean val2 = g_value_get_boolean (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_LONG: { glong val1 = g_value_get_long (value1); glong val2 = g_value_get_long (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_ULONG: { gulong val1 = g_value_get_ulong (value1); gulong val2 = g_value_get_ulong (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_INT: { gint val1 = g_value_get_int (value1); gint val2 = g_value_get_int (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_UINT: { guint val1 = g_value_get_uint (value1); guint val2 = g_value_get_uint (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_INT64: { gint64 val1 = g_value_get_int64 (value1); gint64 val2 = g_value_get_int64 (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_UINT64: { guint64 val1 = g_value_get_uint64 (value1); guint64 val2 = g_value_get_uint64 (value2); if (val1 != val2) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_FLOAT: { gfloat val1 = g_value_get_float (value1); gfloat val2 = g_value_get_float (value2); /* Can't use == or != here due to inexactness of FP */ if (fabsf (val1 - val2) > FLOAT_FACTOR) ret = val1 < val2 ? -1 : val1 > val2; break; } case G_TYPE_DOUBLE: { gdouble val1 = g_value_get_double (value1); gdouble val2 = g_value_get_double (value2); if (fabs (val1 - val2) > FLOAT_FACTOR) ret = val1 < val2 ? -1 : val1 > val2; break; } default: g_warning ("Unhandled fixed size type '%s'", G_VALUE_TYPE_NAME (value1)); } return ret; }
static int is_spurious_event(char *device, int driver, int connected) { /* * Filter out obviously spurious/duplicate events. Spurious events are * events that obviously do not represent any state change (eg. getting * a connected=0 event while already in disconnected state). */ GSList *list; OhmFact *fact; GValue *gval; int val, dmatch, cmatch, spurious = FALSE; OhmFactStore *store; store = ohm_fact_store_get_fact_store(); list = ohm_fact_store_get_facts_by_name(store, FACT_DEVICE_ACCESSIBLE); for ( ; list ; list = list->next) { fact = (OhmFact *)list->data; gval = ohm_fact_get(fact, "name"); if (!gval || G_VALUE_TYPE(gval) != G_TYPE_STRING) continue; if (strcmp(g_value_get_string(gval), device)) continue; if (driver != -1 && (gval = ohm_fact_get(fact, "driver")) != NULL) { switch (G_VALUE_TYPE(gval)) { case G_TYPE_INT: val = g_value_get_int(gval); break; case G_TYPE_UINT: val = g_value_get_uint(gval); break; case G_TYPE_LONG: val = g_value_get_long(gval); break; case G_TYPE_ULONG: val = g_value_get_ulong(gval); break; default: val = driver; /* ignored (ie. match) */ } dmatch = (val == driver); } else dmatch = TRUE; if (connected != -1 && (gval=ohm_fact_get(fact,"connected")) != NULL) { switch (G_VALUE_TYPE(gval)) { case G_TYPE_INT: val = g_value_get_int(gval); break; case G_TYPE_UINT: val = g_value_get_uint(gval); break; case G_TYPE_LONG: val = g_value_get_long(gval); break; case G_TYPE_ULONG: val = g_value_get_ulong(gval); break; default: val = connected; /* ignored (ie. match) */ } cmatch = (val == connected); } else cmatch = TRUE; spurious = dmatch && cmatch; /* no change is a spurious event */ break; } OHM_DEBUG(DBG_INFO, "%s, driver: %d, connected: %d is %sa spurious event", device, driver, connected, spurious ? "" : "not "); return spurious; }
static char * rb_gvalue_array_to_string (GArray *a) { int i; GString *s; if (a == NULL) return strdup (""); s = g_string_new ("("); for (i = 0; i < a->len; i++) { GValue *val; if (i != 0) g_string_append (s, ", "); val = &g_array_index (a, GValue, i); switch (G_VALUE_TYPE (val)) { case G_TYPE_STRING: g_string_append_printf (s, "\"%s\"", g_value_get_string (val)); break; case G_TYPE_BOOLEAN: g_string_append_printf (s, "%d", g_value_get_boolean (val)); break; case G_TYPE_INT: g_string_append_printf (s, "%d", g_value_get_int (val)); break; case G_TYPE_LONG: g_string_append_printf (s, "%ld", g_value_get_long (val)); break; case G_TYPE_ULONG: g_string_append_printf (s, "%lu", g_value_get_ulong (val)); break; case G_TYPE_UINT64: g_string_append_printf (s, "%" G_GUINT64_FORMAT, g_value_get_uint64 (val)); break; case G_TYPE_FLOAT: g_string_append_printf (s, "%f", g_value_get_float (val)); break; case G_TYPE_DOUBLE: g_string_append_printf (s, "%f", g_value_get_double (val)); break; case G_TYPE_POINTER: g_string_append_printf (s, "P:%p", g_value_get_pointer (val)); break; case G_TYPE_BOXED: g_string_append_printf (s, "B:%p", g_value_get_boxed (val)); break; case G_TYPE_OBJECT: g_string_append_printf (s, "O:%p", g_value_get_object (val)); break; default: g_string_append(s, "Unknown"); } } g_string_append_c (s, ')'); return g_string_free (s, FALSE); }
/* Syncs an object property to GConf */ static void prop_binding_sync_prop_to_pref (PropBinding *binding) { GValue value; GConfValue *gconf_value; memset (&value, 0, sizeof (GValue)); g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (binding->prop)); g_object_get_property (binding->object, binding->prop->name, &value); switch (value.g_type) { case G_TYPE_STRING: gconf_value = gconf_value_new (GCONF_VALUE_STRING); gconf_value_set_string (gconf_value, g_value_get_string (&value)); break; case G_TYPE_INT: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_int (&value)); break; case G_TYPE_UINT: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_uint (&value)); break; case G_TYPE_LONG: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_long (&value)); break; case G_TYPE_ULONG: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_ulong (&value)); break; case G_TYPE_INT64: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_int64 (&value)); break; case G_TYPE_UINT64: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_uint64 (&value)); break; case G_TYPE_CHAR: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_char (&value)); break; case G_TYPE_UCHAR: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_uchar (&value)); break; case G_TYPE_ENUM: gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_enum (&value)); break; case G_TYPE_BOOLEAN: gconf_value = gconf_value_new (GCONF_VALUE_BOOL); gconf_value_set_bool (gconf_value, g_value_get_boolean (&value)); break; case G_TYPE_DOUBLE: gconf_value = gconf_value_new (GCONF_VALUE_FLOAT); #ifdef HAVE_CORBA_GCONF /* FIXME we cast to a float explicitly as CORBA GConf * uses doubles in its API, but treats them as floats * when transporting them over CORBA. See #322837 */ gconf_value_set_float (gconf_value, (float) g_value_get_double (&value)); #else gconf_value_set_float (gconf_value, g_value_get_double (&value)); #endif break; case G_TYPE_FLOAT: gconf_value = gconf_value_new (GCONF_VALUE_FLOAT); gconf_value_set_float (gconf_value, g_value_get_float (&value)); break; default: if (g_type_is_a (value.g_type, G_TYPE_ENUM)) { gconf_value = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gconf_value, g_value_get_enum (&value)); } else { g_warning ("prop_binding_sync_prop_to_pref: " "Unhandled value type '%s'.\n", g_type_name (value.g_type)); goto done; } break; } /* Set to GConf */ gconf_client_set (bridge->client, binding->key, gconf_value, NULL); /* Store until change notification comes in, so that we are able * to ignore it */ binding->val_changes = g_slist_append (binding->val_changes, gconf_value); done: g_value_unset (&value); }
static HaskellObj #ifdef GHC_RTS_USES_CAPABILITY gtk2hs_value_as_haskellobj(Capability *cap, const GValue *value) { #else gtk2hs_value_as_haskellobj(const GValue *value) { #endif switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INTERFACE: if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) return rts_mkPtr(CAP g_value_get_object(value)); else break; case G_TYPE_CHAR: return rts_mkChar(CAP g_value_get_char(value)); case G_TYPE_UCHAR: return rts_mkChar(CAP g_value_get_uchar(value)); case G_TYPE_BOOLEAN: return rts_mkBool(CAP g_value_get_boolean(value)); case G_TYPE_INT: return rts_mkInt(CAP g_value_get_int(value)); case G_TYPE_UINT: return rts_mkWord(CAP g_value_get_uint(value)); case G_TYPE_LONG: return rts_mkInt(CAP g_value_get_long(value)); case G_TYPE_ULONG: return rts_mkWord(CAP g_value_get_ulong(value)); /* case G_TYPE_INT64: return rts_mkInt64(CAP g_value_get_int64(value)); case G_TYPE_UINT64: return rts_mkWord64(CAP g_value_get_uint64(value)); */ case G_TYPE_ENUM: return rts_mkInt(CAP g_value_get_enum(value)); case G_TYPE_FLAGS: return rts_mkWord(CAP g_value_get_enum(value)); case G_TYPE_FLOAT: return rts_mkFloat(CAP g_value_get_float(value)); case G_TYPE_DOUBLE: return rts_mkDouble(CAP g_value_get_double(value)); case G_TYPE_STRING: return rts_mkPtr(CAP (char *)g_value_get_string(value)); /* CHECKME: is the string freed? */ case G_TYPE_POINTER: return rts_mkPtr(CAP g_value_get_pointer(value)); case G_TYPE_BOXED: return rts_mkPtr(CAP g_value_get_boxed(value)); /* case G_TYPE_PARAM: return g_value_get_param(value); */ case G_TYPE_OBJECT: return rts_mkPtr(CAP g_value_get_object(value)); } g_error("gtk2hs_value_as_haskellobj: unable to handle GValue with type %s\n" "please report this as a bug to [email protected]", g_type_name(G_VALUE_TYPE(value))); } void gtk2hs_value_from_haskellobj(GValue *value, HaskellObj obj) { switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INVALID: case G_TYPE_NONE: return; case G_TYPE_INTERFACE: /* we only handle interface types that have a GObject prereq */ if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) { g_value_set_object(value, rts_getPtr(obj)); } else { break; } return; case G_TYPE_CHAR: g_value_set_char(value, rts_getChar(obj)); return; case G_TYPE_UCHAR: g_value_set_char(value, rts_getChar(obj)); return; case G_TYPE_BOOLEAN: g_value_set_boolean(value, rts_getBool(obj)); return; case G_TYPE_INT: g_value_set_int(value, rts_getInt(obj)); return; case G_TYPE_UINT: g_value_set_uint(value, rts_getWord(obj)); return; case G_TYPE_LONG: g_value_set_long(value, rts_getInt(obj)); return; case G_TYPE_ULONG: g_value_set_ulong(value, rts_getWord(obj)); return; /* case G_TYPE_INT64: g_value_set_int64(value, rts_getInt64(obj)); return; case G_TYPE_UINT64: g_value_set_uint64(value, rts_getWord64(obj)); return; */ case G_TYPE_ENUM: g_value_set_enum(value, rts_getInt(obj)); return; case G_TYPE_FLAGS: g_value_set_flags(value, rts_getInt(obj)); return; case G_TYPE_FLOAT: g_value_set_float(value, rts_getFloat(obj)); return; case G_TYPE_DOUBLE: g_value_set_double(value, rts_getDouble(obj)); return; case G_TYPE_STRING: g_value_set_string(value, rts_getPtr(obj)); return; case G_TYPE_POINTER: g_value_set_pointer(value, rts_getPtr(obj)); return; /* case G_TYPE_BOXED: { g_value_set_boxed(value, obj); break; } case G_TYPE_PARAM: g_value_set_param(value, (obj)); break; */ case G_TYPE_OBJECT: g_value_set_object(value, rts_getPtr(obj)); return; } g_error("gtk2hs_value_from_haskellobj: unable to handle GValue with type %s\n" "please report this as a bug to [email protected]", g_type_name(G_VALUE_TYPE(value))); }
JsonNode * json_serialize_pspec (const GValue *real_value, GParamSpec *pspec) { JsonNode *retval = NULL; GValue value = { 0, }; JsonNodeType node_type; switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (real_value))) { case G_TYPE_INT64: case G_TYPE_BOOLEAN: case G_TYPE_DOUBLE: /* JSON native types */ retval = json_node_new (JSON_NODE_VALUE); g_value_init (&value, G_VALUE_TYPE (real_value)); g_value_copy (real_value, &value); json_node_set_value (retval, &value); g_value_unset (&value); break; case G_TYPE_STRING: /* strings might be NULL, so we handle it differently */ if (!g_value_get_string (real_value)) retval = json_node_new (JSON_NODE_NULL); else { retval = json_node_new (JSON_NODE_VALUE); json_node_set_string (retval, g_value_get_string (real_value)); break; } break; case G_TYPE_INT: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_int (real_value)); break; case G_TYPE_FLOAT: retval = json_node_new (JSON_NODE_VALUE); json_node_set_double (retval, g_value_get_float (real_value)); break; case G_TYPE_BOXED: if (G_VALUE_HOLDS (real_value, G_TYPE_STRV)) { gchar **strv = g_value_get_boxed (real_value); gint i, strv_len; JsonArray *array; strv_len = g_strv_length (strv); array = json_array_sized_new (strv_len); for (i = 0; i < strv_len; i++) { JsonNode *str = json_node_new (JSON_NODE_VALUE); json_node_set_string (str, strv[i]); json_array_add_element (array, str); } retval = json_node_new (JSON_NODE_ARRAY); json_node_take_array (retval, array); } else if (json_boxed_can_serialize (G_VALUE_TYPE (real_value), &node_type)) { gpointer boxed = g_value_get_boxed (real_value); retval = json_boxed_serialize (G_VALUE_TYPE (real_value), boxed); } else g_warning ("Boxed type '%s' is not handled by JSON-GLib", g_type_name (G_VALUE_TYPE (real_value))); break; case G_TYPE_UINT: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_uint (real_value)); break; case G_TYPE_LONG: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_long (real_value)); break; case G_TYPE_ULONG: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_long (real_value)); break; case G_TYPE_CHAR: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_char (real_value)); break; case G_TYPE_UCHAR: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_uchar (real_value)); break; case G_TYPE_ENUM: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_enum (real_value)); break; case G_TYPE_FLAGS: retval = json_node_new (JSON_NODE_VALUE); json_node_set_int (retval, g_value_get_flags (real_value)); break; case G_TYPE_OBJECT: { GObject *object = g_value_get_object (real_value); if (object != NULL) { retval = json_node_new (JSON_NODE_OBJECT); json_node_take_object (retval, json_gobject_dump (object)); } else retval = json_node_new (JSON_NODE_NULL); } break; case G_TYPE_NONE: retval = json_node_new (JSON_NODE_NULL); break; default: g_warning ("Unsupported type `%s'", g_type_name (G_VALUE_TYPE (real_value))); break; } return retval; }
static GtkCellEditable * parasite_property_cell_renderer_start_editing(GtkCellRenderer *renderer, GdkEvent *event, GtkWidget *widget, const gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags) { PangoFontDescription *font_desc; GtkCellEditable *editable = NULL; GObject *object; const char *name; GValue gvalue = {0}; GParamSpec *prop; g_object_get(renderer, "object", &object, "name", &name, NULL); prop = g_object_class_find_property(G_OBJECT_GET_CLASS(object), name); if (!(prop->flags & G_PARAM_WRITABLE)) return NULL; g_value_init(&gvalue, prop->value_type); g_object_get_property(object, name, &gvalue); if (G_VALUE_HOLDS_ENUM(&gvalue) || G_VALUE_HOLDS_BOOLEAN(&gvalue)) { GtkWidget *combobox = gtk_combo_box_new_text(); gtk_widget_show(combobox); g_object_set(G_OBJECT(combobox), "has-frame", FALSE, NULL); GList *renderers; if (G_VALUE_HOLDS_BOOLEAN(&gvalue)) { gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "FALSE"); gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "TRUE"); gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), g_value_get_boolean(&gvalue) ? 1 : 0); } else if (G_VALUE_HOLDS_ENUM(&gvalue)) { gint value = g_value_get_enum(&gvalue); GEnumClass *enum_class = G_PARAM_SPEC_ENUM(prop)->enum_class; guint i; for (i = 0; i < enum_class->n_values; i++) { GEnumValue *enum_value = &enum_class->values[i]; gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), enum_value->value_name); if (enum_value->value == value) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), i); } } renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(combobox)); g_object_set(G_OBJECT(renderers->data), "scale", TREE_TEXT_SCALE, NULL); g_list_free(renderers); editable = GTK_CELL_EDITABLE(combobox); } else if (G_VALUE_HOLDS_STRING(&gvalue)) { GtkWidget *entry = gtk_entry_new(); gtk_widget_show(entry); gtk_entry_set_text(GTK_ENTRY(entry), g_value_get_string(&gvalue)); editable = GTK_CELL_EDITABLE(entry); } else if (G_VALUE_HOLDS_INT(&gvalue) || G_VALUE_HOLDS_UINT(&gvalue) || G_VALUE_HOLDS_INT64(&gvalue) || G_VALUE_HOLDS_UINT64(&gvalue) || G_VALUE_HOLDS_LONG(&gvalue) || G_VALUE_HOLDS_ULONG(&gvalue) || G_VALUE_HOLDS_DOUBLE(&gvalue)) { double min, max, value; GtkWidget *spinbutton; guint digits = 0; if (G_VALUE_HOLDS_INT(&gvalue)) { GParamSpecInt *paramspec = G_PARAM_SPEC_INT(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_int(&gvalue); } else if (G_VALUE_HOLDS_UINT(&gvalue)) { GParamSpecUInt *paramspec = G_PARAM_SPEC_UINT(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_uint(&gvalue); } else if (G_VALUE_HOLDS_INT64(&gvalue)) { GParamSpecInt64 *paramspec = G_PARAM_SPEC_INT64(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_int64(&gvalue); } else if (G_VALUE_HOLDS_UINT64(&gvalue)) { GParamSpecUInt64 *paramspec = G_PARAM_SPEC_UINT64(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_uint64(&gvalue); } else if (G_VALUE_HOLDS_LONG(&gvalue)) { GParamSpecLong *paramspec = G_PARAM_SPEC_LONG(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_long(&gvalue); } else if (G_VALUE_HOLDS_ULONG(&gvalue)) { GParamSpecULong *paramspec = G_PARAM_SPEC_ULONG(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_ulong(&gvalue); } else if (G_VALUE_HOLDS_DOUBLE(&gvalue)) { GParamSpecDouble *paramspec = G_PARAM_SPEC_DOUBLE(prop); min = paramspec->minimum; max = paramspec->maximum; value = g_value_get_double(&gvalue); digits = 2; } else { // Shouldn't really be able to happen. return NULL; } spinbutton = gtk_spin_button_new_with_range(min, max, 1); gtk_widget_show(spinbutton); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton), value); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spinbutton), digits); editable = GTK_CELL_EDITABLE(spinbutton); } font_desc = pango_font_description_new(); pango_font_description_set_size(font_desc, 8 * PANGO_SCALE); gtk_widget_modify_font(GTK_WIDGET(editable), font_desc); pango_font_description_free(font_desc); g_value_unset(&gvalue); g_signal_connect(G_OBJECT(editable), "editing_done", G_CALLBACK(parasite_property_cell_renderer_stop_editing), renderer); g_object_set_data_full(G_OBJECT(editable), "_prop_name", g_strdup(name), g_free); g_object_set_data(G_OBJECT(editable), "_prop_object", object); return editable; }
static void print_element_properties_info (GstElement * element) { GParamSpec **property_specs; guint num_properties, i; gboolean readable; gboolean first_flag; property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (element), &num_properties); n_print ("\n"); n_print ("Element Properties:\n"); for (i = 0; i < num_properties; i++) { GValue value = { 0, }; GParamSpec *param = property_specs[i]; readable = FALSE; g_value_init (&value, param->value_type); n_print (" %-20s: %s\n", g_param_spec_get_name (param), g_param_spec_get_blurb (param)); first_flag = TRUE; n_print ("%-23.23s flags: ", ""); if (param->flags & G_PARAM_READABLE) { g_object_get_property (G_OBJECT (element), param->name, &value); readable = TRUE; g_print ("%s%s", (first_flag) ? "" : ", ", _("readable")); first_flag = FALSE; } else { /* if we can't read the property value, assume it's set to the default * (which might not be entirely true for sub-classes, but that's an * unlikely corner-case anyway) */ g_param_value_set_default (param, &value); } if (param->flags & G_PARAM_WRITABLE) { g_print ("%s%s", (first_flag) ? "" : ", ", _("writable")); first_flag = FALSE; } if (param->flags & G_PARAM_DEPRECATED) { g_print ("%s%s", (first_flag) ? "" : ", ", _("deprecated")); first_flag = FALSE; } if (param->flags & GST_PARAM_CONTROLLABLE) { g_print (", %s", _("controllable")); first_flag = FALSE; } if (param->flags & GST_PARAM_MUTABLE_PLAYING) { g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state")); } else if (param->flags & GST_PARAM_MUTABLE_PAUSED) { g_print (", %s", _("changeable only in NULL, READY or PAUSED state")); } else if (param->flags & GST_PARAM_MUTABLE_READY) { g_print (", %s", _("changeable only in NULL or READY state")); } if (param->flags & ~KNOWN_PARAM_FLAGS) { g_print ("%s0x%0x", (first_flag) ? "" : ", ", param->flags & ~KNOWN_PARAM_FLAGS); } n_print ("\n"); switch (G_VALUE_TYPE (&value)) { case G_TYPE_STRING: { const char *string_val = g_value_get_string (&value); n_print ("%-23.23s String. ", ""); if (string_val == NULL) g_print ("Default: null"); else g_print ("Default: \"%s\"", string_val); break; } case G_TYPE_BOOLEAN: { gboolean bool_val = g_value_get_boolean (&value); n_print ("%-23.23s Boolean. ", ""); g_print ("Default: %s", bool_val ? "true" : "false"); break; } case G_TYPE_ULONG: { GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param); n_print ("%-23.23s Unsigned Long. ", ""); g_print ("Range: %lu - %lu Default: %lu ", pulong->minimum, pulong->maximum, g_value_get_ulong (&value)); GST_ERROR ("%s: property '%s' of type ulong: consider changing to " "uint/uint64", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); break; } case G_TYPE_LONG: { GParamSpecLong *plong = G_PARAM_SPEC_LONG (param); n_print ("%-23.23s Long. ", ""); g_print ("Range: %ld - %ld Default: %ld ", plong->minimum, plong->maximum, g_value_get_long (&value)); GST_ERROR ("%s: property '%s' of type long: consider changing to " "int/int64", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); break; } case G_TYPE_UINT: { GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param); n_print ("%-23.23s Unsigned Integer. ", ""); g_print ("Range: %u - %u Default: %u ", puint->minimum, puint->maximum, g_value_get_uint (&value)); break; } case G_TYPE_INT: { GParamSpecInt *pint = G_PARAM_SPEC_INT (param); n_print ("%-23.23s Integer. ", ""); g_print ("Range: %d - %d Default: %d ", pint->minimum, pint->maximum, g_value_get_int (&value)); break; } case G_TYPE_UINT64: { GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param); n_print ("%-23.23s Unsigned Integer64. ", ""); g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT " Default: %" G_GUINT64_FORMAT " ", puint64->minimum, puint64->maximum, g_value_get_uint64 (&value)); break; } case G_TYPE_INT64: { GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param); n_print ("%-23.23s Integer64. ", ""); g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT " Default: %" G_GINT64_FORMAT " ", pint64->minimum, pint64->maximum, g_value_get_int64 (&value)); break; } case G_TYPE_FLOAT: { GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param); n_print ("%-23.23s Float. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pfloat->minimum, pfloat->maximum, g_value_get_float (&value)); break; } case G_TYPE_DOUBLE: { GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param); n_print ("%-23.23s Double. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pdouble->minimum, pdouble->maximum, g_value_get_double (&value)); break; } case G_TYPE_CHAR: case G_TYPE_UCHAR: GST_ERROR ("%s: property '%s' of type char: consider changing to " "int/string", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); /* fall through */ default: if (param->value_type == GST_TYPE_CAPS) { const GstCaps *caps = gst_value_get_caps (&value); if (!caps) n_print ("%-23.23s Caps (NULL)", ""); else { print_caps (caps, " "); } } else if (G_IS_PARAM_SPEC_ENUM (param)) { GEnumValue *values; guint j = 0; gint enum_value; const gchar *value_nick = ""; values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values; enum_value = g_value_get_enum (&value); while (values[j].value_name) { if (values[j].value == enum_value) value_nick = values[j].value_nick; j++; } n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick); j = 0; while (values[j].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (%d): %-16s - %s", "", values[j].value, values[j].value_nick, values[j].value_name); j++; } /* g_type_class_unref (ec); */ } else if (G_IS_PARAM_SPEC_FLAGS (param)) { GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param); GFlagsValue *vals; gchar *cur; vals = pflags->flags_class->values; cur = flags_to_string (vals, g_value_get_flags (&value)); n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), g_value_get_flags (&value), cur); while (vals[0].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (0x%08x): %-16s - %s", "", vals[0].value, vals[0].value_nick, vals[0].value_name); ++vals; } g_free (cur); } else if (G_IS_PARAM_SPEC_OBJECT (param)) { n_print ("%-23.23s Object of type \"%s\"", "", g_type_name (param->value_type)); } else if (G_IS_PARAM_SPEC_BOXED (param)) { n_print ("%-23.23s Boxed pointer of type \"%s\"", "", g_type_name (param->value_type)); if (param->value_type == GST_TYPE_STRUCTURE) { const GstStructure *s = gst_value_get_structure (&value); if (s) gst_structure_foreach (s, print_field, (gpointer) " "); } } else if (G_IS_PARAM_SPEC_POINTER (param)) { if (param->value_type != G_TYPE_POINTER) { n_print ("%-23.23s Pointer of type \"%s\".", "", g_type_name (param->value_type)); } else { n_print ("%-23.23s Pointer.", ""); } } else if (param->value_type == G_TYPE_VALUE_ARRAY) { GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param); if (pvarray->element_spec) { n_print ("%-23.23s Array of GValues of type \"%s\"", "", g_type_name (pvarray->element_spec->value_type)); } else { n_print ("%-23.23s Array of GValues", ""); } } else if (GST_IS_PARAM_SPEC_FRACTION (param)) { GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param); n_print ("%-23.23s Fraction. ", ""); g_print ("Range: %d/%d - %d/%d Default: %d/%d ", pfraction->min_num, pfraction->min_den, pfraction->max_num, pfraction->max_den, gst_value_get_fraction_numerator (&value), gst_value_get_fraction_denominator (&value)); } else { n_print ("%-23.23s Unknown type %ld \"%s\"", "", (glong) param->value_type, g_type_name (param->value_type)); } break; } if (!readable) g_print (" Write only\n"); else g_print ("\n"); g_value_reset (&value); } if (num_properties == 0) n_print (" none\n"); g_free (property_specs); }
/* * Signature the prototype of (*GClosureMarshall), meeting the requirements * to be the second argument to g_closure_set_marshal() */ static void bindings_java_marshaller ( GClosure* closure, GValue* return_value, guint n_param_values, const GValue* param_values, gpointer invocation_hint, gpointer marshal_data ) { BindingsJavaClosure* bjc; JNIEnv* env; jvalue* jargs; guint i; GType type; // Return values, as necessary jboolean _b; gboolean b; jint _e; jstring _str; gchar* str; GObject* obj; /* * Begin marshaller by downcasting the GClosure we got. */ bjc = (BindingsJavaClosure*) closure; /* * Get the JNIEnv interface pointer */ env = bindings_java_getEnv(); if (env == NULL) { g_critical("Couldn't get JNIEnv interface, aborting marshal"); return; } /* * Build the parameters for the callback. The signature of the * handlers on the Java side for a signal "name" would be: * * receiveName(Signal handler, type arg0, type arg1, ...) * * Note that arg0 is universally the source object (in otherwords, a * method function where the first argument is always a reference to * self). * * In case you didn't know, JNI's jvalue us a rather complex union * which holds any of the possible things you can send across the * boundary. So we allocate an array of them, then for each parameter * passed to the marshaller, whack them in. */ jargs = g_newa(jvalue, n_param_values + 1); jargs[0].l = bjc->handler; for(i = 0; i < n_param_values; i++) { type = G_VALUE_TYPE(¶m_values[i]); switch(G_TYPE_FUNDAMENTAL(type)) { case G_TYPE_CHAR: jargs[i+1].c = g_value_get_char(¶m_values[i]); break; case G_TYPE_UCHAR: jargs[i+1].c = g_value_get_uchar(¶m_values[i]); break; case G_TYPE_BOOLEAN: b = g_value_get_boolean(¶m_values[i]); jargs[i+1].z = (b == TRUE) ? JNI_TRUE : JNI_FALSE; break; case G_TYPE_INT: jargs[i+1].i = g_value_get_int(¶m_values[i]); break; case G_TYPE_UINT: jargs[i+1].i = g_value_get_uint(¶m_values[i]); break; case G_TYPE_ENUM: jargs[i+1].i = g_value_get_enum(¶m_values[i]); break; case G_TYPE_FLAGS: jargs[i+1].i = g_value_get_flags(¶m_values[i]); break; case G_TYPE_LONG: jargs[i+1].j = g_value_get_long(¶m_values[i]); break; case G_TYPE_ULONG: jargs[i+1].j = g_value_get_ulong(¶m_values[i]); break; case G_TYPE_FLOAT: jargs[i+1].f = g_value_get_float(¶m_values[i]); break; case G_TYPE_DOUBLE: jargs[i+1].d = g_value_get_double(¶m_values[i]); break; case G_TYPE_STRING: jargs[i+1].l = bindings_java_newString(env, g_value_get_string(¶m_values[i])); break; case G_TYPE_OBJECT: case G_TYPE_INTERFACE: /* * GObjects are just pointers, and so we pass up the * address across the boundary to be looked up and * either an existing Proxy returned or a new Proxy * created. */ obj = g_value_get_object(¶m_values[i]); bindings_java_memory_cleanup(obj, FALSE); jargs[i+1].j = (jlong) obj; break; case G_TYPE_BOXED: /* * We make a copy of the GBoxed so that we own it and * thus it can (will) survive the duration of the * signal in the event that the developer using this * code keeps a reference to the returned Boxed. */ jargs[i+1].j = (jlong) g_boxed_copy(type, g_value_get_boxed(¶m_values[i])); break; case G_TYPE_PARAM: /* * We're ignoring GParamSpec at the moment. They * normally only show up in 'notify' signals, and we * don't need them. */ case G_TYPE_POINTER: /* * and, we're ignoring something that gets registered * as a gpointer, by definition it has no type * information and there's nothing we can do. */ jargs[i+1].j = (jlong) NULL; break; default: /* * Unrecognized. Probably means we need to add a clause above. */ g_printerr("Don't know how to marshal a %s", g_type_name(type)); jargs[i+1].l = 0; break; } } /* * And now we invoke the callback on the Java side Signal handler; we have to * select the correct function based on what return type is necessary. */ switch(bjc->returnType) { case 'V': /* * void return signals */ (*env)->CallStaticVoidMethodA(env, bjc->receiver, bjc->method, jargs); break; case 'Z': /* * boolean return signals */ _b = (*env)->CallStaticBooleanMethodA(env, bjc->receiver, bjc->method, jargs); if (_b == JNI_TRUE) { b = TRUE; } else if (_b == JNI_FALSE) { b = FALSE; } else { g_critical("How did you manage to return a boolean that's neither TRUE nor FALSE?"); return; } g_value_set_boolean(return_value, b); break; case 'I': /* * integer return signals */ _e = (*env)->CallStaticIntMethodA(env, bjc->receiver, bjc->method, jargs); g_value_set_int(return_value, _e); break; case 'E': /* * enum return signals */ _e = (*env)->CallStaticIntMethodA(env, bjc->receiver, bjc->method, jargs); g_value_set_enum(return_value, _e); break; case 'L': /* * String return signals * * L is actually Object, of course, but the only type we need to * worry about is java.lang.String encode it for now, and so make the * enormous assumption that a string is what we get back. */ _str = (*env)->CallStaticObjectMethodA(env, bjc->receiver, bjc->method, jargs); if (_str == NULL) { g_warning("Invoking string handler returned null. That's probably bad"); break; } str = (gchar*) bindings_java_getString(env, _str); if (str == NULL) { /* OutOfMemoryError already thrown */ return; } // according to the API docs, this copies the input... g_value_set_string(return_value, str); // ... so we can release str bindings_java_releaseString(str); break; default: /* * If it's not void, boolean or gchar*, then what kind of signal is it? */ g_critical("Invocation for return type %c not implemented", bjc->returnType); break; } /* * Cleanup */ for(i = 0; i < n_param_values; i++) { type = G_VALUE_TYPE(¶m_values[i]); switch(G_TYPE_FUNDAMENTAL(type)) { case G_TYPE_STRING: (*env)->DeleteLocalRef(env, jargs[i+1].l); break; default: break; } } /* * Don't need to free jargs - we alloca()'d it */ /* * Now, check if an exception occurred in the callback. There's a * catch: because we're in native code right now [care of the call to * gtk_main()] the exception gets swallowed until we return from that * native call. So we call the function which causes the main loop to * terminate, with the result that the exception will propegate out * and, yes, probably halt the program. * * This is abrupt, but it is deliberate: we need to force developers * to deal with criticals emitted by the underlying libraries. * Otherwise, the next thing that is likely to happen is a * segmentation fault, and not only does that crash the "program" but * it takes out the Java Virtual Machine running it. People don't * like VM crashes. * * Uncaught exceptions of any kind leaving a signal handler are to be * considered programmer error and will be fatal. */ if ((*env)->ExceptionOccurred(env)) { gtk_main_quit(); } }
/* Pass in the pspec so we can get the generic type. For example, a * held in a GParamSpec allowing OBJECT, but the value could be of type * VipsImage. generics are much faster to compare. */ static unsigned int vips_value_hash( GParamSpec *pspec, GValue *value ) { GType generic = G_PARAM_SPEC_TYPE( pspec ); /* Not compile-time constants, so we have to use a set of if()s. Could * make a table at run time I guess. */ if( generic == G_TYPE_PARAM_BOOLEAN ) return( (unsigned int) g_value_get_boolean( value ) ); else if( generic == G_TYPE_PARAM_CHAR ) return( (unsigned int) VIPS_VALUE_GET_CHAR( value ) ); else if( generic == G_TYPE_PARAM_UCHAR ) return( (unsigned int) g_value_get_uchar( value ) ); else if( generic == G_TYPE_PARAM_INT ) return( (unsigned int) g_value_get_int( value ) ); else if( generic == G_TYPE_PARAM_UINT ) return( (unsigned int) g_value_get_uint( value ) ); else if( generic == G_TYPE_PARAM_LONG ) return( (unsigned int) g_value_get_long( value ) ); else if( generic == G_TYPE_PARAM_ULONG ) return( (unsigned int) g_value_get_ulong( value ) ); else if( generic == G_TYPE_PARAM_ENUM ) return( (unsigned int) g_value_get_enum( value ) ); else if( generic == G_TYPE_PARAM_FLAGS ) return( (unsigned int) g_value_get_flags( value ) ); else if( generic == G_TYPE_PARAM_UINT64 ) { guint64 i = g_value_get_uint64( value ); return( INT64_HASH( (gint64 *) &i ) ); } else if( generic == G_TYPE_PARAM_INT64 ) { gint64 i = g_value_get_int64( value ); return( INT64_HASH( &i ) ); } else if( generic == G_TYPE_PARAM_FLOAT ) { float f = g_value_get_float( value ); return( g_direct_hash( (void *) &f ) ); } else if( generic == G_TYPE_PARAM_DOUBLE ) { double d = g_value_get_double( value ); return( DOUBLE_HASH( &d ) ); } else if( generic == G_TYPE_PARAM_STRING ) { const char *s = g_value_get_string( value ); return( s ? g_str_hash( s ) : 0 ); } else if( generic == G_TYPE_PARAM_BOXED ) { void *p = g_value_get_boxed( value ); return( p ? g_direct_hash( p ) : 0 ); } else if( generic == G_TYPE_PARAM_POINTER ) { void *p = g_value_get_pointer( value ); return( p ? g_direct_hash( p ) : 0 ); } else if( generic == G_TYPE_PARAM_OBJECT ) { void *p = g_value_get_object( value ); return( p ? g_direct_hash( p ) : 0 ); } else { /* Fallback: convert to a string and hash that. * This is very slow, print a warning if we use it * so we can add another case. */ char *s; unsigned int hash; s = g_strdup_value_contents( value ); hash = g_str_hash( s ); printf( "vips_value_hash: no case for %s\n", s ); printf( "\ttype %d, %s\n", (int) G_VALUE_TYPE( value ), g_type_name( G_VALUE_TYPE( value ) ) ); printf( "\tgeneric %d, %s\n", (int) G_VALUE_TYPE( generic ), g_type_name( generic ) ); g_free( s ); return( hash ); } }
static gboolean compare_record_property (DMAPRecord * record, const gchar * property_name, const gchar * property_value) { GParamSpec *pspec; GValue value = { 0, }; /* Note that this string belongs to value and will not be freed explicitely. */ const gchar *str_value; gboolean accept; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (record), property_name); if (pspec == NULL) // Can't find the property in this record, so don't accept it. return FALSE; // Get the property value as a GValue set to the type of this // property. g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec)); g_object_get_property (G_OBJECT (record), property_name, &value); if (G_VALUE_HOLDS_STRING (&value)) { str_value = g_value_get_string (&value); } else if (G_VALUE_HOLDS_BOOLEAN (&value)) { g_debug ("Compare %s (boolean): %d %s", property_name, g_value_get_boolean (&value), property_value); accept = (g_value_get_boolean (&value) && g_strcmp0 (property_value, "1") == 0); g_value_unset (&value); return accept; } else if (g_value_type_transformable (G_VALUE_TYPE (&value), G_TYPE_LONG)) { // Prefer integer conversion. GValue dest = { 0, }; g_value_init (&dest, G_TYPE_LONG); if (!g_value_transform (&value, &dest)) { g_warning ("Failed to convert value into long for property %s", property_name); g_value_unset (&value); return FALSE; } g_debug ("Compare %s (long): %ld %s", property_name, g_value_get_long (&dest), property_value); accept = (g_value_get_long (&dest) == strtol (property_value, NULL, 10)); g_value_unset (&value); return accept; } else if (g_value_type_transformable (G_VALUE_TYPE (&value), G_TYPE_STRING)) { // Use standard transform functions from GLib (note that these // functions are unreliable and known cases should be handled // above). GValue dest; g_value_init (&dest, G_TYPE_STRING); if (!g_value_transform (&value, &dest)) { g_warning ("Failed to convert value into string for property %s", property_name); g_value_unset (&value); return FALSE; } str_value = g_value_dup_string (&dest); g_value_reset (&value); //Sets the string to value so that it will be freed later. g_value_take_string (&value, (gchar *) str_value); g_value_unset (&dest); } else { g_warning ("Attempt to compare unhandled type"); g_value_unset (&value); return FALSE; } // Only arrive here if we are handling strings. g_debug ("Compare %s (string): %s %s", property_name, str_value, property_value); if (str_value != NULL && property_value != NULL && g_ascii_strcasecmp (str_value, property_value) == 0) { accept = TRUE; } else if (str_value == NULL && property_value == NULL) { accept = TRUE; } else { accept = FALSE; } // This will destroy str_value since it belongs to value. g_value_unset (&value); return accept; }
/* Pass in the pspec so we can get the generic type. For example, a * value could be held in a GParamSpec allowing OBJECT, but the value * could be of type VipsImage. generics are much faster to compare. */ static gboolean vips_value_equal( GParamSpec *pspec, GValue *v1, GValue *v2 ) { GType generic = G_PARAM_SPEC_TYPE( pspec ); GType t1 = G_VALUE_TYPE( v1 ); GType t2 = G_VALUE_TYPE( v2 ); if( t1 != t2 ) return( FALSE ); /* Not compile-time constants, so we have to use a set of if()s. Could * make a table at run time I guess. */ if( generic == G_TYPE_PARAM_BOOLEAN ) return( g_value_get_boolean( v1 ) == g_value_get_boolean( v2 ) ); else if( generic == G_TYPE_PARAM_CHAR ) return( VIPS_VALUE_GET_CHAR( v1 ) == VIPS_VALUE_GET_CHAR( v2 ) ); if( generic == G_TYPE_PARAM_UCHAR ) return( g_value_get_uchar( v1 ) == g_value_get_uchar( v2 ) ); if( generic == G_TYPE_PARAM_INT ) return( g_value_get_int( v1 ) == g_value_get_int( v2 ) ); if( generic == G_TYPE_PARAM_UINT ) return( g_value_get_uint( v1 ) == g_value_get_uint( v2 ) ); if( generic == G_TYPE_PARAM_LONG ) return( g_value_get_long( v1 ) == g_value_get_long( v2 ) ); if( generic == G_TYPE_PARAM_ULONG ) return( g_value_get_ulong( v1 ) == g_value_get_ulong( v2 ) ); if( generic == G_TYPE_PARAM_ENUM ) return( g_value_get_enum( v1 ) == g_value_get_enum( v2 ) ); if( generic == G_TYPE_PARAM_FLAGS ) return( g_value_get_flags( v1 ) == g_value_get_flags( v2 ) ); if( generic == G_TYPE_PARAM_UINT64 ) return( g_value_get_uint64( v1 ) == g_value_get_uint64( v2 ) ); if( generic == G_TYPE_PARAM_INT64 ) return( g_value_get_int64( v1 ) == g_value_get_int64( v2 ) ); if( generic == G_TYPE_PARAM_FLOAT ) return( g_value_get_float( v1 ) == g_value_get_float( v2 ) ); if( generic == G_TYPE_PARAM_DOUBLE ) return( g_value_get_double( v1 ) == g_value_get_double( v2 ) ); if( generic == G_TYPE_PARAM_STRING ) { const char *s1 = g_value_get_string( v1 ); const char *s2 = g_value_get_string( v2 ); if( s1 == s2 ) return( TRUE ); else return( s1 && s2 && strcmp( s1, s2 ) == 0 ); } if( generic == G_TYPE_PARAM_BOXED ) return( g_value_get_boxed( v1 ) == g_value_get_boxed( v2 ) ); if( generic == G_TYPE_PARAM_POINTER ) return( g_value_get_pointer( v1 ) == g_value_get_pointer( v2 ) ); if( generic == G_TYPE_PARAM_OBJECT ) return( g_value_get_object( v1 ) == g_value_get_object( v2 ) ); else { /* Fallback: convert to a string and compare that. * This is very slow, print a warning if we use it * so we can add another case. */ char *s1; char *s2; gboolean equal; s1 = g_strdup_value_contents( v1 ); s2 = g_strdup_value_contents( v2 ); equal = strcmp( s1, s2 ) == 0; printf( "vips_value_equal: no case for %s, %s\n", s1, s2 ); printf( "\tt1 %d, %s\n", (int) t1, g_type_name( t1 ) ); printf( "\tt2 %d, %s\n", (int) t2, g_type_name( t2 ) ); printf( "\tgeneric %d, %s\n", (int) G_VALUE_TYPE( generic ), g_type_name( generic ) ); g_free( s1 ); g_free( s2 ); return( equal ); } }
gint _gtk_tree_data_list_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data) { gint column = GPOINTER_TO_INT (user_data); GType type = gtk_tree_model_get_column_type (model, column); GValue a_value = G_VALUE_INIT; GValue b_value = G_VALUE_INIT; gint retval; const gchar *stra, *strb; gtk_tree_model_get_value (model, a, column, &a_value); gtk_tree_model_get_value (model, b, column, &b_value); switch (get_fundamental_type (type)) { case G_TYPE_BOOLEAN: if (g_value_get_boolean (&a_value) < g_value_get_boolean (&b_value)) retval = -1; else if (g_value_get_boolean (&a_value) == g_value_get_boolean (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_CHAR: if (g_value_get_schar (&a_value) < g_value_get_schar (&b_value)) retval = -1; else if (g_value_get_schar (&a_value) == g_value_get_schar (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_UCHAR: if (g_value_get_uchar (&a_value) < g_value_get_uchar (&b_value)) retval = -1; else if (g_value_get_uchar (&a_value) == g_value_get_uchar (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_INT: if (g_value_get_int (&a_value) < g_value_get_int (&b_value)) retval = -1; else if (g_value_get_int (&a_value) == g_value_get_int (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_UINT: if (g_value_get_uint (&a_value) < g_value_get_uint (&b_value)) retval = -1; else if (g_value_get_uint (&a_value) == g_value_get_uint (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_LONG: if (g_value_get_long (&a_value) < g_value_get_long (&b_value)) retval = -1; else if (g_value_get_long (&a_value) == g_value_get_long (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_ULONG: if (g_value_get_ulong (&a_value) < g_value_get_ulong (&b_value)) retval = -1; else if (g_value_get_ulong (&a_value) == g_value_get_ulong (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_INT64: if (g_value_get_int64 (&a_value) < g_value_get_int64 (&b_value)) retval = -1; else if (g_value_get_int64 (&a_value) == g_value_get_int64 (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_UINT64: if (g_value_get_uint64 (&a_value) < g_value_get_uint64 (&b_value)) retval = -1; else if (g_value_get_uint64 (&a_value) == g_value_get_uint64 (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_ENUM: /* this is somewhat bogus. */ if (g_value_get_enum (&a_value) < g_value_get_enum (&b_value)) retval = -1; else if (g_value_get_enum (&a_value) == g_value_get_enum (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_FLAGS: /* this is even more bogus. */ if (g_value_get_flags (&a_value) < g_value_get_flags (&b_value)) retval = -1; else if (g_value_get_flags (&a_value) == g_value_get_flags (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_FLOAT: if (g_value_get_float (&a_value) < g_value_get_float (&b_value)) retval = -1; else if (g_value_get_float (&a_value) == g_value_get_float (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_DOUBLE: if (g_value_get_double (&a_value) < g_value_get_double (&b_value)) retval = -1; else if (g_value_get_double (&a_value) == g_value_get_double (&b_value)) retval = 0; else retval = 1; break; case G_TYPE_STRING: stra = g_value_get_string (&a_value); strb = g_value_get_string (&b_value); if (stra == NULL) stra = ""; if (strb == NULL) strb = ""; retval = g_utf8_collate (stra, strb); break; case G_TYPE_VARIANT: case G_TYPE_POINTER: case G_TYPE_BOXED: case G_TYPE_OBJECT: default: g_warning ("Attempting to sort on invalid type %s\n", g_type_name (type)); retval = FALSE; break; } g_value_unset (&a_value); g_value_unset (&b_value); return retval; }
Data IMInvoker::purpleValueToData(PURPLE_VALUE* value) { Data data; #if LIBPURPLE_VERSION_MAJOR >= 3 if (false) { } else if (g_type_check_value_holds(value, G_TYPE_CHAR)) { data = Data(g_value_get_schar(value), Data::VERBATIM); } else if (g_type_check_value_holds(value, G_TYPE_UCHAR)) { data = Data(g_value_get_uchar(value), Data::VERBATIM); } else if (g_type_check_value_holds(value, G_TYPE_BOOLEAN)) { data = Data(g_value_get_boolean(value)); } else if (g_type_check_value_holds(value, G_TYPE_INT)) { data = Data(g_value_get_int(value)); } else if (g_type_check_value_holds(value, G_TYPE_UINT)) { data = Data(g_value_get_uint(value)); } else if (g_type_check_value_holds(value, G_TYPE_LONG)) { data = Data(g_value_get_long(value)); } else if (g_type_check_value_holds(value, G_TYPE_ULONG)) { data = Data(g_value_get_ulong(value)); } else if (g_type_check_value_holds(value, G_TYPE_INT64)) { data = Data(g_value_get_int64(value)); } else if (g_type_check_value_holds(value, G_TYPE_FLOAT)) { data = Data(g_value_get_float(value)); } else if (g_type_check_value_holds(value, G_TYPE_DOUBLE)) { data = Data(g_value_get_double(value)); } else if (g_type_check_value_holds(value, G_TYPE_STRING)) { const gchar* tmp = g_value_get_string(value); if (tmp == NULL) { data = Data("", Data::VERBATIM); } else { data = Data(g_value_get_string(value), Data::VERBATIM); } } else if (g_type_check_value_holds(value, G_TYPE_OBJECT) || g_type_check_value_holds(value, G_TYPE_PARAM) || g_type_check_value_holds(value, G_TYPE_POINTER) || g_type_check_value_holds(value, G_TYPE_FLAGS) || g_type_check_value_holds(value, G_TYPE_ENUM)) { LOG(ERROR) << "purple thingy not supported"; } else { LOG(ERROR) << "purple thingy unknown"; } #else switch (purple_value_get_type(value)) { case PURPLE_TYPE_BOOLEAN: if (purple_value_get_boolean(value)) data = Data("true"); data = Data("false"); break; case PURPLE_TYPE_STRING: if (purple_value_get_string(value)) { data = Data(purple_value_get_string(value), Data::VERBATIM); } break; case PURPLE_TYPE_CHAR: Data(purple_value_get_char(value)); break; case PURPLE_TYPE_UCHAR: Data(purple_value_get_uchar(value)); break; case PURPLE_TYPE_SHORT: Data(purple_value_get_short(value)); break; case PURPLE_TYPE_USHORT: Data(purple_value_get_ushort(value)); break; case PURPLE_TYPE_INT: Data(purple_value_get_int(value)); break; case PURPLE_TYPE_UINT: Data(purple_value_get_uint(value)); break; case PURPLE_TYPE_LONG: Data(purple_value_get_long(value)); break; case PURPLE_TYPE_ULONG: Data(purple_value_get_ulong(value)); break; case PURPLE_TYPE_INT64: Data(purple_value_get_int64(value)); break; case PURPLE_TYPE_UINT64: Data(purple_value_get_uint64(value)); break; case PURPLE_TYPE_OBJECT: case PURPLE_TYPE_POINTER: case PURPLE_TYPE_ENUM: case PURPLE_TYPE_BOXED: case PURPLE_TYPE_UNKNOWN: case PURPLE_TYPE_SUBTYPE: LOG(ERROR) << "purple thingy not supported"; break; } #endif return data; }