/* GTK - The GIMP Toolkit
* gtktextbuffer.c Copyright (C) 2000 Red Hat, Inc.
+ * Copyright (C) 2004 Nokia Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-
+#include <config.h>
#include <string.h>
+#include <stdarg.h>
+#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
#include "gtkclipboard.h"
+#include "gtkdnd.h"
#include "gtkinvisible.h"
-#include "gtksignal.h"
+#include "gtkmarshalers.h"
#include "gtktextbuffer.h"
+#include "gtktextbufferrichtext.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
-#include <string.h>
+#include "gtkprivate.h"
+#include "gtkintl.h"
+#include "gtkalias.h"
+
+
+#define GTK_TEXT_BUFFER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TEXT_BUFFER, GtkTextBufferPrivate))
+
+typedef struct _GtkTextBufferPrivate GtkTextBufferPrivate;
+
+struct _GtkTextBufferPrivate
+{
+ GtkTargetList *copy_target_list;
+ GtkTargetEntry *copy_target_entries;
+ gint n_copy_target_entries;
+
+ GtkTargetList *paste_target_list;
+ GtkTargetEntry *paste_target_entries;
+ gint n_paste_target_entries;
+};
+
typedef struct _ClipboardRequest ClipboardRequest;
};
enum {
- ARG_0,
- LAST_ARG
-};
+ PROP_0,
-enum {
- TARGET_STRING,
- TARGET_TEXT,
- TARGET_COMPOUND_TEXT,
- TARGET_UTF8_STRING,
- TARGET_TEXT_BUFFER_CONTENTS
+ /* Construct */
+ PROP_TAG_TABLE,
+
+ /* Normal */
+ PROP_TEXT,
+ PROP_HAS_SELECTION,
+ PROP_CURSOR_POSITION,
+ PROP_COPY_TARGET_LIST,
+ PROP_PASTE_TARGET_LIST
};
-static void gtk_text_buffer_init (GtkTextBuffer *tkxt_buffer);
-static void gtk_text_buffer_class_init (GtkTextBufferClass *klass);
static void gtk_text_buffer_finalize (GObject *object);
-
-static void gtk_text_buffer_update_primary_selection (GtkTextBuffer *buffer);
static void gtk_text_buffer_real_insert_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
const GtkTextIter *start_char,
const GtkTextIter *end_char);
static void gtk_text_buffer_real_changed (GtkTextBuffer *buffer);
+static void gtk_text_buffer_real_mark_set (GtkTextBuffer *buffer,
+ const GtkTextIter *iter,
+ GtkTextMark *mark);
static GtkTextBTree* get_btree (GtkTextBuffer *buffer);
static void free_log_attr_cache (GtkTextLogAttrCache *cache);
-static GtkObjectClass *parent_class = NULL;
-static guint signals[LAST_SIGNAL] = { 0 };
+static void remove_all_selection_clipboards (GtkTextBuffer *buffer);
+static void update_selection_clipboards (GtkTextBuffer *buffer);
-GType
-gtk_text_buffer_get_type (void)
-{
- static GType our_type = 0;
+static GtkTextBuffer *create_clipboard_contents_buffer (GtkTextBuffer *buffer);
- if (our_type == 0)
- {
- static const GTypeInfo our_info =
- {
- sizeof (GtkTextBufferClass),
- (GBaseInitFunc) NULL,
- (GBaseFinalizeFunc) NULL,
- (GClassInitFunc) gtk_text_buffer_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkTextBuffer),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gtk_text_buffer_init
- };
+static void gtk_text_buffer_free_target_lists (GtkTextBuffer *buffer);
- our_type = g_type_register_static (G_TYPE_OBJECT,
- "GtkTextBuffer",
- &our_info,
- 0);
- }
+static guint signals[LAST_SIGNAL] = { 0 };
- return our_type;
-}
+static void gtk_text_buffer_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_text_buffer_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void gtk_text_buffer_notify (GObject *object,
+ GParamSpec *pspec);
+
+G_DEFINE_TYPE (GtkTextBuffer, gtk_text_buffer, G_TYPE_OBJECT)
static void
gtk_text_buffer_class_init (GtkTextBufferClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- parent_class = g_type_class_peek_parent (klass);
-
object_class->finalize = gtk_text_buffer_finalize;
-
+ object_class->set_property = gtk_text_buffer_set_property;
+ object_class->get_property = gtk_text_buffer_get_property;
+ object_class->notify = gtk_text_buffer_notify;
+
klass->insert_text = gtk_text_buffer_real_insert_text;
klass->insert_pixbuf = gtk_text_buffer_real_insert_pixbuf;
klass->insert_child_anchor = gtk_text_buffer_real_insert_anchor;
klass->apply_tag = gtk_text_buffer_real_apply_tag;
klass->remove_tag = gtk_text_buffer_real_remove_tag;
klass->changed = gtk_text_buffer_real_changed;
+ klass->mark_set = gtk_text_buffer_real_mark_set;
+
+ /* Construct */
+ g_object_class_install_property (object_class,
+ PROP_TAG_TABLE,
+ g_param_spec_object ("tag-table",
+ P_("Tag Table"),
+ P_("Text Tag Table"),
+ GTK_TYPE_TEXT_TAG_TABLE,
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+ /* Normal properties*/
+
+ /**
+ * GtkTextBuffer:text:
+ *
+ * The text content of the buffer. Without child widgets and images,
+ * see gtk_text_buffer_get_text () for more information.
+ *
+ * Since: 2.8
+ */
+ g_object_class_install_property (object_class,
+ PROP_TEXT,
+ g_param_spec_string ("text",
+ P_("Text"),
+ P_("Current text of the buffer"),
+ "",
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkTextBuffer:has-selection:
+ *
+ * Whether the buffer has some text currently selected.
+ *
+ * Since: 2.10
+ */
+ g_object_class_install_property (object_class,
+ PROP_HAS_SELECTION,
+ g_param_spec_boolean ("has-selection",
+ P_("Has selection"),
+ P_("Whether the buffer has some text currently selected"),
+ FALSE,
+ GTK_PARAM_READABLE));
+
+ /**
+ * GtkTextBuffer:cursor-position:
+ *
+ * The position of the insert mark (as offset from the beginning of the buffer).
+ * It is useful for getting notified when the cursor moves.
+ *
+ * Since: 2.10
+ */
+ g_object_class_install_property (object_class,
+ PROP_CURSOR_POSITION,
+ g_param_spec_int ("cursor-position",
+ P_("Cursor position"),
+ P_("The position of the insert mark (as offset from the beginning of the buffer)"),
+ 0, G_MAXINT, 0,
+ GTK_PARAM_READABLE));
+
+ /**
+ * GtkTextBuffer:copy-target-list:
+ *
+ * The list of targets this buffer supports for clipboard copying
+ * and as DND source.
+ *
+ * Since: 2.10
+ */
+ g_object_class_install_property (object_class,
+ PROP_COPY_TARGET_LIST,
+ g_param_spec_boxed ("copy-target-list",
+ P_("Copy target list"),
+ P_("The list of targets this buffer supports for clipboard copying and DND source"),
+ GTK_TYPE_TARGET_LIST,
+ GTK_PARAM_READABLE));
+
+ /**
+ * GtkTextBuffer:paste-target-list:
+ *
+ * The list of targets this buffer supports for clipboard pasting
+ * and as DND destination.
+ *
+ * Since: 2.10
+ */
+ g_object_class_install_property (object_class,
+ PROP_PASTE_TARGET_LIST,
+ g_param_spec_boxed ("paste-target-list",
+ P_("Paste target list"),
+ P_("The list of targets this buffer supports for clipboard pasting and DND destination"),
+ GTK_TYPE_TARGET_LIST,
+ GTK_PARAM_READABLE));
signals[INSERT_TEXT] =
- g_signal_newc ("insert_text",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, insert_text),
- NULL, NULL,
- gtk_marshal_VOID__BOXED_STRING_INT,
- GTK_TYPE_NONE,
- 3,
- GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
- GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
- GTK_TYPE_INT);
+ g_signal_new (I_("insert_text"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, insert_text),
+ NULL, NULL,
+ _gtk_marshal_VOID__BOXED_STRING_INT,
+ G_TYPE_NONE,
+ 3,
+ GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
+ G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
+ G_TYPE_INT);
signals[INSERT_PIXBUF] =
- g_signal_newc ("insert_pixbuf",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, insert_pixbuf),
- NULL, NULL,
- gtk_marshal_VOID__BOXED_OBJECT,
- GTK_TYPE_NONE,
- 2,
- GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
- GDK_TYPE_PIXBUF);
+ g_signal_new (I_("insert_pixbuf"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, insert_pixbuf),
+ NULL, NULL,
+ _gtk_marshal_VOID__BOXED_OBJECT,
+ G_TYPE_NONE,
+ 2,
+ GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
+ GDK_TYPE_PIXBUF);
signals[INSERT_CHILD_ANCHOR] =
- g_signal_newc ("insert_child_anchor",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, insert_child_anchor),
- NULL, NULL,
- gtk_marshal_VOID__BOXED_OBJECT,
- GTK_TYPE_NONE,
- 2,
- GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
- GTK_TYPE_TEXT_CHILD_ANCHOR);
+ g_signal_new (I_("insert_child_anchor"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, insert_child_anchor),
+ NULL, NULL,
+ _gtk_marshal_VOID__BOXED_OBJECT,
+ G_TYPE_NONE,
+ 2,
+ GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
+ GTK_TYPE_TEXT_CHILD_ANCHOR);
+ /**
+ * GtkTextBuffer::delete_range:
+ * @buffer: the object which received the signal.
+ * @start: the start of the range to be deleted
+ * @end: the end of the range to be deleted
+ *
+ * The ::delete_range signal is emitted to delete a range from
+ * a #GtkTextBuffer. Note that your handler must not invalidate the
+ * @start and @end iters (or has to revalidate them), if it runs before the
+ * default handler. There is no need to keep the iters valid in handlers
+ * which run after the default handler (see g_signal_connect_after()), but
+ * those don't have access to the deleted text.
+ */
signals[DELETE_RANGE] =
- g_signal_newc ("delete_range",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, delete_range),
- NULL, NULL,
- gtk_marshal_VOID__BOXED_BOXED,
- GTK_TYPE_NONE,
- 2,
- GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
- GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
+ g_signal_new (I_("delete_range"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, delete_range),
+ NULL, NULL,
+ _gtk_marshal_VOID__BOXED_BOXED,
+ G_TYPE_NONE,
+ 2,
+ GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
+ GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[CHANGED] =
- g_signal_newc ("changed",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, changed),
- NULL, NULL,
- gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
- 0);
+ g_signal_new (I_("changed"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, changed),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0);
signals[MODIFIED_CHANGED] =
- g_signal_newc ("modified_changed",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, modified_changed),
- NULL, NULL,
- gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
- 0);
+ g_signal_new (I_("modified_changed"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, modified_changed),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0);
signals[MARK_SET] =
- g_signal_newc ("mark_set",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, mark_set),
- NULL, NULL,
- gtk_marshal_VOID__BOXED_OBJECT,
- GTK_TYPE_NONE,
- 2,
- GTK_TYPE_TEXT_ITER,
- GTK_TYPE_TEXT_MARK);
+ g_signal_new (I_("mark_set"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, mark_set),
+ NULL, NULL,
+ _gtk_marshal_VOID__BOXED_OBJECT,
+ G_TYPE_NONE,
+ 2,
+ GTK_TYPE_TEXT_ITER,
+ GTK_TYPE_TEXT_MARK);
signals[MARK_DELETED] =
- g_signal_newc ("mark_deleted",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, mark_deleted),
- NULL, NULL,
- gtk_marshal_VOID__OBJECT,
- GTK_TYPE_NONE,
- 1,
- GTK_TYPE_TEXT_MARK);
+ g_signal_new (I_("mark_deleted"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, mark_deleted),
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT,
+ G_TYPE_NONE,
+ 1,
+ GTK_TYPE_TEXT_MARK);
signals[APPLY_TAG] =
- g_signal_newc ("apply_tag",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, apply_tag),
- NULL, NULL,
- gtk_marshal_VOID__OBJECT_BOXED_BOXED,
- GTK_TYPE_NONE,
- 3,
- GTK_TYPE_TEXT_TAG,
- GTK_TYPE_TEXT_ITER,
- GTK_TYPE_TEXT_ITER);
+ g_signal_new (I_("apply_tag"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, apply_tag),
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_BOXED_BOXED,
+ G_TYPE_NONE,
+ 3,
+ GTK_TYPE_TEXT_TAG,
+ GTK_TYPE_TEXT_ITER,
+ GTK_TYPE_TEXT_ITER);
signals[REMOVE_TAG] =
- g_signal_newc ("remove_tag",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, remove_tag),
- NULL, NULL,
- gtk_marshal_VOID__OBJECT_BOXED_BOXED,
- GTK_TYPE_NONE,
- 3,
- GTK_TYPE_TEXT_TAG,
- GTK_TYPE_TEXT_ITER,
- GTK_TYPE_TEXT_ITER);
+ g_signal_new (I_("remove_tag"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, remove_tag),
+ NULL, NULL,
+ _gtk_marshal_VOID__OBJECT_BOXED_BOXED,
+ G_TYPE_NONE,
+ 3,
+ GTK_TYPE_TEXT_TAG,
+ GTK_TYPE_TEXT_ITER,
+ GTK_TYPE_TEXT_ITER);
signals[BEGIN_USER_ACTION] =
- g_signal_newc ("begin_user_action",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, begin_user_action),
- NULL, NULL,
- gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
- 0);
+ g_signal_new (I_("begin_user_action"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, begin_user_action),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0);
signals[END_USER_ACTION] =
- g_signal_newc ("end_user_action",
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GtkTextBufferClass, end_user_action),
- NULL, NULL,
- gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
- 0);
+ g_signal_new (I_("end_user_action"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkTextBufferClass, end_user_action),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0);
+
+ g_type_class_add_private (object_class, sizeof (GtkTextBufferPrivate));
}
-void
+static void
gtk_text_buffer_init (GtkTextBuffer *buffer)
{
- buffer->clipboard_contents = NULL;
+ buffer->clipboard_contents_buffers = NULL;
+ buffer->tag_table = NULL;
+
+ /* allow copying of arbiatray stuff in the internal rich text format */
+ gtk_text_buffer_register_serialize_tagset (buffer, NULL);
+}
+
+static void
+set_table (GtkTextBuffer *buffer, GtkTextTagTable *table)
+{
+ g_return_if_fail (buffer->tag_table == NULL);
+
+ if (table)
+ {
+ buffer->tag_table = table;
+ g_object_ref (buffer->tag_table);
+ _gtk_text_tag_table_add_buffer (table, buffer);
+ }
+}
+
+static GtkTextTagTable*
+get_table (GtkTextBuffer *buffer)
+{
+ if (buffer->tag_table == NULL)
+ {
+ buffer->tag_table = gtk_text_tag_table_new ();
+ _gtk_text_tag_table_add_buffer (buffer->tag_table, buffer);
+ }
+
+ return buffer->tag_table;
+}
+
+static void
+gtk_text_buffer_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GtkTextBuffer *text_buffer;
+
+ text_buffer = GTK_TEXT_BUFFER (object);
+
+ switch (prop_id)
+ {
+ case PROP_TAG_TABLE:
+ set_table (text_buffer, g_value_get_object (value));
+ break;
+
+ case PROP_TEXT:
+ gtk_text_buffer_set_text (text_buffer,
+ g_value_get_string (value), -1);
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void
+gtk_text_buffer_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkTextBuffer *text_buffer;
+ GtkTextIter iter;
+
+ text_buffer = GTK_TEXT_BUFFER (object);
+
+ switch (prop_id)
+ {
+ case PROP_TAG_TABLE:
+ g_value_set_object (value, get_table (text_buffer));
+ break;
+
+ case PROP_TEXT:
+ {
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_start_iter (text_buffer, &start);
+ gtk_text_buffer_get_end_iter (text_buffer, &end);
+
+ g_value_take_string (value,
+ gtk_text_buffer_get_text (text_buffer,
+ &start, &end, FALSE));
+ break;
+ }
+
+ case PROP_HAS_SELECTION:
+ g_value_set_boolean (value, text_buffer->has_selection);
+ break;
+
+ case PROP_CURSOR_POSITION:
+ gtk_text_buffer_get_iter_at_mark (text_buffer, &iter,
+ gtk_text_buffer_get_insert (text_buffer));
+ g_value_set_int (value, gtk_text_iter_get_offset (&iter));
+ break;
+
+ case PROP_COPY_TARGET_LIST:
+ g_value_set_boxed (value, gtk_text_buffer_get_copy_target_list (text_buffer));
+ break;
+
+ case PROP_PASTE_TARGET_LIST:
+ g_value_set_boxed (value, gtk_text_buffer_get_paste_target_list (text_buffer));
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void
+gtk_text_buffer_notify (GObject *object,
+ GParamSpec *pspec)
+{
+ if (!strcmp (pspec->name, "copy-target-list") ||
+ !strcmp (pspec->name, "paste-target-list"))
+ {
+ gtk_text_buffer_free_target_lists (GTK_TEXT_BUFFER (object));
+ }
}
/**
{
GtkTextBuffer *text_buffer;
- text_buffer = GTK_TEXT_BUFFER (g_object_new (gtk_text_buffer_get_type (), NULL));
-
- if (table)
- {
- text_buffer->tag_table = table;
-
- g_object_ref (G_OBJECT (text_buffer->tag_table));
- }
+ text_buffer = g_object_new (GTK_TYPE_TEXT_BUFFER, "tag-table", table, NULL);
- g_object_ref (G_OBJECT (text_buffer));
-
return text_buffer;
}
buffer = GTK_TEXT_BUFFER (object);
- if (buffer->clipboard_contents)
- {
- g_object_unref (G_OBJECT (buffer->clipboard_contents));
- buffer->clipboard_contents = NULL;
- }
-
+ priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+
+ remove_all_selection_clipboards (buffer);
+
if (buffer->tag_table)
{
- g_object_unref (G_OBJECT (buffer->tag_table));
+ _gtk_text_tag_table_remove_buffer (buffer->tag_table, buffer);
+ g_object_unref (buffer->tag_table);
buffer->tag_table = NULL;
}
free_log_attr_cache (buffer->log_attr_cache);
buffer->log_attr_cache = NULL;
-
- G_OBJECT_CLASS (parent_class)->finalize (object);
-}
-static GtkTextTagTable*
-get_table (GtkTextBuffer *buffer)
-{
- if (buffer->tag_table == NULL)
- buffer->tag_table = gtk_text_tag_table_new ();
+ gtk_text_buffer_free_target_lists (buffer);
- return buffer->tag_table;
+ G_OBJECT_CLASS (gtk_text_buffer_parent_class)->finalize (object);
}
static GtkTextBTree*
{
if (buffer->btree == NULL)
buffer->btree = _gtk_text_btree_new (gtk_text_buffer_get_tag_table (buffer),
- buffer);
+ buffer);
return buffer->btree;
}
* @text: UTF-8 text to insert
* @len: length of @text in bytes
*
- * Deletes current contents of @buffer, and inserts @text instead. If
- * @text doesn't end with a newline, a newline is added;
- * #GtkTextBuffer contents must always end with a newline. If @text
- * ends with a newline, the new buffer contents will be exactly
- * @text. If @len is -1, @text must be nul-terminated.
+ * Deletes current contents of @buffer, and inserts @text instead. If
+ * @len is -1, @text must be nul-terminated. @text must be valid UTF-8.
**/
void
gtk_text_buffer_set_text (GtkTextBuffer *buffer,
if (len < 0)
len = strlen (text);
- /* Chop newline, since the buffer will already have one
- * in it.
- */
- if (len > 0 && text[len-1] == '\n')
- len -= 1;
-
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_delete (buffer, &start, &end);
gtk_text_buffer_get_iter_at_offset (buffer, &start, 0);
gtk_text_buffer_insert (buffer, &start, text, len);
}
+
+ g_object_notify (G_OBJECT (buffer), "text");
}
+
+
/*
* Insertion
*/
static void
-
gtk_text_buffer_real_insert_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
-
+
_gtk_text_btree_insert (iter, text, len);
- g_signal_emit (G_OBJECT (buffer), signals[CHANGED], 0);
+ g_signal_emit (buffer, signals[CHANGED], 0);
+ g_object_notify (G_OBJECT (buffer), "cursor-position");
}
static void
if (len < 0)
len = strlen (text);
- g_assert (g_utf8_validate (text, len, NULL));
+ g_return_if_fail (g_utf8_validate (text, len, NULL));
if (len > 0)
{
- g_signal_emit (G_OBJECT (buffer), signals[INSERT_TEXT], 0,
+ g_signal_emit (buffer, signals[INSERT_TEXT], 0,
iter, text, len);
}
}
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (text != NULL);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
+
gtk_text_buffer_emit_insert (buffer, iter, text, len);
}
* @len: length of text in bytes, or -1
* @default_editable: default editability of buffer
*
- * Like gtk_text_buffer_insert (), but the insertion will not occur if
+ * Like gtk_text_buffer_insert(), but the insertion will not occur if
* @iter is at a non-editable location in the buffer. Usually you
* want to prevent insertions at ineditable locations if the insertion
* results from a user action (is interactive).
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
g_return_val_if_fail (text != NULL, FALSE);
+ g_return_val_if_fail (gtk_text_iter_get_buffer (iter) == buffer, FALSE);
- if (gtk_text_iter_editable (iter, default_editable))
+ if (gtk_text_iter_can_insert (iter, default_editable))
{
gtk_text_buffer_begin_user_action (buffer);
gtk_text_buffer_emit_insert (buffer, iter, text, len);
r = g_new (Range, 1);
r->buffer = gtk_text_iter_get_buffer (range_start);
- g_object_ref (G_OBJECT (r->buffer));
+ g_object_ref (r->buffer);
r->start_mark =
gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (range_start),
NULL,
range_start,
- TRUE);
+ FALSE);
r->end_mark =
gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (range_start),
NULL,
range_end,
- FALSE);
+ TRUE);
r->whole_end_mark =
gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (range_start),
NULL,
whole_end,
- FALSE);
+ TRUE);
r->range_start = range_start;
r->range_end = range_end;
gtk_text_buffer_get_iter_at_mark (r->buffer,
r->whole_end,
- r->whole_end_mark);
-
+ r->whole_end_mark);
+
gtk_text_buffer_delete_mark (r->buffer, r->start_mark);
gtk_text_buffer_delete_mark (r->buffer, r->end_mark);
gtk_text_buffer_delete_mark (r->buffer, r->whole_end_mark);
- g_object_unref (G_OBJECT (r->buffer));
+ /* Due to the gravities on the marks, the ordering could have
+ * gotten mangled; we switch to an empty range in that
+ * case
+ */
+
+ if (gtk_text_iter_compare (r->range_start, r->range_end) > 0)
+ *r->range_start = *r->range_end;
+
+ if (gtk_text_iter_compare (r->range_end, r->whole_end) > 0)
+ *r->range_end = *r->whole_end;
+
+ g_object_unref (r->buffer);
g_free (r);
}
GtkTextIter range_start;
GtkTextIter range_end;
GtkTextIter start, end;
- GtkTextBuffer *src_buffer;
Range *r;
if (gtk_text_iter_equal (orig_start, orig_end))
start = *orig_start;
end = *orig_end;
- src_buffer = gtk_text_iter_get_buffer (&start);
-
range_start = start;
range_end = start;
}
static void
-gtk_text_buffer_real_insert_range (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- const GtkTextIter *orig_start,
- const GtkTextIter *orig_end,
- gboolean interactive)
+insert_range_not_inside_self (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ const GtkTextIter *orig_start,
+ const GtkTextIter *orig_end,
+ gboolean interactive)
{
/* Find each range of uniformly-tagged text, insert it,
* then apply the tags.
GtkTextIter end = *orig_end;
GtkTextIter range_start;
GtkTextIter range_end;
- GtkTextBuffer *src_buffer;
- Range *r;
if (gtk_text_iter_equal (orig_start, orig_end))
return;
-
- if (interactive)
- gtk_text_buffer_begin_user_action (buffer);
-
- src_buffer = gtk_text_iter_get_buffer (orig_start);
- gtk_text_iter_reorder (&start, &end);
+ gtk_text_iter_order (&start, &end);
range_start = start;
- range_end = start;
-
+ range_end = start;
+
while (TRUE)
{
gint start_offset;
GtkTextIter start_iter;
GSList *tags;
GSList *tmp_list;
+ Range *r;
if (gtk_text_iter_equal (&range_start, &end))
break; /* All done */
range_start = range_end;
}
+}
+
+static void
+gtk_text_buffer_real_insert_range (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ const GtkTextIter *orig_start,
+ const GtkTextIter *orig_end,
+ gboolean interactive)
+{
+ GtkTextBuffer *src_buffer;
+
+ /* Find each range of uniformly-tagged text, insert it,
+ * then apply the tags.
+ */
+ if (gtk_text_iter_equal (orig_start, orig_end))
+ return;
+
+ if (interactive)
+ gtk_text_buffer_begin_user_action (buffer);
+
+ src_buffer = gtk_text_iter_get_buffer (orig_start);
+
+ if (gtk_text_iter_get_buffer (iter) != src_buffer ||
+ !gtk_text_iter_in_range (iter, orig_start, orig_end))
+ {
+ insert_range_not_inside_self (buffer, iter, orig_start, orig_end, interactive);
+ }
+ else
+ {
+ /* If you insert a range into itself, it could loop infinitely
+ * because the region being copied keeps growing as we insert. So
+ * we have to separately copy the range before and after
+ * the insertion point.
+ */
+ GtkTextIter start = *orig_start;
+ GtkTextIter end = *orig_end;
+ GtkTextIter range_start;
+ GtkTextIter range_end;
+ Range *first_half;
+ Range *second_half;
+
+ gtk_text_iter_order (&start, &end);
+
+ range_start = start;
+ range_end = *iter;
+ first_half = save_range (&range_start, &range_end, &end);
+
+ range_start = *iter;
+ range_end = end;
+ second_half = save_range (&range_start, &range_end, &end);
+ restore_range (first_half);
+ insert_range_not_inside_self (buffer, iter, &range_start, &range_end, interactive);
+
+ restore_range (second_half);
+ insert_range_not_inside_self (buffer, iter, &range_start, &range_end, interactive);
+ }
+
if (interactive)
gtk_text_buffer_end_user_action (buffer);
}
gtk_text_iter_get_buffer (end));
g_return_if_fail (gtk_text_iter_get_buffer (start)->tag_table ==
buffer->tag_table);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
+
gtk_text_buffer_real_insert_range (buffer, iter, start, end, FALSE);
}
buffer->tag_table, FALSE);
- if (gtk_text_iter_editable (iter, default_editable))
+ if (gtk_text_iter_can_insert (iter, default_editable))
{
gtk_text_buffer_real_insert_range (buffer, iter, start, end, TRUE);
return TRUE;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (text != NULL);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
+
start_offset = gtk_text_iter_get_offset (iter);
gtk_text_buffer_insert (buffer, iter, text, len);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (text != NULL);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
+
start_offset = gtk_text_iter_get_offset (iter);
gtk_text_buffer_insert (buffer, iter, text, len);
GtkTextIter *start,
GtkTextIter *end)
{
+ gboolean has_selection;
+
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
_gtk_text_btree_delete (start, end);
/* may have deleted the selection... */
- gtk_text_buffer_update_primary_selection (buffer);
+ update_selection_clipboards (buffer);
- g_signal_emit (G_OBJECT (buffer), signals[CHANGED], 0);
+ has_selection = gtk_text_buffer_get_selection_bounds (buffer, NULL, NULL);
+ if (has_selection != buffer->has_selection)
+ {
+ buffer->has_selection = has_selection;
+ g_object_notify (G_OBJECT (buffer), "has-selection");
+ }
+
+ g_signal_emit (buffer, signals[CHANGED], 0);
+ g_object_notify (G_OBJECT (buffer), "cursor-position");
}
static void
if (gtk_text_iter_equal (start, end))
return;
- gtk_text_iter_reorder (start, end);
+ gtk_text_iter_order (start, end);
- /* Somewhat annoyingly, if you try to delete the final newline
- * the BTree will put it back; which means you can't deduce the
- * final contents of the buffer purely by monitoring insert/delete
- * signals on the buffer. But if you delete the final newline, any
- * tags on the newline will go away, oddly. See comment in
- * gtktextbtree.c. This is all sort of annoying, but really hard
- * to fix.
- */
- g_signal_emit (G_OBJECT (buffer),
+ g_signal_emit (buffer,
signals[DELETE_RANGE],
0,
start, end);
* calling this function; however, the @start and @end will be
* re-initialized to point to the location where text was deleted.
*
- * Note that the final newline in the buffer may not be deleted; a
- * #GtkTextBuffer always contains at least one newline. You can
- * safely include the final newline in the range [@start,@end) but it
- * won't be affected by the deletion.
- *
**/
void
gtk_text_buffer_delete (GtkTextBuffer *buffer,
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (start) == buffer);
+ g_return_if_fail (gtk_text_iter_get_buffer (end) == buffer);
+
gtk_text_buffer_emit_delete (buffer, start, end);
}
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
g_return_val_if_fail (start_iter != NULL, FALSE);
g_return_val_if_fail (end_iter != NULL, FALSE);
+ g_return_val_if_fail (gtk_text_iter_get_buffer (start_iter) == buffer, FALSE);
+ g_return_val_if_fail (gtk_text_iter_get_buffer (end_iter) == buffer, FALSE);
+
gtk_text_buffer_begin_user_action (buffer);
- gtk_text_iter_reorder (start_iter, end_iter);
+ gtk_text_iter_order (start_iter, end_iter);
start_mark = gtk_text_buffer_create_mark (buffer, NULL,
start_iter, TRUE);
end_mark = gtk_text_buffer_create_mark (buffer, NULL,
end_iter, FALSE);
- iter = *start_iter;
+
+ gtk_text_buffer_get_iter_at_mark (buffer, &iter, start_mark);
current_state = gtk_text_iter_editable (&iter, default_editable);
*
* Returns the text in the range [@start,@end). Excludes undisplayed
* text (text marked with tags that set the invisibility attribute) if
- * @include_hidden_chars is FALSE. Does not include characters
+ * @include_hidden_chars is %FALSE. Does not include characters
* representing embedded images, so byte and character indexes into
* the returned string do <emphasis>not</emphasis> correspond to byte
* and character indexes into the buffer. Contrast with
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (start != NULL, NULL);
g_return_val_if_fail (end != NULL, NULL);
-
+ g_return_val_if_fail (gtk_text_iter_get_buffer (start) == buffer, NULL);
+ g_return_val_if_fail (gtk_text_iter_get_buffer (end) == buffer, NULL);
+
if (include_hidden_chars)
return gtk_text_iter_get_text (start, end);
else
*
* Returns the text in the range [@start,@end). Excludes undisplayed
* text (text marked with tags that set the invisibility attribute) if
- * @include_hidden_chars is FALSE. The returned string includes a
+ * @include_hidden_chars is %FALSE. The returned string includes a
* 0xFFFC character whenever the buffer contains
* embedded images, so byte and character indexes into
* the returned string <emphasis>do</emphasis> correspond to byte
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (start != NULL, NULL);
g_return_val_if_fail (end != NULL, NULL);
-
+ g_return_val_if_fail (gtk_text_iter_get_buffer (start) == buffer, NULL);
+ g_return_val_if_fail (gtk_text_iter_get_buffer (end) == buffer, NULL);
+
if (include_hidden_chars)
return gtk_text_iter_get_slice (start, end);
else
gtk_text_buffer_real_insert_pixbuf (GtkTextBuffer *buffer,
GtkTextIter *iter,
GdkPixbuf *pixbuf)
-{
+{
_gtk_text_btree_insert_pixbuf (iter, pixbuf);
- g_signal_emit (G_OBJECT (buffer), signals[CHANGED], 0);
+ g_signal_emit (buffer, signals[CHANGED], 0);
}
/**
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
-
- g_signal_emit (G_OBJECT (buffer), signals[INSERT_PIXBUF], 0,
+ g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
+
+ g_signal_emit (buffer, signals[INSERT_PIXBUF], 0,
iter, pixbuf);
}
{
_gtk_text_btree_insert_child_anchor (iter, anchor);
- g_signal_emit (G_OBJECT (buffer), signals[CHANGED], 0);
+ g_signal_emit (buffer, signals[CHANGED], 0);
}
/**
* when obtaining the buffer contents as a string, will be represented
* by the Unicode "object replacement character" 0xFFFC. Note that the
* "slice" variants for obtaining portions of the buffer as a string
- * include this character for pixbufs, but the "text" variants do
+ * include this character for child anchors, but the "text" variants do
* not. e.g. see gtk_text_buffer_get_slice() and
* gtk_text_buffer_get_text(). Consider
* gtk_text_buffer_create_child_anchor() as a more convenient
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
+ g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
- g_signal_emit (G_OBJECT (buffer), signals[INSERT_CHILD_ANCHOR], 0,
+ g_signal_emit (buffer, signals[INSERT_CHILD_ANCHOR], 0,
iter, anchor);
}
*
* This is a convenience function which simply creates a child anchor
* with gtk_text_child_anchor_new() and inserts it into the buffer
- * with gtk_text_buffer_insert_child_anchor().
+ * with gtk_text_buffer_insert_child_anchor(). The new anchor is
+ * owned by the buffer; no reference count is returned to
+ * the caller of gtk_text_buffer_create_child_anchor().
*
* Return value: the created child anchor
**/
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (iter != NULL, NULL);
-
+ g_return_val_if_fail (gtk_text_iter_get_buffer (iter) == buffer, NULL);
+
anchor = gtk_text_child_anchor_new ();
gtk_text_buffer_insert_child_anchor (buffer, iter, anchor);
- g_object_unref (G_OBJECT (anchor));
+ g_object_unref (anchor);
return anchor;
}
GtkTextMark *mark)
{
/* IMO this should NOT work like insert_text and delete_range,
- where the real action happens in the default handler.
-
- The reason is that the default handler would be _required_,
- i.e. the whole widget would start breaking and segfaulting
- if the default handler didn't get run. So you can't really
- override the default handler or stop the emission; that is,
- this signal is purely for notification, and not to allow users
- to modify the default behavior. */
+ * where the real action happens in the default handler.
+ *
+ * The reason is that the default handler would be _required_,
+ * i.e. the whole widget would start breaking and segfaulting if the
+ * default handler didn't get run. So you can't really override the
+ * default handler or stop the emission; that is, this signal is
+ * purely for notification, and not to allow users to modify the
+ * default behavior.
+ */
- g_object_ref (G_OBJECT (mark));
+ g_object_ref (mark);
- g_signal_emit (G_OBJECT (buffer),
+ g_signal_emit (buffer,
signals[MARK_SET],
0,
location,
mark);
- g_object_unref (G_OBJECT (mark));
+ g_object_unref (mark);
}
/**
GtkTextIter location;
GtkTextMark *mark;
+ g_return_val_if_fail (gtk_text_iter_get_buffer (iter) == buffer, NULL);
+
mark = _gtk_text_btree_set_mark (get_btree (buffer),
- existing_mark,
- mark_name,
- left_gravity,
- iter,
- should_exist);
-
- if (_gtk_text_btree_mark_is_insert (get_btree (buffer), mark) ||
- _gtk_text_btree_mark_is_selection_bound (get_btree (buffer), mark))
- {
- gtk_text_buffer_update_primary_selection (buffer);
- }
-
+ existing_mark,
+ mark_name,
+ left_gravity,
+ iter,
+ should_exist);
+
_gtk_text_btree_get_iter_at_mark (get_btree (buffer),
&location,
mark);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
_gtk_text_btree_get_iter_at_mark (get_btree (buffer),
- iter,
- mark);
+ iter,
+ mark);
}
/**
g_return_if_fail (!gtk_text_mark_get_deleted (mark));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- g_object_ref (G_OBJECT (mark));
+ g_object_ref (mark);
_gtk_text_btree_remove_mark (get_btree (buffer), mark);
* removing the mark, rather than removing the mark in a default
* handler.
*/
- g_signal_emit (G_OBJECT (buffer), signals[MARK_DELETED],
+ g_signal_emit (buffer, signals[MARK_DELETED],
0,
mark);
- g_object_unref (G_OBJECT (mark));
+ g_object_unref (mark);
}
/**
*
* Returns the mark that represents the cursor (insertion point).
* Equivalent to calling gtk_text_buffer_get_mark () to get the mark
- * name "insert," but very slightly more efficient, and involves less
+ * named "insert", but very slightly more efficient, and involves less
* typing.
*
* Return value: insertion point mark
* @buffer: a #GtkTextBuffer
*
* Returns the mark that represents the selection bound. Equivalent
- * to calling gtk_text_buffer_get_mark () to get the mark name
- * "selection_bound," but very slightly more efficient, and involves
+ * to calling gtk_text_buffer_get_mark () to get the mark named
+ * "selection_bound", but very slightly more efficient, and involves
* less typing.
*
* The currently-selected text in @buffer is the region between the
* "selection_bound" and "insert" marks. If "selection_bound" and
* "insert" are in the same place, then there is no current selection.
- * gtk_text_buffer_get_selection_bounds () is another convenient function
+ * gtk_text_buffer_get_selection_bounds() is another convenient function
* for handling the selection, if you just want to know whether there's a
* selection and what its bounds are.
*
return gtk_text_buffer_get_mark (buffer, "selection_bound");
}
+/**
+ * gtk_text_buffer_get_iter_at_child_anchor:
+ * @buffer: a #GtkTextBuffer
+ * @iter: an iterator to be initialized
+ * @anchor: a child anchor that appears in @buffer
+ *
+ * Obtains the location of @anchor within @buffer.
+ *
+ **/
void
gtk_text_buffer_get_iter_at_child_anchor (GtkTextBuffer *buffer,
GtkTextIter *iter,
*
* This function moves the "insert" and "selection_bound" marks
* simultaneously. If you move them to the same place in two steps
- * with gtk_text_buffer_move_mark (), you will temporarily select a
+ * with gtk_text_buffer_move_mark(), you will temporarily select a
* region in between their old and new locations, which can be pretty
* inefficient since the temporarily-selected region will force stuff
* to be recalculated. This function moves them as a unit, which can
gtk_text_buffer_place_cursor (GtkTextBuffer *buffer,
const GtkTextIter *where)
{
- GtkTextIter real;
+ gtk_text_buffer_select_range (buffer, where, where);
+}
- g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- real = *where;
+/**
+ * gtk_text_buffer_select_range:
+ * @buffer: a #GtkTextBuffer
+ * @ins: where to put the "insert" mark
+ * @bound: where to put the "selection_bound" mark
+ *
+ * This function moves the "insert" and "selection_bound" marks
+ * simultaneously. If you move them in two steps
+ * with gtk_text_buffer_move_mark(), you will temporarily select a
+ * region in between their old and new locations, which can be pretty
+ * inefficient since the temporarily-selected region will force stuff
+ * to be recalculated. This function moves them as a unit, which can
+ * be optimized.
+ *
+ * Since: 2.4
+ **/
+void
+gtk_text_buffer_select_range (GtkTextBuffer *buffer,
+ const GtkTextIter *ins,
+ const GtkTextIter *bound)
+{
+ GtkTextIter real_ins;
+ GtkTextIter real_bound;
+
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- if (gtk_text_iter_is_end (&real))
- gtk_text_iter_backward_char (&real);
+ real_ins = *ins;
+ real_bound = *bound;
- _gtk_text_btree_place_cursor (get_btree (buffer), &real);
- gtk_text_buffer_mark_set (buffer, &real,
+ _gtk_text_btree_select_range (get_btree (buffer), &real_ins, &real_bound);
+ gtk_text_buffer_mark_set (buffer, &real_ins,
gtk_text_buffer_get_mark (buffer,
"insert"));
- gtk_text_buffer_mark_set (buffer, &real,
+ gtk_text_buffer_mark_set (buffer, &real_bound,
gtk_text_buffer_get_mark (buffer,
"selection_bound"));
}
* gtk_text_buffer_create_tag:
* @buffer: a #GtkTextBuffer
* @tag_name: name of the new tag, or %NULL
+ * @first_property_name: name of first property to set, or %NULL
+ * @Varargs: %NULL-terminated list of property names and values
+ *
*
* Creates a tag and adds it to the tag table for @buffer.
* Equivalent to calling gtk_text_tag_new () and then adding the
- * tag to the buffer's tag table. The returned tag has its refcount
- * incremented, as if you'd called gtk_text_tag_new ().
+ * tag to the buffer's tag table. The returned tag is owned by
+ * the buffer's tag table, so the ref count will be equal to one.
*
* If @tag_name is %NULL, the tag is anonymous.
*
+ * If @tag_name is non-%NULL, a tag called @tag_name must not already
+ * exist in the tag table for this buffer.
+ *
+ * The @first_property_name argument and subsequent arguments are a list
+ * of properties to set on the tag, as with g_object_set().
+ *
* Return value: a new tag
**/
GtkTextTag*
gtk_text_buffer_create_tag (GtkTextBuffer *buffer,
- const gchar *tag_name)
+ const gchar *tag_name,
+ const gchar *first_property_name,
+ ...)
{
GtkTextTag *tag;
-
+ va_list list;
+
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
tag = gtk_text_tag_new (tag_name);
gtk_text_tag_table_add (get_table (buffer), tag);
+ if (first_property_name)
+ {
+ va_start (list, first_property_name);
+ g_object_set_valist (G_OBJECT (tag), first_property_name, list);
+ va_end (list);
+ }
+
+ g_object_unref (tag);
+
return tag;
}
const GtkTextIter *start,
const GtkTextIter *end)
{
+ if (tag->table != buffer->tag_table)
+ {
+ g_warning ("Can only apply tags that are in the tag table for the buffer");
+ return;
+ }
+
_gtk_text_btree_tag (start, end, tag, TRUE);
}
const GtkTextIter *start,
const GtkTextIter *end)
{
+ if (tag->table != buffer->tag_table)
+ {
+ g_warning ("Can only remove tags that are in the tag table for the buffer");
+ return;
+ }
+
_gtk_text_btree_tag (start, end, tag, FALSE);
}
}
static void
-gtk_text_buffer_emit_tag (GtkTextBuffer *buffer,
- GtkTextTag *tag,
- gboolean apply,
- const GtkTextIter *start,
- const GtkTextIter *end)
+gtk_text_buffer_real_mark_set (GtkTextBuffer *buffer,
+ const GtkTextIter *iter,
+ GtkTextMark *mark)
+{
+ GtkTextMark *insert;
+
+ insert = gtk_text_buffer_get_insert (buffer);
+
+ if (mark == insert || mark == gtk_text_buffer_get_selection_bound (buffer))
+ {
+ gboolean has_selection;
+
+ update_selection_clipboards (buffer);
+
+ has_selection = gtk_text_buffer_get_selection_bounds (buffer,
+ NULL,
+ NULL);
+
+ if (has_selection != buffer->has_selection)
+ {
+ buffer->has_selection = has_selection;
+ g_object_notify (G_OBJECT (buffer), "has-selection");
+ }
+ }
+
+ if (mark == insert)
+ g_object_notify (G_OBJECT (buffer), "cursor-position");
+}
+
+static void
+gtk_text_buffer_emit_tag (GtkTextBuffer *buffer,
+ GtkTextTag *tag,
+ gboolean apply,
+ const GtkTextIter *start,
+ const GtkTextIter *end)
{
GtkTextIter start_tmp = *start;
GtkTextIter end_tmp = *end;
g_return_if_fail (tag != NULL);
- gtk_text_iter_reorder (&start_tmp, &end_tmp);
+ gtk_text_iter_order (&start_tmp, &end_tmp);
if (apply)
- g_signal_emit (G_OBJECT (buffer), signals[APPLY_TAG],
+ g_signal_emit (buffer, signals[APPLY_TAG],
0,
tag, &start_tmp, &end_tmp);
else
- g_signal_emit (G_OBJECT (buffer), signals[REMOVE_TAG],
+ g_signal_emit (buffer, signals[REMOVE_TAG],
0,
tag, &start_tmp, &end_tmp);
}
g_return_if_fail (GTK_IS_TEXT_TAG (tag));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (start) == buffer);
+ g_return_if_fail (gtk_text_iter_get_buffer (end) == buffer);
+ g_return_if_fail (tag->table == buffer->tag_table);
+
gtk_text_buffer_emit_tag (buffer, tag, TRUE, start, end);
}
g_return_if_fail (GTK_IS_TEXT_TAG (tag));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (start) == buffer);
+ g_return_if_fail (gtk_text_iter_get_buffer (end) == buffer);
+ g_return_if_fail (tag->table == buffer->tag_table);
+
gtk_text_buffer_emit_tag (buffer, tag, FALSE, start, end);
}
g_return_if_fail (name != NULL);
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
+ g_return_if_fail (gtk_text_iter_get_buffer (start) == buffer);
+ g_return_if_fail (gtk_text_iter_get_buffer (end) == buffer);
tag = gtk_text_tag_table_lookup (get_table (buffer),
name);
g_return_if_fail (name != NULL);
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
-
+ g_return_if_fail (gtk_text_iter_get_buffer (start) == buffer);
+ g_return_if_fail (gtk_text_iter_get_buffer (end) == buffer);
+
tag = gtk_text_tag_table_lookup (get_table (buffer),
name);
gtk_text_buffer_emit_tag (buffer, tag, FALSE, start, end);
}
+static gint
+pointer_cmp (gconstpointer a,
+ gconstpointer b)
+{
+ if (a < b)
+ return -1;
+ else if (a > b)
+ return 1;
+ else
+ return 0;
+}
+
+/**
+ * gtk_text_buffer_remove_all_tags:
+ * @buffer: a #GtkTextBuffer
+ * @start: one bound of range to be untagged
+ * @end: other bound of range to be untagged
+ *
+ * Removes all tags in the range between @start and @end. Be careful
+ * with this function; it could remove tags added in code unrelated to
+ * the code you're currently writing. That is, using this function is
+ * probably a bad idea if you have two or more unrelated code sections
+ * that add tags.
+ **/
+void
+gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer,
+ const GtkTextIter *start,
+ const GtkTextIter *end)
+{
+ GtkTextIter first, second, tmp;
+ GSList *tags;
+ GSList *tmp_list;
+ GSList *prev, *next;
+ GtkTextTag *tag;
+
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+ g_return_if_fail (start != NULL);
+ g_return_if_fail (end != NULL);
+ g_return_if_fail (gtk_text_iter_get_buffer (start) == buffer);
+ g_return_if_fail (gtk_text_iter_get_buffer (end) == buffer);
+
+ first = *start;
+ second = *end;
+
+ gtk_text_iter_order (&first, &second);
+
+ /* Get all tags turned on at the start */
+ tags = gtk_text_iter_get_tags (&first);
+
+ /* Find any that are toggled on within the range */
+ tmp = first;
+ while (gtk_text_iter_forward_to_tag_toggle (&tmp, NULL))
+ {
+ GSList *toggled;
+ GSList *tmp_list2;
+
+ if (gtk_text_iter_compare (&tmp, &second) >= 0)
+ break; /* past the end of the range */
+
+ toggled = gtk_text_iter_get_toggled_tags (&tmp, TRUE);
+
+ /* We could end up with a really big-ass list here.
+ * Fix it someday.
+ */
+ tmp_list2 = toggled;
+ while (tmp_list2 != NULL)
+ {
+ tags = g_slist_prepend (tags, tmp_list2->data);
+
+ tmp_list2 = g_slist_next (tmp_list2);
+ }
+
+ g_slist_free (toggled);
+ }
+
+ /* Sort the list */
+ tags = g_slist_sort (tags, pointer_cmp);
+
+ /* Strip duplicates */
+ tag = NULL;
+ prev = NULL;
+ tmp_list = tags;
+ while (tmp_list != NULL)
+ {
+ if (tag == tmp_list->data)
+ {
+ /* duplicate */
+ next = tmp_list->next;
+ if (prev)
+ prev->next = next;
+
+ tmp_list->next = NULL;
+
+ g_slist_free (tmp_list);
+
+ tmp_list = next;
+ /* prev is unchanged */
+ }
+ else
+ {
+ /* not a duplicate */
+ tag = GTK_TEXT_TAG (tmp_list->data);
+ prev = tmp_list;
+ tmp_list = tmp_list->next;
+ }
+ }
+
+ g_slist_foreach (tags, (GFunc) g_object_ref, NULL);
+
+ tmp_list = tags;
+ while (tmp_list != NULL)
+ {
+ tag = GTK_TEXT_TAG (tmp_list->data);
+
+ gtk_text_buffer_remove_tag (buffer, tag, &first, &second);
+
+ tmp_list = tmp_list->next;
+ }
+
+ g_slist_foreach (tags, (GFunc) g_object_unref, NULL);
+
+ g_slist_free (tags);
+}
+
/*
* Obtain various iterators
* gtk_text_buffer_get_iter_at_offset:
* @buffer: a #GtkTextBuffer
* @iter: iterator to initialize
- * @char_offset: char offset from start of buffer, counting from 0
+ * @char_offset: char offset from start of buffer, counting from 0, or -1
*
* Initializes @iter to a position @char_offset chars from the start
- * of the entire buffer.
- *
+ * of the entire buffer. If @char_offset is -1 or greater than the number
+ * of characters in the buffer, @iter is initialized to the end iterator,
+ * the iterator one past the last valid character in the buffer.
**/
void
gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer,
_gtk_text_btree_get_iter_at_char (get_btree (buffer), iter, char_offset);
}
+/**
+ * gtk_text_buffer_get_start_iter:
+ * @buffer: a #GtkTextBuffer
+ * @iter: iterator to initialize
+ *
+ * Initialized @iter with the first position in the text buffer. This
+ * is the same as using gtk_text_buffer_get_iter_at_offset() to get
+ * the iter at character offset 0.
+ **/
+void
+gtk_text_buffer_get_start_iter (GtkTextBuffer *buffer,
+ GtkTextIter *iter)
+{
+ g_return_if_fail (iter != NULL);
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+
+ _gtk_text_btree_get_iter_at_char (get_btree (buffer), iter, 0);
+}
+
/**
* gtk_text_buffer_get_end_iter:
* @buffer: a #GtkTextBuffer
* character in the text buffer. If dereferenced with
* gtk_text_iter_get_char(), the end iterator has a character value of
* 0. The entire buffer lies in the range from the first position in
- * the buffer (call gtk_text_buffer_get_iter_at_offset() to get
+ * the buffer (call gtk_text_buffer_get_start_iter() to get
* character position 0) to the end iterator.
*
**/
else
{
buffer->modified = fixed_setting;
- g_signal_emit (G_OBJECT (buffer), signals[MODIFIED_CHANGED], 0);
+ g_signal_emit (buffer, signals[MODIFIED_CHANGED], 0);
}
}
+/**
+ * gtk_text_buffer_get_has_selection:
+ * @buffer: a #GtkTextBuffer
+ *
+ * Indicates whether the buffer has some text currently selected.
+ *
+ * Return value: %TRUE if the there is text selected
+ *
+ * Since: 2.10
+ **/
+gboolean
+gtk_text_buffer_get_has_selection (GtkTextBuffer *buffer)
+{
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
+
+ return buffer->has_selection;
+}
+
/*
* Assorted other stuff
if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
- if (selection_data->target ==
- gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE))
+ if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
{
/* Provide the address of the buffer; this will only be
* used within-process
*/
gtk_selection_data_set (selection_data,
- gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE),
+ selection_data->target,
8, /* bytes */
(void*)&buffer,
sizeof (buffer));
}
+ else if (info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
+ {
+ guint8 *str;
+ gsize len;
+
+ str = gtk_text_buffer_serialize (buffer, buffer,
+ selection_data->target,
+ &start, &end, &len);
+
+ gtk_selection_data_set (selection_data,
+ selection_data->target,
+ 8, /* bytes */
+ str, len);
+ g_free (str);
+ }
else
{
gchar *str;
-
+
str = gtk_text_iter_get_visible_text (&start, &end);
- gtk_selection_data_set_text (selection_data, str);
+ gtk_selection_data_set_text (selection_data, str, -1);
g_free (str);
}
}
}
+static GtkTextBuffer *
+create_clipboard_contents_buffer (GtkTextBuffer *buffer)
+{
+ GtkTextBuffer *contents;
+
+ contents = gtk_text_buffer_new (gtk_text_buffer_get_tag_table (buffer));
+
+ g_object_set_data (G_OBJECT (contents), I_("gtk-text-buffer-clipboard-source"),
+ buffer);
+ g_object_set_data (G_OBJECT (contents), I_("gtk-text-buffer-clipboard"),
+ GINT_TO_POINTER (1));
+
+ /* Ref the source buffer as long as the clipboard contents buffer
+ * exists, because it's needed for serializing the contents buffer.
+ * See http://bugzilla.gnome.org/show_bug.cgi?id=339195
+ */
+ g_object_ref (buffer);
+ g_object_weak_ref (G_OBJECT (contents), (GWeakNotify) g_object_unref, buffer);
+
+ return contents;
+}
+
/* Provide cut/copied data */
static void
clipboard_get_contents_cb (GtkClipboard *clipboard,
guint info,
gpointer data)
{
- GtkTextBuffer *buffer = GTK_TEXT_BUFFER (data);
- GtkTextBuffer *contents = buffer->clipboard_contents;
+ GtkTextBuffer *contents = GTK_TEXT_BUFFER (data);
+
+ g_assert (contents); /* This should never be called unless we own the clipboard */
- if (selection_data->target ==
- gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE))
+ if (info == GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS)
{
/* Provide the address of the clipboard buffer; this will only
* be used within-process. OK to supply a NULL value for contents.
*/
gtk_selection_data_set (selection_data,
- gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE),
+ selection_data->target,
8, /* bytes */
(void*)&contents,
sizeof (contents));
}
+ else if (info == GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT)
+ {
+ GtkTextBuffer *clipboard_source_buffer;
+ GtkTextIter start, end;
+ guint8 *str;
+ gsize len;
+
+ clipboard_source_buffer = g_object_get_data (G_OBJECT (contents),
+ "gtk-text-buffer-clipboard-source");
+
+ gtk_text_buffer_get_bounds (contents, &start, &end);
+
+ str = gtk_text_buffer_serialize (clipboard_source_buffer, contents,
+ selection_data->target,
+ &start, &end, &len);
+
+ gtk_selection_data_set (selection_data,
+ selection_data->target,
+ 8, /* bytes */
+ str, len);
+ g_free (str);
+ }
else
{
- /* Just provide text from the clipboard buffer */
- if (buffer->clipboard_contents)
- {
- gchar *str;
- GtkTextIter start, end;
-
- gtk_text_buffer_get_bounds (contents, &start, &end);
- /* strip off the trailing newline, it isn't part of the text that was cut */
- gtk_text_iter_backward_char (&end);
-
- str = gtk_text_iter_get_visible_text (&start, &end);
- gtk_selection_data_set_text (selection_data, str);
- g_free (str);
- }
- else
- {
- gtk_selection_data_set_text (selection_data, "");
- return;
- }
+ gchar *str;
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_bounds (contents, &start, &end);
+
+ str = gtk_text_iter_get_visible_text (&start, &end);
+ gtk_selection_data_set_text (selection_data, str, -1);
+ g_free (str);
}
}
clipboard_clear_contents_cb (GtkClipboard *clipboard,
gpointer data)
{
- GtkTextBuffer *buffer = GTK_TEXT_BUFFER (data);
+ GtkTextBuffer *contents = GTK_TEXT_BUFFER (data);
- if (buffer->clipboard_contents)
- {
- g_object_unref (G_OBJECT (buffer->clipboard_contents));
- buffer->clipboard_contents = NULL;
- }
+ g_object_unref (contents);
}
static void
}
}
+static void
+free_clipboard_request (ClipboardRequest *request_data)
+{
+ g_object_unref (request_data->buffer);
+ g_free (request_data);
+}
+
/* Called when we request a paste and receive the text data
*/
static void
if (str)
{
GtkTextIter insert_point;
+
+ if (request_data->interactive)
+ gtk_text_buffer_begin_user_action (buffer);
pre_paste_prep (request_data, &insert_point);
- if (request_data->interactive)
- gtk_text_buffer_insert_interactive (buffer, &insert_point,
- str, -1, request_data->default_editable);
+ if (request_data->interactive)
+ gtk_text_buffer_insert_interactive (buffer, &insert_point,
+ str, -1, request_data->default_editable);
else
gtk_text_buffer_insert (buffer, &insert_point,
str, -1);
post_paste_cleanup (request_data);
+
+ if (request_data->interactive)
+ gtk_text_buffer_end_user_action (buffer);
}
- g_object_unref (G_OBJECT (buffer));
- g_free (request_data);
+ free_clipboard_request (request_data);
}
static GtkTextBuffer*
GtkTextBuffer *src_buffer = NULL;
/* If we can get the owner, the selection is in-process */
- owner = gdk_selection_owner_get (selection_data->selection);
+ owner = gdk_selection_owner_get_for_display (selection_data->display,
+ selection_data->selection);
if (owner == NULL)
return NULL;
- if (selection_data->type != gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE))
+ if (gdk_window_get_window_type (owner) == GDK_WINDOW_FOREIGN)
+ return NULL;
+
+ if (selection_data->type !=
+ gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
return NULL;
if (selection_data->length != sizeof (src_buffer))
}
#endif
+static void
+clipboard_rich_text_received (GtkClipboard *clipboard,
+ GdkAtom format,
+ const guint8 *text,
+ gsize length,
+ gpointer data)
+{
+ ClipboardRequest *request_data = data;
+ GtkTextIter insert_point;
+ gboolean retval = TRUE;
+ GError *error = NULL;
+
+ if (text != NULL && length > 0)
+ {
+ pre_paste_prep (request_data, &insert_point);
+
+ if (request_data->interactive)
+ gtk_text_buffer_begin_user_action (request_data->buffer);
+
+ if (!request_data->interactive ||
+ gtk_text_iter_can_insert (&insert_point,
+ request_data->default_editable))
+ {
+ retval = gtk_text_buffer_deserialize (request_data->buffer,
+ request_data->buffer,
+ format,
+ &insert_point,
+ text, length,
+ &error);
+ }
+
+ if (!retval)
+ {
+ g_warning ("error pasting: %s\n", error->message);
+ g_clear_error (&error);
+ }
+
+ if (request_data->interactive)
+ gtk_text_buffer_end_user_action (request_data->buffer);
+
+ if (retval)
+ {
+ post_paste_cleanup (request_data);
+ return;
+ }
+ }
+
+ /* Request the text selection instead */
+ gtk_clipboard_request_text (clipboard,
+ clipboard_text_received,
+ data);
+}
+
static void
paste_from_buffer (ClipboardRequest *request_data,
GtkTextBuffer *src_buffer,
const GtkTextIter *end)
{
GtkTextIter insert_point;
+ GtkTextBuffer *buffer = request_data->buffer;
/* We're about to emit a bunch of signals, so be safe */
- g_object_ref (G_OBJECT (src_buffer));
+ g_object_ref (src_buffer);
pre_paste_prep (request_data, &insert_point);
+ if (request_data->interactive)
+ gtk_text_buffer_begin_user_action (buffer);
+
if (!gtk_text_iter_equal (start, end))
{
- gtk_text_buffer_real_insert_range (request_data->buffer,
- &insert_point,
- start,
- end,
- request_data->interactive);
+ if (!request_data->interactive ||
+ (gtk_text_iter_can_insert (&insert_point,
+ request_data->default_editable)))
+ gtk_text_buffer_real_insert_range (buffer,
+ &insert_point,
+ start,
+ end,
+ request_data->interactive);
}
post_paste_cleanup (request_data);
- g_object_unref (G_OBJECT (src_buffer));
+ if (request_data->interactive)
+ gtk_text_buffer_end_user_action (buffer);
+
+ g_object_unref (src_buffer);
+
+ free_clipboard_request (request_data);
}
static void
{
ClipboardRequest *request_data = data;
GtkTextBuffer *src_buffer;
-
+
src_buffer = selection_data_get_buffer (selection_data, request_data);
if (src_buffer)
{
GtkTextIter start, end;
- gtk_text_buffer_get_bounds (src_buffer, &start, &end);
- /* There's an extra newline on clipboard_contents */
- gtk_text_iter_backward_char (&end);
-
- paste_from_buffer (request_data, src_buffer,
- &start, &end);
+ if (g_object_get_data (G_OBJECT (src_buffer), "gtk-text-buffer-clipboard"))
+ {
+ gtk_text_buffer_get_bounds (src_buffer, &start, &end);
+
+ paste_from_buffer (request_data, src_buffer,
+ &start, &end);
+ }
+ else
+ {
+ if (gtk_text_buffer_get_selection_bounds (src_buffer, &start, &end))
+ paste_from_buffer (request_data, src_buffer,
+ &start, &end);
+ }
}
else
{
- /* Request the text selection instead */
- gtk_clipboard_request_text (clipboard,
- clipboard_text_received,
- data);
+ if (gtk_clipboard_wait_is_rich_text_available (clipboard,
+ request_data->buffer))
+ {
+ /* Request rich text */
+ gtk_clipboard_request_rich_text (clipboard,
+ request_data->buffer,
+ clipboard_rich_text_received,
+ data);
+ }
+ else
+ {
+ /* Request the text selection instead */
+ gtk_clipboard_request_text (clipboard,
+ clipboard_text_received,
+ data);
+ }
}
}
+typedef struct
+{
+ GtkClipboard *clipboard;
+ guint ref_count;
+} SelectionClipboard;
+
static void
-clipboard_selection_buffer_received (GtkClipboard *clipboard,
- GtkSelectionData *selection_data,
- gpointer data)
+update_selection_clipboards (GtkTextBuffer *buffer)
{
- ClipboardRequest *request_data = data;
- GtkTextBuffer *src_buffer;
-
- src_buffer = selection_data_get_buffer (selection_data, request_data);
+ GtkTextBufferPrivate *priv;
+ GSList *tmp_list = buffer->selection_clipboards;
- if (src_buffer)
+ priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+
+ gtk_text_buffer_get_copy_target_list (buffer);
+
+ while (tmp_list)
{
- GtkTextIter start, end;
+ GtkTextIter start;
+ GtkTextIter end;
+
+ SelectionClipboard *selection_clipboard = tmp_list->data;
+ GtkClipboard *clipboard = selection_clipboard->clipboard;
- if (gtk_text_buffer_get_selection_bounds (src_buffer, &start, &end))
- paste_from_buffer (request_data, src_buffer,
- &start, &end);
+ /* Determine whether we have a selection and adjust X selection
+ * accordingly.
+ */
+ if (!gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
+ {
+ if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (buffer))
+ gtk_clipboard_clear (clipboard);
+ }
+ else
+ {
+ /* Even if we already have the selection, we need to update our
+ * timestamp.
+ */
+ if (!gtk_clipboard_set_with_owner (clipboard,
+ priv->copy_target_entries,
+ priv->n_copy_target_entries,
+ clipboard_get_selection_cb,
+ clipboard_clear_selection_cb,
+ G_OBJECT (buffer)))
+ clipboard_clear_selection_cb (clipboard, buffer);
+ }
+
+ tmp_list = tmp_list->next;
}
- else
+}
+
+static SelectionClipboard *
+find_selection_clipboard (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard)
+{
+ GSList *tmp_list = buffer->selection_clipboards;
+ while (tmp_list)
{
- /* Request the text selection instead */
- gtk_clipboard_request_text (clipboard,
- clipboard_text_received,
- data);
+ SelectionClipboard *selection_clipboard = tmp_list->data;
+ if (selection_clipboard->clipboard == clipboard)
+ return selection_clipboard;
+
+ tmp_list = tmp_list->next;
}
-}
-static const GtkTargetEntry targets[] = {
- { "STRING", 0, TARGET_STRING },
- { "TEXT", 0, TARGET_TEXT },
- { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
- { "UTF8_STRING", 0, TARGET_UTF8_STRING },
- { "GTK_TEXT_BUFFER_CONTENTS", 0, TARGET_TEXT_BUFFER_CONTENTS }
-};
+ return NULL;
+}
-static void
-gtk_text_buffer_update_primary_selection (GtkTextBuffer *buffer)
+/**
+ * gtk_text_buffer_add_selection_clipboard:
+ * @buffer: a #GtkTextBuffer
+ * @clipboard: a #GtkClipboard
+ *
+ * Adds @clipboard to the list of clipboards in which the selection contents
+ * of @buffer are available. In most cases, @clipboard will be the #GtkClipboard
+ * of type %GDK_SELECTION_PRIMARY for a view of @buffer.
+ **/
+void
+gtk_text_buffer_add_selection_clipboard (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard)
{
- GtkTextIter start;
- GtkTextIter end;
+ SelectionClipboard *selection_clipboard;
- GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
-
- /* Determine whether we have a selection and adjust X selection
- * accordingly.
- */
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+ g_return_if_fail (clipboard != NULL);
- if (!gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
+ selection_clipboard = find_selection_clipboard (buffer, clipboard);
+ if (selection_clipboard)
{
- if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (buffer))
- gtk_clipboard_clear (clipboard);
+ selection_clipboard->ref_count++;
}
else
{
- /* Even if we already have the selection, we need to update our
- * timestamp.
- */
- if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
- clipboard_get_selection_cb,
- clipboard_clear_selection_cb,
- G_OBJECT (buffer)))
- clipboard_clear_selection_cb (clipboard, buffer);
+ selection_clipboard = g_new (SelectionClipboard, 1);
+
+ selection_clipboard->clipboard = clipboard;
+ selection_clipboard->ref_count = 1;
+
+ buffer->selection_clipboards = g_slist_prepend (buffer->selection_clipboards, selection_clipboard);
+ }
+}
+
+/**
+ * gtk_text_buffer_remove_selection_clipboard:
+ * @buffer: a #GtkTextBuffer
+ * @clipboard: a #GtkClipboard added to @buffer by gtk_text_buffer_add_selection_clipboard().
+ *
+ * Removes a #GtkClipboard added with gtk_text_buffer_add_selection_clipboard()
+ **/
+void
+gtk_text_buffer_remove_selection_clipboard (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard)
+{
+ SelectionClipboard *selection_clipboard;
+
+ g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
+ g_return_if_fail (clipboard != NULL);
+
+ selection_clipboard = find_selection_clipboard (buffer, clipboard);
+ g_return_if_fail (selection_clipboard != NULL);
+
+ selection_clipboard->ref_count--;
+ if (selection_clipboard->ref_count == 0)
+ {
+ if (gtk_clipboard_get_owner (selection_clipboard->clipboard) == G_OBJECT (buffer))
+ gtk_clipboard_clear (selection_clipboard->clipboard);
+
+ buffer->selection_clipboards = g_slist_remove (buffer->selection_clipboards,
+ selection_clipboard);
+
+ g_free (selection_clipboard);
}
}
static void
-paste (GtkTextBuffer *buffer,
- gboolean is_clipboard,
- gboolean interactive,
- gboolean default_editable)
+remove_all_selection_clipboards (GtkTextBuffer *buffer)
+{
+ g_slist_foreach (buffer->selection_clipboards, (GFunc)g_free, NULL);
+ g_slist_free (buffer->selection_clipboards);
+ buffer->selection_clipboards = NULL;
+}
+
+/**
+ * gtk_text_buffer_paste_clipboard:
+ * @buffer: a #GtkTextBuffer
+ * @clipboard: the #GtkClipboard to paste from
+ * @override_location: location to insert pasted text, or %NULL for at the cursor
+ * @default_editable: whether the buffer is editable by default
+ *
+ * Pastes the contents of a clipboard at the insertion point, or at @override_location.
+ * (Note: pasting is asynchronous, that is, we'll ask for the paste data and
+ * return, and at some point later after the main loop runs, the paste
+ * data will be inserted.)
+ *
+ **/
+void
+gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard,
+ GtkTextIter *override_location,
+ gboolean default_editable)
{
ClipboardRequest *data = g_new (ClipboardRequest, 1);
GtkTextIter paste_point;
GtkTextIter start, end;
-
- data->buffer = buffer;
- g_object_ref (G_OBJECT (buffer));
- data->interactive = interactive;
+
+ if (override_location != NULL)
+ gtk_text_buffer_create_mark (buffer,
+ "gtk_paste_point_override",
+ override_location, FALSE);
+
+ data->buffer = g_object_ref (buffer);
+ data->interactive = TRUE;
data->default_editable = default_editable;
/* When pasting with the cursor inside the selection area, you
gtk_text_iter_equal (&paste_point, &end)))
data->replace_selection = TRUE;
- if (is_clipboard)
- gtk_clipboard_request_contents (gtk_clipboard_get (GDK_NONE),
-
- gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE),
- clipboard_clipboard_buffer_received, data);
- else
- gtk_clipboard_request_contents (gtk_clipboard_get (GDK_SELECTION_PRIMARY),
-
- gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE),
- clipboard_selection_buffer_received, data);
-}
-
-/**
- * gtk_text_buffer_paste_primary:
- * @buffer: a #GtkTextBuffer
- * @override_location: location to insert pasted text, or %NULL for at the cursor
- * @default_editable: whether the buffer is editable by default
- *
- * Pastes the primary selection at the insertion point, or at @override_location.
- * (Note: pasting is asynchronous, that is, we'll ask for the paste data
- * and return, and at some point later after the main loop runs, the paste
- * data will be inserted.)
- **/
-void
-gtk_text_buffer_paste_primary (GtkTextBuffer *buffer,
- const GtkTextIter *override_location,
- gboolean default_editable)
-{
- if (override_location != NULL)
- gtk_text_buffer_create_mark (buffer,
- "gtk_paste_point_override",
- override_location, FALSE);
-
- paste (buffer, FALSE, TRUE, default_editable);
-}
-
-/**
- * gtk_text_buffer_paste_clipboard:
- * @buffer: a #GtkTextBuffer
- * @default_editable: whether the buffer is editable by default
- *
- * Pastes the clipboard contents at the insertion point. (Note:
- * pasting is asynchronous, that is, we'll ask for the paste data and
- * return, and at some point later after the main loop runs, the paste
- * data will be inserted.)
- *
- **/
-void
-gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
- gboolean default_editable)
-{
- paste (buffer, TRUE, TRUE, default_editable);
+ gtk_clipboard_request_contents (clipboard,
+ gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
+ clipboard_clipboard_buffer_received, data);
}
/**
}
}
+/**
+ * gtk_text_buffer_backspace:
+ * @buffer: a #GtkTextBuffer
+ * @iter: a position in @buffer
+ * @interactive: whether the deletion is caused by user interaction
+ * @default_editable: whether the buffer is editable by default
+ *
+ * Performs the appropriate action as if the user hit the delete
+ * key with the cursor at the position specified by @iter. In the
+ * normal case a single character will be deleted, but when
+ * combining accents are involved, more than one character can
+ * be deleted, and when precomposed character and accent combinations
+ * are involved, less than one character will be deleted.
+ *
+ * Because the buffer is modified, all outstanding iterators become
+ * invalid after calling this function; however, the @iter will be
+ * re-initialized to point to the location where text was deleted.
+ *
+ * Return value: %TRUE if the buffer was modified
+
+ * Since: 2.6
+ **/
+gboolean
+gtk_text_buffer_backspace (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gboolean interactive,
+ gboolean default_editable)
+{
+ gchar *cluster_text;
+ GtkTextIter start;
+ GtkTextIter end;
+ gboolean retval = FALSE;
+ const PangoLogAttr *attrs;
+ int offset;
+ gboolean backspace_deletes_character;
+
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
+ g_return_val_if_fail (iter != NULL, FALSE);
+
+ start = *iter;
+ end = *iter;
+
+ attrs = _gtk_text_buffer_get_line_log_attrs (buffer, &start, NULL);
+
+ /* For no good reason, attrs is NULL for the empty last line in
+ * a buffer. Special case that here. (#156164)
+ */
+ if (attrs)
+ {
+ offset = gtk_text_iter_get_line_offset (&start);
+ backspace_deletes_character = attrs[offset].backspace_deletes_character;
+ }
+ else
+ backspace_deletes_character = FALSE;
+
+ gtk_text_iter_backward_cursor_position (&start);
+
+ if (gtk_text_iter_equal (&start, &end))
+ return FALSE;
+
+ cluster_text = gtk_text_iter_get_text (&start, &end);
+
+ if (interactive)
+ gtk_text_buffer_begin_user_action (buffer);
+
+ if (gtk_text_buffer_delete_interactive (buffer, &start, &end,
+ default_editable))
+ {
+ if (backspace_deletes_character)
+ {
+ gchar *normalized_text = g_utf8_normalize (cluster_text,
+ strlen (cluster_text),
+ G_NORMALIZE_NFD);
+ glong len = g_utf8_strlen (normalized_text, -1);
+
+ if (len > 1)
+ gtk_text_buffer_insert_interactive (buffer,
+ &start,
+ normalized_text,
+ g_utf8_offset_to_pointer (normalized_text, len - 1) - normalized_text,
+ default_editable);
+
+ g_free (normalized_text);
+ }
+
+ retval = TRUE;
+ }
+
+ if (interactive)
+ gtk_text_buffer_end_user_action (buffer);
+
+ g_free (cluster_text);
+
+ /* Revalidate the users iter */
+ *iter = start;
+
+ return retval;
+}
+
static void
cut_or_copy (GtkTextBuffer *buffer,
- gboolean delete_region_after,
- gboolean interactive,
- gboolean default_editable)
+ GtkClipboard *clipboard,
+ gboolean delete_region_after,
+ gboolean interactive,
+ gboolean default_editable)
{
+ GtkTextBufferPrivate *priv;
+
/* We prefer to cut the selected region between selection_bound and
* insertion point. If that region is empty, then we cut the region
* between the "anchor" and the insertion point (this is for
*/
GtkTextIter start;
GtkTextIter end;
-
- if (buffer->clipboard_contents)
- {
- g_object_unref (G_OBJECT (buffer->clipboard_contents));
- buffer->clipboard_contents = NULL;
- }
-
+
+ priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+
+ gtk_text_buffer_get_copy_target_list (buffer);
+
if (!gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
/* Let's try the anchor thing */
else
{
gtk_text_buffer_get_iter_at_mark (buffer, &end, anchor);
- gtk_text_iter_reorder (&start, &end);
+ gtk_text_iter_order (&start, &end);
}
}
if (!gtk_text_iter_equal (&start, &end))
{
- GtkClipboard *clipboard = gtk_clipboard_get (GDK_NONE);
GtkTextIter ins;
-
- buffer->clipboard_contents =
- gtk_text_buffer_new (gtk_text_buffer_get_tag_table (buffer));
+ GtkTextBuffer *contents;
- gtk_text_buffer_get_iter_at_offset (buffer->clipboard_contents,
- &ins, 0);
+ contents = create_clipboard_contents_buffer (buffer);
+
+ gtk_text_buffer_get_iter_at_offset (contents, &ins, 0);
- gtk_text_buffer_insert_range (buffer->clipboard_contents,
- &ins,
- &start,
- &end);
+ gtk_text_buffer_insert_range (contents, &ins, &start, &end);
- if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
- clipboard_get_contents_cb,
- clipboard_clear_contents_cb,
- G_OBJECT (buffer)))
- clipboard_clear_contents_cb (clipboard, buffer);
+ if (!gtk_clipboard_set_with_data (clipboard,
+ priv->copy_target_entries,
+ priv->n_copy_target_entries,
+ clipboard_get_contents_cb,
+ clipboard_clear_contents_cb,
+ contents))
+ g_object_unref (contents);
+ else
+ gtk_clipboard_set_can_store (clipboard,
+ priv->copy_target_entries + 1,
+ priv->n_copy_target_entries - 1);
if (delete_region_after)
{
/**
* gtk_text_buffer_cut_clipboard:
- * @buffer: a #GtkTextBuffer
+ * @buffer: a #GtkTextBuffer
+ * @clipboard: the #GtkClipboard object to cut to.
* @default_editable: default editability of the buffer
*
- * Copies the currently-selected text to the clipboard, then deletes
+ * Copies the currently-selected text to a clipboard, then deletes
* said text if it's editable.
*
**/
void
gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard,
gboolean default_editable)
{
gtk_text_buffer_begin_user_action (buffer);
- cut_or_copy (buffer, TRUE, TRUE, default_editable);
+ cut_or_copy (buffer, clipboard, TRUE, TRUE, default_editable);
gtk_text_buffer_end_user_action (buffer);
}
/**
* gtk_text_buffer_copy_clipboard:
* @buffer: a #GtkTextBuffer
+ * @clipboard: the #GtkClipboard object to copy to.
*
- * Copies the currently-selected text to the clipboard.
+ * Copies the currently-selected text to a clipboard.
*
**/
void
-gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer)
+gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard)
{
gtk_text_buffer_begin_user_action (buffer);
- cut_or_copy (buffer, FALSE, TRUE, TRUE);
+ cut_or_copy (buffer, clipboard, FALSE, TRUE, TRUE);
gtk_text_buffer_end_user_action (buffer);
}
if (buffer->user_action_count == 1)
{
/* Outermost nested user action begin emits the signal */
- g_signal_emit (G_OBJECT (buffer), signals[BEGIN_USER_ACTION], 0);
+ g_signal_emit (buffer, signals[BEGIN_USER_ACTION], 0);
}
}
if (buffer->user_action_count == 0)
{
/* Ended the outermost-nested user action end, so emit the signal */
- g_signal_emit (G_OBJECT (buffer), signals[END_USER_ACTION], 0);
+ g_signal_emit (buffer, signals[END_USER_ACTION], 0);
}
}
+static void
+gtk_text_buffer_free_target_lists (GtkTextBuffer *buffer)
+{
+ GtkTextBufferPrivate *priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+
+ if (priv->copy_target_list)
+ {
+ gtk_target_list_unref (priv->copy_target_list);
+ priv->copy_target_list = NULL;
+
+ gtk_target_table_free (priv->copy_target_entries,
+ priv->n_copy_target_entries);
+ priv->copy_target_entries = NULL;
+ priv->n_copy_target_entries = 0;
+ }
+
+ if (priv->paste_target_list)
+ {
+ gtk_target_list_unref (priv->paste_target_list);
+ priv->paste_target_list = NULL;
+
+ gtk_target_table_free (priv->paste_target_entries,
+ priv->n_paste_target_entries);
+ priv->paste_target_entries = NULL;
+ priv->n_paste_target_entries = 0;
+ }
+}
+
+static GtkTargetList *
+gtk_text_buffer_get_target_list (GtkTextBuffer *buffer,
+ gboolean deserializable,
+ GtkTargetEntry **entries,
+ gint *n_entries)
+{
+ GtkTargetList *target_list;
+
+ target_list = gtk_target_list_new (NULL, 0);
+
+ gtk_target_list_add (target_list,
+ gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"),
+ GTK_TARGET_SAME_APP,
+ GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS);
+
+ gtk_target_list_add_rich_text_targets (target_list,
+ GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT,
+ deserializable,
+ buffer);
+
+ gtk_target_list_add_text_targets (target_list,
+ GTK_TEXT_BUFFER_TARGET_INFO_TEXT);
+
+ *entries = gtk_target_table_new_from_list (target_list, n_entries);
+
+ return target_list;
+}
+
+/**
+ * gtk_text_buffer_get_copy_target_list:
+ * @buffer: a #GtkTextBuffer
+ *
+ * This function returns the list of targets this text buffer can
+ * provide for copying and as DND source. The targets in the list are
+ * added with %info values from the #GtkTextBufferTargetInfo enum,
+ * using gtk_target_list_add_rich_text_targets() and
+ * gtk_target_list_add_text_targets()
+ *
+ * Return value: the #GtkTargetList
+ *
+ * Since: 2.10
+ **/
+GtkTargetList *
+gtk_text_buffer_get_copy_target_list (GtkTextBuffer *buffer)
+{
+ GtkTextBufferPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
+
+ priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+
+ if (! priv->copy_target_list)
+ priv->copy_target_list =
+ gtk_text_buffer_get_target_list (buffer, FALSE,
+ &priv->copy_target_entries,
+ &priv->n_copy_target_entries);
+
+ return priv->copy_target_list;
+}
+
+/**
+ * gtk_text_buffer_get_paste_target_list:
+ * @buffer: a #GtkTextBuffer
+ *
+ * This function returns the list of targets this text buffer supports
+ * for pasting and as DND destination. The targets in the list are
+ * added with %info values from the #GtkTextBufferTargetInfo enum,
+ * using gtk_target_list_add_rich_text_targets() and
+ * gtk_target_list_add_text_targets()
+ *
+ * Return value: the #GtkTargetList
+ *
+ * Since: 2.10
+ **/
+GtkTargetList *
+gtk_text_buffer_get_paste_target_list (GtkTextBuffer *buffer)
+{
+ GtkTextBufferPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
+
+ priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+
+ if (! priv->paste_target_list)
+ priv->paste_target_list =
+ gtk_text_buffer_get_target_list (buffer, TRUE,
+ &priv->paste_target_entries,
+ &priv->n_paste_target_entries);
+
+ return priv->paste_target_list;
+}
+
/*
* Logical attribute cache
*/
gchar *paragraph;
gint char_len, byte_len;
PangoLogAttr *attrs = NULL;
- gchar *lang;
start = *iter;
end = *iter;
if (char_lenp)
*char_lenp = char_len;
- attrs = g_new (PangoLogAttr, char_len);
-
- lang = gtk_text_iter_get_language (&start);
-
+ attrs = g_new (PangoLogAttr, char_len + 1);
+
+ /* FIXME we need to follow PangoLayout and allow different language
+ * tags within the paragraph
+ */
pango_get_log_attrs (paragraph, byte_len, -1,
- lang,
- attrs);
+ gtk_text_iter_get_language (&start),
+ attrs,
+ char_len + 1);
- g_free (lang);
-
g_free (paragraph);
return attrs;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (anywhere_in_line != NULL, NULL);
- g_return_val_if_fail (!gtk_text_iter_is_end (anywhere_in_line), NULL);
+ /* special-case for empty last line in buffer */
+ if (gtk_text_iter_is_end (anywhere_in_line) &&
+ gtk_text_iter_get_line_offset (anywhere_in_line) == 0)
+ {
+ if (char_len)
+ *char_len = 0;
+ return NULL;
+ }
+
/* FIXME we also need to recompute log attrs if the language tag at
* the start of a paragraph changes
*/
return cache->entries[0].attrs;
}
+void
+_gtk_text_buffer_notify_will_remove_tag (GtkTextBuffer *buffer,
+ GtkTextTag *tag)
+{
+ /* This removes tag from the buffer, but DOESN'T emit the
+ * remove_tag signal, because we can't afford to have user
+ * code messing things up at this point; the tag MUST be removed
+ * entirely.
+ */
+ if (buffer->btree)
+ _gtk_text_btree_notify_will_remove_tag (buffer->btree, tag);
+}
+
/*
* Debug spew
*/
_gtk_text_btree_spew (get_btree (buffer));
}
-
-
-
-
+#define __GTK_TEXT_BUFFER_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff