/*! \brief callback for user selecting an item * * \param [in] selection * \param [in] state */ static void select_cb (GtkTreeSelection *selection, GschemFindTextState *state) { GtkTreeIter iter; gboolean success; g_return_if_fail (selection != NULL); g_return_if_fail (state != NULL); success = gtk_tree_selection_get_selected (selection, NULL, &iter); if (success) { GValue value = G_VALUE_INIT; gtk_tree_model_get_value (GTK_TREE_MODEL (state->store), &iter, COLUMN_OBJECT, &value); if (G_VALUE_HOLDS_POINTER (&value)) { OBJECT *object = (OBJECT*) g_value_get_pointer (&value); if (object != NULL) { g_signal_emit_by_name (state, "select-object", object); } else { g_warning ("NULL object encountered"); } } g_value_unset (&value); } }
static void dump_array(GValueArray *array) { unsigned int i; if (array != NULL) { printf("args = {"); for (i = 0; i < array->n_values; i++) { GValue *value; value = g_value_array_get_nth(array, i); if (i > 0) { printf(", "); } if (G_VALUE_HOLDS_LONG(value)) { printf("%ld", g_value_get_long(value)); } if (G_VALUE_HOLDS_STRING(value)) { printf("`%s'", g_value_get_string(value)); } if (G_VALUE_HOLDS_POINTER(value)) { printf("`%ls'", (wchar_t*) g_value_get_pointer(value)); } } printf("}\n"); } }
/*! \brief delete all items from the list store * * This function deletes all items in the list store and removes all the weak * references to the objects. * * \param [in] state */ static void clear_store (GschemFindTextState *state) { GtkTreeIter iter; gboolean valid; g_return_if_fail (state != NULL); g_return_if_fail (state->store != NULL); valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (state->store), &iter); while (valid) { GValue value = G_VALUE_INIT; gtk_tree_model_get_value (GTK_TREE_MODEL (state->store), &iter, COLUMN_OBJECT, &value); if (G_VALUE_HOLDS_POINTER (&value)) { OBJECT *object = (OBJECT*) g_value_get_pointer (&value); s_object_weak_unref (object, (NotifyFunc) object_weakref_cb, state); } g_value_unset (&value); valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (state->store), &iter); } gtk_list_store_clear (state->store); }
/*! \brief remove an object from the store * * This function gets called in response to the object deletion. And, doesn't * dereference the object. * * This function doesn't remove the weak reference, under the assumption that * the object is being destroyed. * * \param [in] state * \param [in] object the object to remove from the store */ static void remove_object (GschemFindTextState *state, OBJECT *object) { GtkTreeIter iter; gboolean valid; g_return_if_fail (object != NULL); g_return_if_fail (state != NULL); g_return_if_fail (state->store != NULL); valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (state->store), &iter); while (valid) { GValue value = G_VALUE_INIT; gtk_tree_model_get_value (GTK_TREE_MODEL (state->store), &iter, COLUMN_OBJECT, &value); if (G_VALUE_HOLDS_POINTER (&value)) { OBJECT *other = (OBJECT*) g_value_get_pointer (&value); if (object == other) { g_value_unset (&value); valid = gtk_list_store_remove (state->store, &iter); continue; } } g_value_unset (&value); valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (state->store), &iter); } }
/** * g_value_get_pointer: * @value: a valid #GValue of %G_TYPE_POINTER * * Get the contents of a pointer #GValue. * * Returns: (transfer none): pointer contents of @value */ gpointer g_value_get_pointer (const GValue *value) { g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL); return value->data[0].v_pointer; }
/* Print the contents of a GValueArray. */ static void print_array(GValueArray *array) { int i; GValue *value; if (array != NULL) { printf(" ("); for (i = 0; i < array->n_values; i++) { value = g_value_array_get_nth(array, i); if (i > 0) { printf(", "); } if (G_VALUE_HOLDS_LONG(value)) { printf("%ld", g_value_get_long(value)); } else if (G_VALUE_HOLDS_STRING(value)) { printf("\"%s\"", g_value_get_string(value)); } else if (G_VALUE_HOLDS_POINTER(value)) { printf("\"%ls\"", (wchar_t*) g_value_get_pointer(value)); } if (G_VALUE_HOLDS_BOXED(value)) { print_array(g_value_get_boxed(value)); } } printf(")"); /* _vte_matcher_free_params_array(array); */ } }
static void cb_custom_toggled(GtkCellRendererToggle *cell, char *path, gpointer data) { GtkTreeIter iter; GtkTreeModel *model = (GtkTreeModel*) data; if (gtk_tree_model_get_iter_from_string(model, &iter, path)) { PurpleAccount *account; GValue value; memset(&value, 0, sizeof(value)); gtk_tree_model_get_value(model, &iter, 5, &value); assert(G_VALUE_HOLDS_POINTER(&value)); account = g_value_get_pointer(&value); g_value_unset(&value); gboolean flag; char pref[STRLEN]; build_pref(pref, PREF_CUSTOM_DISABLED, purple_account_get_username(account), purple_account_get_protocol_name(account)); memset(&value, 0, sizeof(value)); gtk_tree_model_get_value(model, &iter, 3, &value); assert(G_VALUE_HOLDS_BOOLEAN(&value)); flag = !g_value_get_boolean(&value); g_value_unset(&value); gtk_list_store_set(GTK_LIST_STORE(model), &iter, 3, flag, -1); purple_prefs_set_bool(pref, flag); if (flag) { set_status(account, "", 0); } } }
/** * g_value_set_pointer: * @value: a valid #GValue of %G_TYPE_POINTER * @v_pointer: pointer value to be set * * Set the contents of a pointer #GValue to @v_pointer. */ void g_value_set_pointer (GValue *value, gpointer v_pointer) { g_return_if_fail (G_VALUE_HOLDS_POINTER (value)); value->data[0].v_pointer = v_pointer; }
/* Check if the given pattern matches part of the given trie, returning an * empty string on a partial initial match, a %NULL if there's no match in the * works, and the result string if we have an exact match. */ TRIE_MAYBE_STATIC const char * _vte_trie_match(struct _vte_trie *trie, const gunichar *pattern, gsize length, const char **res, const gunichar **consumed, GQuark *quark, GValueArray **array) { const char *ret = NULL; GQuark tmpquark; GValueArray *valuearray; GValue *value; const gunichar *dummyconsumed; gboolean greedy = FALSE; guint i; if (array != NULL && *array != NULL) { valuearray = *array; } else { valuearray = g_value_array_new(0); } if (quark == NULL) { quark = &tmpquark; } *quark = 0; if (consumed == NULL) { consumed = &dummyconsumed; } *consumed = pattern; ret = _vte_trie_matchx(trie, pattern, length, greedy, res, consumed, quark, valuearray); if (((ret == NULL) || (ret[0] == '\0')) || (valuearray->n_values == 0)){ if (valuearray != NULL) { for (i = 0; i < valuearray->n_values; i++) { value = g_value_array_get_nth(valuearray, i); if (G_VALUE_HOLDS_POINTER(value)) { g_free(g_value_get_pointer(value)); g_value_set_pointer(value, NULL); } } if (array == NULL || valuearray != *array) { _vte_matcher_free_params_array(NULL, valuearray); } } } else { if (array == NULL) { _vte_matcher_free_params_array(NULL, valuearray); } } return ret; }
void MacWidget::onSyncMessage(GstBus * inBus, GstMessage * inMessage) { switch (GST_MESSAGE_TYPE(inMessage)) { case GST_MESSAGE_ELEMENT: { if (gst_structure_has_name(inMessage->structure, "have-ns-view")) { const GValue * value = gst_structure_get_value(inMessage->structure, "nsview"); if (value && G_VALUE_HOLDS_POINTER(value) && mCallback) { mCallback(g_value_get_pointer(value)); } } break; } } }
void FormatDialog::cbFormatChangedCb(GtkComboBox* widget, FormatDialog* dlg) { XOJ_CHECK_TYPE_OBJ(dlg, FormatDialog); GtkTreeIter iter; if (gtk_combo_box_get_active_iter(widget, &iter)) { GtkTreeModel* model = gtk_combo_box_get_model(widget); GValue value = { 0 }; gtk_tree_model_get_value(model, &iter, 1, &value); if (G_VALUE_HOLDS_POINTER(&value)) { GtkPaperSize* s = (GtkPaperSize*) g_value_get_pointer(&value); if (s == NULL) { return; } double width = gtk_paper_size_get_width(s, GTK_UNIT_POINTS) / dlg->scale; double height = gtk_paper_size_get_height(s, GTK_UNIT_POINTS) / dlg->scale; if (dlg->orientation == ORIENTATION_LANDSCAPE) { double tmp = width; width = height; height = tmp; } else { dlg->setOrientation(ORIENTATION_PORTRAIT); } gtk_spin_button_set_value(GTK_SPIN_BUTTON(dlg->get("spinWidth")), width); gtk_spin_button_set_value(GTK_SPIN_BUTTON(dlg->get("spinHeight")), height); } } }
static void cb_custom_edited(GtkCellRendererText *renderer, char *path, char *str, gpointer data) { GtkTreeIter iter; GtkTreeModel *model = (GtkTreeModel*) data; if (gtk_tree_model_get_iter_from_string(model, &iter, path)) { PurpleAccount *account; GValue value; memset(&value, 0, sizeof(value)); gtk_tree_model_get_value(model, &iter, 5, &value); assert(G_VALUE_HOLDS_POINTER(&value)); account = g_value_get_pointer(&value); g_value_unset(&value); char pref[STRLEN]; build_pref(pref, PREF_CUSTOM_FORMAT, purple_account_get_username(account), purple_account_get_protocol_name(account)); gtk_list_store_set(GTK_LIST_STORE(model), &iter, 2, str, -1); purple_prefs_set_string(pref, str); } }
/* Check if the given pattern matches part of the given trie, returning an * empty string on a partial initial match, a %NULL if there's no match in the * works, and the result string if we have an exact match. */ static const char * _vte_trie_matchx(struct _vte_trie *trie, const gunichar *pattern, gsize length, gboolean greedy, const char **res, const gunichar **consumed, GQuark *quark, GValueArray *array) { unsigned int i; const char *hres; enum cclass cc; const char *best = NULL; GValueArray *bestarray = NULL; GQuark bestquark = 0; const gunichar *bestconsumed = pattern; /* Make sure that attempting to save output values doesn't kill us. */ if (res == NULL) { res = &hres; } /* Trivial cases. We've matched an entire pattern, or we're out of * pattern to match. */ if (trie->result != NULL) { *res = trie->result; *quark = trie->quark; *consumed = pattern; return *res; } if (length <= 0) { if (trie->trie_path_count > 0) { *res = ""; *quark = g_quark_from_static_string(""); *consumed = pattern; return *res; } else { *res = NULL; *quark = 0; *consumed = pattern; return *res; } } /* Now figure out which (if any) subtrees to search. First, see * which character class this character matches. */ for (cc = exact; cc < invalid; cc++) for (i = 0; i < trie->trie_path_count; i++) { struct _vte_trie *subtrie = trie->trie_paths[i].trie; struct char_class *cclass = trie->trie_paths[i].cclass; struct char_class_data *data = &trie->trie_paths[i].data; if (trie->trie_paths[i].cclass->type == cc) { /* If it matches this character class... */ if (cclass->check(pattern[0], data)) { const gunichar *prospect = pattern + 1; const char *tmp; GQuark tmpquark = 0; GValueArray *tmparray; gboolean better = FALSE; /* Move past characters which might match this * part of the string... */ while (cclass->multiple && ((gsize)(prospect - pattern) < length) && cclass->check(prospect[0], data)) { prospect++; } /* ... see if there's a parameter here, ... */ tmparray = g_value_array_new(0); cclass->extract(pattern, prospect - pattern, data, tmparray); /* ... and check if the subtree matches the * rest of the input string. Any parameters * further on will be appended to the array. */ _vte_trie_matchx(subtrie, prospect, length - (prospect - pattern), greedy, &tmp, consumed, &tmpquark, tmparray); /* If we haven't seen any matches yet, go ahead * and go by this result. */ if (best == NULL) { better = TRUE; } else /* If we have a match, and we didn't have one * already, go by this result. */ if ((best != NULL) && (best[0] == '\0') && (tmp != NULL) && (tmp[0] != '\0')) { better = TRUE; } else /* If we already have a match, and this one's * better (longer if we're greedy, shorter if * we're not), then go by this result. */ if ((tmp != NULL) && (tmp[0] != '\0') && (bestconsumed != NULL) && (consumed != NULL) && (*consumed != NULL)) { if (greedy && (bestconsumed < *consumed)) { better = TRUE; } else if (!greedy && (bestconsumed > *consumed)) { better = TRUE; } } if (better) { best = tmp; if (bestarray != NULL) { _vte_matcher_free_params_array( NULL, bestarray); } bestarray = tmparray; bestquark = tmpquark; bestconsumed = *consumed; } else { _vte_matcher_free_params_array( NULL, tmparray); tmparray = NULL; } } } } /* We're done searching. Copy out any parameters we picked up. */ if (bestarray != NULL) { for (i = 0; i < bestarray->n_values; i++) { GValue *value = g_value_array_get_nth(bestarray, i); g_value_array_append(array, value); if (G_VALUE_HOLDS_POINTER(value)) { g_value_set_pointer(value, NULL); } } _vte_matcher_free_params_array(NULL, bestarray); } #if 0 printf("`%s' ", best); dump_array(array); #endif *quark = bestquark; *res = best; *consumed = bestconsumed; return *res; }
int main(int argc, char **argv) { struct _vte_matcher *matcher = NULL; GArray *array; unsigned int i, j; int l; unsigned char buf[4096]; GValue *value; int infile; struct _vte_iso2022_state *subst; const char *tmp; GValueArray *values; _vte_debug_init(); if (argc < 1) { g_print("usage: %s [file]\n", argv[0]); return 1; } if ((argc > 1) && (strcmp(argv[1], "-") != 0)) { infile = open (argv[1], O_RDONLY); if (infile == -1) { g_print("error opening %s: %s\n", argv[1], strerror(errno)); exit(1); } } else { infile = 1; } g_type_init(); array = g_array_new(FALSE, FALSE, sizeof(gunichar)); matcher = _vte_matcher_new(); subst = _vte_iso2022_state_new(NULL, VTE_ISO2022_DEFAULT_UTF8_AMBIGUOUS_WIDTH, NULL, NULL); for (;;) { l = read (infile, buf, sizeof (buf)); if (!l) break; if (l == -1) { if (errno == EAGAIN) continue; exit (1); } g_array_set_size (array, 0); _vte_iso2022_process(subst, buf, (unsigned int) l, array); i = 0; while (i <= array->len) { tmp = NULL; values = NULL; for (j = 1; j < (array->len - i); j++) { _vte_matcher_match(matcher, &g_array_index(array, gunichar, i), j, &tmp, NULL, &values); if ((tmp == NULL) || (strlen(tmp) > 0)) { break; } } if (i + j == array->len) { break; } if (tmp == NULL) { gunichar c; c = g_array_index(array, gunichar, i); if (VTE_ISO2022_HAS_ENCODED_WIDTH(c)) { c &= ~VTE_ISO2022_ENCODED_WIDTH_MASK; } if (c < 32) { g_print("`^%c'\n", c + 64); } else if (c < 127) { g_print("`%c'\n", c); } else { g_print("`0x%x'\n", c); } i++; continue; } l = j; g_print("%s(", tmp); for (j = 0; (values != NULL) && (j < values->n_values); j++) { if (j > 0) { g_print(", "); } value = g_value_array_get_nth(values, j); if (G_VALUE_HOLDS_LONG(value)) { g_print("%ld", g_value_get_long(value)); } if (G_VALUE_HOLDS_STRING(value)) { g_print("`%s'", g_value_get_string(value)); } if (G_VALUE_HOLDS_POINTER(value)) { g_print("`%ls'", (wchar_t*) g_value_get_pointer(value)); } } if (values != NULL) { _vte_matcher_free_params_array(matcher, values); } g_print(")\n"); i += l; } } g_print("End of data.\n"); close (infile); _vte_iso2022_state_free(subst); g_array_free(array, TRUE); _vte_matcher_free(matcher); return 0; }
static GstStateChangeReturn gst_visual_gl_change_state (GstElement * element, GstStateChange transition) { GstVisualGL *visual = GST_VISUAL_GL (element); GstStateChangeReturn ret; switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: break; case GST_STATE_CHANGE_READY_TO_PAUSED: { GstElement *parent = GST_ELEMENT (gst_element_get_parent (visual)); GstStructure *structure = NULL; GstQuery *query = NULL; gboolean isPerformed = FALSE; gchar *name; if (!parent) { GST_ELEMENT_ERROR (visual, CORE, STATE_CHANGE, (NULL), ("A parent bin is required")); return FALSE; } name = gst_element_get_name (visual); structure = gst_structure_new (name, NULL); query = gst_query_new_application (GST_QUERY_CUSTOM, structure); g_free (name); isPerformed = gst_element_query (parent, query); if (isPerformed) { const GValue *id_value = gst_structure_get_value (structure, "gstgldisplay"); if (G_VALUE_HOLDS_POINTER (id_value)) /* at least one gl element is after in our gl chain */ visual->display = gst_object_ref (GST_GL_DISPLAY (g_value_get_pointer (id_value))); else { /* this gl filter is a sink in terms of the gl chain */ visual->display = gst_gl_display_new (); gst_gl_display_create_context (visual->display, 0); //TODO visual->external_gl_context); } gst_visual_gl_reset (visual); visual->actor = visual_actor_new (GST_VISUAL_GL_GET_CLASS (visual)->plugin->info-> plugname); visual->video = visual_video_new (); visual->audio = visual_audio_new (); if (!visual->actor || !visual->video) goto actor_setup_failed; gst_gl_display_thread_add (visual->display, (GstGLDisplayThreadFunc) actor_setup, visual); if (visual->actor_setup_result != 0) goto actor_setup_failed; else visual_actor_set_video (visual->actor, visual->video); } gst_query_unref (query); gst_object_unref (GST_OBJECT (parent)); if (!isPerformed) return GST_STATE_CHANGE_FAILURE; } break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: { if (visual->fbo) { gst_gl_display_del_fbo (visual->display, visual->fbo, visual->depthbuffer); visual->fbo = 0; visual->depthbuffer = 0; } if (visual->midtexture) { gst_gl_display_del_texture (visual->display, visual->midtexture, visual->width, visual->height); visual->midtexture = 0; } if (visual->display) { gst_object_unref (visual->display); visual->display = NULL; } gst_visual_gl_clear_actors (visual); } break; case GST_STATE_CHANGE_READY_TO_NULL: break; default: break; } return ret; /* ERRORS */ actor_setup_failed: { GST_ELEMENT_ERROR (visual, LIBRARY, INIT, (NULL), ("could not set up actor")); gst_visual_gl_clear_actors (visual); return GST_STATE_CHANGE_FAILURE; } }
gboolean pointer_in_gvalue(GValue* v) { return G_VALUE_HOLDS_POINTER(v); }
/** * g_strdup_value_contents: * @value: #GValue which contents are to be described. * * Return a newly allocated string, which describes the contents of a * #GValue. The main purpose of this function is to describe #GValue * contents for debugging output, the way in which the contents are * described may change between different GLib versions. * * Returns: Newly allocated string. */ gchar* g_strdup_value_contents (const GValue *value) { const gchar *src; gchar *contents; g_return_val_if_fail (G_IS_VALUE (value), NULL); if (G_VALUE_HOLDS_STRING (value)) { src = g_value_get_string (value); if (!src) contents = g_strdup ("NULL"); else { gchar *s = g_strescape (src, NULL); contents = g_strdup_printf ("\"%s\"", s); g_free (s); } } else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING)) { GValue tmp_value = { 0, }; gchar *s; g_value_init (&tmp_value, G_TYPE_STRING); g_value_transform (value, &tmp_value); s = g_strescape (g_value_get_string (&tmp_value), NULL); g_value_unset (&tmp_value); if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value)) contents = g_strdup_printf ("((%s) %s)", g_type_name (G_VALUE_TYPE (value)), s); else contents = g_strdup (s ? s : "NULL"); g_free (s); } else if (g_value_fits_pointer (value)) { gpointer p = g_value_peek_pointer (value); if (!p) contents = g_strdup ("NULL"); else if (G_VALUE_HOLDS_OBJECT (value)) contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p); else if (G_VALUE_HOLDS_PARAM (value)) contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p); else if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { GStrv strv = g_value_get_boxed (value); GString *tmp = g_string_new ("["); while (*strv != NULL) { gchar *escaped = g_strescape (*strv, NULL); g_string_append_printf (tmp, "\"%s\"", escaped); g_free (escaped); if (*++strv != NULL) g_string_append (tmp, ", "); } g_string_append (tmp, "]"); contents = g_string_free (tmp, FALSE); } else if (G_VALUE_HOLDS_BOXED (value)) contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p); else if (G_VALUE_HOLDS_POINTER (value)) contents = g_strdup_printf ("((gpointer) %p)", p); else contents = g_strdup ("???"); } else contents = g_strdup ("???"); return contents; }