static void escCleanAllBuf_set_callback(PropertyContext *ctx, GValue *value){ #ifdef IBUS_CHEWING_MAIN IBusChewingEngine *engine=(IBusChewingEngine *) ctx->userData; chewing_set_escCleanAllBuf(engine->context,(g_value_get_boolean(value)) ? 1: 0); #endif }
static void gst_curl_smtp_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstCurlSmtpSink *sink; GstState cur_state; g_return_if_fail (GST_IS_CURL_SMTP_SINK (object)); sink = GST_CURL_SMTP_SINK (object); gst_element_get_state (GST_ELEMENT (sink), &cur_state, NULL, 0); if (cur_state != GST_STATE_PLAYING && cur_state != GST_STATE_PAUSED) { GST_OBJECT_LOCK (sink); switch (prop_id) { case PROP_MAIL_RCPT: g_free (sink->mail_rcpt); sink->mail_rcpt = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "mail-rcpt set to %s", sink->mail_rcpt); break; case PROP_MAIL_FROM: g_free (sink->mail_from); sink->mail_from = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "mail-from set to %s", sink->mail_from); break; case PROP_SUBJECT: g_free (sink->subject); sink->subject = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "subject set to %s", sink->subject); break; case PROP_MESSAGE_BODY: g_free (sink->message_body); sink->message_body = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "message-body set to %s", sink->message_body); break; case PROP_CONTENT_TYPE: g_free (sink->content_type); sink->content_type = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "content-type set to %s", sink->content_type); break; case PROP_USE_SSL: sink->use_ssl = g_value_get_boolean (value); GST_DEBUG_OBJECT (sink, "use-ssl set to %d", sink->use_ssl); break; case PROP_NBR_ATTACHMENTS: sink->nbr_attachments = g_value_get_int (value); sink->nbr_attachments_left = sink->nbr_attachments; GST_DEBUG_OBJECT (sink, "nbr-attachments set to %d", sink->nbr_attachments); break; case PROP_POP_USER_NAME: g_free (sink->pop_user); sink->pop_user = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "pop-user set to %s", sink->pop_user); break; case PROP_POP_USER_PASSWD: g_free (sink->pop_passwd); sink->pop_passwd = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "pop-passwd set to %s", sink->pop_passwd); break; case PROP_POP_LOCATION: g_free (sink->pop_location); sink->pop_location = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "pop-location set to %s", sink->pop_location); break; default: GST_DEBUG_OBJECT (sink, "invalid property id %d", prop_id); break; } GST_OBJECT_UNLOCK (sink); return; } /* in PLAYING or PAUSED state */ GST_OBJECT_LOCK (sink); switch (prop_id) { case PROP_CONTENT_TYPE: g_free (sink->content_type); sink->content_type = g_value_dup_string (value); GST_DEBUG_OBJECT (sink, "content type set to %s", sink->content_type); break; default: GST_WARNING_OBJECT (sink, "cannot set property when PLAYING"); break; } GST_OBJECT_UNLOCK (sink); }
static void gst_pocketsphinx_set_boolean(GstPocketSphinx *ps, const gchar *key, const GValue *value) { cmd_ln_set_boolean_r(ps->config, key, g_value_get_boolean(value)); }
static void gst_fake_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstFakeSrc *src; GstBaseSrc *basesrc; src = GST_FAKE_SRC (object); basesrc = GST_BASE_SRC (object); switch (prop_id) { case PROP_OUTPUT: g_warning ("not yet implemented"); break; case PROP_DATA: src->data = (GstFakeSrcDataType) g_value_get_enum (value); if (src->data == FAKE_SRC_DATA_SUBBUFFER) { if (!src->parent) gst_fake_src_alloc_parent (src); } else { if (src->parent) { gst_buffer_unref (src->parent); src->parent = NULL; } } break; case PROP_SIZETYPE: src->sizetype = (GstFakeSrcSizeType) g_value_get_enum (value); break; case PROP_SIZEMIN: src->sizemin = g_value_get_int (value); break; case PROP_SIZEMAX: src->sizemax = g_value_get_int (value); break; case PROP_PARENTSIZE: src->parentsize = g_value_get_int (value); break; case PROP_FILLTYPE: src->filltype = (GstFakeSrcFillType) g_value_get_enum (value); break; case PROP_DATARATE: src->datarate = g_value_get_int (value); break; case PROP_SYNC: src->sync = g_value_get_boolean (value); break; case PROP_PATTERN: break; case PROP_SILENT: src->silent = g_value_get_boolean (value); break; case PROP_SIGNAL_HANDOFFS: src->signal_handoffs = g_value_get_boolean (value); break; case PROP_DUMP: src->dump = g_value_get_boolean (value); break; case PROP_CAN_ACTIVATE_PUSH: g_return_if_fail (!GST_OBJECT_FLAG_IS_SET (object, GST_BASE_SRC_FLAG_STARTED)); GST_BASE_SRC (src)->can_activate_push = g_value_get_boolean (value); break; case PROP_CAN_ACTIVATE_PULL: g_return_if_fail (!GST_OBJECT_FLAG_IS_SET (object, GST_BASE_SRC_FLAG_STARTED)); src->can_activate_pull = g_value_get_boolean (value); break; case PROP_IS_LIVE: gst_base_src_set_live (basesrc, g_value_get_boolean (value)); break; case PROP_FORMAT: src->format = (GstFormat) g_value_get_enum (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
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 gint game_store_compare (GtkTreeModel *model, GtkTreeIter *iter_a, GtkTreeIter *iter_b, gpointer user_data) { GType type; GValue value_a; GValue value_b; gint column; gint result; memset (&value_a, 0, sizeof (GValue)); memset (&value_b, 0, sizeof (GValue)); column = GPOINTER_TO_INT (user_data); type = gtk_tree_model_get_column_type (model, column); gtk_tree_model_get_value (model, iter_a, column, &value_a); gtk_tree_model_get_value (model, iter_b, column, &value_b); if (type == G_TYPE_BOOLEAN) { gboolean va, vb; va = g_value_get_boolean (&value_a); vb = g_value_get_boolean (&value_b); result = (va < vb) ? -1 : (va == vb) ? 0 : 1; } else if (type == G_TYPE_INT) { gint va, vb; va = g_value_get_int (&value_a); vb = g_value_get_int (&value_b); result = (va < vb) ? -1 : (va == vb) ? 0 : 1; } else if (type == G_TYPE_STRING) { const gchar *va, *vb; va = g_value_get_string (&value_a); vb = g_value_get_string (&value_b); if (va == NULL) va = ""; if (vb == NULL) vb = ""; result = strcmp (va, vb); } else if (type == GVA_TYPE_TIME) { gdouble diff; time_t *va, *vb; va = (time_t *) g_value_get_boxed (&value_a); vb = (time_t *) g_value_get_boxed (&value_b); diff = difftime (*va, *vb); result = (diff < 0.0) ? -1 : (diff == 0.0) ? 0 : 1; } else { g_assert_not_reached (); } g_value_unset (&value_a); g_value_unset (&value_b); /* If the values are equal, compare the default sort column * (being careful not to introduce infinite recursion!). */ if (result != 0 || column == DEFAULT_SORT_COLUMN) return result; user_data = GINT_TO_POINTER (DEFAULT_SORT_COLUMN); return game_store_compare (model, iter_a, iter_b, user_data); }
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; }
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 void sch_config_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { SchConfig *config = SCH_CONFIG(object); switch (property_id) { case SCH_CONFIG_ATTRIBUTE_PROMOTION: sch_config_set_attribute_promotion(config, g_value_get_boolean(value)); break; case SCH_CONFIG_BUBBLE_COLOR: sch_config_set_bubble_color(config, g_value_get_int(value)); break; case SCH_CONFIG_BUBBLE_DIAMETER: sch_config_set_bubble_diameter(config, g_value_get_int(value)); break; case SCH_CONFIG_BUS_COLOR: sch_config_set_bus_color(config, g_value_get_int(value)); break; case SCH_CONFIG_FILL_STYLE: sch_config_set_fill_style(config, SCH_FILL_STYLE(g_value_get_boxed(value))); break; case SCH_CONFIG_GRAPHIC_COLOR: sch_config_set_graphic_color(config, g_value_get_int(value)); break; case SCH_CONFIG_KEEP_INVISIBLE: sch_config_set_keep_invisible(config, g_value_get_boolean(value)); break; case SCH_CONFIG_LINE_STYLE: sch_config_set_line_style(config, SCH_LINE_STYLE(g_value_get_boxed(value))); break; case SCH_CONFIG_LINE_WIDTH: sch_config_set_line_width(config, g_value_get_int(value)); break; case SCH_CONFIG_NET_COLOR: sch_config_set_net_color(config, g_value_get_int(value)); break; case SCH_CONFIG_PIN_COLOR: sch_config_set_pin_color(config, g_value_get_int(value)); break; case SCH_CONFIG_PIN_LENGTH: sch_config_set_pin_length(config, g_value_get_int(value)); break; case SCH_CONFIG_PIN_SPACING: sch_config_set_pin_spacing(config, g_value_get_int(value)); break; case SCH_CONFIG_PROMOTE_INVISIBLE: sch_config_set_promote_invisible(config, g_value_get_boolean(value)); break; case SCH_CONFIG_TEXT_COLOR: sch_config_set_text_color(config, g_value_get_int(value)); break; case SCH_CONFIG_TEXT_SIZE: sch_config_set_text_size(config, g_value_get_int(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); } }
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; } }
static void gst_rtsp_cam_media_factory_set_property (GObject *object, guint propid, const GValue *value, GParamSpec *pspec) { GstRTSPCamMediaFactory *factory = GST_RTSP_CAM_MEDIA_FACTORY (object); switch (propid) { case PROP_VIDEO: factory->video = g_value_get_boolean (value); break; case PROP_AUDIO: factory->audio = g_value_get_boolean (value); break; case PROP_VIDEO_SOURCE: g_free (factory->video_source); factory->video_source = g_value_dup_string (value); if (factory->video_source == NULL) factory->video_source = g_strdup (DEFAULT_VIDEO_SOURCE); break; case PROP_VIDEO_DEVICE: g_free (factory->video_device); factory->video_device = g_value_dup_string (value); if (factory->video_device == NULL) factory->video_device = g_strdup (DEFAULT_VIDEO_DEVICE); break; case PROP_VIDEO_WIDTH: factory->video_width = g_value_get_int (value); break; case PROP_VIDEO_HEIGHT: factory->video_height = g_value_get_int (value); break; case PROP_VIDEO_BITRATE: factory->video_bitrate = g_value_get_int (value); break; case PROP_VIDEO_FRAMERATE: factory->fps_n = gst_value_get_fraction_numerator (value); factory->fps_d = gst_value_get_fraction_denominator (value); break; case PROP_VIDEO_CODEC: g_free (factory->video_codec); factory->video_codec = g_value_dup_string (value); if (factory->video_codec == NULL) factory->video_codec = g_strdup (DEFAULT_VIDEO_CODEC); break; case PROP_AUDIO_SOURCE: g_free (factory->audio_source); factory->audio_source = g_value_dup_string (value); if (factory->audio_source == NULL) factory->audio_source = g_strdup (DEFAULT_AUDIO_SOURCE); break; case PROP_AUDIO_DEVICE: g_free (factory->audio_device); factory->audio_device = g_value_dup_string (value); if (factory->audio_device == NULL) factory->audio_device = g_strdup (DEFAULT_AUDIO_DEVICE); break; case PROP_AUDIO_CODEC: g_free (factory->audio_codec); factory->audio_codec = g_value_dup_string (value); if (factory->audio_codec == NULL) factory->audio_codec = g_strdup (DEFAULT_AUDIO_CODEC); break; case PROP_AUDIO_CHANNELS: factory->audio_channels = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, propid, pspec); } }
static char * rb_gvalue_array_to_string (GArray *a) { int i; GString *s; if (a == NULL) return strdup (""); s = g_string_new ("("); for (i = 0; i < a->len; i++) { GValue *val; if (i != 0) g_string_append (s, ", "); val = &g_array_index (a, GValue, i); switch (G_VALUE_TYPE (val)) { case G_TYPE_STRING: g_string_append_printf (s, "\"%s\"", g_value_get_string (val)); break; case G_TYPE_BOOLEAN: g_string_append_printf (s, "%d", g_value_get_boolean (val)); break; case G_TYPE_INT: g_string_append_printf (s, "%d", g_value_get_int (val)); break; case G_TYPE_LONG: g_string_append_printf (s, "%ld", g_value_get_long (val)); break; case G_TYPE_ULONG: g_string_append_printf (s, "%lu", g_value_get_ulong (val)); break; case G_TYPE_UINT64: g_string_append_printf (s, "%" G_GUINT64_FORMAT, g_value_get_uint64 (val)); break; case G_TYPE_FLOAT: g_string_append_printf (s, "%f", g_value_get_float (val)); break; case G_TYPE_DOUBLE: g_string_append_printf (s, "%f", g_value_get_double (val)); break; case G_TYPE_POINTER: g_string_append_printf (s, "P:%p", g_value_get_pointer (val)); break; case G_TYPE_BOXED: g_string_append_printf (s, "B:%p", g_value_get_boxed (val)); break; case G_TYPE_OBJECT: g_string_append_printf (s, "O:%p", g_value_get_object (val)); break; default: g_string_append(s, "Unknown"); } } g_string_append_c (s, ')'); return g_string_free (s, FALSE); }
static void spaceAsSelection_set_callback(PropertyContext *ctx, GValue *value){ #ifdef IBUS_CHEWING_MAIN IBusChewingEngine *engine=(IBusChewingEngine *) ctx->userData; chewing_set_spaceAsSelection(engine->context,(g_value_get_boolean(value)) ? 1: 0); #endif }
static void phraseChoiceRearward_set_callback(PropertyContext *ctx, GValue *value){ #ifdef IBUS_CHEWING_MAIN IBusChewingEngine *engine=(IBusChewingEngine *) ctx->userData; chewing_set_phraseChoiceRearward(engine->context,(g_value_get_boolean(value)) ? 1: 0); #endif }
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; }
/* Set/get properties */ static void _xfdashboard_text_box_set_property(GObject *inObject, guint inPropID, const GValue *inValue, GParamSpec *inSpec) { XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inObject); switch(inPropID) { case PROP_PADDING: xfdashboard_text_box_set_padding(self, g_value_get_float(inValue)); break; case PROP_SPACING: xfdashboard_text_box_set_spacing(self, g_value_get_float(inValue)); break; case PROP_EDITABLE: xfdashboard_text_box_set_editable(self, g_value_get_boolean(inValue)); break; case PROP_PRIMARY_ICON_NAME: xfdashboard_text_box_set_primary_icon(self, g_value_get_string(inValue)); break; case PROP_SECONDARY_ICON_NAME: xfdashboard_text_box_set_secondary_icon(self, g_value_get_string(inValue)); break; case PROP_TEXT: xfdashboard_text_box_set_text(self, g_value_get_string(inValue)); break; case PROP_TEXT_FONT: xfdashboard_text_box_set_text_font(self, g_value_get_string(inValue)); break; case PROP_TEXT_COLOR: xfdashboard_text_box_set_text_color(self, clutter_value_get_color(inValue)); break; case PROP_SELECTION_TEXT_COLOR: xfdashboard_text_box_set_selection_text_color(self, clutter_value_get_color(inValue)); break; case PROP_SELECTION_BACKGROUND_COLOR: xfdashboard_text_box_set_selection_background_color(self, clutter_value_get_color(inValue)); break; case PROP_HINT_TEXT: xfdashboard_text_box_set_hint_text(self, g_value_get_string(inValue)); break; case PROP_HINT_TEXT_FONT: xfdashboard_text_box_set_hint_text_font(self, g_value_get_string(inValue)); break; case PROP_HINT_TEXT_COLOR: xfdashboard_text_box_set_hint_text_color(self, clutter_value_get_color(inValue)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec); break; } }
static void etgl_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { ETableGroup *etg = E_TABLE_GROUP (object); ETableGroupLeaf *etgl = E_TABLE_GROUP_LEAF (object); switch (property_id) { case PROP_FROZEN: etg->frozen = g_value_get_boolean (value); break; case PROP_MINIMUM_WIDTH: case PROP_WIDTH: etgl->minimum_width = g_value_get_double (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "minimum_width", etgl->minimum_width, NULL); } break; case PROP_LENGTH_THRESHOLD: etgl->length_threshold = g_value_get_int (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "length_threshold", etgl->length_threshold, NULL); } break; case PROP_SELECTION_MODEL: if (etgl->selection_model) g_object_unref (etgl->selection_model); etgl->selection_model = E_SELECTION_MODEL (g_value_get_object (value)); if (etgl->selection_model) { g_object_ref (etgl->selection_model); } if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "selection_model", etgl->selection_model, NULL); } break; case PROP_UNIFORM_ROW_HEIGHT: etgl->uniform_row_height = g_value_get_boolean (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "uniform_row_height", etgl->uniform_row_height, NULL); } break; case PROP_TABLE_ALTERNATING_ROW_COLORS: etgl->alternating_row_colors = g_value_get_boolean (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "alternating_row_colors", etgl->alternating_row_colors, NULL); } break; case PROP_TABLE_HORIZONTAL_DRAW_GRID: etgl->horizontal_draw_grid = g_value_get_boolean (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "horizontal_draw_grid", etgl->horizontal_draw_grid, NULL); } break; case PROP_TABLE_VERTICAL_DRAW_GRID: etgl->vertical_draw_grid = g_value_get_boolean (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "vertical_draw_grid", etgl->vertical_draw_grid, NULL); } break; case PROP_TABLE_DRAW_FOCUS: etgl->draw_focus = g_value_get_boolean (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "drawfocus", etgl->draw_focus, NULL); } break; case PROP_CURSOR_MODE: etgl->cursor_mode = g_value_get_int (value); if (etgl->item) { gnome_canvas_item_set ( GNOME_CANVAS_ITEM (etgl->item), "cursor_mode", etgl->cursor_mode, NULL); } break; default: break; } }
static void xfce_xsettings_helper_setting_append (const gchar *name, XfceXSetting *setting, XfceXSettingsNotify *notify) { gsize buf_len, new_len; gsize name_len, name_len_pad; gsize value_len, value_len_pad; const gchar *str = NULL; guchar *needle; guchar type = 0; gint num; name_len = strlen (name) - 1 /* -1 for the xfconf slash */; name_len_pad = XSETTINGS_PAD (name_len, 4); buf_len = 8 + name_len_pad; value_len_pad = value_len = 0; /* get the total size of this setting */ switch (G_VALUE_TYPE (setting->value)) { case G_TYPE_INT: case G_TYPE_BOOLEAN: type = XSettingsTypeInteger; buf_len += 4; break; case G_TYPE_STRING: type = XSettingsTypeString; buf_len += 4; str = g_value_get_string (setting->value); if (str != NULL) { value_len = strlen (str); value_len_pad = XSETTINGS_PAD (value_len, 4); buf_len += value_len_pad; } break; case G_TYPE_INT64 /* TODO */: type = XSettingsTypeColor; buf_len += 8; break; default: g_assert_not_reached (); break; } /* additional length for this setting */ new_len = notify->buf_len + buf_len; /* resize the buffer to fit this setting */ notify->buf = g_renew (guchar, notify->buf, new_len); if (G_UNLIKELY (notify->buf == NULL)) return; needle = notify->buf + notify->buf_len; notify->buf_len = new_len; /* setting record: * * 1 SETTING_TYPE type * 1 unused * 2 n name-len * n STRING8 name * P unused, p=pad(n) * 4 CARD32 last-change-serial */ /* setting type */ *needle++ = type; /* unused */ *needle++ = 0; /* name length */ *(CARD16 *)needle = name_len; needle += 2; /* name */ memcpy (needle, name + 1 /* +1 for the xfconf slash */, name_len); needle += name_len; /* zero the padding */ for (; name_len_pad > name_len; name_len_pad--) *needle++ = 0; /* setting's last change serial */ *(CARD32 *)needle = setting->last_change_serial; needle += 4; /* set setting value */ switch (type) { case XSettingsTypeString: /* body for XSettingsTypeString: * * 4 n value-len * n STRING8 value * P unused, p=pad(n) */ if (G_LIKELY (value_len > 0 && str != NULL)) { /* value length */ *(CARD32 *)needle = value_len; needle += 4; /* value */ memcpy (needle, str, value_len); needle += value_len; /* zero the padding */ for (; value_len_pad > value_len; value_len_pad--) *needle++ = 0; } else { /* value length */ *(CARD32 *)needle = 0; needle += 4; } break; case XSettingsTypeInteger: /* Body for XSettingsTypeInteger: * * 4 INT32 value */ if (G_VALUE_TYPE (setting->value) == G_TYPE_INT) { num = g_value_get_int (setting->value); /* special case handling for DPI */ if (strcmp (name, "/Xft/DPI") == 0) { /* remember the offset for screen dependend dpi * or clamp the value and set 1/1024ths of an inch * for Xft */ if (num < 1) notify->dpi_offset = needle - notify->buf; else num = CLAMP (num, DPI_LOW_REASONABLE, DPI_HIGH_REASONABLE) * 1024; } } else { num = g_value_get_boolean (setting->value); } *(INT32 *)needle = num; needle += 4; break; /* TODO */ case XSettingsTypeColor: /* body for XSettingsTypeColor: * * 2 CARD16 red * 2 CARD16 blue * 2 CARD16 green * 2 CARD16 alpha */ *(CARD16 *)needle = 0; *(CARD16 *)(needle + 2) = 0; *(CARD16 *)(needle + 4) = 0; *(CARD16 *)(needle + 6) = 0; needle += 8; break; default: g_assert_not_reached (); break; } notify->n_settings++; }
static void gimp_paint_options_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpPaintOptions *options = GIMP_PAINT_OPTIONS (object); GimpFadeOptions *fade_options = options->fade_options; GimpJitterOptions *jitter_options = options->jitter_options; GimpGradientOptions *gradient_options = options->gradient_options; GimpSmoothingOptions *smoothing_options = options->smoothing_options; switch (property_id) { case PROP_PAINT_INFO: options->paint_info = g_value_dup_object (value); break; case PROP_USE_APPLICATOR: options->use_applicator = g_value_get_boolean (value); break; case PROP_BRUSH_SIZE: options->brush_size = g_value_get_double (value); break; case PROP_BRUSH_ZOOM: options->brush_zoom = g_value_get_boolean (value); break; case PROP_BRUSH_ASPECT_RATIO: options->brush_aspect_ratio = g_value_get_double (value); break; case PROP_BRUSH_ANGLE: options->brush_angle = - 1.0 * g_value_get_double (value) / 360.0; /* let's make the angle mathematically correct */ break; case PROP_BRUSH_SPACING: options->brush_spacing = g_value_get_double (value); break; case PROP_BRUSH_HARDNESS: options->brush_hardness = g_value_get_double (value); break; case PROP_BRUSH_FORCE: options->brush_force = g_value_get_double (value); break; case PROP_BRUSH_LINK_SIZE: options->brush_link_size = g_value_get_boolean (value); break; case PROP_BRUSH_LINK_ASPECT_RATIO: options->brush_link_aspect_ratio = g_value_get_boolean (value); break; case PROP_BRUSH_LINK_ANGLE: options->brush_link_angle = g_value_get_boolean (value); break; case PROP_BRUSH_LINK_SPACING: options->brush_link_spacing = g_value_get_boolean (value); break; case PROP_BRUSH_LINK_HARDNESS: options->brush_link_hardness = g_value_get_boolean (value); break; case PROP_APPLICATION_MODE: options->application_mode = g_value_get_enum (value); break; case PROP_HARD: options->hard = g_value_get_boolean (value); break; case PROP_USE_JITTER: jitter_options->use_jitter = g_value_get_boolean (value); break; case PROP_JITTER_AMOUNT: jitter_options->jitter_amount = g_value_get_double (value); break; case PROP_DYNAMICS_EXPANDED: options->dynamics_expanded = g_value_get_boolean (value); break; case PROP_FADE_LENGTH: fade_options->fade_length = g_value_get_double (value); break; case PROP_FADE_REVERSE: fade_options->fade_reverse = g_value_get_boolean (value); break; case PROP_FADE_REPEAT: fade_options->fade_repeat = g_value_get_enum (value); break; case PROP_FADE_UNIT: fade_options->fade_unit = g_value_get_int (value); break; case PROP_GRADIENT_REVERSE: gradient_options->gradient_reverse = g_value_get_boolean (value); break; case PROP_BRUSH_VIEW_TYPE: options->brush_view_type = g_value_get_enum (value); break; case PROP_BRUSH_VIEW_SIZE: options->brush_view_size = g_value_get_int (value); break; case PROP_DYNAMICS_VIEW_TYPE: options->dynamics_view_type = g_value_get_enum (value); break; case PROP_DYNAMICS_VIEW_SIZE: options->dynamics_view_size = g_value_get_int (value); break; case PROP_PATTERN_VIEW_TYPE: options->pattern_view_type = g_value_get_enum (value); break; case PROP_PATTERN_VIEW_SIZE: options->pattern_view_size = g_value_get_int (value); break; case PROP_GRADIENT_VIEW_TYPE: options->gradient_view_type = g_value_get_enum (value); break; case PROP_GRADIENT_VIEW_SIZE: options->gradient_view_size = g_value_get_int (value); break; case PROP_USE_SMOOTHING: smoothing_options->use_smoothing = g_value_get_boolean (value); break; case PROP_SMOOTHING_QUALITY: smoothing_options->smoothing_quality = g_value_get_int (value); break; case PROP_SMOOTHING_FACTOR: smoothing_options->smoothing_factor = g_value_get_double (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
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; }
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 int ephy_node_view_sort_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, EphyNodeView *view) { GValue a_value = {0, }; GValue b_value = {0, }; int p_column, column, retval = 0; GtkSortType sort_type; g_return_val_if_fail (model != NULL, 0); g_return_val_if_fail (view != NULL, 0); p_column = view->priv->priority_column; column = view->priv->sort_column; sort_type = view->priv->sort_type; if (p_column >= 0) { gtk_tree_model_get_value (model, a, p_column, &a_value); gtk_tree_model_get_value (model, b, p_column, &b_value); 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; } g_value_unset (&a_value); g_value_unset (&b_value); } if (retval == 0) { GType type; type = gtk_tree_model_get_column_type (model, column); gtk_tree_model_get_value (model, a, column, &a_value); gtk_tree_model_get_value (model, b, column, &b_value); switch (G_TYPE_FUNDAMENTAL (type)) { case G_TYPE_STRING: retval = compare_string_values (&a_value, &b_value); 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_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; default: g_warning ("Attempting to sort on invalid type %s\n", g_type_name (type)); break; } g_value_unset (&a_value); g_value_unset (&b_value); } if (sort_type == GTK_SORT_DESCENDING) { if (retval > 0) { retval = -1; } else if (retval < 0) { retval = 1; } } return retval; }
/* * 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 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); }
static GimpValueArray * image_convert_indexed_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; gint32 dither_type; gint32 palette_type; gint32 num_cols; gboolean alpha_dither; gboolean remove_unused; const gchar *palette; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); dither_type = g_value_get_enum (gimp_value_array_index (args, 1)); palette_type = g_value_get_enum (gimp_value_array_index (args, 2)); num_cols = g_value_get_int (gimp_value_array_index (args, 3)); alpha_dither = g_value_get_boolean (gimp_value_array_index (args, 4)); remove_unused = g_value_get_boolean (gimp_value_array_index (args, 5)); palette = g_value_get_string (gimp_value_array_index (args, 6)); if (success) { GimpPalette *pal = NULL; if (gimp_pdb_image_is_not_base_type (image, GIMP_INDEXED, error) && gimp_pdb_image_is_precision (image, GIMP_PRECISION_U8, error) && gimp_item_stack_is_flat (GIMP_ITEM_STACK (gimp_image_get_layers (image)))) { switch (palette_type) { case GIMP_MAKE_PALETTE: if (num_cols < 1 || num_cols > MAXNUMCOLORS) success = FALSE; break; case GIMP_CUSTOM_PALETTE: pal = gimp_pdb_get_palette (gimp, palette, FALSE, error); if (! pal) { success = FALSE; } else if (pal->n_colors > MAXNUMCOLORS) { g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT, _("Cannot convert to a palette " "with more than 256 colors.")); success = FALSE; } break; default: break; } } else { success = FALSE; } if (success) success = gimp_image_convert_type (image, GIMP_INDEXED, num_cols, dither_type, alpha_dither, FALSE, remove_unused, palette_type, pal, NULL, error); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
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 void gst_motion_cells_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstMotioncells *filter = gst_motion_cells (object); //variables for overlay regions setup gchar **strs, **colorstr, **motioncellsstr, **motionmaskcellsstr; int i, ux, uy, lx, ly; int r, g, b; int cellscolorscnt = 0; int linidx, colidx, masklinidx, maskcolidx; int tmpux = -1; int tmpuy = -1; int tmplx = -1; int tmply = -1; GstStateChangeReturn ret; g_mutex_lock (filter->propset_mutex); switch (prop_id) { case PROP_GRID_X: ret = gst_element_get_state (GST_ELEMENT (filter), &filter->state, NULL, 250 * GST_NSECOND); filter->gridx = g_value_get_int (value); if (filter->prevgridx != filter->gridx && ret == GST_STATE_CHANGE_SUCCESS && filter->state == GST_STATE_PLAYING) { filter->changed_gridx = true; } filter->prevgridx = filter->gridx; break; case PROP_GRID_Y: ret = gst_element_get_state (GST_ELEMENT (filter), &filter->state, NULL, 250 * GST_NSECOND); filter->gridy = g_value_get_int (value); if (filter->prevgridy != filter->gridy && ret == GST_STATE_CHANGE_SUCCESS && filter->state == GST_STATE_PLAYING) { filter->changed_gridy = true; } filter->prevgridy = filter->gridy; break; case PROP_GAP: filter->gap = g_value_get_int (value); break; case PROP_POSTNOMOTION: filter->postnomotion = g_value_get_int (value); break; case PROP_MINIMUNMOTIONFRAMES: filter->minimum_motion_frames = g_value_get_int (value); break; case PROP_SENSITIVITY: filter->sensitivity = g_value_get_double (value); break; case PROP_THRESHOLD: filter->threshold = g_value_get_double (value); break; case PROP_DISPLAY: filter->display = g_value_get_boolean (value); break; case PROP_POSTALLMOTION: filter->postallmotion = g_value_get_boolean (value); break; case PROP_USEALPHA: filter->usealpha = g_value_get_boolean (value); break; case PROP_CALCULATEMOTION: filter->calculate_motion = g_value_get_boolean (value); break; case PROP_DATE: ret = gst_element_get_state (GST_ELEMENT (filter), &filter->state, NULL, 250 * GST_NSECOND); if (ret == GST_STATE_CHANGE_SUCCESS && filter->state == GST_STATE_PLAYING) { filter->changed_startime = true; } filter->starttime = g_value_get_long (value); break; case PROP_DATAFILE: GFREE (filter->cur_datafile); GFREE (filter->basename_datafile); filter->basename_datafile = g_value_dup_string (value); if (strlen (filter->basename_datafile) == 0) { filter->cur_datafile = g_strdup (NULL); break; } filter->cur_datafile = g_strdup_printf ("%s-0.%s", filter->basename_datafile, filter->datafile_extension); if (g_strcmp0 (filter->prev_datafile, filter->basename_datafile) != 0) { filter->changed_datafile = TRUE; filter->sent_init_error_msg = FALSE; filter->sent_save_error_msg = FALSE; filter->datafileidx = 0; motion_cells_free_resources (filter->id); } else { filter->changed_datafile = FALSE; } GFREE (filter->prev_datafile); filter->prev_datafile = g_strdup (filter->basename_datafile); break; case PROP_DATAFILE_EXT: GFREE (filter->datafile_extension); filter->datafile_extension = g_value_dup_string (value); break; case PROP_MOTIONMASKCOORD: strs = g_strsplit (g_value_get_string (value), ",", 255); GFREE (filter->motionmaskcoords); //setting number of regions for (filter->motionmaskcoord_count = 0; strs[filter->motionmaskcoord_count] != NULL; ++filter->motionmaskcoord_count); if (filter->motionmaskcoord_count > 0) { sscanf (strs[0], "%d:%d:%d:%d", &tmpux, &tmpuy, &tmplx, &tmply); if (tmpux > -1 && tmpuy > -1 && tmplx > -1 && tmply > -1) { filter->motionmaskcoords = g_new0 (motionmaskcoordrect, filter->motionmaskcoord_count); for (i = 0; i < filter->motionmaskcoord_count; ++i) { sscanf (strs[i], "%d:%d:%d:%d", &ux, &uy, &lx, &ly); ux = CLAMP (ux, 0, filter->width - 1); uy = CLAMP (uy, 0, filter->height - 1); lx = CLAMP (lx, 0, filter->width - 1); ly = CLAMP (ly, 0, filter->height - 1); filter->motionmaskcoords[i].upper_left_x = ux; filter->motionmaskcoords[i].upper_left_y = uy; filter->motionmaskcoords[i].lower_right_x = lx; filter->motionmaskcoords[i].lower_right_y = ly; } } else { filter->motionmaskcoord_count = 0; } } if (strs) g_strfreev (strs); tmpux = -1; tmpuy = -1; tmplx = -1; tmply = -1; break; case PROP_MOTIONMASKCELLSPOS: motionmaskcellsstr = g_strsplit (g_value_get_string (value), ",", 255); GFREE (filter->motionmaskcellsidx); //setting number of regions for (filter->motionmaskcells_count = 0; motionmaskcellsstr[filter->motionmaskcells_count] != NULL; ++filter->motionmaskcells_count); if (filter->motionmaskcells_count > 0) { sscanf (motionmaskcellsstr[0], "%d:%d", &tmpux, &tmpuy); if (tmpux > -1 && tmpuy > -1) { filter->motionmaskcellsidx = g_new0 (motioncellidx, filter->motionmaskcells_count); for (i = 0; i < filter->motionmaskcells_count; ++i) { sscanf (motionmaskcellsstr[i], "%d:%d", &masklinidx, &maskcolidx); filter->motionmaskcellsidx[i].lineidx = masklinidx; filter->motionmaskcellsidx[i].columnidx = maskcolidx; } } else { filter->motionmaskcells_count = 0; } } if (motionmaskcellsstr) g_strfreev (motionmaskcellsstr); tmpux = -1; tmpuy = -1; tmplx = -1; tmply = -1; break; case PROP_CELLSCOLOR: colorstr = g_strsplit (g_value_get_string (value), ",", 255); for (cellscolorscnt = 0; colorstr[cellscolorscnt] != NULL; ++cellscolorscnt); if (cellscolorscnt == 3) { sscanf (colorstr[0], "%d", &r); sscanf (colorstr[1], "%d", &g); sscanf (colorstr[2], "%d", &b); //check right RGB color format r = CLAMP (r, 1, 255); g = CLAMP (g, 1, 255); b = CLAMP (b, 1, 255); filter->motioncellscolor->R_channel_value = r; filter->motioncellscolor->G_channel_value = g; filter->motioncellscolor->B_channel_value = b; } if (colorstr) g_strfreev (colorstr); break; case PROP_MOTIONCELLSIDX: motioncellsstr = g_strsplit (g_value_get_string (value), ",", 255); //setting number of regions for (filter->motioncells_count = 0; motioncellsstr[filter->motioncells_count] != NULL; ++filter->motioncells_count); if (filter->motioncells_count > 0) { sscanf (motioncellsstr[0], "%d:%d", &tmpux, &tmpuy); if (tmpux > -1 && tmpuy > -1) { GFREE (filter->motioncellsidx); filter->motioncellsidx = g_new0 (motioncellidx, filter->motioncells_count); for (i = 0; i < filter->motioncells_count; ++i) { sscanf (motioncellsstr[i], "%d:%d", &linidx, &colidx); filter->motioncellsidx[i].lineidx = linidx; filter->motioncellsidx[i].columnidx = colidx; } } else { filter->motioncells_count = 0; } } if (motioncellsstr) g_strfreev (motioncellsstr); tmpux = -1; tmpuy = -1; tmplx = -1; tmply = -1; break; case PROP_MOTIONCELLTHICKNESS: filter->thickness = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } g_mutex_unlock (filter->propset_mutex); }
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); }