static void impl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { RhythmDBImportJob *job = RHYTHMDB_IMPORT_JOB (object); switch (prop_id) { case PROP_DB: g_value_set_object (value, job->priv->db); break; case PROP_ENTRY_TYPE: g_value_set_object (value, job->priv->entry_type); break; case PROP_IGNORE_TYPE: g_value_set_object (value, job->priv->ignore_type); break; case PROP_ERROR_TYPE: g_value_set_object (value, job->priv->error_type); break; case PROP_TASK_LABEL: g_value_set_string (value, job->priv->task_label); break; case PROP_TASK_DETAIL: if (job->priv->scan_complete == FALSE) { g_value_set_string (value, _("Scanning")); } else if (job->priv->total > 0) { g_value_take_string (value, g_strdup_printf (_("%d of %d"), job->priv->processed, job->priv->total)); } break; case PROP_TASK_PROGRESS: if (job->priv->scan_complete == FALSE) { g_value_set_double (value, -1.0); } else if (job->priv->total == 0) { g_value_set_double (value, 0.0); } else { g_value_set_double (value, ((float)job->priv->processed / (float)job->priv->total)); } break; case PROP_TASK_OUTCOME: if (job->priv->complete) { g_value_set_enum (value, RB_TASK_OUTCOME_COMPLETE); } else if (g_cancellable_is_cancelled (job->priv->cancel)) { g_value_set_enum (value, RB_TASK_OUTCOME_CANCELLED); } else { g_value_set_enum (value, RB_TASK_OUTCOME_NONE); } break; case PROP_TASK_NOTIFY: g_value_set_boolean (value, job->priv->task_notify); break; case PROP_TASK_CANCELLABLE: g_value_set_boolean (value, TRUE); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void ptk_file_list_get_value ( GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value ) { GList* l; PtkFileList* list = PTK_FILE_LIST(tree_model); VFSFileInfo* info; GdkPixbuf* icon; g_return_if_fail (PTK_IS_FILE_LIST (tree_model)); g_return_if_fail (iter != NULL); g_return_if_fail (column < G_N_ELEMENTS(column_types) ); g_value_init (value, column_types[column] ); l = (GList*) iter->user_data; g_return_if_fail ( l != NULL ); info = (VFSFileInfo*)iter->user_data2; switch(column) { case COL_FILE_BIG_ICON: icon = NULL; /* special file can use special icons saved as thumbnails*/ if( list->max_thumbnail > vfs_file_info_get_size( info ) && info->flags == VFS_FILE_INFO_NONE ) icon = vfs_file_info_get_big_thumbnail( info ); if( ! icon ) icon = vfs_file_info_get_big_icon( info ); if( icon ) { g_value_set_object( value, icon ); g_object_unref( icon ); } break; case COL_FILE_SMALL_ICON: icon = NULL; /* special file can use special icons saved as thumbnails*/ if( list->max_thumbnail > vfs_file_info_get_size( info ) ) icon = vfs_file_info_get_small_thumbnail( info ); if( !icon ) icon = vfs_file_info_get_small_icon( info ); if( icon ) { g_value_set_object( value, icon ); g_object_unref( icon ); } break; case COL_FILE_NAME: g_value_set_string( value, vfs_file_info_get_disp_name(info) ); break; case COL_FILE_SIZE: if ( S_ISDIR( info->mode ) || ( S_ISLNK( info->mode ) && 0 == strcmp( vfs_mime_type_get_type( info->mime_type ), XDG_MIME_TYPE_DIRECTORY ) ) ) g_value_set_string( value, NULL ); else g_value_set_string( value, vfs_file_info_get_disp_size(info) ); break; case COL_FILE_DESC: g_value_set_string( value, vfs_file_info_get_mime_type_desc( info ) ); break; case COL_FILE_PERM: g_value_set_string( value, vfs_file_info_get_disp_perm(info) ); break; case COL_FILE_OWNER: g_value_set_string( value, vfs_file_info_get_disp_owner(info) ); break; case COL_FILE_MTIME: g_value_set_string( value, vfs_file_info_get_disp_mtime(info) ); break; case COL_FILE_INFO: g_value_set_pointer( value, vfs_file_info_ref( info ) ); break; } }
/****************************************************************************** * gtk_ListStoreSetValue(list,path_string, ncol, val) ******************************************************************************/ int clip_GTK_LISTSTORESETVALUE(ClipMachine * cm) { C_object *cslist = _fetch_co_arg(cm); gchar *path = _clip_parc(cm, 2); gint column = _clip_parni(cm, 3); ClipVar *val = _clip_par(cm, 4);; GtkTreeIter iter; ClipArrVar *utypes; GValue value; C_object *cobj; gchar *str; int j, n; double d; CHECKARG2(1, MAP_t, NUMERIC_t);CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); CHECKARG(2, CHARACTER_t); CHECKARG(3, NUMERIC_t); gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_LIST_STORE(cslist->object)), &iter, gtk_tree_path_new_from_string(path)); utypes = (ClipArrVar *)_clip_vptr(_clip_mget(cm, &cslist->obj, HASH_UTYPES)); column --; memset(&value, 0, sizeof(value)); switch ((int)utypes->items[column].n.d) { case TREE_TYPE_NUMERIC: g_value_init(&value, G_TYPE_INT); if (val->t.type == NUMERIC_t) g_value_set_int(&value, (int)val->n.d); else { n = _clip_strtod(val->s.str.buf, &j); g_value_set_int(&value, n); } break; case TREE_TYPE_NUMERIC_FLOAT: g_value_init(&value, G_TYPE_FLOAT); if (val->t.type == NUMERIC_t) g_value_set_float(&value, val->n.d); else { d = _clip_strtod(val->s.str.buf, &j); g_value_set_float(&value, d); } break; case TREE_TYPE_STRING: str = val->s.str.buf; LOCALE_TO_UTF(str); g_value_init(&value, G_TYPE_STRING); g_value_set_string(&value, str); FREE_TEXT(str); break; case TREE_TYPE_LOGICAL: g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, val->l.val); break; case TREE_TYPE_PIXBUF: g_value_init(&value, GDK_TYPE_PIXBUF); cobj = _fetch_cobject(cm, val); g_value_set_object(&value, cobj->object); break; case TREE_TYPE_DATE: g_value_init(&value, G_TYPE_STRING); if (val->t.type == DATE_t) str = _clip_date_to_str(val->lv.l, cm->date_format); else str = _clip_date_to_str(_clip_str_to_date(val->s.str.buf, cm->date_format, cm->epoch), cm->date_format); g_value_set_string(&value, str); break; } gtk_list_store_set_value(GTK_LIST_STORE(cslist->object), &iter, column, &value); return 0; err: return 1; }
static void null_value(GValue *value, GObject *where_the_object_was) { g_value_set_object(value, NULL); }
gboolean json_deserialize_pspec (GValue *value, GParamSpec *pspec, JsonNode *node) { GValue node_value = { 0, }; gboolean retval = FALSE; if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOXED) { JsonNodeType node_type = json_node_get_node_type (node); GType boxed_type = G_VALUE_TYPE (value); if (json_boxed_can_deserialize (boxed_type, node_type)) { gpointer boxed = json_boxed_deserialize (boxed_type, node); g_value_take_boxed (value, boxed); return TRUE; } } switch (JSON_NODE_TYPE (node)) { case JSON_NODE_OBJECT: if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT)) { GObject *object; object = json_gobject_new (G_VALUE_TYPE (value), json_node_get_object (node)); if (object != NULL) g_value_take_object (value, object); else g_value_set_object (value, NULL); retval = TRUE; } break; case JSON_NODE_ARRAY: if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { JsonArray *array = json_node_get_array (node); guint i, array_len = json_array_get_length (array); GPtrArray *str_array = g_ptr_array_sized_new (array_len + 1); for (i = 0; i < array_len; i++) { JsonNode *val = json_array_get_element (array, i); if (JSON_NODE_TYPE (val) != JSON_NODE_VALUE) continue; if (json_node_get_string (val) != NULL) g_ptr_array_add (str_array, (gpointer) json_node_get_string (val)); } g_ptr_array_add (str_array, NULL); g_value_set_boxed (value, str_array->pdata); g_ptr_array_free (str_array, TRUE); retval = TRUE; } break; case JSON_NODE_VALUE: json_node_get_value (node, &node_value); #if 0 { gchar *node_str = g_strdup_value_contents (&node_value); g_debug ("%s: value type '%s' := node value type '%s' -> '%s'", G_STRLOC, g_type_name (G_VALUE_TYPE (value)), g_type_name (G_VALUE_TYPE (&node_value)), node_str); g_free (node_str); } #endif switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) { case G_TYPE_BOOLEAN: case G_TYPE_INT64: case G_TYPE_STRING: if (G_VALUE_HOLDS (&node_value, G_VALUE_TYPE (value))) { g_value_copy (&node_value, value); retval = TRUE; } break; case G_TYPE_INT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_int (value, (gint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_CHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_schar (value, (gchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UINT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uint (value, (guint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UCHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uchar (value, (guchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_DOUBLE: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_double (value, g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_double (value, (gdouble) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_FLOAT: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_float (value, (gfloat) g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_float (value, (gfloat) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_ENUM: { gint enum_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { enum_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = enum_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &enum_value); } if (retval) g_value_set_enum (value, enum_value); } break; case G_TYPE_FLAGS: { gint flags_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { flags_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = flags_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &flags_value); } if (retval) g_value_set_flags (value, flags_value); } break; default: retval = FALSE; break; } g_value_unset (&node_value); break; case JSON_NODE_NULL: if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) { g_value_set_string (value, NULL); retval = TRUE; } else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT) { g_value_set_object (value, NULL); retval = TRUE; } else retval = FALSE; break; } return retval; }
void ags_recycling_context_get_property(GObject *gobject, guint prop_id, GValue *value, GParamSpec *param_spec) { AgsRecyclingContext *recycling_context; pthread_mutex_t *recycling_context_mutex; recycling_context = AGS_RECYCLING_CONTEXT(gobject); /* get recycling context mutex */ pthread_mutex_lock(ags_recycling_context_get_class_mutex()); recycling_context_mutex = recycling_context->obj_mutex; pthread_mutex_unlock(ags_recycling_context_get_class_mutex()); switch(prop_id){ case PROP_RECALL_ID: { pthread_mutex_lock(recycling_context_mutex); g_value_set_object(value, recycling_context->recall_id); pthread_mutex_unlock(recycling_context_mutex); } break; case PROP_PARENT: { pthread_mutex_lock(recycling_context_mutex); g_value_set_object(value, recycling_context->parent); pthread_mutex_unlock(recycling_context_mutex); } break; case PROP_CHILD: { pthread_mutex_lock(recycling_context_mutex); g_value_set_pointer(value, g_list_copy_deep(recycling_context->children, (GCopyFunc) g_object_ref, NULL)); pthread_mutex_unlock(recycling_context_mutex); } break; case PROP_LENGTH: { pthread_mutex_lock(recycling_context_mutex); g_value_set_uint64(value, recycling_context->length); pthread_mutex_unlock(recycling_context_mutex); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
static void tree_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value) { GList *proposal_node; ProposalInfo *proposal_info; ProviderInfo *provider_info; GtkSourceCompletionProposal *completion_proposal; GtkSourceCompletionProvider *completion_provider; g_return_if_fail (GTK_SOURCE_IS_COMPLETION_MODEL (tree_model)); g_return_if_fail (iter != NULL); g_return_if_fail (iter->user_data != NULL); g_return_if_fail (0 <= column && column < GTK_SOURCE_COMPLETION_MODEL_N_COLUMNS); proposal_node = iter->user_data; proposal_info = proposal_node->data; provider_info = proposal_info->provider_node->data; completion_proposal = proposal_info->completion_proposal; completion_provider = provider_info->completion_provider; g_value_init (value, GTK_SOURCE_COMPLETION_MODEL (tree_model)->priv->column_types[column]); switch (column) { case GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROVIDER: g_value_set_object (value, completion_provider); break; case GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROPOSAL: g_value_set_object (value, completion_proposal); break; case GTK_SOURCE_COMPLETION_MODEL_COLUMN_MARKUP: if (is_header (proposal_info)) { gchar *name = gtk_source_completion_provider_get_name (completion_provider); if (name != NULL) { gchar *escaped = g_markup_escape_text (name, -1); gchar *markup = g_strdup_printf ("<b>%s</b>", escaped); g_value_take_string (value, markup); g_free (name); g_free (escaped); } else { gchar *markup = g_strdup_printf ("<b>%s</b>", _("Provider")); g_value_take_string (value, markup); } } else { gchar *markup = gtk_source_completion_proposal_get_markup (completion_proposal); if (markup == NULL) { gchar *label = gtk_source_completion_proposal_get_label (completion_proposal); markup = g_markup_escape_text (label != NULL ? label : "", -1); g_free (label); } g_value_take_string (value, markup); } break; case GTK_SOURCE_COMPLETION_MODEL_COLUMN_ICON: if (is_header (proposal_info)) { GdkPixbuf *icon = gtk_source_completion_provider_get_icon (completion_provider); g_value_set_object (value, (gpointer)icon); } else { GdkPixbuf *icon = gtk_source_completion_proposal_get_icon (completion_proposal); g_value_set_object (value, (gpointer)icon); } break; case GTK_SOURCE_COMPLETION_MODEL_COLUMN_IS_HEADER: g_value_set_boolean (value, is_header (proposal_info)); break; default: g_assert_not_reached (); } }
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: #if GLIB_CHECK_VERSION(2,31,0) return rts_mkChar(CAP g_value_get_schar(value)); #else return rts_mkChar(CAP g_value_get_char(value)); #endif 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 rts_mkPtr(CAP 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: #if GLIB_CHECK_VERSION(2,31,0) g_value_set_schar(value, rts_getChar(obj)); #else g_value_set_char(value, rts_getChar(obj)); #endif return; case G_TYPE_UCHAR: #if GLIB_CHECK_VERSION(2,31,0) g_value_set_schar(value, rts_getChar(obj)); #else g_value_set_char(value, rts_getChar(obj)); #endif 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 void vinagre_connection_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { VinagreConnection *conn; g_return_if_fail (VINAGRE_IS_CONNECTION (object)); conn = VINAGRE_CONNECTION (object); switch (prop_id) { case PROP_PROTOCOL: g_value_set_enum (value, conn->priv->protocol); break; case PROP_HOST: g_value_set_string (value, conn->priv->host); break; case PROP_PORT: g_value_set_int (value, conn->priv->port); break; case PROP_USERNAME: g_value_set_string (value, conn->priv->username); break; case PROP_PASSWORD: g_value_set_string (value, conn->priv->password); break; case PROP_NAME: g_value_set_string (value, conn->priv->name); break; case PROP_DESKTOP_NAME: g_value_set_string (value, conn->priv->desktop_name); break; case PROP_BEST_NAME: g_value_set_string (value, vinagre_connection_get_best_name (conn)); break; case PROP_ICON: g_value_set_object (value, vinagre_connection_get_icon (conn)); break; case PROP_VIEW_ONLY: g_value_set_boolean (value, conn->priv->view_only); break; case PROP_SCALING: g_value_set_boolean (value, conn->priv->scaling); break; case PROP_FULLSCREEN: g_value_set_boolean (value, conn->priv->fullscreen); break; case PROP_SHARED: g_value_set_int (value, conn->priv->shared); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_camera_bin_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstCameraBin *camera = GST_CAMERA_BIN_CAST (object); switch (prop_id) { case PROP_MODE: g_value_set_enum (value, camera->mode); break; case PROP_LOCATION: if (camera->mode == MODE_VIDEO) { g_value_set_string (value, camera->video_location); } else { g_value_set_string (value, camera->image_location); } break; case PROP_CAMERA_SRC: g_value_set_object (value, camera->src); break; case PROP_VIDEO_CAPTURE_SUPPORTED_CAPS: case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS:{ GstPad *pad; GstCaps *caps; const gchar *padname; if (prop_id == PROP_VIDEO_CAPTURE_SUPPORTED_CAPS) { padname = GST_BASE_CAMERA_SRC_VIDEO_PAD_NAME; } else { padname = GST_BASE_CAMERA_SRC_IMAGE_PAD_NAME; } if (camera->src) { pad = gst_element_get_static_pad (camera->src, padname); g_assert (pad != NULL); /* TODO not sure if we want get_caps or get_allowed_caps to already * consider the full pipeline scenario and avoid picking a caps that * won't negotiate. Need to take care on the special case of the * pad being unlinked. */ caps = gst_pad_get_caps_reffed (pad); if (caps) { gst_value_set_caps (value, caps); gst_caps_unref (caps); } gst_object_unref (pad); } else { GST_DEBUG_OBJECT (camera, "Camera source not created, can't get " "supported caps"); } } break; case PROP_IMAGE_CAPTURE_CAPS:{ GstCaps *caps = NULL; g_object_get (camera->imagebin_capsfilter, "caps", &caps, NULL); gst_value_set_caps (value, caps); gst_caps_unref (caps); } break; case PROP_VIDEO_CAPTURE_CAPS:{ GstCaps *caps = NULL; g_object_get (camera->videobin_capsfilter, "caps", &caps, NULL); gst_value_set_caps (value, caps); gst_caps_unref (caps); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gboolean json_deserialize_pspec (GValue *value, GParamSpec *pspec, json_t *node) { switch (json_typeof(node)) { case JSON_OBJECT: if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT)) { GObject *object; object = json_gobject_deserialize (G_VALUE_TYPE (value), node); if (object) g_value_take_object (value, object); else g_value_set_object (value, NULL); return TRUE; } break; case JSON_STRING: if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) { g_value_set_string(value, json_string_value(node)); return TRUE; } break; case JSON_INTEGER: { json_int_t int_value = json_integer_value (node); switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) { case G_TYPE_CHAR: g_value_set_schar(value, (gchar)int_value); return TRUE; case G_TYPE_UCHAR: g_value_set_uchar (value, (guchar)int_value); return TRUE; case G_TYPE_INT: g_value_set_int (value, (gint)int_value); return TRUE; case G_TYPE_UINT: g_value_set_uint(value, (guint)int_value); return TRUE; case G_TYPE_LONG: g_value_set_long(value, (glong)int_value); return TRUE; case G_TYPE_ULONG: g_value_set_ulong(value, (gulong)int_value); return TRUE; case G_TYPE_INT64: g_value_set_int64(value,(gint64)int_value); return TRUE; case G_TYPE_ENUM: g_value_set_enum(value,(gint64)int_value); return TRUE; case G_TYPE_FLAGS: g_value_set_flags(value,(gint64)int_value); return TRUE; } } break; case JSON_REAL: { double real_value = json_real_value(node); switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) { case G_TYPE_FLOAT: g_value_set_float(value,(gfloat)real_value); return TRUE; case G_TYPE_DOUBLE: g_value_set_double(value,(gdouble)real_value); return TRUE; } } break; case JSON_TRUE: case JSON_FALSE: if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOOLEAN) { g_value_set_boolean(value,(gboolean)json_is_true(node)); return TRUE; } break; case JSON_NULL: if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) { g_value_set_string (value, NULL); return TRUE; } else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT) { g_value_set_object (value, NULL); return TRUE; } break; case JSON_ARRAY: return FALSE; break; default: return FALSE; } return FALSE; }
static JSBool gjs_value_to_g_value_internal(JSContext *context, jsval value, GValue *gvalue, gboolean no_copy) { GType gtype; gtype = G_VALUE_TYPE(gvalue); if (gtype == 0) { gtype = gjs_value_guess_g_type(context, value); if (gtype == G_TYPE_INVALID) { gjs_throw(context, "Could not guess unspecified GValue type"); return JS_FALSE; } gjs_debug_marshal(GJS_DEBUG_GCLOSURE, "Guessed GValue type %s from JS Value", g_type_name(gtype)); g_value_init(gvalue, gtype); } gjs_debug_marshal(GJS_DEBUG_GCLOSURE, "Converting jsval to gtype %s", g_type_name(gtype)); if (gtype == G_TYPE_STRING) { /* Don't use ValueToString since we don't want to just toString() * everything automatically */ if (JSVAL_IS_NULL(value)) { g_value_set_string(gvalue, NULL); } else if (JSVAL_IS_STRING(value)) { gchar *utf8_string; if (!gjs_string_to_utf8(context, value, &utf8_string)) return JS_FALSE; g_value_take_string(gvalue, utf8_string); } else { gjs_throw(context, "Wrong type %s; string expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (gtype == G_TYPE_CHAR) { gint32 i; if (JS_ValueToInt32(context, value, &i) && i >= SCHAR_MIN && i <= SCHAR_MAX) { g_value_set_schar(gvalue, (signed char)i); } else { gjs_throw(context, "Wrong type %s; char expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (gtype == G_TYPE_UCHAR) { guint16 i; if (JS_ValueToUint16(context, value, &i) && i <= UCHAR_MAX) { g_value_set_uchar(gvalue, (unsigned char)i); } else { gjs_throw(context, "Wrong type %s; unsigned char expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (gtype == G_TYPE_INT) { gint32 i; if (JS_ValueToInt32(context, value, &i)) { g_value_set_int(gvalue, i); } else { gjs_throw(context, "Wrong type %s; integer expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (gtype == G_TYPE_DOUBLE) { gdouble d; if (JS_ValueToNumber(context, value, &d)) { g_value_set_double(gvalue, d); } else { gjs_throw(context, "Wrong type %s; double expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (gtype == G_TYPE_FLOAT) { gdouble d; if (JS_ValueToNumber(context, value, &d)) { g_value_set_float(gvalue, d); } else { gjs_throw(context, "Wrong type %s; float expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (gtype == G_TYPE_UINT) { guint32 i; if (JS_ValueToECMAUint32(context, value, &i)) { g_value_set_uint(gvalue, i); } else { gjs_throw(context, "Wrong type %s; unsigned integer expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (gtype == G_TYPE_BOOLEAN) { JSBool b; /* JS_ValueToBoolean() pretty much always succeeds, * which is maybe surprising sometimes, but could * be handy also... */ if (JS_ValueToBoolean(context, value, &b)) { g_value_set_boolean(gvalue, b); } else { gjs_throw(context, "Wrong type %s; boolean expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (g_type_is_a(gtype, G_TYPE_OBJECT) || g_type_is_a(gtype, G_TYPE_INTERFACE)) { GObject *gobj; gobj = NULL; if (JSVAL_IS_NULL(value)) { /* nothing to do */ } else if (JSVAL_IS_OBJECT(value)) { JSObject *obj; obj = JSVAL_TO_OBJECT(value); if (!gjs_typecheck_object(context, obj, gtype, JS_TRUE)) return JS_FALSE; gobj = gjs_g_object_from_object(context, obj); } else { gjs_throw(context, "Wrong type %s; object %s expected", gjs_get_type_name(value), g_type_name(gtype)); return JS_FALSE; } g_value_set_object(gvalue, gobj); } else if (gtype == G_TYPE_STRV) { if (JSVAL_IS_NULL(value)) { /* do nothing */ } else if (gjs_object_has_property(context, JSVAL_TO_OBJECT(value), "length")) { jsval length_value; guint32 length; if (!gjs_object_require_property(context, JSVAL_TO_OBJECT(value), NULL, "length", &length_value) || !JS_ValueToECMAUint32(context, length_value, &length)) { gjs_throw(context, "Wrong type %s; strv expected", gjs_get_type_name(value)); return JS_FALSE; } else { void *result; char **strv; if (!gjs_array_to_strv (context, value, length, &result)) return JS_FALSE; /* cast to strv in a separate step to avoid type-punning */ strv = result; g_value_take_boxed (gvalue, strv); } } else { gjs_throw(context, "Wrong type %s; strv expected", gjs_get_type_name(value)); return JS_FALSE; } } else if (g_type_is_a(gtype, G_TYPE_BOXED)) { void *gboxed; gboxed = NULL; if (JSVAL_IS_NULL(value)) { /* nothing to do */ } else if (JSVAL_IS_OBJECT(value)) { JSObject *obj; obj = JSVAL_TO_OBJECT(value); if (g_type_is_a(gtype, G_TYPE_ERROR)) { /* special case GError */ if (!gjs_typecheck_gerror(context, obj, JS_TRUE)) return JS_FALSE; gboxed = gjs_gerror_from_error(context, obj); } else { /* First try a union, if that fails, assume a boxed struct. Distinguishing which one is expected would require checking the associated GIBaseInfo, which is not necessary possible, if e.g. we see the GType without loading the typelib. */ if (gjs_typecheck_union(context, obj, NULL, gtype, JS_FALSE)) { gboxed = gjs_c_union_from_union(context, obj); } else { if (!gjs_typecheck_boxed(context, obj, NULL, gtype, JS_TRUE)) return JS_FALSE; gboxed = gjs_c_struct_from_boxed(context, obj); } } } else { gjs_throw(context, "Wrong type %s; boxed type %s expected", gjs_get_type_name(value), g_type_name(gtype)); return JS_FALSE; } if (no_copy) g_value_set_static_boxed(gvalue, gboxed); else g_value_set_boxed(gvalue, gboxed); } else if (g_type_is_a(gtype, G_TYPE_VARIANT)) { GVariant *variant = NULL; if (JSVAL_IS_NULL(value)) { /* nothing to do */ } else if (JSVAL_IS_OBJECT(value)) { JSObject *obj = JSVAL_TO_OBJECT(value); if (!gjs_typecheck_boxed(context, obj, NULL, G_TYPE_VARIANT, JS_TRUE)) return JS_FALSE; variant = gjs_c_struct_from_boxed(context, obj); } else { gjs_throw(context, "Wrong type %s; boxed type %s expected", gjs_get_type_name(value), g_type_name(gtype)); return JS_FALSE; } g_value_set_variant (gvalue, variant); } else if (g_type_is_a(gtype, G_TYPE_ENUM)) { gint64 value_int64; if (gjs_value_to_int64 (context, value, &value_int64)) { GEnumValue *v; /* See arg.c:_gjs_enum_to_int() */ v = g_enum_get_value(G_ENUM_CLASS(g_type_class_peek(gtype)), (int)value_int64); if (v == NULL) { gjs_throw(context, "%d is not a valid value for enumeration %s", JSVAL_TO_INT(value), g_type_name(gtype)); return JS_FALSE; } g_value_set_enum(gvalue, v->value); } else { gjs_throw(context, "Wrong type %s; enum %s expected", gjs_get_type_name(value), g_type_name(gtype)); return JS_FALSE; } } else if (g_type_is_a(gtype, G_TYPE_FLAGS)) { gint64 value_int64; if (gjs_value_to_int64 (context, value, &value_int64)) { if (!_gjs_flags_value_is_valid(context, gtype, value_int64)) return JS_FALSE; /* See arg.c:_gjs_enum_to_int() */ g_value_set_flags(gvalue, (int)value_int64); } else { gjs_throw(context, "Wrong type %s; flags %s expected", gjs_get_type_name(value), g_type_name(gtype)); return JS_FALSE; } } else if (g_type_is_a(gtype, G_TYPE_PARAM)) { void *gparam; gparam = NULL; if (JSVAL_IS_NULL(value)) { /* nothing to do */ } else if (JSVAL_IS_OBJECT(value)) { JSObject *obj; obj = JSVAL_TO_OBJECT(value); if (!gjs_typecheck_param(context, obj, gtype, JS_TRUE)) return JS_FALSE; gparam = gjs_g_param_from_param(context, obj); } else { gjs_throw(context, "Wrong type %s; param type %s expected", gjs_get_type_name(value), g_type_name(gtype)); return JS_FALSE; } g_value_set_param(gvalue, gparam); } else if (g_type_is_a(gtype, G_TYPE_GTYPE)) { GType type; if (!JSVAL_IS_OBJECT(value)) { gjs_throw(context, "Wrong type %s; expect a GType object", gjs_get_type_name(value)); return JS_FALSE; } type = gjs_gtype_get_actual_gtype(context, JSVAL_TO_OBJECT(value)); g_value_set_gtype(gvalue, type); } else if (g_type_is_a(gtype, G_TYPE_POINTER)) { if (JSVAL_IS_NULL(value)) { /* Nothing to do */ } else { gjs_throw(context, "Cannot convert non-null JS value to G_POINTER"); return JS_FALSE; } } else if (JSVAL_IS_NUMBER(value) && g_value_type_transformable(G_TYPE_INT, gtype)) { /* Only do this crazy gvalue transform stuff after we've * exhausted everything else. Adding this for * e.g. ClutterUnit. */ gint32 i; if (JS_ValueToInt32(context, value, &i)) { GValue int_value = { 0, }; g_value_init(&int_value, G_TYPE_INT); g_value_set_int(&int_value, i); g_value_transform(&int_value, gvalue); } else { gjs_throw(context, "Wrong type %s; integer expected", gjs_get_type_name(value)); return JS_FALSE; } } else { gjs_debug(GJS_DEBUG_GCLOSURE, "jsval is number %d gtype fundamental %d transformable to int %d from int %d", JSVAL_IS_NUMBER(value), G_TYPE_IS_FUNDAMENTAL(gtype), g_value_type_transformable(gtype, G_TYPE_INT), g_value_type_transformable(G_TYPE_INT, gtype)); gjs_throw(context, "Don't know how to convert JavaScript object to GType %s", g_type_name(gtype)); return JS_FALSE; } return JS_TRUE; }
/** * pyg_value_from_pyobject: * @value: the GValue object to store the converted value in. * @obj: the Python object to convert. * * This function converts a Python object and stores the result in a * GValue. The GValue must be initialised in advance with * g_value_init(). If the Python object can't be converted to the * type of the GValue, then an error is returned. * * Returns: 0 on success, -1 on error. */ int pyg_value_from_pyobject(GValue *value, PyObject *obj) { PyObject *tmp; switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { 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)) { if (obj == Py_None) g_value_set_object(value, NULL); else { if (!PyObject_TypeCheck(obj, &PyGObject_Type)) { return -1; } if (!G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj), G_VALUE_TYPE(value))) { return -1; } g_value_set_object(value, pygobject_get(obj)); } } else { return -1; } break; case G_TYPE_CHAR: #if PY_VERSION_HEX < 0x03000000 if (PyString_Check(obj)) { g_value_set_char(value, PyString_AsString(obj)[0]); } else #endif if (PyUnicode_Check(obj)) { tmp = PyUnicode_AsUTF8String(obj); g_value_set_char(value, PYGLIB_PyBytes_AsString(tmp)[0]); Py_DECREF(tmp); } else { PyErr_Clear(); return -1; } break; case G_TYPE_UCHAR: if (PYGLIB_PyLong_Check(obj)) { glong val; val = PYGLIB_PyLong_AsLong(obj); if (val >= 0 && val <= 255) g_value_set_uchar(value, (guchar)PYGLIB_PyLong_AsLong (obj)); else return -1; #if PY_VERSION_HEX < 0x03000000 } else if (PyString_Check(obj)) { g_value_set_uchar(value, PyString_AsString(obj)[0]); #endif } else if (PyUnicode_Check(obj)) { tmp = PyUnicode_AsUTF8String(obj); g_value_set_uchar(value, PYGLIB_PyBytes_AsString(tmp)[0]); Py_DECREF(tmp); } else { PyErr_Clear(); return -1; } break; case G_TYPE_BOOLEAN: g_value_set_boolean(value, PyObject_IsTrue(obj)); break; case G_TYPE_INT: g_value_set_int(value, PYGLIB_PyLong_AsLong(obj)); break; case G_TYPE_UINT: { if (PYGLIB_PyLong_Check(obj)) { glong val; val = PYGLIB_PyLong_AsLong(obj); if (val >= 0 && val <= G_MAXUINT) g_value_set_uint(value, (guint)val); else return -1; } else { g_value_set_uint(value, PyLong_AsUnsignedLong(obj)); } } break; case G_TYPE_LONG: g_value_set_long(value, PYGLIB_PyLong_AsLong(obj)); break; case G_TYPE_ULONG: #if PY_VERSION_HEX < 0x03000000 if (PyInt_Check(obj)) { long val; val = PYGLIB_PyLong_AsLong(obj); if (val < 0) { PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property"); return -1; } g_value_set_ulong(value, (gulong)val); } else #endif if (PyLong_Check(obj)) g_value_set_ulong(value, PyLong_AsUnsignedLong(obj)); else return -1; break; case G_TYPE_INT64: g_value_set_int64(value, PyLong_AsLongLong(obj)); break; case G_TYPE_UINT64: #if PY_VERSION_HEX < 0x03000000 if (PyInt_Check(obj)) { long v = PyInt_AsLong(obj); if (v < 0) { PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property"); return -1; } g_value_set_uint64(value, v); } else #endif if (PyLong_Check(obj)) g_value_set_uint64(value, PyLong_AsUnsignedLongLong(obj)); else return -1; break; case G_TYPE_ENUM: { gint val = 0; if (pyg_enum_get_value(G_VALUE_TYPE(value), obj, &val) < 0) { PyErr_Clear(); return -1; } g_value_set_enum(value, val); } break; case G_TYPE_FLAGS: { gint val = 0; if (pyg_flags_get_value(G_VALUE_TYPE(value), obj, &val) < 0) { PyErr_Clear(); return -1; } g_value_set_flags(value, val); } break; case G_TYPE_FLOAT: g_value_set_float(value, PyFloat_AsDouble(obj)); break; case G_TYPE_DOUBLE: g_value_set_double(value, PyFloat_AsDouble(obj)); break; case G_TYPE_STRING: if (obj == Py_None) { g_value_set_string(value, NULL); #if PY_VERSION_HEX < 0x03000000 } else if (PyString_Check(obj)) { g_value_set_string(value, PyString_AsString(obj)); #endif } else if (PyUnicode_Check(obj)) { tmp = PyUnicode_AsUTF8String(obj); g_value_set_string(value, PYGLIB_PyBytes_AsString(tmp)); Py_DECREF(tmp); } else { PyErr_Clear(); return -1; } break; case G_TYPE_POINTER: if (obj == Py_None) g_value_set_pointer(value, NULL); else if (PyObject_TypeCheck(obj, &PyGPointer_Type) && G_VALUE_HOLDS(value, ((PyGPointer *)obj)->gtype)) g_value_set_pointer(value, pyg_pointer_get(obj, gpointer)); else if (PYGLIB_CPointer_Check(obj)) g_value_set_pointer(value, PYGLIB_CPointer_GetPointer(obj, NULL)); else return -1; break; case G_TYPE_BOXED: { PyGTypeMarshal *bm; if (obj == Py_None) g_value_set_boxed(value, NULL); else if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) g_value_set_boxed(value, obj); else if (PyObject_TypeCheck(obj, &PyGBoxed_Type) && G_VALUE_HOLDS(value, ((PyGBoxed *)obj)->gtype)) g_value_set_boxed(value, pyg_boxed_get(obj, gpointer)); else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) { GType type; GValue *n_value; type = pyg_type_from_object((PyObject*)Py_TYPE(obj)); if (G_UNLIKELY (! type)) { PyErr_Clear(); return -1; } n_value = g_new0 (GValue, 1); g_value_init (n_value, type); g_value_take_boxed (value, n_value); return pyg_value_from_pyobject (n_value, obj); } else if (PySequence_Check(obj) && G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY)) return pyg_value_array_from_pyobject(value, obj, NULL); else if (PYGLIB_PyUnicode_Check(obj) && G_VALUE_HOLDS(value, G_TYPE_GSTRING)) { GString *string; char *buffer; Py_ssize_t len; if (PYGLIB_PyUnicode_AsStringAndSize(obj, &buffer, &len)) return -1; string = g_string_new_len(buffer, len); g_value_set_boxed(value, string); g_string_free (string, TRUE); break; } else if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL) return bm->tovalue(value, obj); else if (PYGLIB_CPointer_Check(obj)) g_value_set_boxed(value, PYGLIB_CPointer_GetPointer(obj, NULL)); else return -1; break; } case G_TYPE_PARAM: if (PyGParamSpec_Check(obj)) g_value_set_param(value, PYGLIB_CPointer_GetPointer(obj, NULL)); else return -1; break; case G_TYPE_OBJECT: if (obj == Py_None) { g_value_set_object(value, NULL); } else if (PyObject_TypeCheck(obj, &PyGObject_Type) && G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj), G_VALUE_TYPE(value))) { g_value_set_object(value, pygobject_get(obj)); } else return -1; break; default: { PyGTypeMarshal *bm; if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL) return bm->tovalue(value, obj); break; } } if (PyErr_Occurred()) { g_value_unset(value); PyErr_Clear(); return -1; } return 0; }
static void gimp_core_config_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpCoreConfig *core_config = GIMP_CORE_CONFIG (object); switch (property_id) { case PROP_LANGUAGE: g_value_set_string (value, core_config->language); break; case PROP_INTERPOLATION_TYPE: g_value_set_enum (value, core_config->interpolation_type); break; case PROP_DEFAULT_THRESHOLD: g_value_set_int (value, core_config->default_threshold); break; case PROP_PLUG_IN_PATH: g_value_set_string (value, core_config->plug_in_path); break; case PROP_MODULE_PATH: g_value_set_string (value, core_config->module_path); break; case PROP_INTERPRETER_PATH: g_value_set_string (value, core_config->interpreter_path); break; case PROP_ENVIRON_PATH: g_value_set_string (value, core_config->environ_path); break; case PROP_BRUSH_PATH: g_value_set_string (value, core_config->brush_path); break; case PROP_BRUSH_PATH_WRITABLE: g_value_set_string (value, core_config->brush_path_writable); break; case PROP_DYNAMICS_PATH: g_value_set_string (value, core_config->dynamics_path); break; case PROP_DYNAMICS_PATH_WRITABLE: g_value_set_string (value, core_config->dynamics_path_writable); break; case PROP_MYPAINT_BRUSH_PATH: g_value_set_string (value, core_config->mypaint_brush_path); break; case PROP_MYPAINT_BRUSH_PATH_WRITABLE: g_value_set_string (value, core_config->mypaint_brush_path_writable); break; case PROP_PATTERN_PATH: g_value_set_string (value, core_config->pattern_path); break; case PROP_PATTERN_PATH_WRITABLE: g_value_set_string (value, core_config->pattern_path_writable); break; case PROP_PALETTE_PATH: g_value_set_string (value, core_config->palette_path); break; case PROP_PALETTE_PATH_WRITABLE: g_value_set_string (value, core_config->palette_path_writable); break; case PROP_GRADIENT_PATH: g_value_set_string (value, core_config->gradient_path); break; case PROP_GRADIENT_PATH_WRITABLE: g_value_set_string (value, core_config->gradient_path_writable); break; case PROP_TOOL_PRESET_PATH: g_value_set_string (value, core_config->tool_preset_path); break; case PROP_TOOL_PRESET_PATH_WRITABLE: g_value_set_string (value, core_config->tool_preset_path_writable); break; case PROP_FONT_PATH: g_value_set_string (value, core_config->font_path); break; case PROP_FONT_PATH_WRITABLE: g_value_set_string (value, core_config->font_path_writable); break; case PROP_DEFAULT_BRUSH: g_value_set_string (value, core_config->default_brush); break; case PROP_DEFAULT_DYNAMICS: g_value_set_string (value, core_config->default_dynamics); break; case PROP_DEFAULT_MYPAINT_BRUSH: g_value_set_string (value, core_config->default_mypaint_brush); break; case PROP_DEFAULT_PATTERN: g_value_set_string (value, core_config->default_pattern); break; case PROP_DEFAULT_PALETTE: g_value_set_string (value, core_config->default_palette); break; case PROP_DEFAULT_GRADIENT: g_value_set_string (value, core_config->default_gradient); break; case PROP_DEFAULT_TOOL_PRESET: g_value_set_string (value, core_config->default_tool_preset); break; case PROP_DEFAULT_FONT: g_value_set_string (value, core_config->default_font); break; case PROP_GLOBAL_BRUSH: g_value_set_boolean (value, core_config->global_brush); break; case PROP_GLOBAL_DYNAMICS: g_value_set_boolean (value, core_config->global_dynamics); break; case PROP_GLOBAL_PATTERN: g_value_set_boolean (value, core_config->global_pattern); break; case PROP_GLOBAL_PALETTE: g_value_set_boolean (value, core_config->global_palette); break; case PROP_GLOBAL_GRADIENT: g_value_set_boolean (value, core_config->global_gradient); break; case PROP_GLOBAL_FONT: g_value_set_boolean (value, core_config->global_font); break; case PROP_DEFAULT_IMAGE: g_value_set_object (value, core_config->default_image); break; case PROP_DEFAULT_GRID: g_value_set_object (value, core_config->default_grid); break; case PROP_FILTER_HISTORY_SIZE: g_value_set_int (value, core_config->filter_history_size); break; case PROP_UNDO_LEVELS: g_value_set_int (value, core_config->levels_of_undo); break; case PROP_UNDO_SIZE: g_value_set_uint64 (value, core_config->undo_size); break; case PROP_UNDO_PREVIEW_SIZE: g_value_set_enum (value, core_config->undo_preview_size); break; case PROP_PLUGINRC_PATH: g_value_set_string (value, core_config->plug_in_rc_path); break; case PROP_LAYER_PREVIEWS: g_value_set_boolean (value, core_config->layer_previews); break; case PROP_GROUP_LAYER_PREVIEWS: g_value_set_boolean (value, core_config->group_layer_previews); break; case PROP_LAYER_PREVIEW_SIZE: g_value_set_enum (value, core_config->layer_preview_size); break; case PROP_THUMBNAIL_SIZE: g_value_set_enum (value, core_config->thumbnail_size); break; case PROP_THUMBNAIL_FILESIZE_LIMIT: g_value_set_uint64 (value, core_config->thumbnail_filesize_limit); break; case PROP_COLOR_MANAGEMENT: g_value_set_object (value, core_config->color_management); break; case PROP_SAVE_DOCUMENT_HISTORY: g_value_set_boolean (value, core_config->save_document_history); break; case PROP_QUICK_MASK_COLOR: gimp_value_set_rgb (value, &core_config->quick_mask_color); break; case PROP_IMPORT_PROMOTE_FLOAT: g_value_set_boolean (value, core_config->import_promote_float); break; case PROP_IMPORT_PROMOTE_DITHER: g_value_set_boolean (value, core_config->import_promote_dither); break; case PROP_IMPORT_ADD_ALPHA: g_value_set_boolean (value, core_config->import_add_alpha); break; case PROP_IMPORT_RAW_PLUG_IN: g_value_set_string (value, core_config->import_raw_plug_in); break; case PROP_EXPORT_FILE_TYPE: g_value_set_enum (value, core_config->export_file_type); break; case PROP_EXPORT_COLOR_PROFILE: g_value_set_boolean (value, core_config->export_color_profile); break; case PROP_EXPORT_METADATA_EXIF: g_value_set_boolean (value, core_config->export_metadata_exif); break; case PROP_EXPORT_METADATA_XMP: g_value_set_boolean (value, core_config->export_metadata_xmp); break; case PROP_EXPORT_METADATA_IPTC: g_value_set_boolean (value, core_config->export_metadata_iptc); break; case PROP_DEBUG_POLICY: g_value_set_enum (value, core_config->debug_policy); break; case PROP_INSTALL_COLORMAP: case PROP_MIN_COLORS: /* ignored */ break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { ExampleEchoChannel *self = EXAMPLE_ECHO_CHANNEL (object); switch (property_id) { case PROP_OBJECT_PATH: g_value_set_string (value, self->priv->object_path); break; case PROP_CHANNEL_TYPE: g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_TEXT); break; case PROP_HANDLE_TYPE: g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT); break; case PROP_HANDLE: g_value_set_uint (value, self->priv->handle); break; case PROP_TARGET_ID: { TpHandleRepoIface *contact_repo = tp_base_connection_get_handles ( self->priv->conn, TP_HANDLE_TYPE_CONTACT); g_value_set_string (value, tp_handle_inspect (contact_repo, self->priv->handle)); } break; case PROP_REQUESTED: g_value_set_boolean (value, (self->priv->initiator == self->priv->conn->self_handle)); break; case PROP_INITIATOR_HANDLE: g_value_set_uint (value, self->priv->initiator); break; case PROP_INITIATOR_ID: { TpHandleRepoIface *contact_repo = tp_base_connection_get_handles ( self->priv->conn, TP_HANDLE_TYPE_CONTACT); g_value_set_string (value, self->priv->initiator == 0 ? "" : tp_handle_inspect (contact_repo, self->priv->initiator)); } break; case PROP_CONNECTION: g_value_set_object (value, self->priv->conn); break; case PROP_INTERFACES: g_value_set_boxed (value, example_echo_channel_interfaces); break; case PROP_CHANNEL_DESTROYED: g_value_set_boolean (value, self->priv->closed); break; case PROP_CHANNEL_PROPERTIES: g_value_take_boxed (value, tp_dbus_properties_mixin_make_properties_hash (object, TP_IFACE_CHANNEL, "ChannelType", TP_IFACE_CHANNEL, "TargetHandleType", TP_IFACE_CHANNEL, "TargetHandle", TP_IFACE_CHANNEL, "TargetID", TP_IFACE_CHANNEL, "InitiatorHandle", TP_IFACE_CHANNEL, "InitiatorID", TP_IFACE_CHANNEL, "Requested", TP_IFACE_CHANNEL, "Interfaces", NULL)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { ExampleContactListBase *self = EXAMPLE_CONTACT_LIST_BASE (object); switch (property_id) { case PROP_OBJECT_PATH: g_value_set_string (value, self->priv->object_path); break; case PROP_CHANNEL_TYPE: g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_CONTACT_LIST); break; case PROP_HANDLE_TYPE: g_value_set_uint (value, self->priv->handle_type); break; case PROP_HANDLE: g_value_set_uint (value, self->priv->handle); break; case PROP_TARGET_ID: { TpHandleRepoIface *handle_repo = tp_base_connection_get_handles ( self->priv->conn, self->priv->handle_type); g_value_set_string (value, tp_handle_inspect (handle_repo, self->priv->handle)); } break; case PROP_REQUESTED: g_value_set_boolean (value, FALSE); break; case PROP_INITIATOR_HANDLE: g_value_set_uint (value, 0); break; case PROP_INITIATOR_ID: g_value_set_static_string (value, ""); break; case PROP_CONNECTION: g_value_set_object (value, self->priv->conn); break; case PROP_MANAGER: g_value_set_object (value, self->priv->manager); break; case PROP_INTERFACES: g_value_set_boxed (value, contact_list_interfaces); break; case PROP_CHANNEL_DESTROYED: g_value_set_boolean (value, self->priv->closed); break; case PROP_CHANNEL_PROPERTIES: g_value_take_boxed (value, tp_dbus_properties_mixin_make_properties_hash (object, TP_IFACE_CHANNEL, "ChannelType", TP_IFACE_CHANNEL, "TargetHandleType", TP_IFACE_CHANNEL, "TargetHandle", TP_IFACE_CHANNEL, "TargetID", TP_IFACE_CHANNEL, "InitiatorHandle", TP_IFACE_CHANNEL, "InitiatorID", TP_IFACE_CHANNEL, "Requested", TP_IFACE_CHANNEL, "Interfaces", NULL)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void mail_browser_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { switch (property_id) { case PROP_BACKEND: g_value_set_object ( value, e_mail_reader_get_backend ( E_MAIL_READER (object))); return; case PROP_CLOSE_ON_REPLY_POLICY: g_value_set_enum ( value, e_mail_browser_get_close_on_reply_policy ( E_MAIL_BROWSER (object))); return; case PROP_DISPLAY_MODE: g_value_set_enum ( value, e_mail_browser_get_display_mode ( E_MAIL_BROWSER (object))); return; case PROP_FOCUS_TRACKER: g_value_set_object ( value, e_mail_browser_get_focus_tracker ( E_MAIL_BROWSER (object))); return; case PROP_FORWARD_STYLE: g_value_set_enum ( value, e_mail_reader_get_forward_style ( E_MAIL_READER (object))); return; case PROP_GROUP_BY_THREADS: g_value_set_boolean ( value, e_mail_reader_get_group_by_threads ( E_MAIL_READER (object))); return; case PROP_REPLY_STYLE: g_value_set_enum ( value, e_mail_reader_get_reply_style ( E_MAIL_READER (object))); return; case PROP_SHOW_DELETED: g_value_set_boolean ( value, e_mail_browser_get_show_deleted ( E_MAIL_BROWSER (object))); return; case PROP_UI_MANAGER: g_value_set_object ( value, e_mail_browser_get_ui_manager ( E_MAIL_BROWSER (object))); return; case PROP_MARK_SEEN_ALWAYS: g_value_set_boolean ( value, e_mail_reader_get_mark_seen_always ( E_MAIL_READER (object))); return; } G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); }
void rbgobj_rvalue_to_gvalue(VALUE val, GValue* result) { GType type, fundamental_type; type = G_VALUE_TYPE(result); if (rbgobj_convert_rvalue2gvalue(type, val, result)) return; fundamental_type = G_TYPE_FUNDAMENTAL(type); switch (fundamental_type) { case G_TYPE_NONE: return; case G_TYPE_CHAR: g_value_set_char(result, NUM2INT(val)); return; case G_TYPE_UCHAR: g_value_set_uchar(result, NUM2UINT(val)); return; case G_TYPE_BOOLEAN: g_value_set_boolean(result, RVAL2CBOOL(val)); return; case G_TYPE_INT: g_value_set_int(result, NUM2INT(val)); return; case G_TYPE_UINT: g_value_set_uint(result, NUM2UINT(val)); return; case G_TYPE_LONG: g_value_set_long(result, NUM2LONG(val)); return; case G_TYPE_ULONG: g_value_set_ulong(result, NUM2ULONG(val)); return; case G_TYPE_INT64: g_value_set_int64(result, rbglib_num_to_int64(val)); return; case G_TYPE_UINT64: g_value_set_uint64(result, rbglib_num_to_uint64(val)); return; case G_TYPE_ENUM: g_value_set_enum(result, rbgobj_get_enum(val, G_VALUE_TYPE(result))); return; case G_TYPE_FLAGS: g_value_set_flags(result, rbgobj_get_flags(val, G_VALUE_TYPE(result))); return; case G_TYPE_FLOAT: g_value_set_float(result, NUM2DBL(val)); return; case G_TYPE_DOUBLE: g_value_set_double(result, NUM2DBL(val)); return; case G_TYPE_STRING: { if (SYMBOL_P(val)) val = rb_funcall(val, id_to_s, 0); g_value_set_string(result, RVAL2CSTR_ACCEPT_NIL(val)); return; } case G_TYPE_OBJECT: case G_TYPE_INTERFACE: g_value_set_object(result, NIL_P(val) ? NULL : RVAL2GOBJ(val)); return; case G_TYPE_PARAM: g_value_set_param(result, NIL_P(val) ? NULL : RVAL2GOBJ(val)); return; case G_TYPE_POINTER: g_value_set_pointer(result, NIL_P(val) ? NULL : rbgobj_ptr2cptr(val)); return; case G_TYPE_BOXED: { GType gtype; for (gtype = type; gtype != G_TYPE_INVALID; gtype = g_type_parent(gtype)) { RValueToGValueFunc func = g_type_get_qdata(gtype, qRValueToGValueFunc); if (!func) continue; func(val, result); return; } } default: if (!rbgobj_convert_rvalue2gvalue(fundamental_type, val, result)) { RValueToGValueFunc func = g_type_get_qdata(type, qRValueToGValueFunc); if (!func){ g_warning("rbgobj_rvalue_to_gvalue: unsupported type: %s\n", g_type_name(type)); } else { func(val, result); } } } }
int main (int argc, char **argv) { gint i; GTest *test1, *test2; GArray *test_threads; const gint n_threads = 1; #ifdef SYMBIAN g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL); g_set_print_handler(mrtPrintHandler); #endif /*SYMBIAN*/ g_thread_init (NULL); #ifndef SYMBIAN g_print ("START: %s\n", argv[0]); #else #ifdef VERBOSE g_print ("START: %s\n", argv[0]); #endif #endif /*SYMBIAN*/ g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | g_log_set_always_fatal (G_LOG_FATAL_MASK)); g_type_init (); test1 = g_object_new (G_TYPE_TEST, NULL); test2 = g_object_new (G_TYPE_TEST, NULL); g_signal_connect (test1, "notify::test-prop", G_CALLBACK (notify), NULL); g_signal_connect (test1, "test-signal1", G_CALLBACK (notify), NULL); g_signal_connect (test1, "test-signal2", G_CALLBACK (notify), NULL); #ifndef SYMBIAN test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); stopping = FALSE; for (i = 0; i < n_threads; i++) { GThread *thread; thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); g_array_append_val (test_threads, thread); thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); g_array_append_val (test_threads, thread); } g_usleep (500000); stopping = TRUE; g_print ("\nstopping\n"); /* join all threads */ for (i = 0; i < 2 * n_threads; i++) { GThread *thread; thread = g_array_index (test_threads, GThread *, i); g_thread_join (thread); } g_print ("stopped:%d\n",TESTNUM); #else #ifdef MULTITHREAD test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); stopping = FALSE; TESTNUM=1; notifynum=0; handlernum=0; for (i = 0; i < n_threads; i++) { GThread *thread; thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); g_array_append_val (test_threads, thread); thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); g_array_append_val (test_threads, thread); } g_usleep (500000); stopping = TRUE; #ifdef VERBOSE g_print ("\nstopping\n"); #endif /* join all threads */ for (i = 0; i < 2 * n_threads; i++) { GThread *thread; thread = g_array_index (test_threads, GThread *, i); g_thread_join (thread); } g_assert(notifynum != 0); g_assert(handlernum == 0); g_array_free (test_threads, TRUE); #ifdef VERBOSE g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM); #endif test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); stopping = FALSE; TESTNUM=2; notifynum=0; handlernum=0; for (i = 0; i < n_threads; i++) { GThread *thread; thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); g_array_append_val (test_threads, thread); thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); g_array_append_val (test_threads, thread); } g_usleep (500000); stopping = TRUE; #ifdef VERBOSE g_print ("\nstopping\n"); #endif /* join all threads */ for (i = 0; i < 2 * n_threads; i++) { GThread *thread; thread = g_array_index (test_threads, GThread *, i); g_thread_join (thread); } g_assert(notifynum != 0); g_assert(handlernum != 0); g_array_free (test_threads, TRUE); #ifdef VERBOSE g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM); #endif test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); stopping = FALSE; TESTNUM=3; notifynum=0; handlernum=0; for (i = 0; i < n_threads; i++) { GThread *thread; thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); g_array_append_val (test_threads, thread); thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); g_array_append_val (test_threads, thread); } g_usleep (5000000); stopping = TRUE; #ifdef VERBOSE g_print ("\nstopping\n"); #endif /* join all threads */ for (i = 0; i < 2 * n_threads; i++) { GThread *thread; thread = g_array_index (test_threads, GThread *, i); g_thread_join (thread); } g_assert(notifynum != 0); g_assert(handlernum == 0); g_array_free (test_threads, TRUE); #ifdef VERBOSE g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM); #endif #else /* ! MULTITHREAD*/ TESTNUM=1; #ifdef VERBOSE g_print ("\nStarting with TESTNUM=%d\n",TESTNUM); #endif notifynum=0; handlernum=0; run_thread(test1); g_assert(notifynum == LOOP +1); g_assert(handlernum ==0); notifynum=0; handlernum=0; run_thread(test2); g_assert(notifynum == 0); g_assert(handlernum == 0); TESTNUM=2; #ifdef VERBOSE g_print ("\nStarting with TESTNUM=%d\n",TESTNUM); #endif notifynum=0; handlernum=0; run_thread(test1); g_assert(notifynum == LOOP+1); g_assert(handlernum == LOOP+1); notifynum=0; handlernum=0; run_thread(test2); g_assert(notifynum == 0); g_assert(handlernum == LOOP+1); TESTNUM=3; #ifdef VERBOSE g_print ("\nStarting with TESTNUM=%d\n",TESTNUM); #endif notifynum=0; handlernum=0; run_thread(test1); g_assert(notifynum == LOOP +1); g_assert(handlernum ==0); notifynum=0; handlernum=0; run_thread(test2); g_assert(notifynum == 0); g_assert(handlernum == 0); g_assert(g_signal_has_handler_pending(G_OBJECT(test1),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==TRUE); g_assert(g_signal_has_handler_pending(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==FALSE); g_assert(g_signal_handler_is_connected(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST))==TRUE); g_assert(g_signal_handler_is_connected(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST))==FALSE); handlernum=g_signal_lookup("test-signal1",G_TYPE_TEST); #ifdef VERBOSE g_print("Signal id: %d\n",handlernum); #endif g_signal_connect (test2, "test-signal1", G_CALLBACK (notify), NULL); hookid=g_signal_add_emission_hook(handlernum,NULL,(GSignalEmissionHook) hook_function,NULL,NULL); #ifdef VERBOSE g_print("Hookid: %d\n",hookid); #endif /********************/ #ifdef TEST_STOP_EMISSION /* notifynum=0; handlernum=0; g_print("The following call stops signal emission\n"); g_signal_stop_emission(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST),0); g_print("The following call should abort and it is normal\n"); run_thread(test1); printf("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum); */ notifynum=0; handlernum=0; g_signal_stop_emission_by_name(G_OBJECT(test1),"test-signal1"); //run_thread(test1); g_print("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum); #endif /*TEST_STOP_EMISSION*/ /*******************/ handlernum=0; g_signal_emit(G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0); g_signal_emit(G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0); g_assert(handlernum==2); g_signal_remove_emission_hook(g_signal_lookup("test-signal1",G_TYPE_TEST),hookid); #ifdef VERBOSE g_print("Emitting signal again after removing emission hook\n"); #endif handlernum=0; g_signal_emit (G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0); g_signal_emit (G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0); g_assert(handlernum==0); g_assert (strcmp ("test-signal1", g_signal_name (g_signal_lookup("test-signal1",G_TYPE_TEST))) == 0); g_assert (strcmp ("test-signal2", g_signal_name (g_signal_lookup("test-signal2",G_TYPE_TEST))) == 0); memset(&gv,0,sizeof(gv)); g_value_init(&gv,G_TYPE_OBJECT); g_value_set_object(&gv,test1); gi=0; g_signal_list_ids(G_OBJECT_TYPE(test1),&gi); g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gi); notifynum=0; g_signal_emitv (&gv, g_test_signals[TEST_SIGNAL1], 0, &gv); g_assert(notifynum==1); g_signal_query(g_signal_lookup("test-signal1",G_TYPE_TEST),&gq); g_assert(strcmp("test-signal1",gq.signal_name)==0); g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gq.signal_id); g_assert(g_signal_handler_find(G_OBJECT(test1), G_SIGNAL_RUN_LAST,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,NULL,NULL)==2); notifynum=g_signal_handlers_block_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL); handlernum=g_signal_handlers_unblock_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL); g_assert(notifynum==handlernum); #endif /*MULTITHREAD*/ #ifdef VERBOSE g_printf ("\nsignals-multithread.c: Completed all tests\n"); #endif #endif /*SYMBIAN*/ #if SYMBIAN testResultXml("signals-singlethread"); #endif /* EMULATOR */ return 0; }
static void terminal_profile_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { TerminalProfile *profile = TERMINAL_PROFILE (object); TerminalProfilePrivate *priv = profile->priv; GValue *prop_value; if (prop_id == 0 || prop_id >= LAST_PROP) { G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); return; } prop_value = g_value_array_get_nth (priv->properties, prop_id); /* Preprocessing */ switch (prop_id) { #if 0 case PROP_FONT: { PangoFontDescription *font_desc, *new_font_desc; font_desc = g_value_get_boxed (prop_value); new_font_desc = g_value_get_boxed (value); if (font_desc && new_font_desc) { /* Merge in case the new string isn't complete enough to load a font */ pango_font_description_merge (font_desc, new_font_desc, TRUE); pango_font_description_free (new_font_desc); break; } /* fall-through */ } #endif default: g_value_copy (value, prop_value); break; } /* Postprocessing */ switch (prop_id) { case PROP_NAME: { const char *name = g_value_get_string (value); g_assert (name != NULL); priv->profile_dir = g_strdup (name); if (priv->settings != NULL) { g_signal_handlers_disconnect_by_func (priv->settings, G_CALLBACK(terminal_profile_gsettings_notify_cb), profile); g_object_unref (priv->settings); priv->settings = g_settings_new_with_path (CONF_PROFILE_SCHEMA, g_strconcat (CONF_PROFILE_PREFIX, priv->profile_dir, "/", NULL)); g_signal_connect (priv->settings, g_strconcat("changed::", priv->profile_dir, "/", NULL), G_CALLBACK(terminal_profile_gsettings_notify_cb), profile); } break; } case PROP_BACKGROUND_IMAGE_FILE: /* Clear the cached image */ g_value_set_object (g_value_array_get_nth (priv->properties, PROP_BACKGROUND_IMAGE), NULL); priv->background_load_failed = FALSE; g_object_notify (object, TERMINAL_PROFILE_BACKGROUND_IMAGE); break; default: break; } }
static void i3ipc_con_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { i3ipcCon *self = I3IPC_CON(object); switch (property_id) { case PROP_ID: g_value_set_int(value, self->priv->id); break; case PROP_NAME: g_value_set_string(value, self->priv->name); break; case PROP_BORDER: g_value_set_string(value, self->priv->border); break; case PROP_CURRENT_BORDER_WIDTH: g_value_set_int(value, self->priv->current_border_width); break; case PROP_LAYOUT: g_value_set_string(value, self->priv->layout); break; case PROP_ORIENTATION: g_value_set_string(value, self->priv->orientation); break; case PROP_PERCENT: g_value_set_double(value, self->priv->percent); break; case PROP_WINDOW: g_value_set_int(value, self->priv->window); break; case PROP_URGENT: g_value_set_boolean(value, self->priv->urgent); break; case PROP_FOCUSED: g_value_set_boolean(value, self->priv->focused); break; case PROP_FULLSCREEN_MODE: g_value_set_boolean(value, self->priv->fullscreen_mode); break; case PROP_TYPE: g_value_set_string(value, self->priv->type); break; case PROP_WINDOW_CLASS: g_value_set_string(value, self->priv->window_class); break; case PROP_MARK: g_value_set_string(value, self->priv->mark); break; case PROP_RECT: g_value_set_boxed(value, self->priv->rect); break; case PROP_DECO_RECT: g_value_set_boxed(value, self->priv->deco_rect); break; case PROP_PARENT: g_value_set_object(value, self->priv->parent); break; case PROP_NODES: g_value_set_pointer(value, self->priv->nodes); break; case PROP_FLOATING_NODES: g_value_set_pointer(value, self->priv->floating_nodes); break; case PROP_FOCUS: g_value_set_pointer(value, self->priv->focus); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } }
static void athena_list_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value) { AthenaListModel *model; FileEntry *file_entry; AthenaFile *file; char *str; GdkPixbuf *icon, *rendered_icon; GIcon *gicon, *emblemed_icon, *emblem_icon; AthenaIconInfo *icon_info; GEmblem *emblem; GList *emblem_icons, *l; int icon_size; AthenaZoomLevel zoom_level; AthenaFile *parent_file; char *emblems_to_ignore[3]; int i; AthenaFileIconFlags flags; model = (AthenaListModel *)tree_model; g_return_if_fail (model->details->stamp == iter->stamp); g_return_if_fail (!g_sequence_iter_is_end (iter->user_data)); file_entry = g_sequence_get (iter->user_data); file = file_entry->file; switch (column) { case ATHENA_LIST_MODEL_FILE_COLUMN: g_value_init (value, ATHENA_TYPE_FILE); g_value_set_object (value, file); break; case ATHENA_LIST_MODEL_SUBDIRECTORY_COLUMN: g_value_init (value, ATHENA_TYPE_DIRECTORY); g_value_set_object (value, file_entry->subdirectory); break; case ATHENA_LIST_MODEL_SMALLEST_ICON_COLUMN: case ATHENA_LIST_MODEL_SMALLER_ICON_COLUMN: case ATHENA_LIST_MODEL_SMALL_ICON_COLUMN: case ATHENA_LIST_MODEL_STANDARD_ICON_COLUMN: case ATHENA_LIST_MODEL_LARGE_ICON_COLUMN: case ATHENA_LIST_MODEL_LARGER_ICON_COLUMN: case ATHENA_LIST_MODEL_LARGEST_ICON_COLUMN: g_value_init (value, GDK_TYPE_PIXBUF); if (file != NULL) { zoom_level = athena_list_model_get_zoom_level_from_column_id (column); icon_size = athena_get_icon_size_for_zoom_level (zoom_level); flags = ATHENA_FILE_ICON_FLAGS_USE_THUMBNAILS | ATHENA_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE | ATHENA_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM; if (model->details->drag_view != NULL) { GtkTreePath *path_a, *path_b; gtk_tree_view_get_drag_dest_row (model->details->drag_view, &path_a, NULL); if (path_a != NULL) { path_b = gtk_tree_model_get_path (tree_model, iter); if (gtk_tree_path_compare (path_a, path_b) == 0) { flags |= ATHENA_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } gtk_tree_path_free (path_a); gtk_tree_path_free (path_b); } } gicon = G_ICON (athena_file_get_icon_pixbuf (file, icon_size, TRUE, flags)); /* render emblems with GEmblemedIcon */ parent_file = athena_file_get_parent (file); i = 0; emblems_to_ignore[i++] = ATHENA_FILE_EMBLEM_NAME_TRASH; if (parent_file) { if (!athena_file_can_write (parent_file)) { emblems_to_ignore[i++] = ATHENA_FILE_EMBLEM_NAME_CANT_WRITE; } athena_file_unref (parent_file); } emblems_to_ignore[i++] = NULL; emblem_icons = athena_file_get_emblem_icons (file, emblems_to_ignore); /* pick only the first emblem we can render for the list view */ for (l = emblem_icons; l != NULL; l = l->next) { emblem_icon = l->data; if (athena_icon_theme_can_render (G_THEMED_ICON (emblem_icon))) { emblem = g_emblem_new (emblem_icon); emblemed_icon = g_emblemed_icon_new (gicon, emblem); g_object_unref (gicon); g_object_unref (emblem); gicon = emblemed_icon; break; } } g_list_free_full (emblem_icons, g_object_unref); icon_info = athena_icon_info_lookup (gicon, icon_size); icon = athena_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); g_object_unref (gicon); if (model->details->highlight_files != NULL && g_list_find_custom (model->details->highlight_files, file, (GCompareFunc) athena_file_compare_location)) { rendered_icon = eel_create_spotlight_pixbuf (icon); if (rendered_icon != NULL) { g_object_unref (icon); icon = rendered_icon; } } g_value_set_object (value, icon); g_object_unref (icon); } break; case ATHENA_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, file != NULL && athena_file_can_rename (file)); break; default: if (column >= ATHENA_LIST_MODEL_NUM_COLUMNS || column < ATHENA_LIST_MODEL_NUM_COLUMNS + model->details->columns->len) { AthenaColumn *athena_column; GQuark attribute; athena_column = model->details->columns->pdata[column - ATHENA_LIST_MODEL_NUM_COLUMNS]; g_value_init (value, G_TYPE_STRING); g_object_get (athena_column, "attribute_q", &attribute, NULL); if (file != NULL) { str = athena_file_get_string_attribute_with_default_q (file, attribute); g_value_take_string (value, str); } else if (attribute == attribute_name_q) { if (file_entry->parent->loaded) { g_value_set_string (value, _("(Empty)")); } else { g_value_set_string (value, _("Loading...")); } } } else { g_assert_not_reached (); } } }
static void gimp_paint_options_get_property (GObject *object, guint property_id, 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: g_value_set_object (value, options->paint_info); break; case PROP_USE_APPLICATOR: g_value_set_boolean (value, options->use_applicator); break; case PROP_BRUSH_SIZE: g_value_set_double (value, options->brush_size); break; case PROP_BRUSH_ASPECT_RATIO: g_value_set_double (value, options->brush_aspect_ratio); break; case PROP_BRUSH_ANGLE: g_value_set_double (value, - 1.0 * options->brush_angle * 360.0); /* mathematically correct -> intuitively correct */ break; case PROP_APPLICATION_MODE: g_value_set_enum (value, options->application_mode); break; case PROP_HARD: g_value_set_boolean (value, options->hard); break; case PROP_USE_JITTER: g_value_set_boolean (value, jitter_options->use_jitter); break; case PROP_JITTER_AMOUNT: g_value_set_double (value, jitter_options->jitter_amount); break; case PROP_DYNAMICS_EXPANDED: g_value_set_boolean (value, options->dynamics_expanded); break; case PROP_FADE_LENGTH: g_value_set_double (value, fade_options->fade_length); break; case PROP_FADE_REVERSE: g_value_set_boolean (value, fade_options->fade_reverse); break; case PROP_FADE_REPEAT: g_value_set_enum (value, fade_options->fade_repeat); break; case PROP_FADE_UNIT: g_value_set_int (value, fade_options->fade_unit); break; case PROP_GRADIENT_REVERSE: g_value_set_boolean (value, gradient_options->gradient_reverse); break; case PROP_BRUSH_VIEW_TYPE: g_value_set_enum (value, options->brush_view_type); break; case PROP_BRUSH_VIEW_SIZE: g_value_set_int (value, options->brush_view_size); break; case PROP_DYNAMICS_VIEW_TYPE: g_value_set_enum (value, options->dynamics_view_type); break; case PROP_DYNAMICS_VIEW_SIZE: g_value_set_int (value, options->dynamics_view_size); break; case PROP_PATTERN_VIEW_TYPE: g_value_set_enum (value, options->pattern_view_type); break; case PROP_PATTERN_VIEW_SIZE: g_value_set_int (value, options->pattern_view_size); break; case PROP_GRADIENT_VIEW_TYPE: g_value_set_enum (value, options->gradient_view_type); break; case PROP_GRADIENT_VIEW_SIZE: g_value_set_int (value, options->gradient_view_size); break; case PROP_USE_SMOOTHING: g_value_set_boolean (value, smoothing_options->use_smoothing); break; case PROP_SMOOTHING_QUALITY: g_value_set_int (value, smoothing_options->smoothing_quality); break; case PROP_SMOOTHING_FACTOR: g_value_set_double (value, smoothing_options->smoothing_factor); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
void moo_plugin_call_method_valist (gpointer plugin, const char *name, va_list var_args) { MooPluginMeth *meth; GValue *plugin_and_args, *args, *freeme = NULL; GValue stack_params[MAX_STACK_VALUES]; guint i; g_return_if_fail (MOO_IS_PLUGIN (plugin)); g_return_if_fail (name != NULL); meth = moo_plugin_lookup_method (plugin, name); if (!meth) { g_warning ("plugin '%s' does not have method '%s'", moo_plugin_id (plugin), name); return; } g_assert (meth->ptype == G_OBJECT_TYPE (plugin)); if (meth->n_params < MAX_STACK_VALUES) plugin_and_args = stack_params; else plugin_and_args = freeme = g_new (GValue, meth->n_params + 1); args = plugin_and_args + 1; for (i = 0; i < meth->n_params; i++) { char *error; GType type = meth->param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE; gboolean static_scope = meth->param_types[i] & G_SIGNAL_TYPE_STATIC_SCOPE; args[i].g_type = 0; g_value_init (args + i, type); G_VALUE_COLLECT (args + i, var_args, static_scope ? G_VALUE_NOCOPY_CONTENTS : 0, &error); if (error) { g_warning ("%s", error); g_free (error); while (i--) g_value_unset (args + i); g_free (freeme); return; } } plugin_and_args->g_type = 0; g_value_init (plugin_and_args, G_OBJECT_TYPE (plugin)); g_value_set_object (plugin_and_args, plugin); if (meth->return_type == G_TYPE_NONE) { moo_plugin_call_methodv (plugin_and_args, name, NULL); } else { GValue return_val; char *error = NULL; GType type = meth->return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE; gboolean static_scope = meth->return_type & G_SIGNAL_TYPE_STATIC_SCOPE; return_val.g_type = 0; g_value_init (&return_val, type); moo_plugin_call_methodv (plugin_and_args, name, &return_val); G_VALUE_LCOPY (&return_val, var_args, static_scope ? G_VALUE_NOCOPY_CONTENTS : 0, &error); if (!error) { g_value_unset (&return_val); } else { g_warning ("%s", error); g_free (error); } } for (i = 0; i < meth->n_params + 1; i++) g_value_unset (plugin_and_args + i); g_free (freeme); }
static void add_pidgin_contacts_to_model (GtkTreeStore *store, GtkTreeIter *iter, GtkTreeIter *parent) { GError *error; GArray *contacts_list; GArray *accounts; int i, j; GdkPixbuf *icon; GHashTableIter hiter; GPtrArray *contacts_group; ContactData *dat; GValue val = {0,}; if(proxy == NULL) return; error = NULL; if (!dbus_g_proxy_call (proxy, "PurpleAccountsGetAllActive", &error, G_TYPE_INVALID, DBUS_TYPE_G_INT_ARRAY, &accounts, G_TYPE_INVALID)) { handle_dbus_exception(error); return; } contact_hash = g_hash_table_new (g_str_hash, g_str_equal); for(i = 0; i < accounts->len; i++) { int account = g_array_index(accounts, int, i); error = NULL; if (!dbus_g_proxy_call (proxy, "PurpleFindBuddies", &error, G_TYPE_INT, account, G_TYPE_STRING, NULL, G_TYPE_INVALID, DBUS_TYPE_G_INT_ARRAY, &contacts_list, G_TYPE_INVALID)) { handle_dbus_exception(error); continue; } for(j = 0; j < contacts_list->len ; j++) { int id = g_array_index(contacts_list, int, j); int online; error = NULL; if (!dbus_g_proxy_call (proxy, "PurpleBuddyIsOnline", &error, G_TYPE_INT, id, G_TYPE_INVALID, G_TYPE_INT, &online, G_TYPE_INVALID)) { handle_dbus_exception(error); continue; } if (!online) continue; dat = g_new0 (ContactData, 1); dat->account = account; dat->id = id; error = NULL; if (!dbus_g_proxy_call (proxy, "PurpleBuddyGetName", &error, G_TYPE_INT, id, G_TYPE_INVALID, G_TYPE_STRING, &dat->name, G_TYPE_INVALID)) { handle_dbus_exception(error); g_free(dat); continue; } if (!dbus_g_proxy_call (proxy, "PurpleBuddyGetAlias", &error, G_TYPE_INT, id, G_TYPE_INVALID, G_TYPE_STRING, &dat->alias, G_TYPE_INVALID)) { handle_dbus_exception(error); } contacts_group = g_hash_table_lookup (contact_hash, dat->alias); if (contacts_group == NULL){ GPtrArray *new_group = g_ptr_array_new (); g_ptr_array_add (new_group, dat); g_hash_table_insert (contact_hash, dat->alias, new_group); } else { g_ptr_array_add (contacts_group, dat); } } g_array_free(contacts_list, TRUE); } g_array_free (accounts, TRUE); g_hash_table_iter_init (&hiter, contact_hash); while (g_hash_table_iter_next (&hiter, NULL, (gpointer)&contacts_group)) { gint accounts; dat = g_ptr_array_index (contacts_group, 0); accounts = contacts_group->len; gtk_tree_store_append (store, parent, NULL); gtk_tree_store_set (store, parent, COL_ICON, NULL, COL_ALIAS, dat->alias, -1); gint i; for (i = 0; i < accounts; ++i) { dat = g_ptr_array_index (contacts_group, i); icon = get_buddy_icon(dat->id); if (accounts == 1) { g_value_init(&val, GDK_TYPE_PIXBUF); g_value_set_object (&val, (gpointer)icon); gtk_tree_store_set_value (store, parent, COL_ICON, &val); g_value_unset (&val); break; } gtk_tree_store_append (store, iter, parent); gtk_tree_store_set (store, iter, COL_ICON, icon, COL_ALIAS, dat->alias, -1); } } }
static void gst_multiudpsink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstMultiUDPSink *udpsink; udpsink = GST_MULTIUDPSINK (object); switch (prop_id) { case PROP_BYTES_TO_SERVE: g_value_set_uint64 (value, udpsink->bytes_to_serve); break; case PROP_BYTES_SERVED: g_value_set_uint64 (value, udpsink->bytes_served); break; case PROP_SOCKET: g_value_set_object (value, udpsink->socket); break; case PROP_SOCKET_V6: g_value_set_object (value, udpsink->socket_v6); break; case PROP_CLOSE_SOCKET: g_value_set_boolean (value, udpsink->close_socket); break; case PROP_USED_SOCKET: g_value_set_object (value, udpsink->used_socket); break; case PROP_USED_SOCKET_V6: g_value_set_object (value, udpsink->used_socket_v6); break; case PROP_CLIENTS: g_value_take_string (value, gst_multiudpsink_get_clients_string (udpsink)); break; case PROP_AUTO_MULTICAST: g_value_set_boolean (value, udpsink->auto_multicast); break; case PROP_MULTICAST_IFACE: g_value_set_string (value, udpsink->multi_iface); break; case PROP_TTL: g_value_set_int (value, udpsink->ttl); break; case PROP_TTL_MC: g_value_set_int (value, udpsink->ttl_mc); break; case PROP_LOOP: g_value_set_boolean (value, udpsink->loop); break; case PROP_FORCE_IPV4: g_value_set_boolean (value, udpsink->force_ipv4); break; case PROP_QOS_DSCP: g_value_set_int (value, udpsink->qos_dscp); break; case PROP_SEND_DUPLICATES: g_value_set_boolean (value, udpsink->send_duplicates); break; case PROP_BUFFER_SIZE: g_value_set_int (value, udpsink->buffer_size); break; case PROP_BIND_ADDRESS: g_value_set_string (value, udpsink->bind_address); break; case PROP_BIND_PORT: g_value_set_int (value, udpsink->bind_port); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gimp_device_info_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpDeviceInfo *info = GIMP_DEVICE_INFO (object); switch (property_id) { case PROP_DEVICE: g_value_set_object (value, info->device); break; case PROP_DISPLAY: g_value_set_object (value, info->display); break; case PROP_MODE: g_value_set_enum (value, gimp_device_info_get_mode (info)); break; case PROP_AXES: { GimpValueArray *array; GValue enum_value = { 0, }; gint n_axes; gint i; array = gimp_value_array_new (6); g_value_init (&enum_value, GDK_TYPE_AXIS_USE); n_axes = gimp_device_info_get_n_axes (info); for (i = 0; i < n_axes; i++) { g_value_set_enum (&enum_value, gimp_device_info_get_axis_use (info, i)); gimp_value_array_append (array, &enum_value); } g_value_unset (&enum_value); g_value_take_boxed (value, array); } break; case PROP_KEYS: { GimpValueArray *array; GValue string_value = { 0, }; gint n_keys; gint i; array = gimp_value_array_new (32); g_value_init (&string_value, G_TYPE_STRING); n_keys = gimp_device_info_get_n_keys (info); for (i = 0; i < n_keys; i++) { guint keyval; GdkModifierType modifiers; gimp_device_info_get_key (info, i, &keyval, &modifiers); if (keyval) { gchar *accel; gchar *escaped; accel = gtk_accelerator_name (keyval, modifiers); escaped = g_strescape (accel, NULL); g_free (accel); g_value_set_string (&string_value, escaped); g_free (escaped); } else { g_value_set_string (&string_value, ""); } gimp_value_array_append (array, &string_value); } g_value_unset (&string_value); g_value_take_boxed (value, array); } break; case PROP_PRESSURE_CURVE: g_value_set_object (value, info->pressure_curve); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
void dt_control_signal_raise(const dt_control_signal_t *ctlsig, dt_signal_t signal, ...) { // ignore all signals on shutdown if(!dt_control_running()) return; dt_signal_description *signal_description = &_signal_description[signal]; _signal_param_t *params = (_signal_param_t *)malloc(sizeof(_signal_param_t)); if(!params) return; GValue *instance_and_params = calloc(1 + signal_description->n_params, sizeof(GValue)); if(!instance_and_params) { free(params); return; } // 0th element has to be the instance to call g_value_init(instance_and_params, _signal_type); g_value_set_object(instance_and_params, ctlsig->sink); // the rest of instance_and_params will be the params for the callback va_list extra_args; va_start(extra_args, signal); for(int i = 1; i <= signal_description->n_params; i++) { GType type = signal_description->param_types[i-1]; g_value_init(&instance_and_params[i], type); switch(type) { case G_TYPE_UINT: g_value_set_uint(&instance_and_params[i], va_arg(extra_args, guint)); break; case G_TYPE_STRING: g_value_set_string(&instance_and_params[i], va_arg(extra_args, const char *)); break; case G_TYPE_POINTER: g_value_set_pointer(&instance_and_params[i], va_arg(extra_args, void *)); break; default: fprintf(stderr, "error: unsupported parameter type `%s' for signal `%s'\n", g_type_name(type), signal_description->name); va_end(extra_args); for(int j = 0; j <= i; j++) g_value_unset(&instance_and_params[j]); free(instance_and_params); free(params); return; } } va_end(extra_args); params->instance_and_params = instance_and_params; params->signal_id = g_signal_lookup(_signal_description[signal].name, _signal_type); params->n_params = signal_description->n_params; if(!signal_description->synchronous) { g_main_context_invoke(NULL, _signal_raise, params); } else { if(pthread_equal(darktable.control->gui_thread, pthread_self())) { _signal_raise(params); } else { async_com_data communication; g_mutex_init(&communication.end_mutex); g_cond_init(&communication.end_cond); g_mutex_lock(&communication.end_mutex); communication.user_data = params; g_main_context_invoke(NULL,_async_com_callback,&communication); g_cond_wait(&communication.end_cond,&communication.end_mutex); g_mutex_unlock(&communication.end_mutex); g_mutex_clear(&communication.end_mutex); } } }
int static __list_store_set(ClipMachine *cm, GtkTreeIter *iter, gint startDataParam) { C_object *cslist = _fetch_co_arg(cm); ClipArrVar *utypes; gint i; CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); utypes = (ClipArrVar *)_clip_vptr(_clip_mget(cm, &cslist->obj, HASH_UTYPES)); for (i=startDataParam; i<=_clip_parinfo(cm, 0); i+=2) { gint column = _clip_parni(cm, i); ClipVar *val; GValue value; C_object *cobj; gchar *str; int j, n; double d; CHECKARG(i, NUMERIC_t); if (column == -1) break; column --; val = _clip_par(cm, i+1); memset(&value, 0, sizeof(value)); switch ((int)utypes->items[column].n.d) { case TREE_TYPE_NUMERIC: g_value_init(&value, G_TYPE_INT); if (val->t.type == NUMERIC_t) g_value_set_int(&value, (int)val->n.d); else { n = _clip_strtod(val->s.str.buf, &j); g_value_set_int(&value, n); } break; case TREE_TYPE_NUMERIC_FLOAT: g_value_init(&value, G_TYPE_FLOAT); if (val->t.type == NUMERIC_t) g_value_set_float(&value, val->n.d); else { d = _clip_strtod(val->s.str.buf, &j); g_value_set_float(&value, d); } break; case TREE_TYPE_STRING: str = val->s.str.buf; LOCALE_TO_UTF(str); g_value_init(&value, G_TYPE_STRING); g_value_set_string(&value, str); FREE_TEXT(str); break; case TREE_TYPE_LOGICAL: g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, val->l.val); break; case TREE_TYPE_PIXBUF: g_value_init(&value, GDK_TYPE_PIXBUF); cobj = _fetch_cobject(cm, val); g_value_set_object(&value, cobj->object); break; case TREE_TYPE_DATE: g_value_init(&value, G_TYPE_STRING); if (val->t.type == DATE_t) str = _clip_date_to_str(val->lv.l, cm->date_format); else str = _clip_date_to_str(_clip_str_to_date(val->s.str.buf, cm->date_format, cm->epoch), cm->date_format); g_value_set_string(&value, str); break; } gtk_list_store_set_value(GTK_LIST_STORE(cslist->object), iter, column, &value); } return 0; err: return 1; }
static void nautilus_list_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value) { NautilusListModel *model; FileEntry *file_entry; NautilusFile *file; char *str; GdkPixbuf *icon, *rendered_icon; GIcon *gicon, *emblemed_icon, *emblem_icon; NautilusIconInfo *icon_info; GEmblem *emblem; GList *emblem_icons, *l; int icon_size, icon_scale; NautilusZoomLevel zoom_level; NautilusFileIconFlags flags; cairo_surface_t *surface; model = (NautilusListModel *)tree_model; g_return_if_fail (model->details->stamp == iter->stamp); g_return_if_fail (!g_sequence_iter_is_end (iter->user_data)); file_entry = g_sequence_get (iter->user_data); file = file_entry->file; switch (column) { case NAUTILUS_LIST_MODEL_FILE_COLUMN: g_value_init (value, NAUTILUS_TYPE_FILE); g_value_set_object (value, file); break; case NAUTILUS_LIST_MODEL_SUBDIRECTORY_COLUMN: g_value_init (value, NAUTILUS_TYPE_DIRECTORY); g_value_set_object (value, file_entry->subdirectory); break; case NAUTILUS_LIST_MODEL_SMALLEST_ICON_COLUMN: case NAUTILUS_LIST_MODEL_SMALLER_ICON_COLUMN: case NAUTILUS_LIST_MODEL_SMALL_ICON_COLUMN: case NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN: case NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN: case NAUTILUS_LIST_MODEL_LARGER_ICON_COLUMN: case NAUTILUS_LIST_MODEL_LARGEST_ICON_COLUMN: g_value_init (value, CAIRO_GOBJECT_TYPE_SURFACE); if (file != NULL) { zoom_level = nautilus_list_model_get_zoom_level_from_column_id (column); icon_size = nautilus_get_icon_size_for_zoom_level (zoom_level); icon_scale = nautilus_list_model_get_icon_scale (model); flags = NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS | NAUTILUS_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE | NAUTILUS_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM; if (model->details->drag_view != NULL) { GtkTreePath *path_a, *path_b; gtk_tree_view_get_drag_dest_row (model->details->drag_view, &path_a, NULL); if (path_a != NULL) { path_b = gtk_tree_model_get_path (tree_model, iter); if (gtk_tree_path_compare (path_a, path_b) == 0) { flags |= NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } gtk_tree_path_free (path_a); gtk_tree_path_free (path_b); } } gicon = G_ICON (nautilus_file_get_icon_pixbuf (file, icon_size, TRUE, icon_scale, flags)); emblem_icons = nautilus_file_get_emblem_icons (file); /* pick only the first emblem we can render for the list view */ for (l = emblem_icons; l != NULL; l = l->next) { emblem_icon = l->data; if (nautilus_icon_theme_can_render (G_THEMED_ICON (emblem_icon))) { emblem = g_emblem_new (emblem_icon); emblemed_icon = g_emblemed_icon_new (gicon, emblem); g_object_unref (gicon); g_object_unref (emblem); gicon = emblemed_icon; break; } } g_list_free_full (emblem_icons, g_object_unref); icon_info = nautilus_icon_info_lookup (gicon, icon_size, icon_scale); icon = nautilus_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); g_object_unref (gicon); if (model->details->highlight_files != NULL && g_list_find_custom (model->details->highlight_files, file, (GCompareFunc) nautilus_file_compare_location)) { rendered_icon = eel_create_spotlight_pixbuf (icon); if (rendered_icon != NULL) { g_object_unref (icon); icon = rendered_icon; } } surface = gdk_cairo_surface_create_from_pixbuf (icon, icon_scale, NULL); g_value_take_boxed (value, surface); g_object_unref (icon); } break; case NAUTILUS_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, file != NULL && nautilus_file_can_rename (file)); break; default: if (column >= NAUTILUS_LIST_MODEL_NUM_COLUMNS || column < NAUTILUS_LIST_MODEL_NUM_COLUMNS + model->details->columns->len) { NautilusColumn *nautilus_column; GQuark attribute; nautilus_column = model->details->columns->pdata[column - NAUTILUS_LIST_MODEL_NUM_COLUMNS]; g_value_init (value, G_TYPE_STRING); g_object_get (nautilus_column, "attribute_q", &attribute, NULL); if (file != NULL) { str = nautilus_file_get_string_attribute_with_default_q (file, attribute); g_value_take_string (value, str); } else if (attribute == attribute_name_q) { if (file_entry->parent->loaded) { g_value_set_string (value, _("(Empty)")); } else { g_value_set_string (value, _("Loading…")); } } } else { g_assert_not_reached (); } } }