#include "gtkclipboard.h"
#include "gtkinvisible.h"
#include "gtkmarshalers.h"
-#include "gtksignal.h"
#include "gtktextbuffer.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
-#include <string.h>
+#include "gtkintl.h"
typedef struct _ClipboardRequest ClipboardRequest;
};
enum {
- ARG_0,
- LAST_ARG
+ PROP_0,
+
+ /* Construct */
+ PROP_TAG_TABLE
};
enum {
static void remove_all_selection_clipboards (GtkTextBuffer *buffer);
static void update_selection_clipboards (GtkTextBuffer *buffer);
-static GtkObjectClass *parent_class = NULL;
+static GObjectClass *parent_class = NULL;
static guint signals[LAST_SIGNAL] = { 0 };
+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);
+
+
GType
gtk_text_buffer_get_type (void)
{
(GInstanceInitFunc) gtk_text_buffer_init
};
- our_type = g_type_register_static (G_TYPE_OBJECT,
- "GtkTextBuffer",
- &our_info,
- 0);
+ our_type = g_type_register_static (G_TYPE_OBJECT, "GtkTextBuffer",
+ &our_info, 0);
}
return our_type;
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;
+
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->remove_tag = gtk_text_buffer_real_remove_tag;
klass->changed = gtk_text_buffer_real_changed;
+ /* Construct */
+ g_object_class_install_property (object_class,
+ PROP_TAG_TABLE,
+ g_param_spec_object ("tag_table",
+ _("Tag Table"),
+ _("Text Tag Table"),
+ GTK_TYPE_TEXT_TAG_TABLE,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
signals[INSERT_TEXT] =
g_signal_new ("insert_text",
G_OBJECT_CLASS_TYPE (object_class),
G_STRUCT_OFFSET (GtkTextBufferClass, insert_text),
NULL, NULL,
_gtk_marshal_VOID__BOXED_STRING_INT,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
3,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
- GTK_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
- GTK_TYPE_INT);
+ G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
+ G_TYPE_INT);
signals[INSERT_PIXBUF] =
g_signal_new ("insert_pixbuf",
G_STRUCT_OFFSET (GtkTextBufferClass, insert_pixbuf),
NULL, NULL,
_gtk_marshal_VOID__BOXED_OBJECT,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GDK_TYPE_PIXBUF);
G_STRUCT_OFFSET (GtkTextBufferClass, insert_child_anchor),
NULL, NULL,
_gtk_marshal_VOID__BOXED_OBJECT,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_CHILD_ANCHOR);
G_STRUCT_OFFSET (GtkTextBufferClass, delete_range),
NULL, NULL,
_gtk_marshal_VOID__BOXED_BOXED,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
G_STRUCT_OFFSET (GtkTextBufferClass, changed),
NULL, NULL,
_gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
0);
signals[MODIFIED_CHANGED] =
G_STRUCT_OFFSET (GtkTextBufferClass, modified_changed),
NULL, NULL,
_gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
0);
signals[MARK_SET] =
G_STRUCT_OFFSET (GtkTextBufferClass, mark_set),
NULL, NULL,
_gtk_marshal_VOID__BOXED_OBJECT,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
2,
GTK_TYPE_TEXT_ITER,
GTK_TYPE_TEXT_MARK);
G_STRUCT_OFFSET (GtkTextBufferClass, mark_deleted),
NULL, NULL,
_gtk_marshal_VOID__OBJECT,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
1,
GTK_TYPE_TEXT_MARK);
G_STRUCT_OFFSET (GtkTextBufferClass, apply_tag),
NULL, NULL,
_gtk_marshal_VOID__OBJECT_BOXED_BOXED,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
3,
GTK_TYPE_TEXT_TAG,
GTK_TYPE_TEXT_ITER,
G_STRUCT_OFFSET (GtkTextBufferClass, remove_tag),
NULL, NULL,
_gtk_marshal_VOID__OBJECT_BOXED_BOXED,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
3,
GTK_TYPE_TEXT_TAG,
GTK_TYPE_TEXT_ITER,
G_STRUCT_OFFSET (GtkTextBufferClass, begin_user_action),
NULL, NULL,
_gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
0);
signals[END_USER_ACTION] =
G_STRUCT_OFFSET (GtkTextBufferClass, end_user_action),
NULL, NULL,
_gtk_marshal_VOID__VOID,
- GTK_TYPE_NONE,
+ G_TYPE_NONE,
0);
}
gtk_text_buffer_init (GtkTextBuffer *buffer)
{
buffer->clipboard_contents_buffers = NULL;
+ buffer->tag_table = 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;
+
+ default:
+ break;
+ }
+}
+
+static void
+gtk_text_buffer_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GtkTextBuffer *text_buffer;
+
+ text_buffer = GTK_TEXT_BUFFER (object);
+
+ switch (prop_id)
+ {
+ case PROP_TAG_TABLE:
+ g_value_set_object (value, get_table (text_buffer));
+ break;
+
+ default:
+ break;
+ }
}
/**
{
GtkTextBuffer *text_buffer;
- text_buffer = GTK_TEXT_BUFFER (g_object_new (gtk_text_buffer_get_type (), NULL));
-
- if (table)
- {
- text_buffer->tag_table = table;
+ text_buffer = g_object_new (GTK_TYPE_TEXT_BUFFER, "tag_table", table, NULL);
- g_object_ref (G_OBJECT (text_buffer->tag_table));
- }
-
return text_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;
}
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 ();
-
- return buffer->tag_table;
-}
-
static GtkTextBTree*
get_btree (GtkTextBuffer *buffer)
{
if (buffer->btree == NULL)
buffer->btree = _gtk_text_btree_new (gtk_text_buffer_get_tag_table (buffer),
- buffer);
+ buffer);
return buffer->btree;
}
_gtk_text_btree_insert (iter, text, len);
- g_signal_emit (G_OBJECT (buffer), signals[CHANGED], 0);
+ g_signal_emit (buffer, signals[CHANGED], 0);
}
static void
if (len > 0)
{
- g_signal_emit (G_OBJECT (buffer), signals[INSERT_TEXT], 0,
+ g_signal_emit (buffer, signals[INSERT_TEXT], 0,
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);
}
}
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 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_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);
}
/* may have deleted the selection... */
update_selection_clipboards (buffer);
- g_signal_emit (G_OBJECT (buffer), signals[CHANGED], 0);
+ g_signal_emit (buffer, signals[CHANGED], 0);
}
static void
gtk_text_iter_order (start, end);
- g_signal_emit (G_OBJECT (buffer),
+ g_signal_emit (buffer,
signals[DELETE_RANGE],
0,
start, end);
{
_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 (GDK_IS_PIXBUF (pixbuf));
g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
- g_signal_emit (G_OBJECT (buffer), signals[INSERT_PIXBUF], 0,
+ 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_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
**/
gtk_text_buffer_insert_child_anchor (buffer, iter, anchor);
- g_object_unref (G_OBJECT (anchor));
+ g_object_unref (anchor);
return anchor;
}
* 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);
}
/**
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);
}
/**
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,
gtk_text_buffer_place_cursor (GtkTextBuffer *buffer,
const GtkTextIter *where)
{
- GtkTextIter real;
+ gtk_text_buffer_select_range (buffer, where, 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.
+ **/
+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));
- real = *where;
+ 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"));
}
*
*
* Creates a tag and adds it to the tag table for @buffer.
- * Equivalent to calling gtk_text_tag_ne () and then adding the
+ * Equivalent to calling gtk_text_tag_new () and then adding the
* 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.
*
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);
}
* 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,
* 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,
else
{
buffer->modified = fixed_setting;
- g_signal_emit (G_OBJECT (buffer), signals[MODIFIED_CHANGED], 0);
+ g_signal_emit (buffer, signals[MODIFIED_CHANGED], 0);
}
}
guint info,
gpointer data)
{
- GtkTextBuffer *buffer = GTK_TEXT_BUFFER (data);
- GtkTextBuffer *contents = get_clipboard_contents_buffer (buffer, clipboard, FALSE);
+ GtkTextBuffer *buffer;
+ GtkTextBuffer *contents;
+ buffer = GTK_TEXT_BUFFER (data);
+ contents = get_clipboard_contents_buffer (buffer, clipboard, FALSE);
+
g_assert (contents); /* This should never be called unless we own the clipboard */
if (selection_data->target ==
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_object_unref (buffer);
g_free (request_data);
}
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 (gdk_window_get_window_type (owner) == GDK_WINDOW_FOREIGN)
+ return NULL;
+
if (selection_data->type != gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE))
return NULL;
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);
+ g_free (request_data);
}
static void
override_location, FALSE);
data->buffer = buffer;
- g_object_ref (G_OBJECT (buffer));
+ g_object_ref (buffer);
data->interactive = TRUE;
data->default_editable = default_editable;
*/
GtkTextIter start;
GtkTextIter end;
-
- remove_clipboard_contents_buffer (buffer, clipboard);
if (!gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
{
{
GtkTextIter ins;
GtkTextBuffer *contents;
-
+
+ remove_clipboard_contents_buffer (buffer, clipboard);
contents = get_clipboard_contents_buffer (buffer, clipboard, TRUE);
gtk_text_buffer_get_iter_at_offset (contents, &ins, 0);
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);
}
}
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));
}
-
-
-
-
-
projects / ~andy / gtk / blobdiff