static gboolean log_button_press_cb(GtkWidget *treeview, GdkEventButton *event, PidginLogViewer *lv) { if (event->type == GDK_BUTTON_PRESS && event->button == 3) { GtkTreePath *path; GtkTreeIter *iter; GValue val; PurpleLog *log; gpointer *data; if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), event->x, event->y, &path, NULL, NULL, NULL)) return FALSE; iter = g_new(GtkTreeIter, 1); gtk_tree_model_get_iter(GTK_TREE_MODEL(lv->treestore), iter, path); val.g_type = 0; gtk_tree_model_get_value(GTK_TREE_MODEL(lv->treestore), iter, 1, &val); gtk_tree_path_free(path); log = g_value_get_pointer(&val); if (log == NULL) { g_free(iter); return FALSE; } data = g_new(gpointer, 4); data[0] = lv; data[1] = log; data[2] = NULL; data[3] = iter; log_show_popup_menu(treeview, event, data); return TRUE; } return FALSE; }
static void ev_attachment_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *param_spec) { EvAttachment *attachment = EV_ATTACHMENT (object); switch (prop_id) { case PROP_NAME: attachment->priv->name = g_value_dup_string (value); break; case PROP_DESCRIPTION: attachment->priv->description = g_value_dup_string (value); break; case PROP_MTIME: attachment->priv->mtime = g_value_get_ulong (value); break; case PROP_CTIME: attachment->priv->ctime = g_value_get_ulong (value); break; case PROP_SIZE: attachment->priv->size = g_value_get_uint (value); break; case PROP_DATA: attachment->priv->data = g_value_get_pointer (value); attachment->priv->mime_type = g_content_type_guess (attachment->priv->name, (guchar *) attachment->priv->data, attachment->priv->size, NULL); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, param_spec); break; } }
static void peas_extension_set_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { PeasExtensionSet *set = PEAS_EXTENSION_SET (object); switch (prop_id) { case PROP_ENGINE: set->priv->engine = g_value_get_object (value); break; case PROP_EXTENSION_TYPE: set->priv->exten_type = g_value_get_gtype (value); break; case PROP_CONSTRUCT_PROPERTIES: set_construct_properties (set, g_value_get_pointer (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
static void gda_tree_manager_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec) { GdaTreeManager *manager; manager = GDA_TREE_MANAGER (object); if (manager->priv) { switch (param_id) { case PROP_RECURS: manager->priv->recursive = g_value_get_boolean (value); break; case PROP_FUNC: manager->priv->update_func = g_value_get_pointer (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; } } }
static void render_contact_method(G_GNUC_UNUSED GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, G_GNUC_UNUSED gpointer data) { GValue value = G_VALUE_INIT; gtk_tree_model_get_value(model, iter, 0, &value); auto cm = (ContactMethod *)g_value_get_pointer(&value); gchar *number = nullptr; if (cm && cm->category()) { // try to get the number category, eg: "home" number = g_strdup_printf("(%s) %s", cm->category()->name().toUtf8().constData(), cm->uri().toUtf8().constData()); } else if (cm) { number = g_strdup_printf("%s", cm->uri().toUtf8().constData()); } g_object_set(G_OBJECT(cell), "text", number, NULL); g_free(number); }
static void moko_history_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { MokoHistoryPrivate *priv; g_return_if_fail (MOKO_IS_HISTORY (object)); priv = (MOKO_HISTORY (object))->priv; switch (prop_id) { case PROP_JOURNAL: priv->journal = (MokoJournal *)g_value_get_pointer (value); if (priv->journal) moko_history_load_entries (MOKO_HISTORY (object)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void budgie_media_label_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { BudgieMediaLabel *self; self = BUDGIE_MEDIA_LABEL(object); switch (prop_id) { case PROP_INFO: self->info = g_value_get_pointer((GValue*)value); update_ui(self); break; case PROP_PLAYING: self->playing = g_value_get_boolean((GValue*)value); budgie_media_label_set_playing(self, self->playing); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static const void *get_column_value_from_row(GtkTreeView *treeview, int column, int type) { GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); const void *retval = NULL; if (selection) { GtkTreeIter iter; GtkTreeModel *store = gtk_tree_view_get_model(treeview); if (gtk_tree_selection_get_selected(selection, &store, &iter) == TRUE) { GValue value = { 0 }; gtk_tree_model_get_value(store, &iter, column, &value); switch(type){ case TYPE_STR: retval = g_value_get_string(&value); break; case TYPE_POINTER: retval = g_value_get_pointer(&value); } } } return retval; }
static void g_win32_output_stream_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GWin32OutputStream *win32_stream; win32_stream = G_WIN32_OUTPUT_STREAM (object); switch (prop_id) { case PROP_HANDLE: win32_stream->priv->handle = g_value_get_pointer (value); break; case PROP_CLOSE_HANDLE: win32_stream->priv->close_handle = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void pseudo_tcp_socket_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { PseudoTcpSocket *self = PSEUDO_TCP_SOCKET (object); switch (property_id) { case PROP_CONVERSATION: self->priv->conv = g_value_get_uint (value); break; case PROP_CALLBACKS: { PseudoTcpCallbacks *c = g_value_get_pointer (value); self->priv->callbacks = *c; } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void nemo_mime_application_chooser_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { NemoMimeApplicationChooser *chooser = NEMO_MIME_APPLICATION_CHOOSER (object); switch (property_id) { case PROP_CONTENT_TYPE: chooser->details->content_type = g_value_dup_string (value); break; case PROP_FILES: chooser->details->files = g_value_get_pointer (value); break; case PROP_URI: chooser->details->uri = g_value_dup_string (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static int edit_plugin_get_index_of_selected_item (PluginEditorDialog *dlg) { int i; GnomeUIInfo *curr_item; GnomeUIInfo *sysmenus; GValue val = {G_TYPE_INVALID}; if (FALSE == dlg->have_selection) return -1; if (! dlg->menus) return -1; /* Get selected item */ gtk_tree_model_get_value (GTK_TREE_MODEL(dlg->treestore), &dlg->curr_selection, PTRCOL, &val); curr_item = g_value_get_pointer(&val); sysmenus = (GnomeUIInfo *) dlg->menus->data; for (i=0; GNOME_APP_UI_ENDOFINFO != sysmenus[i].type; i++) { if (curr_item == &sysmenus[i]) return i; } return -1; }
void marshal_BOOLEAN__POINTER (GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data) { typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer data1, gpointer arg_1, gpointer data2); register GMarshalFunc_BOOLEAN__POINTER callback; register GCClosure *cc = (GCClosure*) closure; register gpointer data1, data2; gboolean v_return; g_return_if_fail (return_value != NULL); g_return_if_fail (n_param_values == 2); if (G_CCLOSURE_SWAP_DATA (closure)) { data1 = closure->data; data2 = g_value_peek_pointer (param_values + 0); } else { data1 = g_value_peek_pointer (param_values + 0); data2 = closure->data; } callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback); v_return = callback (data1, g_value_get_pointer (param_values + 1), data2); g_value_set_boolean (return_value, v_return); }
static void purple_smiley_set_property(GObject *object, guint param_id, const GValue *value, GParamSpec *spec) { PurpleSmiley *smiley = PURPLE_SMILEY(object); switch (param_id) { case PROP_SHORTCUT: { const char *shortcut = g_value_get_string(value); purple_smiley_set_shortcut(smiley, shortcut); } break; case PROP_IMGSTORE: { PurpleStoredImage *img = g_value_get_pointer(value); purple_imgstore_unref(smiley->img); g_free(smiley->checksum); smiley->img = img; if (img) { smiley->checksum = purple_util_get_image_checksum( purple_imgstore_get_data(img), purple_imgstore_get_size(img)); purple_smiley_data_store(img); } else { smiley->checksum = NULL; } g_object_notify(object, PROP_IMGSTORE_S); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, spec); break; } }
static void lpf_trip_part_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { LpfTripPart *self = LPF_TRIP_PART (object); LpfTripPartPrivate *priv = GET_PRIVATE(self); switch (property_id) { case LPF_TRIP_PART_PROP_START: if (priv->start) g_object_unref (priv->start); priv->start = g_value_get_object(value); break; case LPF_TRIP_PART_PROP_END: if (priv->end) g_object_unref (priv->end); priv->end = g_value_get_object(value); break; case LPF_TRIP_PART_PROP_LINE: g_free (priv->line); priv->line = g_value_dup_string(value); break; case LPF_TRIP_PART_PROP_STOPS: priv->stops = g_value_get_pointer(value); break; default: /* We don't have any other property... */ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void coil_expandable_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { CoilExpandable *self = COIL_EXPANDABLE(object); switch (property_id) { case PROP_CONTAINER: { self->container = g_value_get_object(value); break; } /* TODO(jcon): refactor */ case PROP_LOCATION: { if (self->location.filepath) g_free(self->location.filepath); CoilLocation *loc_ptr; loc_ptr = (CoilLocation *)g_value_get_pointer(value); if (loc_ptr) { self->location = *((CoilLocation *)loc_ptr); self->location.filepath = g_strdup(loc_ptr->filepath); } break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } }
static void gupnp_service_info_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GUPnPServiceInfo *info; info = GUPNP_SERVICE_INFO (object); switch (property_id) { case PROP_CONTEXT: info->priv->context = g_object_ref (g_value_get_object (value)); break; case PROP_LOCATION: info->priv->location = g_value_dup_string (value); break; case PROP_UDN: info->priv->udn = g_value_dup_string (value); break; case PROP_SERVICE_TYPE: info->priv->service_type = g_value_dup_string (value); break; case PROP_URL_BASE: info->priv->url_base = g_value_dup_boxed (value); break; case PROP_DOCUMENT: info->priv->doc = g_value_dup_object (value); break; case PROP_ELEMENT: info->priv->element = g_value_get_pointer (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gupnp_didl_lite_create_class_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GUPnPDIDLLiteCreateClass *create_class; create_class = GUPNP_DIDL_LITE_CREATE_CLASS (object); switch (property_id) { case PROP_XML_NODE: create_class->priv->xml_node = g_value_get_pointer (value); break; case PROP_XML_DOC: create_class->priv->xml_doc = g_value_dup_object (value); break; case PROP_CONTENT: gupnp_didl_lite_create_class_set_content (create_class, g_value_get_string (value)); break; case PROP_INCLUDE_DERIVED: gupnp_didl_lite_create_class_set_include_derived (create_class, g_value_get_boolean (value)); break; case PROP_FRIENDLY_NAME: gupnp_didl_lite_create_class_set_friendly_name (create_class, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void seahorse_gpgme_uid_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { SeahorseGpgmeUid *self = SEAHORSE_GPGME_UID (object); gpgme_key_t pubkey; switch (prop_id) { case PROP_PUBKEY: pubkey = g_value_get_boxed (value); g_return_if_fail (pubkey); if (pubkey != self->pv->pubkey) { if (self->pv->pubkey) { /* Should always be set to the same actual key */ g_return_if_fail (compare_pubkeys (pubkey, self->pv->pubkey)); gpgme_key_unref (self->pv->pubkey); } self->pv->pubkey = g_value_get_boxed (value); if (self->pv->pubkey) gpgme_key_ref (self->pv->pubkey); /* This is expected to be set shortly along with pubkey */ self->pv->userid = NULL; } break; case PROP_ACTUAL_INDEX: seahorse_gpgme_uid_set_actual_index (self, g_value_get_uint (value)); break; case PROP_USERID: seahorse_gpgme_uid_set_userid (self, g_value_get_pointer (value)); break; } }
/* DND */ static void drag_data_get_cb(GtkWidget *widget, GdkDragContext *ctx, GtkSelectionData *data, guint info, guint time, gpointer user_data) { GtkListStore *ls = (GtkListStore *) user_data; if (ls == NULL) return; if (data->target == gdk_atom_intern ("STRING", FALSE)) { GtkTreeRowReference *ref; GtkTreePath *source_row; GtkTreeIter iter; GString *s; struct widget *w; GValue val = {0}; ref = g_object_get_data (G_OBJECT(ctx), "gtk-tree-view-source-row"); source_row = gtk_tree_row_reference_get_path (ref); if (source_row == NULL) return; gtk_tree_model_get_iter(GTK_TREE_MODEL(ls), &iter, source_row); gtk_tree_model_get_value(GTK_TREE_MODEL(ls), &iter, 1, &val); w = g_value_get_pointer (&val); s = g_string_new (""); g_string_printf (s, "[%s]", w->alias); gtk_selection_data_set (data, gdk_atom_intern ("STRING", FALSE), 8, (guchar *)s->str, strlen(s->str)+1); g_string_free (s, TRUE); gtk_tree_path_free (source_row); } }
static void component_response_cb(GtkWidget *d, int response, GtkTreeSelection *sel) { GtkTreeModel *model; GtkTreeIter iter; GValue val; struct component *c; switch (response) { case AP_RESPONSE_CHOOSE: gtk_tree_selection_get_selected (sel, &model, &iter); val.g_type = 0; gtk_tree_model_get_value (model, &iter, 1, &val); c = g_value_get_pointer(&val); add_component (c); case GTK_RESPONSE_CLOSE: case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(d); component_dialog = NULL; choose_button = NULL; break; } }
static gboolean visibility_filter_func(GtkTreeModel *model, GtkTreeIter *iter, gpointer data) { GValue val = {0, }; CookieInfo *info; PdmActionInfo *action = (PdmActionInfo *)data; if (action->filter_string == NULL) return TRUE; gtk_tree_model_get_value(model, iter, action->data_col, &val); /* Bit of a sneaky hack. Cookies/passwords/permissions have * different structs, but all have domain/hostname as the first * field. So we can get away with this fudge */ info = (CookieInfo *)g_value_get_pointer(&val); if (g_strrstr(info->domain, action->filter_string) != NULL) return TRUE; else return FALSE; }
static GtkTreeIter * history_dialog_find_site_iter (HistoryDialog *dialog, GtkTreeIter *host_iter, HistoryItem *item) { GtkTreeIter iter; gtk_tree_model_iter_children (dialog->priv->model, &iter, host_iter); do { GValue val = { 0, }; HistoryItem *i; gtk_tree_model_get_value (dialog->priv->model, &iter, 5, &val); i = (HistoryItem *) g_value_get_pointer (&val); if (i == item) return gtk_tree_iter_copy (&iter); } while (gtk_tree_model_iter_next (dialog->priv->model, &iter)); return NULL; }
/* property mutator */ void thrift_memory_buffer_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { ThriftMemoryBuffer *t = THRIFT_MEMORY_BUFFER (object); THRIFT_UNUSED_VAR (pspec); switch (property_id) { case PROP_THRIFT_MEMORY_BUFFER_BUFFER_SIZE: t->buf_size = g_value_get_uint (value); break; case PROP_THRIFT_MEMORY_BUFFER_BUFFER: t->buf = (GByteArray*) g_value_get_pointer (value); break; case PROP_THRIFT_MEMORY_BUFFER_OWNER: t->owner = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void panel_ditem_editor_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { PanelDItemEditor *dialog; g_return_if_fail (PANEL_IS_DITEM_EDITOR (object)); dialog = PANEL_DITEM_EDITOR (object); switch (prop_id) { case PROP_KEYFILE: panel_ditem_editor_set_key_file (dialog, g_value_get_pointer (value)); break; case PROP_URI: panel_ditem_editor_set_uri (dialog, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_skor_sink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstSkorSink *filter = GST_SKORSINK (object); switch (prop_id) { case PROP_CACHE: filter->cache = g_value_get_boolean (value); break; case PROP_MESSAGE: filter->message = g_value_get_boolean (value); break; case PROP_ATTACH_FRAME: filter->attach_frame = g_value_get_boolean (value); break; case PROP_DATA_CONSUMER: filter->data_consumer = g_value_get_pointer (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_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_schar(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 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: g_value_set_schar(value, rts_getChar(obj)); return; case G_TYPE_UCHAR: g_value_set_schar(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))); }
void ags_file_set_property(GObject *gobject, guint prop_id, const GValue *value, GParamSpec *param_spec) { AgsFile *file; pthread_mutex_t *file_mutex; file = AGS_FILE(gobject); /* get file mutex */ pthread_mutex_lock(ags_file_get_class_mutex()); file_mutex = file->obj_mutex; pthread_mutex_unlock(ags_file_get_class_mutex()); switch(prop_id){ case PROP_FILENAME: { gchar *filename; filename = g_value_get_string(value); pthread_mutex_lock(file_mutex); if(file->filename == filename){ pthread_mutex_unlock(file_mutex); return; } if(file->filename != NULL){ g_free(file->filename); } file->filename = g_strdup(filename); pthread_mutex_unlock(file_mutex); } break; case PROP_ENCODING: { gchar *encoding; encoding = g_value_get_string(value); pthread_mutex_lock(file_mutex); file->encoding = encoding; pthread_mutex_unlock(file_mutex); } break; case PROP_AUDIO_FORMAT: { gchar *audio_format; audio_format = g_value_get_string(value); pthread_mutex_lock(file_mutex); file->audio_format = audio_format; pthread_mutex_unlock(file_mutex); } break; case PROP_AUDIO_ENCODING: { gchar *audio_encoding; audio_encoding = g_value_get_string(value); pthread_mutex_lock(file_mutex); file->audio_encoding = audio_encoding; pthread_mutex_unlock(file_mutex); } break; case PROP_XML_DOC: { xmlDoc *doc; doc = (xmlDoc *) g_value_get_pointer(value); pthread_mutex_lock(file_mutex); file->doc = doc; pthread_mutex_unlock(file_mutex); } break; case PROP_APPLICATION_CONTEXT: { GObject *application_context; application_context = g_value_get_object(value); pthread_mutex_lock(file_mutex); if(file->application_context == application_context){ pthread_mutex_unlock(file_mutex); return; } if(file->application_context != NULL){ g_object_unref(file->application_context); } if(application_context != NULL){ g_object_ref(application_context); } file->application_context = application_context; pthread_mutex_unlock(file_mutex); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
void _gtk_tree_data_list_value_to_node (GtkTreeDataList *list, GValue *value) { switch (get_fundamental_type (G_VALUE_TYPE (value))) { case G_TYPE_BOOLEAN: list->data.v_int = g_value_get_boolean (value); break; case G_TYPE_CHAR: list->data.v_char = g_value_get_schar (value); break; case G_TYPE_UCHAR: list->data.v_uchar = g_value_get_uchar (value); break; case G_TYPE_INT: list->data.v_int = g_value_get_int (value); break; case G_TYPE_UINT: list->data.v_uint = g_value_get_uint (value); break; case G_TYPE_LONG: list->data.v_long = g_value_get_long (value); break; case G_TYPE_ULONG: list->data.v_ulong = g_value_get_ulong (value); break; case G_TYPE_INT64: list->data.v_int64 = g_value_get_int64 (value); break; case G_TYPE_UINT64: list->data.v_uint64 = g_value_get_uint64 (value); break; case G_TYPE_ENUM: list->data.v_int = g_value_get_enum (value); break; case G_TYPE_FLAGS: list->data.v_uint = g_value_get_flags (value); break; case G_TYPE_POINTER: list->data.v_pointer = g_value_get_pointer (value); break; case G_TYPE_FLOAT: list->data.v_float = g_value_get_float (value); break; case G_TYPE_DOUBLE: list->data.v_double = g_value_get_double (value); break; case G_TYPE_STRING: g_free (list->data.v_pointer); list->data.v_pointer = g_value_dup_string (value); break; case G_TYPE_OBJECT: if (list->data.v_pointer) g_object_unref (list->data.v_pointer); list->data.v_pointer = g_value_dup_object (value); break; case G_TYPE_BOXED: if (list->data.v_pointer) g_boxed_free (G_VALUE_TYPE (value), list->data.v_pointer); list->data.v_pointer = g_value_dup_boxed (value); break; case G_TYPE_VARIANT: if (list->data.v_pointer) g_variant_unref (list->data.v_pointer); list->data.v_pointer = g_value_dup_variant (value); break; default: g_warning ("%s: Unsupported type (%s) stored.", G_STRLOC, g_type_name (G_VALUE_TYPE (value))); break; } }
static void gst_pocketsphinx_set_property(GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstPocketSphinx *ps = GST_POCKETSPHINX(object); switch (prop_id) { case PROP_CONFIGURED: ps_reinit(ps->ps, ps->config); break; case PROP_HMM_DIR: gst_pocketsphinx_set_string(ps, "-hmm", value); break; case PROP_LM_FILE: /* FSG and LM are mutually exclusive. */ gst_pocketsphinx_set_string(ps, "-fsg", NULL); gst_pocketsphinx_set_string(ps, "-lmctl", NULL); gst_pocketsphinx_set_string(ps, "-lm", value); break; case PROP_LMCTL_FILE: /* FSG and LM are mutually exclusive. */ gst_pocketsphinx_set_string(ps, "-fsg", NULL); gst_pocketsphinx_set_string(ps, "-lmctl", value); gst_pocketsphinx_set_string(ps, "-lm", NULL); break; case PROP_LM_NAME: gst_pocketsphinx_set_string(ps, "-fsg", NULL); gst_pocketsphinx_set_string(ps, "-lm", NULL); gst_pocketsphinx_set_string(ps, "-lmname", value); /** * Chances are that lmctl is already loaded and all * corresponding searches are configured, so we simply * try to set the search */ if (value != NULL) { ps_set_search(ps->ps, g_value_get_string(value)); } break; case PROP_DICT_FILE: gst_pocketsphinx_set_string(ps, "-dict", value); break; case PROP_MLLR_FILE: gst_pocketsphinx_set_string(ps, "-mllr", value); break; case PROP_FSG_MODEL: { fsg_model_t *fsg = g_value_get_pointer(value); const char *name = fsg_model_name(fsg); ps_set_fsg(ps->ps, name, fsg); ps_set_search(ps->ps, name); } break; case PROP_FSG_FILE: /* FSG and LM are mutually exclusive */ gst_pocketsphinx_set_string(ps, "-lm", NULL); gst_pocketsphinx_set_string(ps, "-fsg", value); break; case PROP_FWDFLAT: gst_pocketsphinx_set_boolean(ps, "-fwdflat", value); break; case PROP_BESTPATH: gst_pocketsphinx_set_boolean(ps, "-bestpath", value); break; case PROP_LATDIR: if (ps->latdir) g_free(ps->latdir); ps->latdir = g_strdup(g_value_get_string(value)); break; case PROP_MAXHMMPF: gst_pocketsphinx_set_int(ps, "-maxhmmpf", value); break; case PROP_MAXWPF: gst_pocketsphinx_set_int(ps, "-maxwpf", value); break; case PROP_BEAM: gst_pocketsphinx_set_double(ps, "-beam", value); break; case PROP_PBEAM: gst_pocketsphinx_set_double(ps, "-pbeam", value); break; case PROP_WBEAM: gst_pocketsphinx_set_double(ps, "-wbeam", value); break; case PROP_DSRATIO: gst_pocketsphinx_set_int(ps, "-ds", value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); return; } }