/*! \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;
}
