static gboolean gst_base_rtp_depayload_setcaps (GstPad * pad, GstCaps * caps) { GstBaseRTPDepayload *filter; GstBaseRTPDepayloadClass *bclass; GstBaseRTPDepayloadPrivate *priv; gboolean res; GstStructure *caps_struct; const GValue *value; filter = GST_BASE_RTP_DEPAYLOAD (gst_pad_get_parent (pad)); priv = filter->priv; bclass = GST_BASE_RTP_DEPAYLOAD_GET_CLASS (filter); GST_DEBUG_OBJECT (filter, "Set caps"); caps_struct = gst_caps_get_structure (caps, 0); /* get other values for newsegment */ value = gst_structure_get_value (caps_struct, "npt-start"); if (value && G_VALUE_HOLDS_UINT64 (value)) priv->npt_start = g_value_get_uint64 (value); else priv->npt_start = 0; GST_DEBUG_OBJECT (filter, "NPT start %" G_GUINT64_FORMAT, priv->npt_start); value = gst_structure_get_value (caps_struct, "npt-stop"); if (value && G_VALUE_HOLDS_UINT64 (value)) priv->npt_stop = g_value_get_uint64 (value); else priv->npt_stop = -1; GST_DEBUG_OBJECT (filter, "NPT stop %" G_GUINT64_FORMAT, priv->npt_stop); value = gst_structure_get_value (caps_struct, "play-speed"); if (value && G_VALUE_HOLDS_DOUBLE (value)) priv->play_speed = g_value_get_double (value); else priv->play_speed = 1.0; value = gst_structure_get_value (caps_struct, "play-scale"); if (value && G_VALUE_HOLDS_DOUBLE (value)) priv->play_scale = g_value_get_double (value); else priv->play_scale = 1.0; if (bclass->set_caps) res = bclass->set_caps (filter, caps); else res = TRUE; priv->negotiated = res; gst_object_unref (filter); return res; }
double terminal_profile_get_property_double (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_DOUBLE (value), 0.0); if (!value || !G_VALUE_HOLDS_DOUBLE (value)) return 0.0; return g_value_get_double (value); }
static void print_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data) { gint i, num; num = gst_tag_list_get_tag_size (list, tag); for (i = 0; i < num; ++i) { const GValue *val; val = gst_tag_list_get_value_index (list, tag, i); if (G_VALUE_HOLDS_STRING (val)) { g_print (" %s : %s \n", tag, g_value_get_string (val)); } else if (G_VALUE_HOLDS_UINT (val)) { g_print (" %s : %u \n", tag, g_value_get_uint (val)); } else if (G_VALUE_HOLDS_DOUBLE (val)) { g_print (" %s : %g \n", tag, g_value_get_double (val)); } else if (G_VALUE_HOLDS_BOOLEAN (val)) { g_print (" %s : %s \n", tag, g_value_get_boolean (val) ? "true" : "false"); } else if (GST_VALUE_HOLDS_DATE_TIME (val)) { GstDateTime *dt = g_value_get_boxed (val); gchar *dt_str = gst_date_time_to_iso8601_string (dt); g_print (" %s : %s \n", tag, dt_str); g_free (dt_str); } else { g_print (" %s : tag of type '%s' \n", tag, G_VALUE_TYPE_NAME (val)); } } }
static void bbd_pipeline_process_tag (const GstTagList *tag_list, const gchar *tag_name, BansheeBpmDetector *detector) { const GValue *value; gint value_count; double bpm; g_return_if_fail (detector != NULL); if (detector->progress_cb == NULL) { return; } if (strcmp (tag_name, GST_TAG_BEATS_PER_MINUTE)) { return; } value_count = gst_tag_list_get_tag_size (tag_list, tag_name); if (value_count < 1) { return; } value = gst_tag_list_get_value_index (tag_list, tag_name, 0); if (value != NULL && G_VALUE_HOLDS_DOUBLE (value)) { bpm = g_value_get_double (value); detector->progress_cb (bpm); } }
GArray * gimp_dash_pattern_from_value_array (GValueArray *value_array) { if (value_array == NULL || value_array->n_values == 0) { return NULL; } else { GArray *pattern; gint i; pattern = g_array_sized_new (FALSE, FALSE, sizeof (gdouble), value_array->n_values); for (i = 0; i < value_array->n_values; i++) { GValue *item = g_value_array_get_nth (value_array, i); gdouble val; g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (item), NULL); val = g_value_get_double (item); g_array_append_val (pattern, val); } return pattern; } }
void TagExtractor::printOneTag( const GstTagList * list, const gchar * tag, gpointer user_data ) { int i, num; num = gst_tag_list_get_tag_size( list, tag ); for (i = 0; i < num; ++i) { const GValue *val; /* Note: when looking for specific tags, use the gst_tag_list_get_xyz() API, * we only use the GValue approach here because it is more generic */ val = gst_tag_list_get_value_index( list, tag, i ); if( G_VALUE_HOLDS_STRING (val)) { g_print( "\t%20s : %s\n", tag, g_value_get_string( val ) ); } else if( G_VALUE_HOLDS_UINT (val)) { g_print( "\t%20s : %u\n", tag, g_value_get_uint( val ) ); } else if( G_VALUE_HOLDS_DOUBLE (val)) { g_print( "\t%20s : %g\n", tag, g_value_get_double( val ) ); } else if( G_VALUE_HOLDS_BOOLEAN (val)) { g_print( "\t%20s : %s\n", tag, (g_value_get_boolean( val )) ? "true" : "false" ); } else if( GST_VALUE_HOLDS_BUFFER (val)) { GstBuffer *buf = gst_value_get_buffer (val); guint buffer_size = gst_buffer_get_size( buf ); g_print( "\t%20s : buffer of size %u\n", tag, buffer_size ); } else if( GST_VALUE_HOLDS_DATE_TIME (val)) { GstDateTime *dt = (GstDateTime*) g_value_get_boxed( val ); gchar *dt_str = gst_date_time_to_iso8601_string( dt ); g_print( "\t%20s : %s\n", tag, dt_str ); g_free( dt_str ); } else { g_print( "\t%20s : tag of type '%s'\n", tag, G_VALUE_TYPE_NAME (val)); } } }
GArray * gimp_dash_pattern_from_value_array (GimpValueArray *value_array) { if (value_array == NULL || gimp_value_array_length (value_array) == 0) { return NULL; } else { GArray *pattern; gint length; gint i; length = gimp_value_array_length (value_array); pattern = g_array_sized_new (FALSE, FALSE, sizeof (gdouble), length); for (i = 0; i < length; i++) { GValue *item = gimp_value_array_index (value_array, i); gdouble val; g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (item), NULL); val = g_value_get_double (item); g_array_append_val (pattern, val); } return pattern; } }
/** * g_value_get_double: * @value: a valid #GValue of type %G_TYPE_DOUBLE * * Get the contents of a %G_TYPE_DOUBLE #GValue. * * Returns: double contents of @value */ gdouble g_value_get_double (const GValue *value) { g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0); return value->data[0].v_double; }
static gpointer value_as_pointer (GValue *value) { if (g_value_fits_pointer (value)) return g_value_peek_pointer (value); if (G_VALUE_HOLDS_BOOLEAN (value)) return (void*) g_value_get_boolean (value); if (G_VALUE_HOLDS_CHAR (value)) return (void*) (gssize) g_value_get_char (value); if (G_VALUE_HOLDS_UCHAR (value)) return (void*) (gsize) g_value_get_uchar (value); if (G_VALUE_HOLDS_INT (value)) return (void*) g_value_get_int (value); if (G_VALUE_HOLDS_UINT (value)) return (void*) g_value_get_uint (value); if (G_VALUE_HOLDS_LONG (value)) return (void*) g_value_get_long (value); if (G_VALUE_HOLDS_ULONG (value)) return (void*) g_value_get_ulong (value); if (G_VALUE_HOLDS_FLOAT (value)) return (void*) (gssize) g_value_get_float (value); if (G_VALUE_HOLDS_DOUBLE (value)) return (void*) (gssize) g_value_get_double (value); if (G_VALUE_HOLDS_ENUM (value)) return (void*) (gssize) g_value_get_enum (value); if (G_VALUE_HOLDS_FLAGS (value)) return (void*) (gsize) g_value_get_flags (value); return (void*) 0x1373babe; }
/** * g_value_set_double: * @value: a valid #GValue of type %G_TYPE_DOUBLE * @v_double: double value to be set * * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double. */ void g_value_set_double (GValue *value, gdouble v_double) { g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value)); value->data[0].v_double = v_double; }
/** * gdata_freebase_topic_value_get_double: * @value: a #GDataFreebaseTopicValue * * Returns a #gdouble value held in @value. It is only valid to call this if the #GType is a %G_TYPE_DOUBLE * * Returns: the #gdouble value * * Since: 0.15.1 **/ gdouble gdata_freebase_topic_value_get_double (GDataFreebaseTopicValue *value) { g_return_val_if_fail (value != NULL, 0); g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (&value->value), 0); return g_value_get_double (&value->value); }
static void _value_change_handler (AtkObject *obj, AtkPropertyValues *values) { const gchar *type_name = g_type_name (G_TYPE_FROM_INSTANCE (obj)); GValue *value_back, val; value_back = &val; if (!ATK_IS_VALUE (obj)) { return; } if (strcmp (values->property_name, "accessible-value") == 0) { g_print ("_value_change_handler: Accessible Type: %s\n", type_name ? type_name : "NULL"); if(G_VALUE_HOLDS_DOUBLE (&values->new_value)) { g_print( "adjustment value changed : new value: %f\n", g_value_get_double (&values->new_value)); } g_print("Now calling the AtkValue interface functions\n"); atk_value_get_current_value (ATK_VALUE(obj), value_back); g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value_back)); g_print ("atk_value_get_current_value returns %f\n", g_value_get_double (value_back) ); atk_value_get_maximum_value (ATK_VALUE (obj), value_back); g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value_back)); g_print ("atk_value_get_maximum returns %f\n", g_value_get_double (value_back)); atk_value_get_minimum_value (ATK_VALUE (obj), value_back); g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value_back)); g_print ("atk_value_get_minimum returns %f\n", g_value_get_double (value_back)); } }
static GVariant * g_settings_set_mapping_float (const GValue *value, const GVariantType *expected_type) { GVariant *variant = NULL; gdouble d; gint64 l; if (G_VALUE_HOLDS_DOUBLE (value)) d = g_value_get_double (value); else return NULL; l = (gint64) d; if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16)) { if (G_MININT16 <= l && l <= G_MAXINT16) variant = g_variant_new_int16 ((gint16) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16)) { if (0 <= l && l <= G_MAXUINT16) variant = g_variant_new_uint16 ((guint16) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32)) { if (G_MININT32 <= l && l <= G_MAXINT32) variant = g_variant_new_int32 ((gint) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32)) { if (0 <= l && l <= G_MAXUINT32) variant = g_variant_new_uint32 ((guint) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64)) { if (G_MININT64 <= l && l <= G_MAXINT64) variant = g_variant_new_int64 ((gint64) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64)) { if (0 <= l && l <= G_MAXUINT64) variant = g_variant_new_uint64 ((guint64) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE)) { if (0 <= l && l <= G_MAXUINT32) variant = g_variant_new_handle ((guint) l); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double ((gdouble) d); return variant; }
static gdouble get_double (GHashTable *dict, const char *key) { GValue *val; val = g_hash_table_lookup (dict, key); if (val == NULL) { return 0; } if (!G_VALUE_HOLDS_DOUBLE (val)) { return 0; } return g_value_get_double (val); }
static gboolean gimp_controllers_event_mapped (GimpControllerInfo *info, GimpController *controller, const GimpControllerEvent *event, const gchar *action_name, GimpControllerManager *manager) { GtkUIManager *ui_manager = GTK_UI_MANAGER (manager->ui_manager); GList *list; for (list = gtk_ui_manager_get_action_groups (ui_manager); list; list = g_list_next (list)) { GtkActionGroup *group = list->data; GtkAction *action; action = gtk_action_group_get_action (group, action_name); if (action) { switch (event->type) { case GIMP_CONTROLLER_EVENT_VALUE: if (G_VALUE_HOLDS_DOUBLE (&event->value.value) && GIMP_IS_ENUM_ACTION (action) && GIMP_ENUM_ACTION (action)->value_variable) { gdouble value = g_value_get_double (&event->value.value); gimp_enum_action_selected (GIMP_ENUM_ACTION (action), value * 1000); break; } /* else fallthru */ case GIMP_CONTROLLER_EVENT_TRIGGER: default: gtk_action_activate (action); break; } return TRUE; } } return FALSE; }
static gboolean g_settings_get_mapping_unsigned_int (GValue *value, GVariant *variant) { const GVariantType *type; guint64 u; type = g_variant_get_type (variant); if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16)) u = g_variant_get_uint16 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32)) u = g_variant_get_uint32 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64)) u = g_variant_get_uint64 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE)) u = g_variant_get_handle (variant); else return FALSE; if (G_VALUE_HOLDS_INT (value)) { g_value_set_int (value, u); return (u <= G_MAXINT32); } else if (G_VALUE_HOLDS_UINT (value)) { g_value_set_uint (value, u); return (u <= G_MAXUINT32); } else if (G_VALUE_HOLDS_INT64 (value)) { g_value_set_int64 (value, u); return (u <= G_MAXINT64); } else if (G_VALUE_HOLDS_UINT64 (value)) { g_value_set_uint64 (value, u); return (u <= G_MAXUINT64); } else if (G_VALUE_HOLDS_DOUBLE (value)) { g_value_set_double (value, u); return TRUE; } return FALSE; }
double AccessibilityUIElement::maxValue() { GValue value = { 0, { { 0 } } }; if (!ATK_IS_VALUE(m_element)) return 0.0f; atk_value_get_maximum_value(ATK_VALUE(m_element), &value); if (G_VALUE_HOLDS_DOUBLE(&value)) return g_value_get_double(&value); else if (G_VALUE_HOLDS_INT(&value)) return static_cast<double>(g_value_get_int(&value)); else return 0.0f; }
static gboolean g_settings_get_mapping_int (GValue *value, GVariant *variant) { const GVariantType *type; gint64 l; type = g_variant_get_type (variant); if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16)) l = g_variant_get_int16 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32)) l = g_variant_get_int32 (variant); else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64)) l = g_variant_get_int64 (variant); else return FALSE; if (G_VALUE_HOLDS_INT (value)) { g_value_set_int (value, l); return (G_MININT32 <= l && l <= G_MAXINT32); } else if (G_VALUE_HOLDS_UINT (value)) { g_value_set_uint (value, l); return (0 <= l && l <= G_MAXUINT32); } else if (G_VALUE_HOLDS_INT64 (value)) { g_value_set_int64 (value, l); return (G_MININT64 <= l && l <= G_MAXINT64); } else if (G_VALUE_HOLDS_UINT64 (value)) { g_value_set_uint64 (value, l); return (0 <= l && l <= G_MAXUINT64); } else if (G_VALUE_HOLDS_DOUBLE (value)) { g_value_set_double (value, l); return TRUE; } return FALSE; }
static gdouble gimp_pdb_progress_run_callback (GimpPdbProgress *progress, GimpProgressCommand command, const gchar *text, gdouble value) { gdouble retval = 0; if (progress->callback_name && ! progress->callback_busy) { GimpValueArray *return_vals; progress->callback_busy = TRUE; return_vals = gimp_pdb_execute_procedure_by_name (progress->pdb, progress->context, NULL, NULL, progress->callback_name, GIMP_TYPE_INT32, command, G_TYPE_STRING, text, G_TYPE_DOUBLE, value, G_TYPE_NONE); if (g_value_get_enum (gimp_value_array_index (return_vals, 0)) != GIMP_PDB_SUCCESS) { gimp_message (progress->context->gimp, NULL, GIMP_MESSAGE_ERROR, _("Unable to run %s callback. " "The corresponding plug-in may have crashed."), g_type_name (G_TYPE_FROM_INSTANCE (progress))); } else if (gimp_value_array_length (return_vals) >= 2 && G_VALUE_HOLDS_DOUBLE (gimp_value_array_index (return_vals, 1))) { retval = g_value_get_double (gimp_value_array_index (return_vals, 1)); } gimp_value_array_unref (return_vals); progress->callback_busy = FALSE; } return retval; }
static gboolean gail_scale_button_set_current_value (AtkValue *obj, const GValue *value) { GtkWidget *gtk_widget; g_return_val_if_fail (GAIL_IS_SCALE_BUTTON (obj), FALSE); gtk_widget = GTK_ACCESSIBLE (obj)->widget; if (gtk_widget == NULL) return FALSE; if (G_VALUE_HOLDS_DOUBLE (value)) { gtk_scale_button_set_value (GTK_SCALE_BUTTON (gtk_widget), g_value_get_double (value)); return TRUE; } return FALSE; }
static void _set_values (AtkObject *obj) { GValue *value_back, val; static gint count = 0; gdouble double_value; value_back = &val; if(ATK_IS_VALUE(obj)) { /* Spin button also inherits the text interfaces from GailEntry. * Check when spin button recieves focus. */ if(ATK_IS_TEXT(obj) && ATK_IS_EDITABLE_TEXT(obj)) { if(count == 0) { gint x; gchar* text; count++; x = atk_text_get_character_count (ATK_TEXT (obj)); text = atk_text_get_text (ATK_TEXT (obj), 0, x); g_print("Text : %s\n", text); text = "5.7"; atk_editable_text_set_text_contents(ATK_EDITABLE_TEXT(obj),text); g_print("Set text to %s\n",text); atk_value_get_current_value(ATK_VALUE(obj), value_back); g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value_back)); g_print("atk_value_get_current_value returns %f\n", g_value_get_double( value_back)); } } else { memset (value_back, 0, sizeof (GValue)); g_value_init (value_back, G_TYPE_DOUBLE); g_value_set_double (value_back, 10.0); if (atk_value_set_current_value (ATK_VALUE (obj), value_back)) { double_value = g_value_get_double (value_back); g_print("atk_value_set_current_value returns %f\n", double_value); } } } }
static void print_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data) { int i, num; num = gst_tag_list_get_tag_size (list, tag); for (i = 0; i < num; ++i) { const GValue *val; /* Note: when looking for specific tags, use the g_tag_list_get_xyz() API, * we only use the GValue approach here because it is more generic */ val = gst_tag_list_get_value_index (list, tag, i); if (G_VALUE_HOLDS_STRING (val)) { const char* unformatted = g_value_get_string (val); gchar* formatted = strescape(unformatted,"\"","\""); g_print ("(%s . \"%s\")\n", tag, formatted); g_free(formatted); } else if (G_VALUE_HOLDS_UINT (val)) { unsigned int uint = g_value_get_uint (val); if(uint > 0xf) g_print ("(%s . #x%x)\n", tag, uint); } else if (G_VALUE_HOLDS_DOUBLE (val)) { g_print ("(%s . %g)\n", tag, g_value_get_double (val)); } else if (G_VALUE_HOLDS_BOOLEAN (val)) { g_print ("(%s . %s)\n", tag, (g_value_get_boolean (val)) ? "#t" : "#f"); } else if (GST_VALUE_HOLDS_BUFFER (val)) { g_print ("(%s . (buffer %u))", tag, gst_buffer_get_size(gst_value_get_buffer (val))); } else if (GST_VALUE_HOLDS_DATE_TIME (val)) { GDate* date = (GDate*)g_value_get_boxed(val); g_print ("(%s . (date 0 0 0 %u %u %u))\n", tag, g_date_get_day(date), g_date_get_month(date), g_date_get_year (date)); } else { g_print ("(%20s . (type %s))", tag, G_VALUE_TYPE_NAME (val)); } } }
static void print_value (GValue *value) { if (G_VALUE_HOLDS_STRING (value)) printf ("%s", g_value_get_string (value)); else if (G_VALUE_HOLDS_INT (value)) printf ("%d", g_value_get_int (value)); else if (G_VALUE_HOLDS_DOUBLE (value)) printf ("%f", g_value_get_double (value)); else if (G_VALUE_TYPE (value) == G_TYPE_VALUE_ARRAY) { GValueArray *array = g_value_get_boxed (value); int i; printf ("[ "); for (i = 0; i < array->n_values; i++) { if (i != 0) printf (", "); print_value (&array->values[i]); } printf (" ]"); } else printf ("(%s)", g_type_name (G_VALUE_TYPE (value))); }
static void _do_test(AtkObject *obj) { int child_count = 0; child_count = atk_object_get_n_accessible_children(obj); g_assert(child_count == 2); _printf("n_accessible_children - done\n"); AtkStateSet *state_set = atk_object_ref_state_set(obj); gboolean v_contains = atk_state_set_contains_state(state_set, ATK_STATE_VERTICAL); gboolean h_contains = atk_state_set_contains_state(state_set, ATK_STATE_HORIZONTAL); g_object_unref(state_set); g_assert(v_contains || h_contains); _printf("ref_state_set - done\n"); /*AtkValue iface tests*/ g_assert(ATK_IS_VALUE(obj)); GValue value = G_VALUE_INIT; double d_value; atk_value_get_maximum_value(ATK_VALUE(obj), &value); d_value = g_value_get_double(&value); g_assert(d_value == 1.0); atk_value_get_minimum_value(ATK_VALUE(obj), &value); d_value = g_value_get_double(&value); g_assert(d_value == 0.0); g_value_set_double(&value, 0.3); gboolean success = atk_value_set_current_value(ATK_VALUE(obj), &value); g_assert(success); atk_value_get_current_value(ATK_VALUE(obj), &value); g_assert(G_VALUE_HOLDS_DOUBLE(&value)); d_value = g_value_get_double(&value); g_assert(d_value == 0.3); _printf("atk_value - done\n"); eailu_test_atk_focus(obj, TRUE); }
static gboolean string_to_num (GBinding *binding, const GValue *source_value, GValue *target_value, gpointer userdata) { if (G_VALUE_HOLDS_INT (target_value)) g_value_set_int (target_value, atoi (g_value_get_string (source_value))); else if (G_VALUE_HOLDS_UINT (target_value)) g_value_set_uint (target_value, atoi (g_value_get_string (source_value))); else if (G_VALUE_HOLDS_DOUBLE (target_value)) g_value_set_double (target_value, strtod (g_value_get_string (source_value), NULL)); else if (G_VALUE_HOLDS_FLOAT (target_value)) g_value_set_float (target_value, strtof (g_value_get_string (source_value), NULL)); else return FALSE; return TRUE; }
static gboolean num_to_string (GBinding *binding, const GValue *source_value, GValue *target_value, gpointer userdata) { gchar *string; if (G_VALUE_HOLDS_INT (source_value)) string = g_strdup_printf ("%d", g_value_get_int (source_value)); else if (G_VALUE_HOLDS_UINT (source_value)) string = g_strdup_printf ("%d", g_value_get_uint (source_value)); else if (G_VALUE_HOLDS_DOUBLE (source_value)) string = g_strdup_printf ("%.2f", g_value_get_double (source_value)); else if (G_VALUE_HOLDS_FLOAT (source_value)) string = g_strdup_printf ("%.2f", g_value_get_float (source_value)); else return FALSE; g_value_take_string (target_value, string); return TRUE; }
/** * Implements * org.gnome.glib.GValue.g_value_get_double(long value) * called from * org.gnome.glib.GValue.getDouble(Value value) * called from * org.gnome.glib.Object.getPropertyDouble(String name) * * Extract the gdoulbe value from a GValue of G_TYPE_DOUBLE, returning the * primitive. */ JNIEXPORT jdouble JNICALL Java_org_gnome_glib_GValue_g_1value_1get_1double ( JNIEnv* env, jclass cls, jlong _value ) { GValue* value; gdouble result; // translate value value = (GValue*) _value; if (!G_VALUE_HOLDS_DOUBLE(value)) { bindings_java_throw(env, "You've asked for the double value of a GValue, but it's not a G_TYPE_DOUBLE!"); return 0.0; } // call function result = g_value_get_double(value); // and return return (jdouble) result; }
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 gboolean gst_rdt_depay_setcaps (GstPad * pad, GstCaps * caps) { GstStructure *structure; GstRDTDepay *rdtdepay; GstCaps *srccaps; gint clock_rate = 1000; /* default */ const GValue *value; GstBuffer *header; rdtdepay = GST_RDT_DEPAY (GST_PAD_PARENT (pad)); structure = gst_caps_get_structure (caps, 0); if (gst_structure_has_field (structure, "clock-rate")) gst_structure_get_int (structure, "clock-rate", &clock_rate); /* config contains the RealMedia header as a buffer. */ value = gst_structure_get_value (structure, "config"); if (!value) goto no_header; header = gst_value_get_buffer (value); if (!header) goto no_header; /* get other values for newsegment */ value = gst_structure_get_value (structure, "npt-start"); if (value && G_VALUE_HOLDS_UINT64 (value)) rdtdepay->npt_start = g_value_get_uint64 (value); else rdtdepay->npt_start = 0; GST_DEBUG_OBJECT (rdtdepay, "NPT start %" G_GUINT64_FORMAT, rdtdepay->npt_start); value = gst_structure_get_value (structure, "npt-stop"); if (value && G_VALUE_HOLDS_UINT64 (value)) rdtdepay->npt_stop = g_value_get_uint64 (value); else rdtdepay->npt_stop = -1; GST_DEBUG_OBJECT (rdtdepay, "NPT stop %" G_GUINT64_FORMAT, rdtdepay->npt_stop); value = gst_structure_get_value (structure, "play-speed"); if (value && G_VALUE_HOLDS_DOUBLE (value)) rdtdepay->play_speed = g_value_get_double (value); else rdtdepay->play_speed = 1.0; value = gst_structure_get_value (structure, "play-scale"); if (value && G_VALUE_HOLDS_DOUBLE (value)) rdtdepay->play_scale = g_value_get_double (value); else rdtdepay->play_scale = 1.0; /* caps seem good, configure element */ rdtdepay->clock_rate = clock_rate; /* set caps on pad and on header */ srccaps = gst_caps_new_empty_simple ("application/vnd.rn-realmedia"); gst_pad_set_caps (rdtdepay->srcpad, srccaps); gst_caps_unref (srccaps); if (rdtdepay->header) gst_buffer_unref (rdtdepay->header); rdtdepay->header = gst_buffer_ref (header); return TRUE; /* ERRORS */ no_header: { GST_ERROR_OBJECT (rdtdepay, "no header found in caps, no 'config' field"); return FALSE; } }
static gboolean gimp_controller_info_event (GimpController *controller, const GimpControllerEvent *event, GimpControllerInfo *info) { const gchar *event_name; const gchar *event_blurb; const gchar *action_name = NULL; event_name = gimp_controller_get_event_name (controller, event->any.event_id); event_blurb = gimp_controller_get_event_blurb (controller, event->any.event_id); if (info->debug_events) { g_print ("Received '%s' (class '%s')\n" " controller event '%s (%s)'\n", controller->name, GIMP_CONTROLLER_GET_CLASS (controller)->name, event_name, event_blurb); switch (event->any.type) { case GIMP_CONTROLLER_EVENT_TRIGGER: g_print (" (trigger event)\n"); break; case GIMP_CONTROLLER_EVENT_VALUE: if (G_VALUE_HOLDS_DOUBLE (&event->value.value)) g_print (" (value event, value = %f)\n", g_value_get_double (&event->value.value)); else g_print (" (value event, unhandled type '%s')\n", g_type_name (event->value.value.g_type)); break; } } if (info->snooper) { if (info->snooper (info, controller, event, info->snooper_data)) { if (info->debug_events) g_print (" intercepted by event snooper\n\n"); return TRUE; } } if (! info->enabled) { if (info->debug_events) g_print (" ignoring because controller is disabled\n\n"); return FALSE; } if (info->mapping) action_name = g_hash_table_lookup (info->mapping, event_name); if (action_name) { gboolean retval = FALSE; if (info->debug_events) g_print (" maps to action '%s'\n", action_name); g_signal_emit (info, info_signals[EVENT_MAPPED], 0, controller, event, action_name, &retval); if (info->debug_events) { if (retval) g_print (" action was found\n\n"); else g_print (" action NOT found\n\n"); } return retval; } else { if (info->debug_events) g_print (" doesn't map to action\n\n"); } return FALSE; }