* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
#include "gtktextbufferrichtext.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
+#include "gtktexttagprivate.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))
+/**
+ * SECTION:gtktextbuffer
+ * @Short_description: Stores attributed text for display in a GtkTextView
+ * @Title: GtkTextBuffer
+ * @See_also: #GtkTextView, #GtkTextIter, #GtkTextMark
+ *
+ * You may wish to begin by reading the <link linkend="TextWidget">text widget
+ * conceptual overview</link> which gives an overview of all the objects and data
+ * types related to the text widget and how they work together.
+ */
-typedef struct _GtkTextBufferPrivate GtkTextBufferPrivate;
+
+typedef struct _GtkTextLogAttrCache GtkTextLogAttrCache;
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_copy_target_entries;
gint n_paste_target_entries;
+
+ GtkTextTagTable *tag_table;
+ GtkTextBTree *btree;
+
+ GSList *clipboard_contents_buffers;
+ GSList *selection_clipboards;
+
+ GtkTextLogAttrCache *log_attr_cache;
+
+ guint user_action_count;
+
+ /* Whether the buffer has been modified since last save */
+ guint modified : 1;
+ guint has_selection : 1;
};
struct _ClipboardRequest
{
GtkTextBuffer *buffer;
- gboolean interactive;
- gboolean default_editable;
- gboolean is_clipboard;
- gboolean replace_selection;
+ guint interactive : 1;
+ guint default_editable : 1;
+ guint replace_selection : 1;
};
enum {
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_INT);
+ g_signal_set_va_marshaller (signals[INSERT_TEXT], G_TYPE_FROM_CLASS (klass),
+ _gtk_marshal_VOID__BOXED_STRING_INTv);
/**
* GtkTextBuffer::insert-pixbuf:
static void
gtk_text_buffer_init (GtkTextBuffer *buffer)
{
- buffer->clipboard_contents_buffers = NULL;
- buffer->tag_table = NULL;
+ buffer->priv = G_TYPE_INSTANCE_GET_PRIVATE (buffer,
+ GTK_TYPE_TEXT_BUFFER,
+ GtkTextBufferPrivate);
+
+ buffer->priv->clipboard_contents_buffers = NULL;
+ buffer->priv->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);
+ GtkTextBufferPrivate *priv = buffer->priv;
+
+ g_return_if_fail (priv->tag_table == NULL);
if (table)
{
- buffer->tag_table = table;
- g_object_ref (buffer->tag_table);
+ priv->tag_table = table;
+ g_object_ref (priv->tag_table);
_gtk_text_tag_table_add_buffer (table, buffer);
}
}
static GtkTextTagTable*
get_table (GtkTextBuffer *buffer)
{
- if (buffer->tag_table == NULL)
+ GtkTextBufferPrivate *priv = buffer->priv;
+
+ if (priv->tag_table == NULL)
{
- buffer->tag_table = gtk_text_tag_table_new ();
- _gtk_text_tag_table_add_buffer (buffer->tag_table, buffer);
+ priv->tag_table = gtk_text_tag_table_new ();
+ _gtk_text_tag_table_add_buffer (priv->tag_table, buffer);
}
- return buffer->tag_table;
+ return priv->tag_table;
}
static void
}
case PROP_HAS_SELECTION:
- g_value_set_boolean (value, text_buffer->has_selection);
+ g_value_set_boolean (value, text_buffer->priv->has_selection);
break;
case PROP_CURSOR_POSITION:
gtk_text_buffer_finalize (GObject *object)
{
GtkTextBuffer *buffer;
+ GtkTextBufferPrivate *priv;
buffer = GTK_TEXT_BUFFER (object);
+ priv = buffer->priv;
remove_all_selection_clipboards (buffer);
- if (buffer->tag_table)
+ if (priv->tag_table)
{
- _gtk_text_tag_table_remove_buffer (buffer->tag_table, buffer);
- g_object_unref (buffer->tag_table);
- buffer->tag_table = NULL;
+ _gtk_text_tag_table_remove_buffer (priv->tag_table, buffer);
+ g_object_unref (priv->tag_table);
+ priv->tag_table = NULL;
}
- if (buffer->btree)
+ if (priv->btree)
{
- _gtk_text_btree_unref (buffer->btree);
- buffer->btree = NULL;
+ _gtk_text_btree_unref (priv->btree);
+ priv->btree = NULL;
}
- if (buffer->log_attr_cache)
- free_log_attr_cache (buffer->log_attr_cache);
+ if (priv->log_attr_cache)
+ free_log_attr_cache (priv->log_attr_cache);
- buffer->log_attr_cache = NULL;
+ priv->log_attr_cache = NULL;
gtk_text_buffer_free_target_lists (buffer);
static GtkTextBTree*
get_btree (GtkTextBuffer *buffer)
{
- if (buffer->btree == NULL)
- buffer->btree = _gtk_text_btree_new (gtk_text_buffer_get_tag_table (buffer),
- buffer);
+ GtkTextBufferPrivate *priv = buffer->priv;
+
+ if (priv->btree == NULL)
+ priv->btree = _gtk_text_btree_new (gtk_text_buffer_get_tag_table (buffer),
+ buffer);
- return buffer->btree;
+ return priv->btree;
}
GtkTextBTree*
* gtk_text_buffer_insert:
* @buffer: a #GtkTextBuffer
* @iter: a position in the buffer
- * @text: UTF-8 format text to insert
+ * @text: text in UTF-8 format
* @len: length of text in bytes, or -1
*
* Inserts @len bytes of @text at position @iter. If @len is -1,
/**
* gtk_text_buffer_insert_at_cursor:
* @buffer: a #GtkTextBuffer
- * @text: some text in UTF-8 format
+ * @text: text in UTF-8 format
* @len: length of text, in bytes
*
* Simply calls gtk_text_buffer_insert(), using the current
g_return_if_fail (end != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (start) ==
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 (start)->priv->tag_table ==
+ buffer->priv->tag_table);
g_return_if_fail (gtk_text_iter_get_buffer (iter) == buffer);
gtk_text_buffer_real_insert_range (buffer, iter, start, end, FALSE);
g_return_val_if_fail (end != NULL, FALSE);
g_return_val_if_fail (gtk_text_iter_get_buffer (start) ==
gtk_text_iter_get_buffer (end), FALSE);
- g_return_val_if_fail (gtk_text_iter_get_buffer (start)->tag_table ==
- buffer->tag_table, FALSE);
+ g_return_val_if_fail (gtk_text_iter_get_buffer (start)->priv->tag_table ==
+ buffer->priv->tag_table, FALSE);
if (gtk_text_iter_can_insert (iter, default_editable))
{
* @text: UTF-8 text
* @len: length of @text, or -1
* @first_tag: first tag to apply to @text
- * @Varargs: NULL-terminated list of tags to apply
+ * @...: %NULL-terminated list of tags to apply
*
* Inserts @text into @buffer at @iter, applying the list of tags to
- * the newly-inserted text. The last tag specified must be NULL to
+ * the newly-inserted text. The last tag specified must be %NULL to
* terminate the list. Equivalent to calling gtk_text_buffer_insert(),
* then gtk_text_buffer_apply_tag() on the inserted text;
* gtk_text_buffer_insert_with_tags() is just a convenience function.
* @text: UTF-8 text
* @len: length of @text, or -1
* @first_tag_name: name of a tag to apply to @text
- * @Varargs: more tag names
+ * @...: more tag names
*
* Same as gtk_text_buffer_insert_with_tags(), but allows you
* to pass in tag names instead of tag objects.
{
GtkTextTag *tag;
- tag = gtk_text_tag_table_lookup (buffer->tag_table,
+ tag = gtk_text_tag_table_lookup (buffer->priv->tag_table,
tag_name);
if (tag == NULL)
update_selection_clipboards (buffer);
has_selection = gtk_text_buffer_get_selection_bounds (buffer, NULL, NULL);
- if (has_selection != buffer->has_selection)
+ if (has_selection != buffer->priv->has_selection)
{
- buffer->has_selection = has_selection;
+ buffer->priv->has_selection = has_selection;
g_object_notify (G_OBJECT (buffer), "has-selection");
}
* 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
+ * Return value: (transfer none): the created child anchor
**/
GtkTextChildAnchor*
gtk_text_buffer_create_child_anchor (GtkTextBuffer *buffer,
/**
* gtk_text_buffer_get_iter_at_mark:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): iterator to initialize
+ * @iter: (out): iterator to initialize
* @mark: a #GtkTextMark in @buffer
*
* Initializes @iter with the current position of @mark.
/**
* gtk_text_buffer_get_iter_at_child_anchor:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): an iterator to be initialized
+ * @iter: (out): an iterator to be initialized
* @anchor: a child anchor that appears in @buffer
*
* Obtains the location of @anchor within @buffer.
* @buffer: a #GtkTextBuffer
* @tag_name: (allow-none): name of the new tag, or %NULL
* @first_property_name: (allow-none): name of first property to set, or %NULL
- * @Varargs: %NULL-terminated list of property names and values
- *
+ * @...: %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
* 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
- **/
+ * Return value: (transfer none): a new tag
+ */
GtkTextTag*
gtk_text_buffer_create_tag (GtkTextBuffer *buffer,
const gchar *tag_name,
const GtkTextIter *start,
const GtkTextIter *end)
{
- if (tag->table != buffer->tag_table)
+ if (tag->priv->table != buffer->priv->tag_table)
{
g_warning ("Can only apply tags that are in the tag table for the buffer");
return;
const GtkTextIter *start,
const GtkTextIter *end)
{
- if (tag->table != buffer->tag_table)
+ if (tag->priv->table != buffer->priv->tag_table)
{
g_warning ("Can only remove tags that are in the tag table for the buffer");
return;
NULL,
NULL);
- if (has_selection != buffer->has_selection)
+ if (has_selection != buffer->priv->has_selection)
{
- buffer->has_selection = has_selection;
+ buffer->priv->has_selection = has_selection;
g_object_notify (G_OBJECT (buffer), "has-selection");
}
}
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);
+ g_return_if_fail (tag->priv->table == buffer->priv->tag_table);
gtk_text_buffer_emit_tag (buffer, tag, TRUE, start, end);
}
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);
+ g_return_if_fail (tag->priv->table == buffer->priv->tag_table);
gtk_text_buffer_emit_tag (buffer, tag, FALSE, start, end);
}
/**
* gtk_text_buffer_get_iter_at_line_offset:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): iterator to initialize
+ * @iter: (out): iterator to initialize
* @line_number: line number counting from 0
* @char_offset: char offset from start of line
*
/**
* gtk_text_buffer_get_iter_at_line_index:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): iterator to initialize
+ * @iter: (out): iterator to initialize
* @line_number: line number counting from 0
* @byte_index: byte index from start of line
*
/**
* gtk_text_buffer_get_iter_at_line:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): iterator to initialize
+ * @iter: (out): iterator to initialize
* @line_number: line number counting from 0
*
* Initializes @iter to the start of the given line.
/**
* gtk_text_buffer_get_iter_at_offset:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): iterator to initialize
+ * @iter: (out): iterator to initialize
* @char_offset: char offset from start of buffer, counting from 0, or -1
*
* Initializes @iter to a position @char_offset chars from the start
/**
* gtk_text_buffer_get_start_iter:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): iterator to initialize
+ * @iter: (out): 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
/**
* gtk_text_buffer_get_end_iter:
* @buffer: a #GtkTextBuffer
- * @iter: (out caller-allocates): iterator to initialize
+ * @iter: (out): iterator to initialize
*
* Initializes @iter with the "end iterator," one past the last valid
* character in the text buffer. If dereferenced with
/**
* gtk_text_buffer_get_bounds:
* @buffer: a #GtkTextBuffer
- * @start: (out caller-allocates): iterator to initialize with first position in the buffer
- * @end: (out caller-allocates): iterator to initialize with the end iterator
+ * @start: (out): iterator to initialize with first position in the buffer
+ * @end: (out): iterator to initialize with the end iterator
*
* Retrieves the first and last iterators in the buffer, i.e. the
* entire buffer lies within the range [@start,@end).
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
- return buffer->modified;
+ return buffer->priv->modified;
}
/**
fixed_setting = setting != FALSE;
- if (buffer->modified == fixed_setting)
+ if (buffer->priv->modified == fixed_setting)
return;
else
{
- buffer->modified = fixed_setting;
+ buffer->priv->modified = fixed_setting;
g_signal_emit (buffer, signals[MODIFIED_CHANGED], 0);
}
}
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
- return buffer->has_selection;
+ return buffer->priv->has_selection;
}
* used within-process
*/
gtk_selection_data_set (selection_data,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
8, /* bytes */
(void*)&buffer,
sizeof (buffer));
gsize len;
str = gtk_text_buffer_serialize (buffer, buffer,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
&start, &end, &len);
gtk_selection_data_set (selection_data,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
8, /* bytes */
str, len);
g_free (str);
* be used within-process. OK to supply a NULL value for contents.
*/
gtk_selection_data_set (selection_data,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
8, /* bytes */
(void*)&contents,
sizeof (contents));
gtk_text_buffer_get_bounds (contents, &start, &end);
str = gtk_text_buffer_serialize (clipboard_source_buffer, contents,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
&start, &end, &len);
gtk_selection_data_set (selection_data,
- selection_data->target,
+ gtk_selection_data_get_target (selection_data),
8, /* bytes */
str, len);
g_free (str);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_point,
paste_point_override);
if (clear_afterward)
- gtk_text_buffer_delete_mark (buffer,
- gtk_text_buffer_get_mark (buffer,
- "gtk_paste_point_override"));
+ gtk_text_buffer_delete_mark (buffer, paste_point_override);
}
else
{
emit_paste_done (buffer, clipboard);
}
+ else
+ {
+ /* It may happen that we set a point override but we are not inserting
+ any text, so we must remove it afterwards */
+ GtkTextMark *paste_point_override;
+
+ paste_point_override = gtk_text_buffer_get_mark (buffer,
+ "gtk_paste_point_override");
+
+ if (paste_point_override != NULL)
+ gtk_text_buffer_delete_mark (buffer, paste_point_override);
+ }
free_clipboard_request (request_data);
}
GtkTextBuffer *src_buffer = NULL;
/* If we can get the owner, the selection is in-process */
- owner = gdk_selection_owner_get_for_display (selection_data->display,
- selection_data->selection);
+ owner = gdk_selection_owner_get_for_display (gtk_selection_data_get_display (selection_data),
+ gtk_selection_data_get_selection (selection_data));
if (owner == NULL)
return NULL;
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"))
+
+ if (gtk_selection_data_get_data_type (selection_data) != gdk_atom_intern_static_string ("GTK_TEXT_BUFFER_CONTENTS"))
return NULL;
- if (selection_data->length != sizeof (src_buffer))
+ if (gtk_selection_data_get_length (selection_data) != sizeof (src_buffer))
return NULL;
-
- memcpy (&src_buffer, selection_data->data, sizeof (src_buffer));
+
+ memcpy (&src_buffer, gtk_selection_data_get_data (selection_data), sizeof (src_buffer));
if (src_buffer == NULL)
return NULL;
update_selection_clipboards (GtkTextBuffer *buffer)
{
GtkTextBufferPrivate *priv;
- GSList *tmp_list = buffer->selection_clipboards;
+ GSList *tmp_list = buffer->priv->selection_clipboards;
- priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+ priv = buffer->priv;
gtk_text_buffer_get_copy_target_list (buffer);
find_selection_clipboard (GtkTextBuffer *buffer,
GtkClipboard *clipboard)
{
- GSList *tmp_list = buffer->selection_clipboards;
+ GSList *tmp_list = buffer->priv->selection_clipboards;
while (tmp_list)
{
SelectionClipboard *selection_clipboard = tmp_list->data;
selection_clipboard->clipboard = clipboard;
selection_clipboard->ref_count = 1;
- buffer->selection_clipboards = g_slist_prepend (buffer->selection_clipboards, selection_clipboard);
+ buffer->priv->selection_clipboards = g_slist_prepend (buffer->priv->selection_clipboards,
+ selection_clipboard);
}
}
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);
+ buffer->priv->selection_clipboards = g_slist_remove (buffer->priv->selection_clipboards,
+ selection_clipboard);
g_free (selection_clipboard);
}
static void
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;
+ GtkTextBufferPrivate *priv = buffer->priv;
+
+ g_slist_foreach (priv->selection_clipboards, (GFunc)g_free, NULL);
+ g_slist_free (priv->selection_clipboards);
+ priv->selection_clipboards = NULL;
}
/**
* 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.)
+ * 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,
data->buffer = g_object_ref (buffer);
data->interactive = TRUE;
- data->default_editable = default_editable;
+ data->default_editable = !!default_editable;
/* When pasting with the cursor inside the selection area, you
* replace the selection with the new text, otherwise, you
GtkTextIter start;
GtkTextIter end;
- priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+ priv = buffer->priv;
gtk_text_buffer_get_copy_target_list (buffer);
/**
* gtk_text_buffer_get_selection_bounds:
* @buffer: a #GtkTextBuffer a #GtkTextBuffer
- * @start: iterator to initialize with selection start
- * @end: iterator to initialize with selection end
+ * @start: (out): iterator to initialize with selection start
+ * @end: (out): iterator to initialize with selection end
*
* Returns %TRUE if some text is selected; places the bounds
* of the selection in @start and @end (if the selection has length 0,
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- buffer->user_action_count += 1;
+ buffer->priv->user_action_count += 1;
- if (buffer->user_action_count == 1)
+ if (buffer->priv->user_action_count == 1)
{
/* Outermost nested user action begin emits the signal */
g_signal_emit (buffer, signals[BEGIN_USER_ACTION], 0);
gtk_text_buffer_end_user_action (GtkTextBuffer *buffer)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- g_return_if_fail (buffer->user_action_count > 0);
+ g_return_if_fail (buffer->priv->user_action_count > 0);
- buffer->user_action_count -= 1;
+ buffer->priv->user_action_count -= 1;
- if (buffer->user_action_count == 0)
+ if (buffer->priv->user_action_count == 0)
{
/* Ended the outermost-nested user action end, so emit the signal */
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);
+ GtkTextBufferPrivate *priv = buffer->priv;
if (priv->copy_target_list)
{
* using gtk_target_list_add_rich_text_targets() and
* gtk_target_list_add_text_targets().
*
- * Return value: the #GtkTargetList
+ * Return value: (transfer none): the #GtkTargetList
*
* Since: 2.10
**/
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
- priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+ priv = buffer->priv;
if (! priv->copy_target_list)
priv->copy_target_list =
* using gtk_target_list_add_rich_text_targets() and
* gtk_target_list_add_text_targets().
*
- * Return value: the #GtkTargetList
+ * Return value: (transfer none): the #GtkTargetList
*
* Since: 2.10
**/
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
- priv = GTK_TEXT_BUFFER_GET_PRIVATE (buffer);
+ priv = buffer->priv;
if (! priv->paste_target_list)
priv->paste_target_list =
const GtkTextIter *anywhere_in_line,
gint *char_len)
{
+ GtkTextBufferPrivate *priv;
gint line;
GtkTextLogAttrCache *cache;
gint i;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (anywhere_in_line != NULL, NULL);
+ priv = buffer->priv;
+
/* 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)
* the start of a paragraph changes
*/
- if (buffer->log_attr_cache == NULL)
+ if (priv->log_attr_cache == NULL)
{
- buffer->log_attr_cache = g_new0 (GtkTextLogAttrCache, 1);
- buffer->log_attr_cache->chars_changed_stamp =
+ priv->log_attr_cache = g_new0 (GtkTextLogAttrCache, 1);
+ priv->log_attr_cache->chars_changed_stamp =
_gtk_text_btree_get_chars_changed_stamp (get_btree (buffer));
}
- else if (buffer->log_attr_cache->chars_changed_stamp !=
+ else if (priv->log_attr_cache->chars_changed_stamp !=
_gtk_text_btree_get_chars_changed_stamp (get_btree (buffer)))
{
- clear_log_attr_cache (buffer->log_attr_cache);
+ clear_log_attr_cache (priv->log_attr_cache);
}
- cache = buffer->log_attr_cache;
+ cache = priv->log_attr_cache;
line = gtk_text_iter_get_line (anywhere_in_line);
i = 0;
* 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);
+ if (buffer->priv->btree)
+ _gtk_text_btree_notify_will_remove_tag (buffer->priv->btree, tag);
}
/*
_gtk_text_btree_spew (get_btree (buffer));
}
-#define __GTK_TEXT_BUFFER_C__
-#include "gtkaliasdef.c"
+void
+_gtk_text_buffer_get_text_before (GtkTextBuffer *buffer,
+ AtkTextBoundary boundary_type,
+ GtkTextIter *position,
+ GtkTextIter *start,
+ GtkTextIter *end)
+{
+ gint line_number;
+
+ *start = *position;
+ *end = *start;
+
+ switch (boundary_type)
+ {
+ case ATK_TEXT_BOUNDARY_CHAR:
+ gtk_text_iter_backward_char (start);
+ break;
+
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ if (!gtk_text_iter_starts_word (start))
+ gtk_text_iter_backward_word_start (start);
+ *end = *start;
+ gtk_text_iter_backward_word_start (start);
+ break;
+
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ if (gtk_text_iter_inside_word (start) &&
+ !gtk_text_iter_starts_word (start))
+ gtk_text_iter_backward_word_start (start);
+ while (!gtk_text_iter_ends_word (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ *end = *start;
+ gtk_text_iter_backward_word_start (start);
+ while (!gtk_text_iter_ends_word (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ break;
+
+ case ATK_TEXT_BOUNDARY_SENTENCE_START:
+ if (!gtk_text_iter_starts_sentence (start))
+ gtk_text_iter_backward_sentence_start (start);
+ *end = *start;
+ gtk_text_iter_backward_sentence_start (start);
+ break;
+
+ case ATK_TEXT_BOUNDARY_SENTENCE_END:
+ if (gtk_text_iter_inside_sentence (start) &&
+ !gtk_text_iter_starts_sentence (start))
+ gtk_text_iter_backward_sentence_start (start);
+ while (!gtk_text_iter_ends_sentence (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ *end = *start;
+ gtk_text_iter_backward_sentence_start (start);
+ while (!gtk_text_iter_ends_sentence (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ break;
+
+ case ATK_TEXT_BOUNDARY_LINE_START:
+ line_number = gtk_text_iter_get_line (start);
+ if (line_number == 0)
+ {
+ gtk_text_buffer_get_iter_at_offset (buffer, start, 0);
+ }
+ else
+ {
+ gtk_text_iter_backward_line (start);
+ gtk_text_iter_forward_line (start);
+ }
+ *end = *start;
+ gtk_text_iter_backward_line (start);
+ break;
+
+ case ATK_TEXT_BOUNDARY_LINE_END:
+ line_number = gtk_text_iter_get_line (start);
+ if (line_number == 0)
+ {
+ gtk_text_buffer_get_iter_at_offset (buffer, start, 0);
+ *end = *start;
+ }
+ else
+ {
+ gtk_text_iter_backward_line (start);
+ *end = *start;
+ while (!gtk_text_iter_ends_line (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ gtk_text_iter_forward_to_line_end (end);
+ }
+ break;
+ }
+}
+
+void
+_gtk_text_buffer_get_text_at (GtkTextBuffer *buffer,
+ AtkTextBoundary boundary_type,
+ GtkTextIter *position,
+ GtkTextIter *start,
+ GtkTextIter *end)
+{
+ gint line_number;
+
+ *start = *position;
+ *end = *start;
+
+ switch (boundary_type)
+ {
+ case ATK_TEXT_BOUNDARY_CHAR:
+ gtk_text_iter_forward_char (end);
+ break;
+
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ if (!gtk_text_iter_starts_word (start))
+ gtk_text_iter_backward_word_start (start);
+ if (gtk_text_iter_inside_word (end))
+ gtk_text_iter_forward_word_end (end);
+ while (!gtk_text_iter_starts_word (end))
+ {
+ if (!gtk_text_iter_forward_char (end))
+ break;
+ }
+ break;
+
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ if (gtk_text_iter_inside_word (start) &&
+ !gtk_text_iter_starts_word (start))
+ gtk_text_iter_backward_word_start (start);
+ while (!gtk_text_iter_ends_word (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ gtk_text_iter_forward_word_end (end);
+ break;
+
+ case ATK_TEXT_BOUNDARY_SENTENCE_START:
+ if (!gtk_text_iter_starts_sentence (start))
+ gtk_text_iter_backward_sentence_start (start);
+ if (gtk_text_iter_inside_sentence (end))
+ gtk_text_iter_forward_sentence_end (end);
+ while (!gtk_text_iter_starts_sentence (end))
+ {
+ if (!gtk_text_iter_forward_char (end))
+ break;
+ }
+ break;
+
+ case ATK_TEXT_BOUNDARY_SENTENCE_END:
+ if (gtk_text_iter_inside_sentence (start) &&
+ !gtk_text_iter_starts_sentence (start))
+ gtk_text_iter_backward_sentence_start (start);
+ while (!gtk_text_iter_ends_sentence (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ gtk_text_iter_forward_sentence_end (end);
+ break;
+
+ case ATK_TEXT_BOUNDARY_LINE_START:
+ line_number = gtk_text_iter_get_line (start);
+ if (line_number == 0)
+ {
+ gtk_text_buffer_get_iter_at_offset (buffer, start, 0);
+ }
+ else
+ {
+ gtk_text_iter_backward_line (start);
+ gtk_text_iter_forward_line (start);
+ }
+ gtk_text_iter_forward_line (end);
+ break;
+
+ case ATK_TEXT_BOUNDARY_LINE_END:
+ line_number = gtk_text_iter_get_line (start);
+ if (line_number == 0)
+ {
+ gtk_text_buffer_get_iter_at_offset (buffer, start, 0);
+ }
+ else
+ {
+ gtk_text_iter_backward_line (start);
+ gtk_text_iter_forward_line (start);
+ }
+ while (!gtk_text_iter_ends_line (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ gtk_text_iter_forward_to_line_end (end);
+ break;
+ }
+}
+
+void
+_gtk_text_buffer_get_text_after (GtkTextBuffer *buffer,
+ AtkTextBoundary boundary_type,
+ GtkTextIter *position,
+ GtkTextIter *start,
+ GtkTextIter *end)
+{
+ *start = *position;
+ *end = *start;
+
+ switch (boundary_type)
+ {
+ case ATK_TEXT_BOUNDARY_CHAR:
+ gtk_text_iter_forward_char (start);
+ gtk_text_iter_forward_chars (end, 2);
+ break;
+
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ if (gtk_text_iter_inside_word (end))
+ gtk_text_iter_forward_word_end (end);
+ while (!gtk_text_iter_starts_word (end))
+ {
+ if (!gtk_text_iter_forward_char (end))
+ break;
+ }
+ *start = *end;
+ if (!gtk_text_iter_is_end (end))
+ {
+ gtk_text_iter_forward_word_end (end);
+ while (!gtk_text_iter_starts_word (end))
+ {
+ if (!gtk_text_iter_forward_char (end))
+ break;
+ }
+ }
+ break;
+
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ gtk_text_iter_forward_word_end (end);
+ *start = *end;
+ if (!gtk_text_iter_is_end (end))
+ gtk_text_iter_forward_word_end (end);
+ break;
+
+ case ATK_TEXT_BOUNDARY_SENTENCE_START:
+ if (gtk_text_iter_inside_sentence (end))
+ gtk_text_iter_forward_sentence_end (end);
+ while (!gtk_text_iter_starts_sentence (end))
+ {
+ if (!gtk_text_iter_forward_char (end))
+ break;
+ }
+ *start = *end;
+ if (!gtk_text_iter_is_end (end))
+ {
+ gtk_text_iter_forward_sentence_end (end);
+ while (!gtk_text_iter_starts_sentence (end))
+ {
+ if (!gtk_text_iter_forward_char (end))
+ break;
+ }
+ }
+ break;
+
+ case ATK_TEXT_BOUNDARY_SENTENCE_END:
+ gtk_text_iter_forward_sentence_end (end);
+ *start = *end;
+ if (!gtk_text_iter_is_end (end))
+ gtk_text_iter_forward_sentence_end (end);
+ break;
+
+ case ATK_TEXT_BOUNDARY_LINE_START:
+ gtk_text_iter_forward_line (end);
+ *start = *end;
+ gtk_text_iter_forward_line (end);
+ break;
+
+ case ATK_TEXT_BOUNDARY_LINE_END:
+ gtk_text_iter_forward_line (start);
+ *end = *start;
+ if (!gtk_text_iter_is_end (start))
+ {
+ while (!gtk_text_iter_ends_line (start))
+ {
+ if (!gtk_text_iter_backward_char (start))
+ break;
+ }
+ gtk_text_iter_forward_to_line_end (end);
+ }
+ break;
+ }
+}
projects / ~andy / gtk / blobdiff