static void modem_properties_changed (DBusGProxy *proxy, const char *interface, GHashTable *props, gpointer user_data) { Modem *modem = user_data; GValue *value; gboolean old_avail = modem->enabled && modem->loc_enabled && modem->has_location; gboolean new_avail; if (strcmp (interface, MM_DBUS_MODEM_INTERFACE) == 0) { value = g_hash_table_lookup (props, "Enabled"); if (value && G_VALUE_HOLDS_BOOLEAN (value)) { modem->enabled = g_value_get_boolean (value); modem->got_enabled = TRUE; debugmsg ("%s: (%s) modem %s", __func__, modem->path, modem->enabled ? "enabled" : "disabled"); } } else if (strcmp (interface, MM_DBUS_LOC_INTERFACE) == 0) { value = g_hash_table_lookup (props, "Enabled"); if (value && G_VALUE_HOLDS_BOOLEAN (value)) { modem->loc_enabled = g_value_get_boolean (value); modem->got_loc_enabled = TRUE; debugmsg ("%s: (%s) modem location services %s", __func__, modem->path, modem->loc_enabled ? "enabled" : "disabled"); } value = g_hash_table_lookup (props, "SignalsLocation"); if (value && G_VALUE_HOLDS_BOOLEAN (value)) { modem->signals = g_value_get_boolean (value); debugmsg ("%s: (%s) modem %s signal location updates", __func__, modem->path, modem->signals ? "will" : "does not"); } value = g_hash_table_lookup (props, "Capabilities"); if (value && G_VALUE_HOLDS_UINT (value)) { debugmsg ("%s: (%s) modem location capabilities: 0x%X", __func__, modem->path, g_value_get_uint (value)); if (g_value_get_uint (value) & LOC_CAP_GSM_LACCI) modem->has_location = TRUE; } value = g_hash_table_lookup (props, "Location"); if (value && G_VALUE_HOLDS_BOXED (value)) modem_location_update (modem, (GHashTable *) g_value_get_boxed (value)); } new_avail = modem->enabled && modem->loc_enabled && modem->has_location; /* If the modem doesn't signal its location, start polling for the * location now. */ if (new_avail && !modem->signals && !modem->loc_idle) { modem->loc_idle = g_timeout_add_seconds (20, modem_loc_poll, modem); /* Kick off a quick location request */ modem_loc_poll (modem); } /* If the modem is no longer enabled, or it now signals its location * then we no longer need to poll. */ if ((!new_avail || modem->signals) && modem->loc_idle) g_source_remove (modem->loc_idle); /* Tell the manager to recheck availability of location info */ if (old_avail != new_avail) recheck_available (modem->owner); /* If we've successfully retrieved modem properties and the modem * isn't enabled, do that now. */ if (modem->got_enabled && !modem->enabled && !modem->enabling) { debugmsg ("%s: (%s) enabling...", __func__, modem->path); modem->enabling = TRUE; dbus_g_proxy_begin_call (modem->modem_proxy, "Enable", modem_enable_cb, modem, NULL, G_TYPE_BOOLEAN, TRUE, G_TYPE_INVALID); } /* If the modem was already enabled but location services weren't, * enable them now. */ modem_try_loc_enable (modem); /* After location is enabled, try to get the location ASAP */ if (modem->has_location && modem->loc_enabled && !modem->got_initial_loc) { modem->got_initial_loc = TRUE; modem_loc_poll (modem); } }
/** * tp_cm_param_setter_offset: * @paramspec: A parameter specification with offset set to some * meaningful value. * @value: The value for that parameter, either provided by the user or * constructed from the parameter's default. * @params: An opaque data structure such that the address at (@params + * @paramspec->offset) is a valid pointer to a variable of the * appropriate type. * * A #TpCMParamSetter which sets parameters by dereferencing an offset * from @params. If @paramspec->offset is G_MAXSIZE, the parameter is * deemed obsolete, and is accepted but ignored. * * Since: 0.7.0 */ void tp_cm_param_setter_offset (const TpCMParamSpec *paramspec, const GValue *value, gpointer params) { char *params_mem = params; if (paramspec->offset == G_MAXSIZE) { /* quietly ignore any obsolete params provided */ return; } switch (paramspec->dtype[0]) { case DBUS_TYPE_STRING: { gchar **save_to = (gchar **) (params_mem + paramspec->offset); const gchar *str; g_assert (paramspec->gtype == G_TYPE_STRING); str = g_value_get_string (value); g_free (*save_to); if (str == NULL) { *save_to = g_strdup (""); } else { *save_to = g_value_dup_string (value); } if (DEBUGGING) { if (strstr (paramspec->name, "password") != NULL) DEBUG ("%s = <hidden>", paramspec->name); else DEBUG ("%s = \"%s\"", paramspec->name, *save_to); } } break; case DBUS_TYPE_INT16: case DBUS_TYPE_INT32: { gint *save_to = (gint *) (params_mem + paramspec->offset); gint i = g_value_get_int (value); g_assert (paramspec->gtype == G_TYPE_INT); *save_to = i; DEBUG ("%s = %d = 0x%x", paramspec->name, i, i); } break; case DBUS_TYPE_UINT16: case DBUS_TYPE_UINT32: { guint *save_to = (guint *) (params_mem + paramspec->offset); guint i = g_value_get_uint (value); g_assert (paramspec->gtype == G_TYPE_UINT); *save_to = i; DEBUG ("%s = %u = 0x%x", paramspec->name, i, i); } break; case DBUS_TYPE_INT64: { gint64 *save_to = (gint64 *) (params_mem + paramspec->offset); gint64 i = g_value_get_int64 (value); g_assert (paramspec->gtype == G_TYPE_INT64); *save_to = i; DEBUG ("%s = %" G_GINT64_FORMAT, paramspec->name, i); } break; case DBUS_TYPE_UINT64: { guint64 *save_to = (guint64 *) (params_mem + paramspec->offset); guint64 i = g_value_get_uint64 (value); g_assert (paramspec->gtype == G_TYPE_UINT64); *save_to = i; DEBUG ("%s = %" G_GUINT64_FORMAT, paramspec->name, i); } break; case DBUS_TYPE_DOUBLE: { gdouble *save_to = (gdouble *) (params_mem + paramspec->offset); gdouble i = g_value_get_double (value); g_assert (paramspec->gtype == G_TYPE_DOUBLE); *save_to = i; DEBUG ("%s = %f", paramspec->name, i); } break; case DBUS_TYPE_OBJECT_PATH: { gchar **save_to = (gchar **) (params_mem + paramspec->offset); g_assert (paramspec->gtype == DBUS_TYPE_G_OBJECT_PATH); g_free (*save_to); *save_to = g_value_dup_boxed (value); DEBUG ("%s = \"%s\"", paramspec->name, *save_to); } break; case DBUS_TYPE_BOOLEAN: { gboolean *save_to = (gboolean *) (params_mem + paramspec->offset); gboolean b = g_value_get_boolean (value); g_assert (paramspec->gtype == G_TYPE_BOOLEAN); g_assert (b == TRUE || b == FALSE); *save_to = b; DEBUG ("%s = %s", paramspec->name, b ? "TRUE" : "FALSE"); } break; case DBUS_TYPE_ARRAY: switch (paramspec->dtype[1]) { case DBUS_TYPE_STRING: { GStrv *save_to = (GStrv *) (params_mem + paramspec->offset); g_strfreev (*save_to); *save_to = g_value_dup_boxed (value); if (DEBUGGING) { gchar *joined = g_strjoinv (", ", *save_to); DEBUG ("%s = [%s]", paramspec->name, joined); g_free (joined); } } break; case DBUS_TYPE_BYTE: { GArray **save_to = (GArray **) (params_mem + paramspec->offset); if (*save_to != NULL) { g_array_unref (*save_to); } *save_to = g_value_dup_boxed (value); DEBUG ("%s = ...[%u]", paramspec->name, (*save_to)->len); } break; default: ERROR ("encountered unhandled D-Bus array type %s on " "argument %s", paramspec->dtype, paramspec->name); g_assert_not_reached (); } break; default: ERROR ("encountered unhandled D-Bus type %s on argument %s", paramspec->dtype, paramspec->name); g_assert_not_reached (); } }
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; }
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 foreach_property_cb (gpointer key, gpointer value, gpointer user_data) { GValue *variant = (GValue *) value; NMAccessPoint *ap = (NMAccessPoint *) user_data; if (G_VALUE_HOLDS_BOXED (variant)) { GArray *array = g_value_get_boxed (variant); if (!strcmp (key, "ssid")) { guint32 len = MIN (IW_ESSID_MAX_SIZE, array->len); GByteArray * ssid; /* Stupid ieee80211 layer uses <hidden> */ if (((len == 8) || (len == 9)) && (memcmp (array->data, "<hidden>", 8) == 0)) return; if (nm_utils_is_empty_ssid ((const guint8 *) array->data, len)) return; ssid = g_byte_array_sized_new (len); g_byte_array_append (ssid, (const guint8 *) array->data, len); nm_ap_set_ssid (ap, ssid); g_byte_array_free (ssid, TRUE); } else if (!strcmp (key, "bssid")) { struct ether_addr addr; if (array->len != ETH_ALEN) return; memset (&addr, 0, sizeof (struct ether_addr)); memcpy (&addr, array->data, ETH_ALEN); nm_ap_set_address (ap, &addr); } else if (!strcmp (key, "wpaie")) { guint8 * ie = (guint8 *) array->data; guint32 flags = nm_ap_get_wpa_flags (ap); if (array->len <= 0 || array->len > WPA_MAX_IE_LEN) return; flags = nm_ap_add_security_from_ie (flags, ie, array->len); nm_ap_set_wpa_flags (ap, flags); } else if (!strcmp (key, "rsnie")) { guint8 * ie = (guint8 *) array->data; guint32 flags = nm_ap_get_rsn_flags (ap); if (array->len <= 0 || array->len > WPA_MAX_IE_LEN) return; flags = nm_ap_add_security_from_ie (flags, ie, array->len); nm_ap_set_rsn_flags (ap, flags); } } else if (G_VALUE_HOLDS_INT (variant)) { gint32 int_val = g_value_get_int (variant); if (!strcmp (key, "frequency")) { nm_ap_set_freq (ap, (guint32) int_val); } else if (!strcmp (key, "maxrate")) { /* Supplicant reports as b/s, we use Kb/s internally */ nm_ap_set_max_bitrate (ap, int_val / 1000); } } else if (G_VALUE_HOLDS_UINT (variant)) { guint32 val = g_value_get_uint (variant); if (!strcmp (key, "capabilities")) { if (val & IEEE80211_CAP_ESS) { nm_ap_set_mode (ap, NM_802_11_MODE_INFRA); } else if (val & IEEE80211_CAP_IBSS) { nm_ap_set_mode (ap, NM_802_11_MODE_ADHOC); } if (val & IEEE80211_CAP_PRIVACY) { guint32 flags = nm_ap_get_flags (ap); nm_ap_set_flags (ap, flags | NM_802_11_AP_FLAGS_PRIVACY); } } } }
static void modem_get_all_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { NmaBtDevice *self = NMA_BT_DEVICE (user_data); NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self); const char *path; GHashTable *properties = NULL; GError *error = NULL; GValue *value; NMDeviceType devtype = NM_DEVICE_TYPE_UNKNOWN; path = dbus_g_proxy_get_path (proxy); g_message ("%s: (%s) processing GetAll reply", __func__, path); if (!dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_MAP_OF_VARIANT, &properties, G_TYPE_INVALID)) { g_warning ("%s: (%s) Error getting modem properties: (%d) %s", __func__, path, error ? error->code : -1, (error && error->message) ? error->message : "(unknown)"); g_error_free (error); goto out; } /* check whether this is the device we care about */ value = g_hash_table_lookup (properties, "Device"); if (value && G_VALUE_HOLDS_STRING (value) && g_value_get_string (value)) { char *iface_basename = g_path_get_basename (priv->rfcomm_iface); const char *modem_iface = g_value_get_string (value); if (strcmp (iface_basename, modem_iface) == 0) { /* yay, found it! */ value = g_hash_table_lookup (properties, "Type"); if (value && G_VALUE_HOLDS_UINT (value)) { switch (g_value_get_uint (value)) { case 1: devtype = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS; break; case 2: devtype = NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO; break; default: g_message ("%s: (%s) unknown modem type", __func__, path); break; } } } else { g_message ("%s: (%s) (%s) not the modem we're looking for (%s)", __func__, path, modem_iface, iface_basename); } g_free (iface_basename); } else g_message ("%s: (%s) modem had no 'Device' property", __func__, path); g_hash_table_unref (properties); /* Launch wizard! */ start_wizard (self, path, devtype); out: g_message ("%s: finished", __func__); }
void ags_libao_set_property(GObject *gobject, guint prop_id, const GValue *value, GParamSpec *param_spec) { AgsLibao *libao; libao = AGS_LIBAO(gobject); //TODO:JK: implement set functionality switch(prop_id) { case PROP_APPLICATION_CONTEXT: { AgsApplicationContext *application_context; application_context = g_value_get_object(value); if(libao->application_context == application_context) { return; } if(libao->application_context != NULL) { g_object_unref(G_OBJECT(libao->application_context)); } if(application_context != NULL) { g_object_ref(G_OBJECT(application_context)); } libao->application_context = application_context; } break; case PROP_DEVICE: { char *device; device = (char *) g_value_get_string(value); if((AGS_LIBAO_LIBAO & (libao->flags)) != 0) { //TODO:JK: implement me } } break; case PROP_DSP_CHANNELS: { guint dsp_channels; dsp_channels = g_value_get_uint(value); if(dsp_channels == libao->dsp_channels) { return; } libao->dsp_channels = dsp_channels; } break; case PROP_PCM_CHANNELS: { guint pcm_channels; pcm_channels = g_value_get_uint(value); if(pcm_channels == libao->pcm_channels) { return; } libao->pcm_channels = pcm_channels; free(libao->buffer[0]); free(libao->buffer[1]); free(libao->buffer[2]); free(libao->buffer[3]); libao->buffer[0] = (signed short *) malloc((pcm_channels * libao->buffer_size) * sizeof(signed short)); libao->buffer[1] = (signed short *) malloc((pcm_channels * libao->buffer_size) * sizeof(signed short)); libao->buffer[2] = (signed short *) malloc((pcm_channels * libao->buffer_size) * sizeof(signed short)); libao->buffer[3] = (signed short *) malloc((pcm_channels * libao->buffer_size) * sizeof(signed short)); } break; case PROP_BITS: { //TODO:JK: implement me } break; case PROP_BUFFER_SIZE: { guint buffer_size; buffer_size = g_value_get_uint(value); if(buffer_size == libao->buffer_size) { return; } libao->buffer_size = buffer_size; free(libao->buffer[0]); free(libao->buffer[1]); free(libao->buffer[2]); free(libao->buffer[3]); libao->buffer[0] = (signed short *) malloc((libao->pcm_channels * buffer_size) * sizeof(signed short)); libao->buffer[1] = (signed short *) malloc((libao->pcm_channels * buffer_size) * sizeof(signed short)); libao->buffer[2] = (signed short *) malloc((libao->pcm_channels * buffer_size) * sizeof(signed short)); libao->buffer[3] = (signed short *) malloc((libao->pcm_channels * buffer_size) * sizeof(signed short)); } break; case PROP_FREQUENCY: { guint frequency; frequency = g_value_get_uint(value); if(frequency == libao->frequency) { return; } libao->frequency = frequency; } break; case PROP_BUFFER: { //TODO:JK: implement me } break; case PROP_BPM: { //TODO:JK: implement me } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
static void create_demo_item (GooCanvasItem *table, gint demo_item_type, gint row, gint column, gint rows, gint columns, gchar *text, gdouble width, gdouble xalign, gdouble yalign, PangoAlignment text_alignment) { GooCanvasItem *item = NULL; GtkWidget *widget; GValue value = { 0 }; guint new_row; switch (demo_item_type) { case DEMO_RECT_ITEM: item = goo_canvas_rect_new (table, 0, 0, 38, 19, "fill-color", "red", NULL); break; case DEMO_TEXT_ITEM: case DEMO_TEXT_ITEM_2: case DEMO_TEXT_ITEM_3: item = goo_canvas_text_new (table, text, 0, 0, width, GOO_CANVAS_ANCHOR_NW, "alignment", text_alignment, NULL); break; case DEMO_WIDGET_ITEM: widget = gtk_button_new_with_label (text); item = goo_canvas_widget_new (table, widget, 0, 0, -1, -1, NULL); break; } g_value_init (&value, G_TYPE_UINT); g_value_set_uint (&value, row); goo_canvas_item_set_child_property (table, item, "row", &value); g_value_set_uint (&value, column); goo_canvas_item_set_child_property (table, item, "column", &value); g_value_set_uint (&value, rows); goo_canvas_item_set_child_property (table, item, "rows", &value); g_value_set_uint (&value, columns); goo_canvas_item_set_child_property (table, item, "columns", &value); goo_canvas_item_set_child_properties (table, item, "x-expand", TRUE, "y-expand", TRUE, "x-align", xalign, "y-align", yalign, NULL); /* Test the get function. */ goo_canvas_item_get_child_property (table, item, "row", &value); new_row = g_value_get_uint (&value); if (new_row != row) g_warning ("Got bad row setting: %i should be: %i\n", new_row, row); /* If we make the item's fill the cells then alignment can't be used. */ #if 0 goo_canvas_item_set_child_properties (table, item, "x-fill", TRUE, "y-fill", TRUE, NULL); #endif g_object_set_data (G_OBJECT (item), "id", text); g_signal_connect (item, "button_press_event", G_CALLBACK (on_button_press), NULL); }
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; }
static gboolean gst_rtp_dtmf_src_negotiate (GstBaseSrc * basesrc) { GstCaps *srccaps, *peercaps; GstRTPDTMFSrc *dtmfsrc = GST_RTP_DTMF_SRC (basesrc); gboolean ret; /* fill in the defaults, there properties cannot be negotiated. */ srccaps = gst_caps_new_simple ("application/x-rtp", "media", G_TYPE_STRING, "audio", "encoding-name", G_TYPE_STRING, "TELEPHONE-EVENT", NULL); /* the peer caps can override some of the defaults */ peercaps = gst_pad_peer_query_caps (GST_BASE_SRC_PAD (basesrc), NULL); if (peercaps == NULL) { /* no peer caps, just add the other properties */ gst_caps_set_simple (srccaps, "payload", G_TYPE_INT, dtmfsrc->pt, "ssrc", G_TYPE_UINT, dtmfsrc->current_ssrc, "timestamp-offset", G_TYPE_UINT, dtmfsrc->ts_base, "clock-rate", G_TYPE_INT, dtmfsrc->clock_rate, "seqnum-offset", G_TYPE_UINT, dtmfsrc->seqnum_base, NULL); GST_DEBUG_OBJECT (dtmfsrc, "no peer caps: %" GST_PTR_FORMAT, srccaps); } else { GstCaps *temp; GstStructure *s; const GValue *value; gint pt; gint clock_rate; /* peer provides caps we can use to fixate, intersect. This always returns a * writable caps. */ temp = gst_caps_intersect (srccaps, peercaps); gst_caps_unref (srccaps); gst_caps_unref (peercaps); if (!temp) { GST_DEBUG_OBJECT (dtmfsrc, "Could not get intersection with peer caps"); return FALSE; } if (gst_caps_is_empty (temp)) { GST_DEBUG_OBJECT (dtmfsrc, "Intersection with peer caps is empty"); gst_caps_unref (temp); return FALSE; } /* now fixate, start by taking the first caps */ temp = gst_caps_truncate (temp); temp = gst_caps_make_writable (temp); srccaps = temp; /* get first structure */ s = gst_caps_get_structure (srccaps, 0); if (gst_structure_get_int (s, "payload", &pt)) { /* use peer pt */ dtmfsrc->pt = pt; GST_LOG_OBJECT (dtmfsrc, "using peer pt %d", pt); } else { if (gst_structure_has_field (s, "payload")) { /* can only fixate if there is a field */ gst_structure_fixate_field_nearest_int (s, "payload", dtmfsrc->pt); gst_structure_get_int (s, "payload", &pt); GST_LOG_OBJECT (dtmfsrc, "using peer pt %d", pt); } else { /* no pt field, use the internal pt */ pt = dtmfsrc->pt; gst_structure_set (s, "payload", G_TYPE_INT, pt, NULL); GST_LOG_OBJECT (dtmfsrc, "using internal pt %d", pt); } } if (gst_structure_get_int (s, "clock-rate", &clock_rate)) { dtmfsrc->clock_rate = clock_rate; GST_LOG_OBJECT (dtmfsrc, "using clock-rate from caps %d", dtmfsrc->clock_rate); } else { GST_LOG_OBJECT (dtmfsrc, "using existing clock-rate %d", dtmfsrc->clock_rate); } gst_structure_set (s, "clock-rate", G_TYPE_INT, dtmfsrc->clock_rate, NULL); if (gst_structure_has_field_typed (s, "ssrc", G_TYPE_UINT)) { value = gst_structure_get_value (s, "ssrc"); dtmfsrc->current_ssrc = g_value_get_uint (value); GST_LOG_OBJECT (dtmfsrc, "using peer ssrc %08x", dtmfsrc->current_ssrc); } else { /* FIXME, fixate_nearest_uint would be even better */ gst_structure_set (s, "ssrc", G_TYPE_UINT, dtmfsrc->current_ssrc, NULL); GST_LOG_OBJECT (dtmfsrc, "using internal ssrc %08x", dtmfsrc->current_ssrc); } if (gst_structure_has_field_typed (s, "timestamp-offset", G_TYPE_UINT)) { value = gst_structure_get_value (s, "timestamp-offset"); dtmfsrc->ts_base = g_value_get_uint (value); GST_LOG_OBJECT (dtmfsrc, "using peer timestamp-offset %u", dtmfsrc->ts_base); } else { /* FIXME, fixate_nearest_uint would be even better */ gst_structure_set (s, "timestamp-offset", G_TYPE_UINT, dtmfsrc->ts_base, NULL); GST_LOG_OBJECT (dtmfsrc, "using internal timestamp-offset %u", dtmfsrc->ts_base); } if (gst_structure_has_field_typed (s, "seqnum-offset", G_TYPE_UINT)) { value = gst_structure_get_value (s, "seqnum-offset"); dtmfsrc->seqnum_base = g_value_get_uint (value); GST_LOG_OBJECT (dtmfsrc, "using peer seqnum-offset %u", dtmfsrc->seqnum_base); } else { /* FIXME, fixate_nearest_uint would be even better */ gst_structure_set (s, "seqnum-offset", G_TYPE_UINT, dtmfsrc->seqnum_base, NULL); GST_LOG_OBJECT (dtmfsrc, "using internal seqnum-offset %u", dtmfsrc->seqnum_base); } if (gst_structure_has_field_typed (s, "ptime", G_TYPE_UINT)) { value = gst_structure_get_value (s, "ptime"); dtmfsrc->ptime = g_value_get_uint (value); GST_LOG_OBJECT (dtmfsrc, "using peer ptime %u", dtmfsrc->ptime); } else if (gst_structure_has_field_typed (s, "maxptime", G_TYPE_UINT)) { value = gst_structure_get_value (s, "maxptime"); dtmfsrc->ptime = g_value_get_uint (value); GST_LOG_OBJECT (dtmfsrc, "using peer maxptime as ptime %u", dtmfsrc->ptime); } else { /* FIXME, fixate_nearest_uint would be even better */ gst_structure_set (s, "ptime", G_TYPE_UINT, dtmfsrc->ptime, NULL); GST_LOG_OBJECT (dtmfsrc, "using internal ptime %u", dtmfsrc->ptime); } GST_DEBUG_OBJECT (dtmfsrc, "with peer caps: %" GST_PTR_FORMAT, srccaps); } ret = gst_pad_set_caps (GST_BASE_SRC_PAD (basesrc), srccaps); gst_caps_unref (srccaps); dtmfsrc->dirty = FALSE; return ret; }
static void rstto_settings_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GdkColor *color; const gchar *str_val = NULL; RsttoSettings *settings = RSTTO_SETTINGS (object); switch (property_id) { case PROP_SHOW_TOOLBAR: settings->priv->show_toolbar = g_value_get_boolean (value); break; case PROP_SHOW_THUMBNAILBAR: settings->priv->show_thumbnailbar = g_value_get_boolean (value); break; case PROP_SHOW_STATUSBAR: settings->priv->show_statusbar = g_value_get_boolean (value); break; case PROP_SHOW_CLOCK: settings->priv->show_clock = g_value_get_boolean (value); break; case PROP_LIMIT_QUALITY: settings->priv->limit_quality = g_value_get_boolean (value); break; case PROP_HIDE_THUMBNAILS_FULLSCREEN: settings->priv->hide_thumbnails_fullscreen = g_value_get_boolean (value); break; case PROP_NAVBAR_POSITION: str_val = g_value_get_string (value); if ((!g_ascii_strcasecmp (str_val, "left")) || (!g_ascii_strcasecmp (str_val, "right")) || (!g_ascii_strcasecmp (str_val, "bottom")) || (!g_ascii_strcasecmp (str_val, "top"))) { if (settings->priv->navigationbar_position) g_free (settings->priv->navigationbar_position); settings->priv->navigationbar_position = g_strdup (str_val); } break; case PROP_INVERT_ZOOM_DIRECTION: settings->priv->invert_zoom_direction = g_value_get_boolean (value); break; case PROP_WINDOW_WIDTH: settings->priv->window_width = g_value_get_uint (value); break; case PROP_WINDOW_HEIGHT: settings->priv->window_height = g_value_get_uint (value); break; case PROP_BGCOLOR: color = g_value_get_boxed (value); settings->priv->bgcolor->red = color->red; settings->priv->bgcolor->green = color->green; settings->priv->bgcolor->blue = color->blue; break; case PROP_BGCOLOR_OVERRIDE: settings->priv->bgcolor_override = g_value_get_boolean (value); break; case PROP_CURRENT_URI: if (settings->priv->last_file_path) g_free (settings->priv->last_file_path); settings->priv->last_file_path = g_value_dup_string (value); break; case PROP_SLIDESHOW_TIMEOUT: settings->priv->slideshow_timeout = g_value_get_uint (value); break; case PROP_BGCOLOR_FULLSCREEN: color = g_value_get_boxed (value); settings->priv->bgcolor_fullscreen->red = color->red; settings->priv->bgcolor_fullscreen->green = color->green; settings->priv->bgcolor_fullscreen->blue = color->blue; break; case PROP_WRAP_IMAGES: settings->priv->wrap_images = g_value_get_boolean (value); break; case PROP_DESKTOP_TYPE: if (settings->priv->desktop_type) g_free (settings->priv->desktop_type); settings->priv->desktop_type = g_value_dup_string (value); break; case PROP_USE_THUNAR_PROPERTIES: settings->priv->use_thunar_properties = g_value_get_boolean (value); break; case PROP_MAXIMIZE_ON_STARTUP: settings->priv->maximize_on_startup = g_value_get_boolean (value); break; case PROP_ERROR_MISSING_THUMBNAILER: settings->priv->errors.missing_thumbnailer = g_value_get_boolean (value); break; case PROP_SORT_TYPE: settings->priv->sort_type = g_value_get_uint ( value ); break; case PROP_THUMBNAIL_SIZE: settings->priv->thumbnail_size = g_value_get_uint (value); break; default: break; } }
void ags_devout_set_property(GObject *gobject, guint prop_id, const GValue *value, GParamSpec *param_spec) { AgsDevout *devout; devout = AGS_DEVOUT(gobject); //TODO:JK: implement set functionality switch(prop_id){ case PROP_APPLICATION_CONTEXT: { AgsApplicationContext *application_context; application_context = g_value_get_object(value); if(devout->application_context == application_context){ return; } if(devout->application_context != NULL){ g_object_unref(G_OBJECT(devout->application_context)); } if(application_context != NULL){ AgsConfig *config; g_object_ref(G_OBJECT(application_context)); devout->application_mutex = &(application_context->mutex); config = application_context->config; devout->dsp_channels = g_ascii_strtoull(ags_config_get_value(config, AGS_CONFIG_SOUNDCARD, "dsp-channels\0"), NULL, 10); devout->pcm_channels = g_ascii_strtoull(ags_config_get_value(config, AGS_CONFIG_SOUNDCARD, "pcm-channels\0"), NULL, 10); devout->format = AGS_SOUNDCARD_DEFAULT_FORMAT; devout->buffer_size = g_ascii_strtoull(ags_config_get_value(config, AGS_CONFIG_SOUNDCARD, "buffer-size\0"), NULL, 10); devout->samplerate = g_ascii_strtoull(ags_config_get_value(config, AGS_CONFIG_SOUNDCARD, "samplerate\0"), NULL, 10); // devout->out.oss.device = NULL; devout->out.alsa.handle = NULL; devout->out.alsa.device = g_strdup(ags_config_get_value(config, AGS_CONFIG_SOUNDCARD, "alsa-handle\0")); }else{ devout->application_mutex = NULL; } devout->application_context = application_context; } break; case PROP_DEVICE: { char *device; device = (char *) g_value_get_string(value); if((AGS_DEVOUT_OSS & (devout->flags)) != 0){ devout->out.oss.device = g_strdup(device); }else if((AGS_DEVOUT_ALSA & (devout->flags)) != 0){ devout->out.alsa.device = g_strdup(device); } } break; case PROP_DSP_CHANNELS: { guint dsp_channels; dsp_channels = g_value_get_uint(value); if(dsp_channels == devout->dsp_channels){ return; } devout->dsp_channels = dsp_channels; } break; case PROP_PCM_CHANNELS: { guint pcm_channels; pcm_channels = g_value_get_uint(value); if(pcm_channels == devout->pcm_channels){ return; } devout->pcm_channels = pcm_channels; free(devout->buffer[0]); free(devout->buffer[1]); free(devout->buffer[2]); free(devout->buffer[3]); devout->buffer[0] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short)); devout->buffer[1] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short)); devout->buffer[2] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short)); devout->buffer[3] = (signed short *) malloc((pcm_channels * devout->buffer_size) * sizeof(signed short)); } break; case PROP_FORMAT: { //TODO:JK: implement me } break; case PROP_BUFFER_SIZE: { guint buffer_size; buffer_size = g_value_get_uint(value); if(buffer_size == devout->buffer_size){ return; } devout->buffer_size = buffer_size; free(devout->buffer[0]); free(devout->buffer[1]); free(devout->buffer[2]); free(devout->buffer[3]); devout->buffer[0] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short)); devout->buffer[1] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short)); devout->buffer[2] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short)); devout->buffer[3] = (signed short *) malloc((devout->pcm_channels * buffer_size) * sizeof(signed short)); } break; case PROP_SAMPLERATE: { guint samplerate; samplerate = g_value_get_uint(value); if(samplerate == devout->samplerate){ return; } devout->samplerate = samplerate; } break; case PROP_BUFFER: { //TODO:JK: implement me } break; case PROP_BPM: { //TODO:JK: implement me } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
static void _write_nodes(GObject *object, xmlNodePtr node) { g_assert(object); g_assert(node); guint prop_n; MidgardObject *mgdobject = (MidgardObject *)object; MidgardReflectionProperty *mrp = NULL; MidgardObjectClass *klass = NULL; GParamSpec **pspec = g_object_class_list_properties( G_OBJECT_GET_CLASS(G_OBJECT(object)), &prop_n); if(MIDGARD_IS_OBJECT(object)) { klass = MIDGARD_OBJECT_GET_CLASS(object); if(klass) mrp = midgard_reflection_property_new( MIDGARD_DBOBJECT_CLASS(klass)); } GValue pval = {0, }, *lval; GString *gstring; gchar *strprop = NULL; xmlChar *escaped; guint i; xmlNodePtr op_node = NULL; const gchar *linktype; MidgardCollector *mc; guint _uint; gint _int; GObject *_object; if(MIDGARD_IS_OBJECT(mgdobject)) { gint object_action = -1; if(MGD_OBJECT_GUID (mgdobject)) { GString *_sql = g_string_new(" "); g_string_append_printf(_sql, "guid = '%s' ", MGD_OBJECT_GUID (mgdobject)); gchar *tmpstr = g_string_free(_sql, FALSE); GValue *avalue = midgard_core_query_get_field_value( MGD_OBJECT_CNC (mgdobject), "object_action", "repligard", (const gchar*)tmpstr); if(avalue) { MIDGARD_GET_UINT_FROM_VALUE(object_action, avalue); g_value_unset(avalue); g_free(avalue); } g_free(tmpstr); } gchar *_action; if(object_action > -1) { switch(object_action) { case MGD_OBJECT_ACTION_CREATE: _action = "created"; break; case MGD_OBJECT_ACTION_UPDATE: _action = "updated"; break; case MGD_OBJECT_ACTION_DELETE: _action = "deleted"; break; case MGD_OBJECT_ACTION_PURGE: _action = "purged"; break; default: _action = "none"; break; } xmlNewProp(node, BAD_CAST "action", BAD_CAST _action); } } for(i = 0; i < prop_n; i++) { g_value_init(&pval,pspec[i]->value_type); g_object_get_property(G_OBJECT(object), pspec[i]->name, &pval); if(g_str_equal("guid", pspec[i]->name)) { /* Add guid attribute */ xmlNewProp(node, BAD_CAST "guid", BAD_CAST MGD_OBJECT_GUID (object)); g_value_unset(&pval); continue; } /* Object is not fetched from database. Skip references */ if(MGD_OBJECT_GUID (mgdobject) == NULL) goto export_unchecked_property; /* If property is a link we need to query guid * which identifies link object. Only if property * is not of guid or string type */ if(mrp){ if(midgard_reflection_property_is_link(mrp, pspec[i]->name)){ lval = g_new0(GValue, 1); switch(pspec[i]->value_type) { case G_TYPE_UINT: g_value_init(lval, G_TYPE_UINT); _uint = g_value_get_uint(&pval); if(!_uint){ g_value_unset(lval); g_free(lval); goto export_unchecked_property; } g_value_set_uint(lval, _uint); break; case G_TYPE_INT: g_value_init(lval, G_TYPE_INT); _int = g_value_get_int(&pval); if(!_int){ g_value_unset(lval); g_free(lval); goto export_unchecked_property; } g_value_set_int(lval, _int); break; default: g_free(lval); goto export_unchecked_property; } linktype = midgard_reflection_property_get_link_name( mrp, pspec[i]->name); if(linktype){ mc = midgard_collector_new( MGD_OBJECT_CNC (mgdobject), linktype, "id", lval); midgard_collector_set_key_property( mc, "guid", NULL); if(!midgard_collector_execute(mc)){ g_object_unref(mc); g_value_unset(&pval); continue; } gchar **linkguid = midgard_collector_list_keys(mc); if(linkguid){ if(linkguid[0]) strprop = g_strdup(linkguid[0]); } if(!strprop) strprop = g_strdup(""); /* Create node */ escaped = xmlEncodeEntitiesReentrant( NULL, (const xmlChar*)strprop); xmlNewTextChild(node, NULL, BAD_CAST pspec[i]->name, BAD_CAST escaped); g_free(linkguid); g_free(strprop); g_free(escaped); g_object_unref(mc); } g_value_unset(&pval); continue; } } export_unchecked_property: switch (G_TYPE_FUNDAMENTAL(pspec[i]->value_type)) { case G_TYPE_STRING: strprop = g_value_dup_string(&pval); if(!strprop) strprop = g_strdup(""); escaped = xmlEncodeEntitiesReentrant( NULL, (const xmlChar*)strprop); xmlNewTextChild(node, NULL, BAD_CAST pspec[i]->name, BAD_CAST escaped); g_free(strprop); g_free(escaped); break; case G_TYPE_INT: gstring = g_string_new(""); g_string_append_printf(gstring, "%d", g_value_get_int(&pval)); xmlNewChild(node, NULL, BAD_CAST pspec[i]->name, BAD_CAST (xmlChar *)gstring->str); g_string_free (gstring, TRUE); break; case G_TYPE_UINT: gstring = g_string_new(""); g_string_append_printf(gstring, "%d", g_value_get_uint(&pval)); xmlNewChild(node, NULL, BAD_CAST pspec[i]->name, BAD_CAST (xmlChar *)gstring->str); g_string_free (gstring, TRUE); break; case G_TYPE_FLOAT: gstring = g_string_new(""); g_string_append_printf(gstring, "%g", g_value_get_float(&pval)); xmlNewChild(node, NULL, BAD_CAST pspec[i]->name, BAD_CAST (xmlChar *)gstring->str); g_string_free (gstring, TRUE); break; case G_TYPE_BOOLEAN: if(g_value_get_boolean(&pval)) strprop = "1"; else strprop = "0"; xmlNewChild(node, NULL, BAD_CAST pspec[i]->name, BAD_CAST (xmlChar *)strprop); break; case G_TYPE_OBJECT: _object = g_value_get_object (&pval); if (_object) { op_node = xmlNewNode(NULL, BAD_CAST pspec[i]->name); _write_nodes(_object, op_node); xmlAddChild(node, op_node); } break; default: if (pspec[i]->value_type == MIDGARD_TYPE_TIMESTAMP) { GValue strval = {0, }; g_value_init (&strval, G_TYPE_STRING); g_value_transform (&pval, &strval); xmlNewChild(node, NULL, BAD_CAST pspec[i]->name, BAD_CAST (xmlChar *)g_value_get_string (&strval)); g_value_unset (&strval); } else { g_warning ("midgard_replicator_serialize: unhandled %s property type (%s)", pspec[i]->name, g_type_name (pspec[i]->value_type)); } } g_value_unset(&pval); } g_free(pspec); if(mrp) g_object_unref(mrp); }
static void ft_operation_provide_or_accept_file_cb (TpChannel *proxy, const GValue *address, const GError *error, gpointer user_data, GObject *weak_object) { EmpathyTpFile *self = EMPATHY_TP_FILE (weak_object); GError *myerr = NULL; g_cancellable_set_error_if_cancelled (self->priv->cancellable, &myerr); if (error != NULL) { if (myerr != NULL) { /* if we were both cancelled and failed when calling the method, * report the method error. */ g_clear_error (&myerr); } myerr = g_error_copy (error); } if (myerr != NULL) { DEBUG ("Error: %s", myerr->message); ft_operation_close_with_error (self, myerr); g_clear_error (&myerr); return; } if (G_VALUE_TYPE (address) == DBUS_TYPE_G_UCHAR_ARRAY) { self->priv->socket_address = g_value_dup_boxed (address); } else if (G_VALUE_TYPE (address) == G_TYPE_STRING) { /* Old bugged version of telepathy-salut used to store the address * as a 's' instead of an 'ay' */ const gchar *path; path = g_value_get_string (address); self->priv->socket_address = g_array_sized_new (TRUE, FALSE, sizeof (gchar), strlen (path)); g_array_insert_vals (self->priv->socket_address, 0, path, strlen (path)); } else if (G_VALUE_TYPE (address) == TP_STRUCT_TYPE_SOCKET_ADDRESS_IPV4) { GValueArray *val_array; GValue *v; const char *addr; val_array = g_value_get_boxed (address); /* IPV4 address */ v = g_value_array_get_nth (val_array, 0); addr = g_value_get_string (v); self->priv->socket_address = g_array_sized_new (TRUE, FALSE, sizeof (gchar), strlen (addr)); g_array_insert_vals (self->priv->socket_address, 0, addr, strlen (addr)); /* port number */ v = g_value_array_get_nth (val_array, 1); self->priv->port = g_value_get_uint (v); } DEBUG ("Got socket address: %s, port (not zero if IPV4): %d", self->priv->socket_address->data, self->priv->port); /* if the channel is already open, start the transfer now, otherwise, * wait for the state change signal. */ if (self->priv->state == TP_FILE_TRANSFER_STATE_OPEN) tp_file_start_transfer (self); }
static GConfValue * _to_gconf_value (const GValue *value) { GConfValue *gv; GType type = G_VALUE_TYPE (value); switch (type) { case G_TYPE_STRING: { gv = gconf_value_new (GCONF_VALUE_STRING); gconf_value_set_string (gv, g_value_get_string (value)); } break; case G_TYPE_INT: { gv = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gv, g_value_get_int (value)); } break; case G_TYPE_UINT: { gv = gconf_value_new (GCONF_VALUE_INT); gconf_value_set_int (gv, g_value_get_uint (value)); } break; case G_TYPE_BOOLEAN: { gv = gconf_value_new (GCONF_VALUE_BOOL); gconf_value_set_bool (gv, g_value_get_boolean (value)); } break; case G_TYPE_DOUBLE: { gv = gconf_value_new (GCONF_VALUE_FLOAT); gconf_value_set_float (gv, g_value_get_double (value)); } break; case G_TYPE_FLOAT: { gv = gconf_value_new (GCONF_VALUE_FLOAT); gconf_value_set_float (gv, g_value_get_float (value)); } break; default: if (type == G_TYPE_VALUE_ARRAY) { GSList *l = NULL; GType list_type = G_TYPE_STRING; GValueArray *array = g_value_get_boxed (value); gint i; if (array && array->n_values > 0) { list_type = G_VALUE_TYPE (&(array->values[0])); } gv = gconf_value_new (GCONF_VALUE_LIST); switch (list_type) { case G_TYPE_STRING: gconf_value_set_list_type (gv, GCONF_VALUE_STRING); break; case G_TYPE_INT: case G_TYPE_UINT: gconf_value_set_list_type (gv, GCONF_VALUE_INT); break; case G_TYPE_BOOLEAN: gconf_value_set_list_type (gv, GCONF_VALUE_BOOL); break; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: gconf_value_set_list_type (gv, GCONF_VALUE_FLOAT); break; default: g_assert_not_reached (); } for (i = 0; array && i < array->n_values; i++) { GConfValue *tmp; g_assert (G_VALUE_TYPE (&(array->values[i])) == list_type); tmp = _to_gconf_value (&(array->values[i])); l = g_slist_append (l, tmp); } gconf_value_set_list_nocopy (gv, l); } else g_assert_not_reached (); } return gv; }
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))); }
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 clutter_settings_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { ClutterSettings *self = CLUTTER_SETTINGS (gobject); switch (prop_id) { case PROP_BACKEND: self->backend = g_value_get_object (value); break; case PROP_DOUBLE_CLICK_TIME: self->double_click_time = g_value_get_int (value); break; case PROP_DOUBLE_CLICK_DISTANCE: self->double_click_distance = g_value_get_int (value); break; case PROP_DND_DRAG_THRESHOLD: self->dnd_drag_threshold = g_value_get_int (value); break; case PROP_FONT_NAME: g_free (self->font_name); self->font_name = g_value_dup_string (value); settings_update_font_name (self); break; case PROP_FONT_ANTIALIAS: self->xft_antialias = g_value_get_int (value); settings_update_font_options (self); break; case PROP_FONT_DPI: self->font_dpi = g_value_get_int (value); settings_update_resolution (self); break; case PROP_FONT_HINTING: self->xft_hinting = g_value_get_int (value); settings_update_font_options (self); break; case PROP_FONT_HINT_STYLE: g_free (self->xft_hint_style); self->xft_hint_style = g_value_dup_string (value); settings_update_font_options (self); break; case PROP_FONT_RGBA: g_free (self->xft_rgba); self->xft_rgba = g_value_dup_string (value); settings_update_font_options (self); break; case PROP_LONG_PRESS_DURATION: self->long_press_duration = g_value_get_int (value); break; case PROP_FONTCONFIG_TIMESTAMP: settings_update_fontmap (self, g_value_get_uint (value)); break; case PROP_PASSWORD_HINT_TIME: self->password_hint_time = g_value_get_uint (value); break; case PROP_WINDOW_SCALING_FACTOR: if (!self->fixed_scaling_factor) { self->window_scaling_factor = g_value_get_int (value); self->fixed_scaling_factor = TRUE; } break; case PROP_UNSCALED_FONT_DPI: self->font_dpi = g_value_get_int (value); settings_update_resolution (self); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
static void uint_value_print (const GValue *value, GString *string) { g_string_append_printf (string, "%u", g_value_get_uint (value)); }
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); }
/** * up_device_set_property: **/ static void up_device_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { UpDevice *device = UP_DEVICE (object); switch (prop_id) { case PROP_NATIVE_PATH: g_free (device->priv->native_path); device->priv->native_path = g_strdup (g_value_get_string (value)); break; case PROP_VENDOR: g_free (device->priv->vendor); device->priv->vendor = g_strdup (g_value_get_string (value)); break; case PROP_MODEL: g_free (device->priv->model); device->priv->model = g_strdup (g_value_get_string (value)); break; case PROP_SERIAL: g_free (device->priv->serial); device->priv->serial = g_strdup (g_value_get_string (value)); break; case PROP_UPDATE_TIME: device->priv->update_time = g_value_get_uint64 (value); break; case PROP_TYPE: device->priv->type = g_value_get_uint (value); break; case PROP_POWER_SUPPLY: device->priv->power_supply = g_value_get_boolean (value); break; case PROP_ONLINE: device->priv->online = g_value_get_boolean (value); break; case PROP_IS_PRESENT: device->priv->is_present = g_value_get_boolean (value); break; case PROP_IS_RECHARGEABLE: device->priv->is_rechargeable = g_value_get_boolean (value); break; case PROP_HAS_HISTORY: device->priv->has_history = g_value_get_boolean (value); break; case PROP_HAS_STATISTICS: device->priv->has_statistics = g_value_get_boolean (value); break; case PROP_STATE: device->priv->state = g_value_get_uint (value); break; case PROP_CAPACITY: device->priv->capacity = g_value_get_double (value); break; case PROP_ENERGY: device->priv->energy = g_value_get_double (value); break; case PROP_ENERGY_EMPTY: device->priv->energy_empty = g_value_get_double (value); break; case PROP_ENERGY_FULL: device->priv->energy_full = g_value_get_double (value); break; case PROP_ENERGY_FULL_DESIGN: device->priv->energy_full_design = g_value_get_double (value); break; case PROP_ENERGY_RATE: device->priv->energy_rate = g_value_get_double (value); break; case PROP_VOLTAGE: device->priv->voltage = g_value_get_double (value); break; case PROP_TIME_TO_EMPTY: device->priv->time_to_empty = g_value_get_int64 (value); break; case PROP_TIME_TO_FULL: device->priv->time_to_full = g_value_get_int64 (value); break; case PROP_PERCENTAGE: device->priv->percentage = g_value_get_double (value); break; case PROP_TECHNOLOGY: device->priv->technology = g_value_get_uint (value); break; case PROP_RECALL_NOTICE: device->priv->recall_notice = g_value_get_boolean (value); break; case PROP_RECALL_VENDOR: g_free (device->priv->recall_vendor); device->priv->recall_vendor = g_strdup (g_value_get_string (value)); break; case PROP_RECALL_URL: g_free (device->priv->recall_url); device->priv->recall_url = g_strdup (g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void create_adapter(adapter_data *adapter) { GHashTable *hash = NULL; GValue *value; DBusGProxy *default_proxy; const gchar *name; gboolean powered, discoverable; guint timeout; GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *image; GtkWidget *button; GtkWidget *entry; GtkWidget *buttonbox; int page_num; dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash != NULL) { value = g_hash_table_lookup(hash, "Name"); name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Powered"); powered = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "Discoverable"); discoverable = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "DiscoverableTimeout"); timeout = value ? g_value_get_uint(value) : 0; } else { name = NULL; powered = FALSE; discoverable = FALSE; timeout = 0; } adapter->powered = powered; adapter->discoverable = discoverable; adapter->timeout_value = timeout; default_proxy = bluetooth_client_get_default_adapter (client); if (default_proxy != NULL) { adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy), dbus_g_proxy_get_path (adapter->proxy)); g_object_unref (default_proxy); } mainbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook), mainbox, NULL); adapter->child = mainbox; vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0); /* The discoverable checkbox */ button = gtk_check_button_new_with_mnemonic (_("Make computer _visible")); if (powered == FALSE) discoverable = FALSE; if (discoverable != FALSE && timeout == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); else if (discoverable == FALSE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); } gtk_widget_set_sensitive (button, adapter->powered); adapter->button_discoverable = button; adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(discoverable_changed_cb), adapter); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); /* The friendly name */ vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); label = create_label(_("Friendly name")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 248); gtk_widget_set_size_request(entry, 240, -1); gtk_container_add (GTK_CONTAINER (alignment), entry); if (name != NULL) gtk_entry_set_text(GTK_ENTRY(entry), name); adapter->entry = entry; adapter->name_vbox = vbox; g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(name_callback), adapter); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(focus_callback), adapter); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); /* The known devices */ table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0); label = create_label(_("Devices")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6); /* Note that this will only ever show the devices on the default * adapter, this is on purpose */ adapter->chooser = bluetooth_chooser_new (NULL); g_object_set (adapter->chooser, "show-searching", FALSE, "show-device-type", FALSE, "show-device-category", FALSE, "show-pairing", TRUE, "show-connected", TRUE, "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL); g_signal_connect (adapter->chooser, "notify::device-selected", G_CALLBACK(device_selected_cb), adapter); gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); adapter->devices_table = table; buttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(buttonbox), 6); gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE); gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 6, 6); button = gtk_button_new_with_mnemonic(_("Set up _new device...")); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wizard_callback), adapter); button = gtk_button_new_with_label(_("Disconnect")); image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(disconnect_callback), adapter); adapter->button_disconnect = button; button = gtk_button_new_with_mnemonic(_("_Remove")); image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_callback), adapter); adapter->button_delete = button; gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); g_object_set_data(G_OBJECT(mainbox), "adapter", adapter); gtk_widget_show_all(mainbox); if (adapter->is_default != FALSE) gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num); }
/* * 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(); } }
static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NMSettingPppPrivate *priv = NM_SETTING_PPP_GET_PRIVATE (object); switch (prop_id) { case PROP_NOAUTH: priv->noauth = g_value_get_boolean (value); break; case PROP_REFUSE_EAP: priv->refuse_eap = g_value_get_boolean (value); break; case PROP_REFUSE_PAP: priv->refuse_pap = g_value_get_boolean (value); break; case PROP_REFUSE_CHAP: priv->refuse_chap = g_value_get_boolean (value); break; case PROP_REFUSE_MSCHAP: priv->refuse_mschap = g_value_get_boolean (value); break; case PROP_REFUSE_MSCHAPV2: priv->refuse_mschapv2 = g_value_get_boolean (value); break; case PROP_NOBSDCOMP: priv->nobsdcomp = g_value_get_boolean (value); break; case PROP_NODEFLATE: priv->nodeflate = g_value_get_boolean (value); break; case PROP_NO_VJ_COMP: priv->no_vj_comp = g_value_get_boolean (value); break; case PROP_REQUIRE_MPPE: priv->require_mppe = g_value_get_boolean (value); break; case PROP_REQUIRE_MPPE_128: priv->require_mppe_128 = g_value_get_boolean (value); break; case PROP_MPPE_STATEFUL: priv->mppe_stateful = g_value_get_boolean (value); break; case PROP_CRTSCTS: priv->crtscts = g_value_get_boolean (value); break; case PROP_BAUD: priv->baud = g_value_get_uint (value); break; case PROP_MRU: priv->mru = g_value_get_uint (value); break; case PROP_MTU: priv->mtu = g_value_get_uint (value); break; case PROP_LCP_ECHO_FAILURE: priv->lcp_echo_failure = g_value_get_uint (value); break; case PROP_LCP_ECHO_INTERVAL: priv->lcp_echo_interval = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static KValueRef StatusCheckWork(const ValueList& args) { GError* error = 0; gchar* result = 0; bool foundNetworkManager = false; wicdWiredProxy = dbus_g_proxy_new_for_name( bus, "org.wicd.daemon", "/org/wicd/daemon", "org.wicd.daemon.wired"); if (!dbus_g_proxy_call( wicdWiredProxy, "GetWiredIP", &error, G_TYPE_INVALID, G_TYPE_STRING, &result, G_TYPE_INVALID)) { // 16 == interface not up if (error->code == 16) foundNetworkManager = true; g_error_free(error); } else if (result) { return Value::NewBool(true); } if (wicdWiredProxy) g_object_unref(wicdWiredProxy); wicdWirelessProxy = dbus_g_proxy_new_for_name(bus, "org.wicd.daemon", "/org/wicd/daemon", "org.wicd.daemon.wireless"); error = 0; if (!dbus_g_proxy_call(wicdWirelessProxy, "GetWirelessIP", &error, G_TYPE_INVALID, G_TYPE_STRING, &result, G_TYPE_INVALID)) { // 16 == interface not up if (error->code == 16) foundNetworkManager = true; g_error_free(error); } else if (result) { return Value::NewBool(true); } if (!wicdWirelessProxy) g_object_unref(wicdWirelessProxy); networkManagerProxy = dbus_g_proxy_new_for_name(bus, "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager", "org.freedesktop.DBus.Properties"); error = 0; GValue nm_state_val = {0, }; if (!dbus_g_proxy_call(networkManagerProxy, "Get", &error, G_TYPE_STRING, "org.freedesktop.NetworkManager", G_TYPE_STRING, "state", G_TYPE_INVALID, G_TYPE_VALUE, &nm_state_val, G_TYPE_INVALID)) { g_error_free(error); } else if (g_value_get_uint(&nm_state_val) == 3) { return Value::NewBool(true); } else { foundNetworkManager = true; } if (networkManagerProxy) g_object_unref(networkManagerProxy); if (!foundNetworkManager) return Value::NewBool(true); else return Value::NewBool(false); }
static void gst_soup_http_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (object); switch (prop_id) { case PROP_LOCATION: { const gchar *location; location = g_value_get_string (value); if (location == NULL) { GST_WARNING ("location property cannot be NULL"); goto done; } if (!gst_soup_http_src_set_location (src, location)) { GST_WARNING ("badly formatted location"); goto done; } break; } case PROP_USER_AGENT: if (src->user_agent) g_free (src->user_agent); src->user_agent = g_value_dup_string (value); break; case PROP_IRADIO_MODE: src->iradio_mode = g_value_get_boolean (value); break; case PROP_AUTOMATIC_REDIRECT: src->automatic_redirect = g_value_get_boolean (value); break; case PROP_PROXY: { const gchar *proxy; proxy = g_value_get_string (value); if (proxy == NULL) { GST_WARNING ("proxy property cannot be NULL"); goto done; } if (!gst_soup_http_src_set_proxy (src, proxy)) { GST_WARNING ("badly formatted proxy URI"); goto done; } break; } case PROP_COOKIES: g_strfreev (src->cookies); src->cookies = g_strdupv (g_value_get_boxed (value)); break; case PROP_IS_LIVE: gst_base_src_set_live (GST_BASE_SRC (src), g_value_get_boolean (value)); break; case PROP_USER_ID: if (src->user_id) g_free (src->user_id); src->user_id = g_value_dup_string (value); break; case PROP_USER_PW: if (src->user_pw) g_free (src->user_pw); src->user_pw = g_value_dup_string (value); break; case PROP_PROXY_ID: if (src->proxy_id) g_free (src->proxy_id); src->proxy_id = g_value_dup_string (value); break; case PROP_PROXY_PW: if (src->proxy_pw) g_free (src->proxy_pw); src->proxy_pw = g_value_dup_string (value); break; case PROP_TIMEOUT: src->timeout = g_value_get_uint (value); break; case PROP_EXTRA_HEADERS:{ const GstStructure *s = gst_value_get_structure (value); if (src->extra_headers) gst_structure_free (src->extra_headers); src->extra_headers = s ? gst_structure_copy (s) : NULL; break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } done: return; }
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; } }
/** * gst_rtp_base_payload_set_outcaps: * @payload: a #GstRTPBasePayload * @fieldname: the first field name or %NULL * @...: field values * * Configure the output caps with the optional parameters. * * Variable arguments should be in the form field name, field type * (as a GType), value(s). The last variable argument should be NULL. * * Returns: %TRUE if the caps could be set. */ gboolean gst_rtp_base_payload_set_outcaps (GstRTPBasePayload * payload, const gchar * fieldname, ...) { GstCaps *srccaps, *peercaps; gboolean res; /* fill in the defaults, their properties cannot be negotiated. */ srccaps = gst_caps_new_simple ("application/x-rtp", "media", G_TYPE_STRING, payload->media, "clock-rate", G_TYPE_INT, payload->clock_rate, "encoding-name", G_TYPE_STRING, payload->encoding_name, NULL); GST_DEBUG_OBJECT (payload, "defaults: %" GST_PTR_FORMAT, srccaps); if (fieldname) { va_list varargs; /* override with custom properties */ va_start (varargs, fieldname); gst_caps_set_simple_valist (srccaps, fieldname, varargs); va_end (varargs); GST_DEBUG_OBJECT (payload, "custom added: %" GST_PTR_FORMAT, srccaps); } payload->priv->caps_max_ptime = DEFAULT_MAX_PTIME; payload->ptime = 0; /* the peer caps can override some of the defaults */ peercaps = gst_pad_peer_query_caps (payload->srcpad, srccaps); if (peercaps == NULL) { /* no peer caps, just add the other properties */ gst_caps_set_simple (srccaps, "payload", G_TYPE_INT, GST_RTP_BASE_PAYLOAD_PT (payload), "ssrc", G_TYPE_UINT, payload->current_ssrc, "timestamp-offset", G_TYPE_UINT, payload->ts_base, "seqnum-offset", G_TYPE_UINT, payload->seqnum_base, NULL); GST_DEBUG_OBJECT (payload, "no peer caps: %" GST_PTR_FORMAT, srccaps); } else { GstCaps *temp; GstStructure *s, *d; const GValue *value; gint pt; guint max_ptime, ptime; /* peer provides caps we can use to fixate. They are already intersected * with our srccaps, just make them writable */ temp = gst_caps_make_writable (peercaps); gst_caps_unref (srccaps); if (gst_caps_is_empty (temp)) { gst_caps_unref (temp); return FALSE; } /* now fixate, start by taking the first caps */ temp = gst_caps_truncate (temp); /* get first structure */ s = gst_caps_get_structure (temp, 0); if (gst_structure_get_uint (s, "maxptime", &max_ptime)) payload->priv->caps_max_ptime = max_ptime * GST_MSECOND; if (gst_structure_get_uint (s, "ptime", &ptime)) payload->ptime = ptime * GST_MSECOND; if (gst_structure_get_int (s, "payload", &pt)) { /* use peer pt */ GST_RTP_BASE_PAYLOAD_PT (payload) = pt; GST_LOG_OBJECT (payload, "using peer pt %d", pt); } else { if (gst_structure_has_field (s, "payload")) { /* can only fixate if there is a field */ gst_structure_fixate_field_nearest_int (s, "payload", GST_RTP_BASE_PAYLOAD_PT (payload)); gst_structure_get_int (s, "payload", &pt); GST_LOG_OBJECT (payload, "using peer pt %d", pt); } else { /* no pt field, use the internal pt */ pt = GST_RTP_BASE_PAYLOAD_PT (payload); gst_structure_set (s, "payload", G_TYPE_INT, pt, NULL); GST_LOG_OBJECT (payload, "using internal pt %d", pt); } } if (gst_structure_has_field_typed (s, "ssrc", G_TYPE_UINT)) { value = gst_structure_get_value (s, "ssrc"); payload->current_ssrc = g_value_get_uint (value); GST_LOG_OBJECT (payload, "using peer ssrc %08x", payload->current_ssrc); } else { /* FIXME, fixate_nearest_uint would be even better */ gst_structure_set (s, "ssrc", G_TYPE_UINT, payload->current_ssrc, NULL); GST_LOG_OBJECT (payload, "using internal ssrc %08x", payload->current_ssrc); } if (gst_structure_has_field_typed (s, "timestamp-offset", G_TYPE_UINT)) { value = gst_structure_get_value (s, "timestamp-offset"); payload->ts_base = g_value_get_uint (value); GST_LOG_OBJECT (payload, "using peer timestamp-offset %u", payload->ts_base); } else { /* FIXME, fixate_nearest_uint would be even better */ gst_structure_set (s, "timestamp-offset", G_TYPE_UINT, payload->ts_base, NULL); GST_LOG_OBJECT (payload, "using internal timestamp-offset %u", payload->ts_base); } if (gst_structure_has_field_typed (s, "seqnum-offset", G_TYPE_UINT)) { value = gst_structure_get_value (s, "seqnum-offset"); payload->seqnum_base = g_value_get_uint (value); GST_LOG_OBJECT (payload, "using peer seqnum-offset %u", payload->seqnum_base); } else { /* FIXME, fixate_nearest_uint would be even better */ gst_structure_set (s, "seqnum-offset", G_TYPE_UINT, payload->seqnum_base, NULL); GST_LOG_OBJECT (payload, "using internal seqnum-offset %u", payload->seqnum_base); } /* make the target caps by copying over all the fixed caps, removing the * unfixed caps. */ srccaps = gst_caps_new_empty_simple (gst_structure_get_name (s)); d = gst_caps_get_structure (srccaps, 0); gst_structure_foreach (s, (GstStructureForeachFunc) copy_fixed, d); gst_caps_unref (temp); GST_DEBUG_OBJECT (payload, "with peer caps: %" GST_PTR_FORMAT, srccaps); } update_max_ptime (payload); res = gst_pad_set_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), srccaps); gst_caps_unref (srccaps); return res; }
static void gst_msdkvpp_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMsdkVPP *thiz = GST_MSDKVPP (object); switch (prop_id) { case PROP_HARDWARE: thiz->hardware = g_value_get_boolean (value); break; case PROP_ASYNC_DEPTH: thiz->async_depth = g_value_get_uint (value); break; case PROP_DENOISE: thiz->denoise_factor = g_value_get_uint (value); thiz->flags |= GST_MSDK_FLAG_DENOISE; break; case PROP_ROTATION: thiz->rotation = g_value_get_enum (value); thiz->flags |= GST_MSDK_FLAG_ROTATION; break; case PROP_DEINTERLACE_MODE: thiz->deinterlace_mode = g_value_get_enum (value); break; case PROP_DEINTERLACE_METHOD: thiz->deinterlace_method = g_value_get_enum (value); break; case PROP_HUE: thiz->hue = g_value_get_float (value); thiz->flags |= GST_MSDK_FLAG_HUE; break; case PROP_SATURATION: thiz->saturation = g_value_get_float (value); thiz->flags |= GST_MSDK_FLAG_SATURATION; break; case PROP_BRIGHTNESS: thiz->brightness = g_value_get_float (value); thiz->flags |= GST_MSDK_FLAG_BRIGHTNESS; break; case PROP_CONTRAST: thiz->contrast = g_value_get_float (value); thiz->flags |= GST_MSDK_FLAG_CONTRAST; break; case PROP_DETAIL: thiz->detail = g_value_get_uint (value); thiz->flags |= GST_MSDK_FLAG_DETAIL; break; case PROP_MIRRORING: thiz->mirroring = g_value_get_enum (value); thiz->flags |= GST_MSDK_FLAG_MIRRORING; break; case PROP_SCALING_MODE: thiz->scaling_mode = g_value_get_enum (value); thiz->flags |= GST_MSDK_FLAG_SCALING_MODE; break; case PROP_FORCE_ASPECT_RATIO: thiz->keep_aspect = g_value_get_boolean (value); break; case PROP_FRC_ALGORITHM: thiz->frc_algm = g_value_get_enum (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void mx_settings_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { guint uint_value; gboolean boolean_value; const gchar *string_value; MxSettingsPrivate *priv = MX_SETTINGS (object)->priv; /* Check if the settings provider can set these settings first */ if (priv->provider) { switch (property_id) { case MX_SETTINGS_ICON_THEME: case MX_SETTINGS_FONT_NAME: string_value = g_value_get_string (value); if (_mx_settings_provider_set_setting (priv->provider, property_id, &string_value)) return; break; case MX_SETTINGS_LONG_PRESS_TIMEOUT: uint_value = g_value_get_uint (value); if (_mx_settings_provider_set_setting (priv->provider, property_id, &uint_value)) return; break; case MX_SETTINGS_SMALL_SCREEN: boolean_value = g_value_get_boolean (value); if (_mx_settings_provider_set_setting (priv->provider, property_id, &boolean_value)) return; break; case MX_SETTINGS_DRAG_THRESHOLD: uint_value = g_value_get_uint (value); if (_mx_settings_provider_set_setting (priv->provider, property_id, &uint_value)) return; break; case MX_SETTINGS_TOUCH_MODE: boolean_value = g_value_get_boolean (value); if (_mx_settings_provider_set_setting (priv->provider, property_id, &boolean_value)) return; break; } } switch (property_id) { case MX_SETTINGS_ICON_THEME: g_free (priv->icon_theme); priv->icon_theme = g_value_dup_string (value); break; case MX_SETTINGS_FONT_NAME: g_free (priv->font_name); priv->font_name = g_value_dup_string (value); break; case MX_SETTINGS_LONG_PRESS_TIMEOUT: priv->long_press_timeout = g_value_get_uint (value); break; case MX_SETTINGS_SMALL_SCREEN: priv->small_screen = g_value_get_boolean (value); break; case MX_SETTINGS_DRAG_THRESHOLD: priv->drag_threshold = g_value_get_uint (value); break; case MX_SETTINGS_TOUCH_MODE: priv->touch_mode = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }