callisto-debian/gtk3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
30a1a79322f4097ce47c2a08678479d00cc54b69
gtk3/gtk/gtktextbufferserialize.c
Javier Jardón 9d0febc9a6 Change FSF Address
2012-02-27 17:06:11 +00:00

1883 lines
43 KiB
C
Raw Blame History

/* gtktextbufferserialize.c
*
* Copyright (C) 2001 Havoc Pennington
* Copyright (C) 2004 Nokia Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/* FIXME: We should use other error codes for the
* parts that deal with the format errors
*/
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include "gdk-pixbuf/gdk-pixdata.h"
#include "gtktextbufferserialize.h"
#include "gtktexttagprivate.h"
#include "gtkintl.h"
typedef struct
{
GString *tag_table_str;
GString *text_str;
GHashTable *tags;
GtkTextIter start, end;
gint n_pixbufs;
GList *pixbufs;
gint tag_id;
GHashTable *tag_id_tags;
} SerializationContext;
static gchar *
serialize_value (GValue *value)
{
if (g_value_type_transformable (value->g_type, G_TYPE_STRING))
{
GValue text_value = G_VALUE_INIT;
gchar *tmp;
g_value_init (&text_value, G_TYPE_STRING);
g_value_transform (value, &text_value);
tmp = g_markup_escape_text (g_value_get_string (&text_value), -1);
g_value_unset (&text_value);
return tmp;
}
else if (value->g_type == GDK_TYPE_COLOR)
{
GdkColor *color = g_value_get_boxed (value);
return g_strdup_printf ("%x:%x:%x", color->red, color->green, color->blue);
}
else
{
g_warning ("Type %s is not serializable\n", g_type_name (value->g_type));
}
return NULL;
}
static gboolean
deserialize_value (const gchar *str,
GValue *value)
{
if (g_value_type_transformable (G_TYPE_STRING, value->g_type))
{
GValue text_value = G_VALUE_INIT;
gboolean retval;
g_value_init (&text_value, G_TYPE_STRING);
g_value_set_static_string (&text_value, str);
retval = g_value_transform (&text_value, value);
g_value_unset (&text_value);
return retval;
}
else if (value->g_type == G_TYPE_BOOLEAN)
{
gboolean v;
v = strcmp (str, "TRUE") == 0;
g_value_set_boolean (value, v);
return TRUE;
}
else if (value->g_type == G_TYPE_INT)
{
gchar *tmp;
int v;
errno = 0;
v = g_ascii_strtoll (str, &tmp, 10);
if (errno || tmp == NULL || tmp == str)
return FALSE;
g_value_set_int (value, v);
return TRUE;
}
else if (value->g_type == G_TYPE_DOUBLE)
{
gchar *tmp;
gdouble v;
v = g_ascii_strtod (str, &tmp);
if (tmp == NULL || tmp == str)
return FALSE;
g_value_set_double (value, v);
return TRUE;
}
else if (value->g_type == GDK_TYPE_COLOR)
{
GdkColor color;
const gchar *old;
gchar *tmp;
old = str;
tmp = NULL;
errno = 0;
color.red = g_ascii_strtoll (old, &tmp, 16);
if (errno || tmp == old)
return FALSE;
old = tmp;
if (*old++ != ':')
return FALSE;
tmp = NULL;
errno = 0;
color.green = g_ascii_strtoll (old, &tmp, 16);
if (errno || tmp == old)
return FALSE;
old = tmp;
if (*old++ != ':')
return FALSE;
tmp = NULL;
errno = 0;
color.blue = g_ascii_strtoll (old, &tmp, 16);
if (errno || tmp == old || *tmp != '\0')
return FALSE;
g_value_set_boxed (value, &color);
return TRUE;
}
else if (G_VALUE_HOLDS_ENUM (value))
{
GEnumClass *class = G_ENUM_CLASS (g_type_class_peek (value->g_type));
GEnumValue *enum_value;
enum_value = g_enum_get_value_by_name (class, str);
if (enum_value)
{
g_value_set_enum (value, enum_value->value);
return TRUE;
}
return FALSE;
}
else
{
g_warning ("Type %s can not be deserialized\n", g_type_name (value->g_type));
}
return FALSE;
}
/* Checks if a param is set, or if it's the default value */
static gboolean
is_param_set (GObject *object,
GParamSpec *pspec,
GValue *value)
{
/* We need to special case some attributes here */
if (strcmp (pspec->name, "background-gdk") == 0)
{
gboolean is_set;
g_object_get (object, "background-set", &is_set, NULL);
if (is_set)
{
g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (object, pspec->name, value);
return TRUE;
}
return FALSE;
}
else if (strcmp (pspec->name, "foreground-gdk") == 0)
{
gboolean is_set;
g_object_get (object, "foreground-set", &is_set, NULL);
if (is_set)
{
g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (object, pspec->name, value);
return TRUE;
}
return FALSE;
}
else
{
gboolean is_set;
gchar *is_set_name;
is_set_name = g_strdup_printf ("%s-set", pspec->name);
if (g_object_class_find_property (G_OBJECT_GET_CLASS (object), is_set_name) == NULL)
{
g_free (is_set_name);
return FALSE;
}
else
{
g_object_get (object, is_set_name, &is_set, NULL);
if (!is_set)
{
g_free (is_set_name);
return FALSE;
}
g_free (is_set_name);
g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (object, pspec->name, value);
if (g_param_value_defaults (pspec, value))
{
g_value_unset (value);
return FALSE;
}
}
return TRUE;
}
}
static void
serialize_tag (gpointer key,
gpointer data,
gpointer user_data)
{
SerializationContext *context = user_data;
GtkTextTag *tag = data;
gchar *tag_name;
gint tag_id;
GParamSpec **pspecs;
guint n_pspecs;
int i;
g_string_append (context->tag_table_str, " <tag ");
/* Handle anonymous tags */
if (tag->priv->name)
{
tag_name = g_markup_escape_text (tag->priv->name, -1);
g_string_append_printf (context->tag_table_str, "name=\"%s\"", tag_name);
g_free (tag_name);
}
else
{
tag_id = GPOINTER_TO_INT (g_hash_table_lookup (context->tag_id_tags, tag));
g_string_append_printf (context->tag_table_str, "id=\"%d\"", tag_id);
}
g_string_append_printf (context->tag_table_str, " priority=\"%d\">\n", tag->priv->priority);
/* Serialize properties */
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (tag), &n_pspecs);
for (i = 0; i < n_pspecs; i++)
{
GValue value = G_VALUE_INIT;
gchar *tmp, *tmp2;
if (!(pspecs[i]->flags & G_PARAM_READABLE) ||
!(pspecs[i]->flags & G_PARAM_WRITABLE))
continue;
if (!is_param_set (G_OBJECT (tag), pspecs[i], &value))
continue;
/* Now serialize the attr */
tmp2 = serialize_value (&value);
if (tmp2)
{
tmp = g_markup_escape_text (pspecs[i]->name, -1);
g_string_append_printf (context->tag_table_str, " <attr name=\"%s\" ", tmp);
g_free (tmp);
tmp = g_markup_escape_text (g_type_name (pspecs[i]->value_type), -1);
g_string_append_printf (context->tag_table_str, "type=\"%s\" value=\"%s\" />\n", tmp, tmp2);
g_free (tmp);
g_free (tmp2);
}
g_value_unset (&value);
}
g_free (pspecs);
g_string_append (context->tag_table_str, " </tag>\n");
}
static void
serialize_tags (SerializationContext *context)
{
g_string_append (context->tag_table_str, " <text_view_markup>\n");
g_string_append (context->tag_table_str, " <tags>\n");
g_hash_table_foreach (context->tags, serialize_tag, context);
g_string_append (context->tag_table_str, " </tags>\n");
}
#if 0
static void
dump_tag_list (const gchar *str,
GList *list)
{
g_print ("%s: ", str);
if (!list)
g_print ("(empty)");
else
{
while (list)
{
g_print ("%s ", ((GtkTextTag *)list->data)->name);
list = list->next;
}
}
g_print ("\n");
}
#endif
static void
find_list_delta (GSList *old_list,
GSList *new_list,
GList **added,
GList **removed)
{
GSList *tmp;
GList *tmp_added, *tmp_removed;
tmp_added = NULL;
tmp_removed = NULL;
/* Find added tags */
tmp = new_list;
while (tmp)
{
if (!g_slist_find (old_list, tmp->data))
tmp_added = g_list_prepend (tmp_added, tmp->data);
tmp = tmp->next;
}
*added = tmp_added;
/* Find removed tags */
tmp = old_list;
while (tmp)
{
if (!g_slist_find (new_list, tmp->data))
tmp_removed = g_list_prepend (tmp_removed, tmp->data);
tmp = tmp->next;
}
/* We reverse the list here to match the xml semantics */
*removed = g_list_reverse (tmp_removed);
}
static void
serialize_section_header (GString *str,
const gchar *name,
gint length)
{
g_return_if_fail (strlen (name) == 26);
g_string_append (str, name);
g_string_append_c (str, length >> 24);
g_string_append_c (str, (length >> 16) & 0xff);
g_string_append_c (str, (length >> 8) & 0xff);
g_string_append_c (str, length & 0xff);
}
static void
serialize_text (GtkTextBuffer *buffer,
SerializationContext *context)
{
GtkTextIter iter, old_iter;
GSList *tag_list, *new_tag_list;
GSList *active_tags;
g_string_append (context->text_str, "<text>");
iter = context->start;
tag_list = NULL;
active_tags = NULL;
do
{
GList *added, *removed;
GList *tmp;
gchar *tmp_text, *escaped_text;
new_tag_list = gtk_text_iter_get_tags (&iter);
find_list_delta (tag_list, new_tag_list, &added, &removed);
/* Handle removed tags */
for (tmp = removed; tmp; tmp = tmp->next)
{
GtkTextTag *tag = tmp->data;
/* Only close the tag if we didn't close it before (by using
* the stack logic in the while() loop below)
*/
if (g_slist_find (active_tags, tag))
{
g_string_append (context->text_str, "</apply_tag>");
/* Drop all tags that were opened after this one (which are
* above this on in the stack)
*/
while (active_tags->data != tag)
{
added = g_list_prepend (added, active_tags->data);
active_tags = g_slist_remove (active_tags, active_tags->data);
g_string_append_printf (context->text_str, "</apply_tag>");
}
active_tags = g_slist_remove (active_tags, active_tags->data);
}
}
/* Handle added tags */
for (tmp = added; tmp; tmp = tmp->next)
{
GtkTextTag *tag = tmp->data;
gchar *tag_name;
/* Add it to the tag hash table */
g_hash_table_insert (context->tags, tag, tag);
if (tag->priv->name)
{
tag_name = g_markup_escape_text (tag->priv->name, -1);
g_string_append_printf (context->text_str, "<apply_tag name=\"%s\">", tag_name);
g_free (tag_name);
}
else
{
gpointer tag_id;
/* We've got an anonymous tag, find out if it's been
used before */
if (!g_hash_table_lookup_extended (context->tag_id_tags, tag, NULL, &tag_id))
{
tag_id = GINT_TO_POINTER (context->tag_id++);
g_hash_table_insert (context->tag_id_tags, tag, tag_id);
}
g_string_append_printf (context->text_str, "<apply_tag id=\"%d\">", GPOINTER_TO_INT (tag_id));
}
active_tags = g_slist_prepend (active_tags, tag);
}
g_slist_free (tag_list);
tag_list = new_tag_list;
g_list_free (added);
g_list_free (removed);
old_iter = iter;
/* Now try to go to either the next tag toggle, or if a pixbuf appears */
while (TRUE)
{
gunichar ch = gtk_text_iter_get_char (&iter);
if (ch == 0xFFFC)
{
GdkPixbuf *pixbuf = gtk_text_iter_get_pixbuf (&iter);
if (pixbuf)
{
/* Append the text before the pixbuf */
tmp_text = gtk_text_iter_get_slice (&old_iter, &iter);
escaped_text = g_markup_escape_text (tmp_text, -1);
g_free (tmp_text);
/* Forward so we don't get the 0xfffc char */
gtk_text_iter_forward_char (&iter);
old_iter = iter;
g_string_append (context->text_str, escaped_text);
g_free (escaped_text);
g_string_append_printf (context->text_str, "<pixbuf index=\"%d\" />", context->n_pixbufs);
context->n_pixbufs++;
context->pixbufs = g_list_prepend (context->pixbufs, pixbuf);
}
}
else if (ch == 0)
{
break;
}
else
gtk_text_iter_forward_char (&iter);
if (gtk_text_iter_toggles_tag (&iter, NULL))
break;
}
/* We might have moved too far */
if (gtk_text_iter_compare (&iter, &context->end) > 0)
iter = context->end;
/* Append the text */
tmp_text = gtk_text_iter_get_slice (&old_iter, &iter);
escaped_text = g_markup_escape_text (tmp_text, -1);
g_free (tmp_text);
g_string_append (context->text_str, escaped_text);
g_free (escaped_text);
}
while (!gtk_text_iter_equal (&iter, &context->end));
/* Close any open tags */
for (tag_list = active_tags; tag_list; tag_list = tag_list->next)
g_string_append (context->text_str, "</apply_tag>");
g_slist_free (active_tags);
g_string_append (context->text_str, "</text>\n</text_view_markup>\n");
}
static void
serialize_pixbufs (SerializationContext *context,
GString *text)
{
GList *list;
for (list = context->pixbufs; list != NULL; list = list->next)
{
GdkPixbuf *pixbuf = list->data;
GdkPixdata pixdata;
guint8 *tmp;
guint len;
gdk_pixdata_from_pixbuf (&pixdata, pixbuf, FALSE);
tmp = gdk_pixdata_serialize (&pixdata, &len);
serialize_section_header (text, "GTKTEXTBUFFERPIXBDATA-0001", len);
g_string_append_len (text, (gchar *) tmp, len);
g_free (tmp);
}
}
guint8 *
_gtk_text_buffer_serialize_rich_text (GtkTextBuffer *register_buffer,
GtkTextBuffer *content_buffer,
const GtkTextIter *start,
const GtkTextIter *end,
gsize *length,
gpointer user_data)
{
SerializationContext context;
GString *text;
context.tags = g_hash_table_new (NULL, NULL);
context.text_str = g_string_new (NULL);
context.tag_table_str = g_string_new (NULL);
context.start = *start;
context.end = *end;
context.n_pixbufs = 0;
context.pixbufs = NULL;
context.tag_id = 0;
context.tag_id_tags = g_hash_table_new (NULL, NULL);
/* We need to serialize the text before the tag table so we know
what tags are used */
serialize_text (content_buffer, &context);
serialize_tags (&context);
text = g_string_new (NULL);
serialize_section_header (text, "GTKTEXTBUFFERCONTENTS-0001",
context.tag_table_str->len + context.text_str->len);
g_string_append_len (text, context.tag_table_str->str, context.tag_table_str->len);
g_string_append_len (text, context.text_str->str, context.text_str->len);
context.pixbufs = g_list_reverse (context.pixbufs);
serialize_pixbufs (&context, text);
g_hash_table_destroy (context.tags);
g_list_free (context.pixbufs);
g_string_free (context.text_str, TRUE);
g_string_free (context.tag_table_str, TRUE);
g_hash_table_destroy (context.tag_id_tags);
*length = text->len;
return (guint8 *) g_string_free (text, FALSE);
}
typedef enum
{
STATE_START,
STATE_TEXT_VIEW_MARKUP,
STATE_TAGS,
STATE_TAG,
STATE_ATTR,
STATE_TEXT,
STATE_APPLY_TAG,
STATE_PIXBUF
} ParseState;
typedef struct
{
gchar *text;
GdkPixbuf *pixbuf;
GSList *tags;
} TextSpan;
typedef struct
{
GtkTextTag *tag;
gint prio;
} TextTagPrio;
typedef struct
{
GSList *states;
GList *headers;
GtkTextBuffer *buffer;
/* Tags that are defined in <tag> elements */
GHashTable *defined_tags;
/* Tags that are anonymous */
GHashTable *anonymous_tags;
/* Tag name substitutions */
GHashTable *substitutions;
/* Current tag */
GtkTextTag *current_tag;
/* Priority of current tag */
gint current_tag_prio;
/* Id of current tag */
gint current_tag_id;
/* Tags and their priorities */
GList *tag_priorities;
GSList *tag_stack;
GList *spans;
gboolean create_tags;
gboolean parsed_text;
gboolean parsed_tags;
} ParseInfo;
static void
set_error (GError **err,
GMarkupParseContext *context,
int error_domain,
int error_code,
const char *format,
...)
{
int line, ch;
va_list args;
char *str;
g_markup_parse_context_get_position (context, &line, &ch);
va_start (args, format);
str = g_strdup_vprintf (format, args);
va_end (args);
g_set_error (err, error_domain, error_code,
("Line %d character %d: %s"),
line, ch, str);
g_free (str);
}
static void
push_state (ParseInfo *info,
ParseState state)
{
info->states = g_slist_prepend (info->states, GINT_TO_POINTER (state));
}
static void
pop_state (ParseInfo *info)
{
g_return_if_fail (info->states != NULL);
info->states = g_slist_remove (info->states, info->states->data);
}
static ParseState
peek_state (ParseInfo *info)
{
g_return_val_if_fail (info->states != NULL, STATE_START);
return GPOINTER_TO_INT (info->states->data);
}
#define ELEMENT_IS(name) (strcmp (element_name, (name)) == 0)
static gboolean
check_id_or_name (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gint *id,
const gchar **name,
GError **error)
{
gboolean has_id = FALSE;
gboolean has_name = FALSE;
int i;
*id = 0;
*name = NULL;
for (i = 0; attribute_names[i] != NULL; i++)
{
if (strcmp (attribute_names[i], "name") == 0)
{
*name = attribute_values[i];
if (has_id)
{
set_error (error, context,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("Both \"id\" and \"name\" were found on the <%s> element"),
element_name);
return FALSE;
}
if (has_name)
{
set_error (error, context,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("The attribute \"%s\" was found twice on the <%s> element"),
"name", element_name);
return FALSE;
}
has_name = TRUE;
}
else if (strcmp (attribute_names[i], "id") == 0)
{
gchar *tmp;
if (has_name)
{
set_error (error, context,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("Both \"id\" and \"name\" were found on the <%s> element"),
element_name);
return FALSE;
}
if (has_id)
{
set_error (error, context,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("The attribute \"%s\" was found twice on the <%s> element"),
"id", element_name);
return FALSE;
}
has_id = TRUE;
/* Try parsing the integer */
tmp = NULL;
errno = 0;
*id = g_ascii_strtoll (attribute_values[i], &tmp, 10);
if (errno || tmp == attribute_values[i])
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("<%s> element has invalid ID \"%s\""), attribute_values[i]);
return FALSE;
}
}
}
if (!has_id && !has_name)
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("<%s> element has neither a \"name\" nor an \"id\" attribute"), element_name);
return FALSE;
}
return TRUE;
}
typedef struct
{
const char *name;
const char **retloc;
} LocateAttr;
static gboolean
locate_attributes (GMarkupParseContext *context,
const char *element_name,
const char **attribute_names,
const char **attribute_values,
gboolean allow_unknown_attrs,
GError **error,
const char *first_attribute_name,
const char **first_attribute_retloc,
...)
{
va_list args;
const char *name;
const char **retloc;
int n_attrs;
#define MAX_ATTRS 24
LocateAttr attrs[MAX_ATTRS];
gboolean retval;
int i;
g_return_val_if_fail (first_attribute_name != NULL, FALSE);
g_return_val_if_fail (first_attribute_retloc != NULL, FALSE);
retval = TRUE;
n_attrs = 1;
attrs[0].name = first_attribute_name;
attrs[0].retloc = first_attribute_retloc;
*first_attribute_retloc = NULL;
va_start (args, first_attribute_retloc);
name = va_arg (args, const char*);
retloc = va_arg (args, const char**);
while (name != NULL)
{
g_return_val_if_fail (retloc != NULL, FALSE);
g_assert (n_attrs < MAX_ATTRS);
attrs[n_attrs].name = name;
attrs[n_attrs].retloc = retloc;
n_attrs += 1;
*retloc = NULL;
name = va_arg (args, const char*);
retloc = va_arg (args, const char**);
}
va_end (args);
if (!retval)
return retval;
i = 0;
while (attribute_names[i])
{
int j;
gboolean found;
found = FALSE;
j = 0;
while (j < n_attrs)
{
if (strcmp (attrs[j].name, attribute_names[i]) == 0)
{
retloc = attrs[j].retloc;
if (*retloc != NULL)
{
set_error (error, context,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("Attribute \"%s\" repeated twice on the same <%s> element"),
attrs[j].name, element_name);
retval = FALSE;
goto out;
}
*retloc = attribute_values[i];
found = TRUE;
}
++j;
}
if (!found && !allow_unknown_attrs)
{
set_error (error, context,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("Attribute \"%s\" is invalid on <%s> element in this context"),
attribute_names[i], element_name);
retval = FALSE;
goto out;
}
++i;
}
out:
return retval;
}
static gboolean
check_no_attributes (GMarkupParseContext *context,
const char *element_name,
const char **attribute_names,
const char **attribute_values,
GError **error)
{
if (attribute_names[0] != NULL)
{
set_error (error, context,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("Attribute \"%s\" is invalid on <%s> element in this context"),
attribute_names[0], element_name);
return FALSE;
}
return TRUE;
}
static GtkTextTag *
tag_exists (GMarkupParseContext *context,
const gchar *name,
gint id,
ParseInfo *info,
GError **error)
{
GtkTextTagTable *tag_table;
const gchar *real_name;
tag_table = gtk_text_buffer_get_tag_table (info->buffer);
if (info->create_tags)
{
/* If we have an anonymous tag, just return it directly */
if (!name)
return g_hash_table_lookup (info->anonymous_tags,
GINT_TO_POINTER (id));
/* First, try the substitutions */
real_name = g_hash_table_lookup (info->substitutions, name);
if (real_name)
return gtk_text_tag_table_lookup (tag_table, real_name);
/* Next, try the list of defined tags */
if (g_hash_table_lookup (info->defined_tags, name) != NULL)
return gtk_text_tag_table_lookup (tag_table, name);
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Tag \"%s\" has not been defined."), name);
return NULL;
}
else
{
GtkTextTag *tag;
if (!name)
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Anonymous tag found and tags can not be created."));
return NULL;
}
tag = gtk_text_tag_table_lookup (tag_table, name);
if (tag)
return tag;
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Tag \"%s\" does not exist in buffer and tags can not be created."), name);
return NULL;
}
}
typedef struct
{
const gchar *id;
gint length;
const gchar *start;
} Header;
static GdkPixbuf *
get_pixbuf_from_headers (GList *headers,
int id,
GError **error)
{
Header *header;
GdkPixdata pixdata;
GdkPixbuf *pixbuf;
header = g_list_nth_data (headers, id);
if (!header)
return NULL;
if (!gdk_pixdata_deserialize (&pixdata, header->length,
(const guint8 *) header->start, error))
return NULL;
pixbuf = gdk_pixbuf_from_pixdata (&pixdata, TRUE, error);
return pixbuf;
}
static void
parse_apply_tag_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
ParseInfo *info,
GError **error)
{
const gchar *name, *priority;
gint id;
GtkTextTag *tag;
g_assert (peek_state (info) == STATE_TEXT ||
peek_state (info) == STATE_APPLY_TAG);
if (ELEMENT_IS ("apply_tag"))
{
if (!locate_attributes (context, element_name, attribute_names, attribute_values, TRUE, error,
"priority", &priority, NULL))
return;
if (!check_id_or_name (context, element_name, attribute_names, attribute_values,
&id, &name, error))
return;
tag = tag_exists (context, name, id, info, error);
if (!tag)
return;
info->tag_stack = g_slist_prepend (info->tag_stack, tag);
push_state (info, STATE_APPLY_TAG);
}
else if (ELEMENT_IS ("pixbuf"))
{
int int_id;
GdkPixbuf *pixbuf;
TextSpan *span;
const gchar *pixbuf_id;
if (!locate_attributes (context, element_name, attribute_names, attribute_values, FALSE, error,
"index", &pixbuf_id, NULL))
return;
int_id = atoi (pixbuf_id);
pixbuf = get_pixbuf_from_headers (info->headers, int_id, error);
span = g_new0 (TextSpan, 1);
span->pixbuf = pixbuf;
span->tags = NULL;
info->spans = g_list_prepend (info->spans, span);
if (!pixbuf)
return;
push_state (info, STATE_PIXBUF);
}
else
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Element <%s> is not allowed below <%s>"),
element_name, peek_state(info) == STATE_TEXT ? "text" : "apply_tag");
}
static void
parse_attr_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
ParseInfo *info,
GError **error)
{
const gchar *name, *type, *value;
GType gtype;
GValue gvalue = G_VALUE_INIT;
GParamSpec *pspec;
g_assert (peek_state (info) == STATE_TAG);
if (ELEMENT_IS ("attr"))
{
if (!locate_attributes (context, element_name, attribute_names, attribute_values, FALSE, error,
"name", &name, "type", &type, "value", &value, NULL))
return;
gtype = g_type_from_name (type);
if (gtype == G_TYPE_INVALID)
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("\"%s\" is not a valid attribute type"), type);
return;
}
if (!(pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (info->current_tag), name)))
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("\"%s\" is not a valid attribute name"), name);
return;
}
g_value_init (&gvalue, gtype);
if (!deserialize_value (value, &gvalue))
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("\"%s\" could not be converted to a value of type \"%s\" for attribute \"%s\""),
value, type, name);
return;
}
if (g_param_value_validate (pspec, &gvalue))
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("\"%s\" is not a valid value for attribute \"%s\""),
value, name);
g_value_unset (&gvalue);
return;
}
g_object_set_property (G_OBJECT (info->current_tag),
name, &gvalue);
g_value_unset (&gvalue);
push_state (info, STATE_ATTR);
}
else
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Element <%s> is not allowed below <%s>"),
element_name, "tag");
}
}
static gchar *
get_tag_name (ParseInfo *info,
const gchar *tag_name)
{
GtkTextTagTable *tag_table;
gchar *name;
gint i;
name = g_strdup (tag_name);
if (!info->create_tags)
return name;
i = 0;
tag_table = gtk_text_buffer_get_tag_table (info->buffer);
while (gtk_text_tag_table_lookup (tag_table, name) != NULL)
{
g_free (name);
name = g_strdup_printf ("%s-%d", tag_name, ++i);
}
if (i != 0)
{
g_hash_table_insert (info->substitutions, g_strdup (tag_name), g_strdup (name));
}
return name;
}
static void
parse_tag_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
ParseInfo *info,
GError **error)
{
const gchar *name, *priority;
gchar *tag_name;
gint id;
gint prio;
gchar *tmp;
g_assert (peek_state (info) == STATE_TAGS);
if (ELEMENT_IS ("tag"))
{
if (!locate_attributes (context, element_name, attribute_names, attribute_values, TRUE, error,
"priority", &priority, NULL))
return;
if (!check_id_or_name (context, element_name, attribute_names, attribute_values,
&id, &name, error))
return;
if (name)
{
if (g_hash_table_lookup (info->defined_tags, name) != NULL)
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Tag \"%s\" already defined"), name);
return;
}
}
tmp = NULL;
errno = 0;
prio = g_ascii_strtoll (priority, &tmp, 10);
if (errno || tmp == priority)
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Tag \"%s\" has invalid priority \"%s\""), name, priority);
return;
}
if (name)
{
tag_name = get_tag_name (info, name);
info->current_tag = gtk_text_tag_new (tag_name);
g_free (tag_name);
}
else
{
info->current_tag = gtk_text_tag_new (NULL);
info->current_tag_id = id;
}
info->current_tag_prio = prio;
push_state (info, STATE_TAG);
}
else
{
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Element <%s> is not allowed below <%s>"),
element_name, "tags");
}
}
static void
start_element_handler (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
ParseInfo *info = user_data;
switch (peek_state (info))
{
case STATE_START:
if (ELEMENT_IS ("text_view_markup"))
{
if (!check_no_attributes (context, element_name,
attribute_names, attribute_values, error))
return;
push_state (info, STATE_TEXT_VIEW_MARKUP);
break;
}
else
set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Outermost element in text must be <text_view_markup> not <%s>"),
element_name);
break;
case STATE_TEXT_VIEW_MARKUP:
if (ELEMENT_IS ("tags"))
{
if (info->parsed_tags)
{
set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("A <%s> element has already been specified"), "tags");
return;
}
if (!check_no_attributes (context, element_name,
attribute_names, attribute_values, error))
return;
push_state (info, STATE_TAGS);
break;
}
else if (ELEMENT_IS ("text"))
{
if (info->parsed_text)
{
set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("A <%s> element has already been specified"), "text");
return;
}
else if (!info->parsed_tags)
{
set_error (error, context, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("A <text> element can't occur before a <tags> element"));
return;
}
if (!check_no_attributes (context, element_name,
attribute_names, attribute_values, error))
return;
push_state (info, STATE_TEXT);
break;
}
else
set_error (error, context,
G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
_("Element <%s> is not allowed below <%s>"),
element_name, "text_view_markup");
break;
case STATE_TAGS:
parse_tag_element (context, element_name,
attribute_names, attribute_values,
info, error);
break;
case STATE_TAG:
parse_attr_element (context, element_name,
attribute_names, attribute_values,
info, error);
break;
case STATE_TEXT:
case STATE_APPLY_TAG:
parse_apply_tag_element (context, element_name,
attribute_names, attribute_values,
info, error);
break;
default:
g_assert_not_reached ();
break;
}
}
static gint
sort_tag_prio (TextTagPrio *a,
TextTagPrio *b)
{
if (a->prio < b->prio)
return -1;
else if (a->prio > b->prio)
return 1;
else
return 0;
}
static void
end_element_handler (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
ParseInfo *info = user_data;
gchar *tmp;
GList *list;
switch (peek_state (info))
{
case STATE_TAGS:
pop_state (info);
g_assert (peek_state (info) == STATE_TEXT_VIEW_MARKUP);
info->parsed_tags = TRUE;
/* Sort list and add the tags */
info->tag_priorities = g_list_sort (info->tag_priorities,
(GCompareFunc)sort_tag_prio);
list = info->tag_priorities;
while (list)
{
TextTagPrio *prio = list->data;
if (info->create_tags)
gtk_text_tag_table_add (gtk_text_buffer_get_tag_table (info->buffer),
prio->tag);
g_object_unref (prio->tag);
prio->tag = NULL;
list = list->next;
}
break;
case STATE_TAG:
pop_state (info);
g_assert (peek_state (info) == STATE_TAGS);
if (info->current_tag->priv->name)
{
/* Add tag to defined tags hash */
tmp = g_strdup (info->current_tag->priv->name);
g_hash_table_insert (info->defined_tags,
tmp, tmp);
}
else
{
g_hash_table_insert (info->anonymous_tags,
GINT_TO_POINTER (info->current_tag_id),
info->current_tag);
}
if (info->create_tags)
{
TextTagPrio *prio;
/* add the tag to the list */
prio = g_new0 (TextTagPrio, 1);
prio->prio = info->current_tag_prio;
prio->tag = info->current_tag;
info->tag_priorities = g_list_prepend (info->tag_priorities, prio);
}
info->current_tag = NULL;
break;
case STATE_ATTR:
pop_state (info);
g_assert (peek_state (info) == STATE_TAG);
break;
case STATE_APPLY_TAG:
pop_state (info);
g_assert (peek_state (info) == STATE_APPLY_TAG ||
peek_state (info) == STATE_TEXT);
/* Pop tag */
info->tag_stack = g_slist_delete_link (info->tag_stack,
info->tag_stack);
break;
case STATE_TEXT:
pop_state (info);
g_assert (peek_state (info) == STATE_TEXT_VIEW_MARKUP);
info->spans = g_list_reverse (info->spans);
info->parsed_text = TRUE;
break;
case STATE_TEXT_VIEW_MARKUP:
pop_state (info);
g_assert (peek_state (info) == STATE_START);
break;
case STATE_PIXBUF:
pop_state (info);
g_assert (peek_state (info) == STATE_APPLY_TAG ||
peek_state (info) == STATE_TEXT);
break;
default:
g_assert_not_reached ();
break;
}
}
static gboolean
all_whitespace (const char *text,
int text_len)
{
const char *p;
const char *end;
p = text;
end = text + text_len;
while (p != end)
{
if (!g_ascii_isspace (*p))
return FALSE;
p = g_utf8_next_char (p);
}
return TRUE;
}
static void
text_handler (GMarkupParseContext *context,
const gchar *text,
gsize text_len,
gpointer user_data,
GError **error)
{
ParseInfo *info = user_data;
TextSpan *span;
if (all_whitespace (text, text_len) &&
peek_state (info) != STATE_TEXT &&
peek_state (info) != STATE_APPLY_TAG)
return;
switch (peek_state (info))
{
case STATE_START:
g_assert_not_reached (); /* gmarkup shouldn't do this */
break;
case STATE_TEXT:
case STATE_APPLY_TAG:
if (text_len == 0)
return;
span = g_new0 (TextSpan, 1);
span->text = g_strndup (text, text_len);
span->tags = g_slist_copy (info->tag_stack);
info->spans = g_list_prepend (info->spans, span);
break;
default:
g_assert_not_reached ();
break;
}
}
static void
parse_info_init (ParseInfo *info,
GtkTextBuffer *buffer,
gboolean create_tags,
GList *headers)
{
info->states = g_slist_prepend (NULL, GINT_TO_POINTER (STATE_START));
info->create_tags = create_tags;
info->headers = headers;
info->defined_tags = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
info->substitutions = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
info->anonymous_tags = g_hash_table_new_full (NULL, NULL, NULL, NULL);
info->tag_stack = NULL;
info->spans = NULL;
info->parsed_text = FALSE;
info->parsed_tags = FALSE;
info->current_tag = NULL;
info->current_tag_prio = -1;
info->tag_priorities = NULL;
info->buffer = buffer;
}
static void
text_span_free (TextSpan *span)
{
g_free (span->text);
g_slist_free (span->tags);
g_free (span);
}
static void
parse_info_free (ParseInfo *info)
{
GList *list;
g_slist_free (info->tag_stack);
g_slist_free (info->states);
g_hash_table_destroy (info->substitutions);
g_hash_table_destroy (info->defined_tags);
if (info->current_tag)
g_object_unref (info->current_tag);
list = info->spans;
while (list)
{
text_span_free (list->data);
list = list->next;
}
g_list_free (info->spans);
list = info->tag_priorities;
while (list)
{
TextTagPrio *prio = list->data;
if (prio->tag)
g_object_unref (prio->tag);
g_free (prio);
list = list->next;
}
g_list_free (info->tag_priorities);
}
static void
insert_text (ParseInfo *info,
GtkTextIter *iter)
{
GtkTextIter start_iter;
GtkTextMark *mark;
GList *tmp;
GSList *tags;
start_iter = *iter;
mark = gtk_text_buffer_create_mark (info->buffer, "deserialize_insert_point",
&start_iter, TRUE);
tmp = info->spans;
while (tmp)
{
TextSpan *span = tmp->data;
if (span->text)
gtk_text_buffer_insert (info->buffer, iter, span->text, -1);
else
{
gtk_text_buffer_insert_pixbuf (info->buffer, iter, span->pixbuf);
g_object_unref (span->pixbuf);
}
gtk_text_buffer_get_iter_at_mark (info->buffer, &start_iter, mark);
/* Apply tags */
tags = span->tags;
while (tags)
{
GtkTextTag *tag = tags->data;
gtk_text_buffer_apply_tag (info->buffer, tag,
&start_iter, iter);
tags = tags->next;
}
gtk_text_buffer_move_mark (info->buffer, mark, iter);
tmp = tmp->next;
}
gtk_text_buffer_delete_mark (info->buffer, mark);
}
static int
read_int (const guchar *start)
{
int result;
result =
start[0] << 24 |
start[1] << 16 |
start[2] << 8 |
start[3];
return result;
}
static gboolean
header_is (Header *header,
const gchar *id)
{
return (strncmp (header->id, id, strlen (id)) == 0);
}
static GList *
read_headers (const gchar *start,
gint len,
GError **error)
{
int i = 0;
int section_len;
Header *header;
GList *headers = NULL;
while (i < len)
{
if (i + 30 >= len)
goto error;
if (strncmp (start + i, "GTKTEXTBUFFERCONTENTS-0001", 26) == 0 ||
strncmp (start + i, "GTKTEXTBUFFERPIXBDATA-0001", 26) == 0)
{
section_len = read_int ((const guchar *) start + i + 26);
if (i + 30 + section_len > len)
goto error;
header = g_new0 (Header, 1);
header->id = start + i;
header->length = section_len;
header->start = start + i + 30;
i += 30 + section_len;
headers = g_list_prepend (headers, header);
}
else
break;
}
return g_list_reverse (headers);
error:
g_list_free_full (headers, g_free);
g_set_error_literal (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("Serialized data is malformed"));
return NULL;
}
static gboolean
deserialize_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
gint len,
gboolean create_tags,
GError **error,
GList *headers)
{
GMarkupParseContext *context;
ParseInfo info;
gboolean retval = FALSE;
static const GMarkupParser rich_text_parser = {
start_element_handler,
end_element_handler,
text_handler,
NULL,
NULL
};
parse_info_init (&info, buffer, create_tags, headers);
context = g_markup_parse_context_new (&rich_text_parser,
0, &info, NULL);
if (!g_markup_parse_context_parse (context,
text,
len,
error))
goto out;
if (!g_markup_parse_context_end_parse (context, error))
goto out;
retval = TRUE;
/* Now insert the text */
insert_text (&info, iter);
out:
parse_info_free (&info);
g_markup_parse_context_free (context);
return retval;
}
gboolean
_gtk_text_buffer_deserialize_rich_text (GtkTextBuffer *register_buffer,
GtkTextBuffer *content_buffer,
GtkTextIter *iter,
const guint8 *text,
gsize length,
gboolean create_tags,
gpointer user_data,
GError **error)
{
GList *headers;
Header *header;
gboolean retval;
headers = read_headers ((gchar *) text, length, error);
if (!headers)
return FALSE;
header = headers->data;
if (!header_is (header, "GTKTEXTBUFFERCONTENTS-0001"))
{
g_set_error_literal (error,
G_MARKUP_ERROR,
G_MARKUP_ERROR_PARSE,
_("Serialized data is malformed. First section isn't GTKTEXTBUFFERCONTENTS-0001"));
retval = FALSE;
goto out;
}
retval = deserialize_text (content_buffer, iter,
header->start, header->length,
create_tags, error, headers->next);
out:
g_list_free_full (headers, g_free);
return retval;
}
Reference in New Issue View Git Blame Copy Permalink