/*
- * gtktextbtree.c --
+ * Gtktextbtree.c --
*
* This file contains code that manages the B-tree representation
* of text for the text buffer and implements character and
* California, Sun Microsystems, Inc., and other parties. The
* following terms apply to all files associated with the software
* unless explicitly disclaimed in individual files.
- *
+ *
* The authors hereby grant permission to use, copy, modify,
* distribute, and license this software and its documentation for any
* purpose, provided that existing copyright notices are retained in
* software may be copyrighted by their authors and need not follow
* the licensing terms described here, provided that the new terms are
* clearly indicated on the first page of each file where they apply.
- *
+ *
* IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY
* PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
* DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION,
* OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
- *
+ *
* THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
* foregoing, the authors grant the U.S. Government and others acting
* in its behalf permission to use and distribute the software in
* accordance with the terms specified in this license.
- *
+ *
*/
+#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
+#include "config.h"
#include "gtktextbtree.h"
#include <string.h>
-#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
-#include "gtksignal.h"
#include "gtktexttag.h"
+#include "gtktexttagprivate.h"
#include "gtktexttagtable.h"
#include "gtktextlayout.h"
#include "gtktextiterprivate.h"
/*
* The structure below is used to pass information between
- * gtk_text_btree_get_tags and inc_count:
+ * _gtk_text_btree_get_tags and inc_count:
*/
typedef struct TagInfo {
/* Height and width of this node */
gint height;
- gint width : 24;
-
- /* boolean indicating whether the height/width need to be recomputed */
- gint valid : 8;
+ signed int width : 24;
+
+ /* boolean indicating whether the lines below this node are in need of validation.
+ * However, width/height should always represent the current total width and
+ * max height for lines below this node; the valid flag indicates whether the
+ * width/height on the lines needs recomputing, not whether the totals
+ * need recomputing.
+ */
+ guint valid : 8; /* Actually a boolean */
};
int level; /* Level of this node in the B-tree.
* 0 refers to the bottom of the tree
* (children are lines, not nodes). */
+ int num_lines; /* Total number of lines (leaves) in
+ * the subtree rooted here. */
+ int num_chars; /* Number of chars below here */
+ int num_children; /* Number of children of this node. */
union { /* First in linked list of children. */
struct _GtkTextBTreeNode *node; /* Used if level > 0. */
GtkTextLine *line; /* Used if level == 0. */
} children;
- int num_children; /* Number of children of this node. */
- int num_lines; /* Total number of lines (leaves) in
- * the subtree rooted here. */
- int num_chars; /* Number of chars below here */
NodeData *node_data;
};
GtkTextTagTable *table;
GHashTable *mark_table;
guint refcount;
- GtkTextLineSegment *insert_mark;
- GtkTextLineSegment *selection_bound_mark;
+ GtkTextMark *insert_mark;
+ GtkTextMark *selection_bound_mark;
GtkTextBuffer *buffer;
BTreeView *views;
GSList *tag_infos;
- guint tag_changed_handler;
- guint tag_removed_handler;
+ gulong tag_changed_handler;
+
/* Incremented when a segment with a byte size > 0
- is added to or removed from the tree (i.e. the
- length of a line may have changed, and lines may
- have been added or removed). This invalidates
- all outstanding iterators.
- */
+ * is added to or removed from the tree (i.e. the
+ * length of a line may have changed, and lines may
+ * have been added or removed). This invalidates
+ * all outstanding iterators.
+ */
guint chars_changed_stamp;
/* Incremented when any segments are added or deleted;
- this makes outstanding iterators recalculate their
- pointed-to segment and segment offset.
- */
+ * this makes outstanding iterators recalculate their
+ * pointed-to segment and segment offset.
+ */
guint segments_changed_stamp;
+ /* Cache the last line in the buffer */
+ GtkTextLine *last_line;
+ guint last_line_stamp;
+
+ /* Cache the next-to-last line in the buffer,
+ * containing the end iterator
+ */
GtkTextLine *end_iter_line;
-
+ GtkTextLineSegment *end_iter_segment;
+ int end_iter_segment_byte_index;
+ int end_iter_segment_char_offset;
guint end_iter_line_stamp;
+ guint end_iter_segment_stamp;
+
+ GHashTable *child_anchor_table;
};
guess this may increase memory use though, and make it slower to
walk the tree in order, or locate a particular byte index (which
is done by walking the tree in order).
-
+
There's basically a tradeoff here. However I'm thinking we want to
add pixels, byte counts, and char counts to the tree nodes,
at that point narrow and deep should speed up all operations,
gpointer view_id);
static GtkTextBTreeNode *gtk_text_btree_node_new (void);
+#if 0
static void gtk_text_btree_node_invalidate_downward (GtkTextBTreeNode *node);
+#endif
static void gtk_text_btree_node_invalidate_upward (GtkTextBTreeNode *node,
- gpointer view_id);
+ gpointer view_id);
static NodeData * gtk_text_btree_node_check_valid (GtkTextBTreeNode *node,
- gpointer view_id);
+ gpointer view_id);
static NodeData * gtk_text_btree_node_check_valid_downward (GtkTextBTreeNode *node,
- gpointer view_id);
+ gpointer view_id);
static void gtk_text_btree_node_check_valid_upward (GtkTextBTreeNode *node,
- gpointer view_id);
+ gpointer view_id);
static void gtk_text_btree_node_remove_view (BTreeView *view,
GtkTextBTreeNode *node,
gpointer view_id);
static void gtk_text_btree_node_destroy (GtkTextBTree *tree,
GtkTextBTreeNode *node);
+static void gtk_text_btree_node_free_empty (GtkTextBTree *tree,
+ GtkTextBTreeNode *node);
static NodeData * gtk_text_btree_node_ensure_data (GtkTextBTreeNode *node,
gpointer view_id);
static void gtk_text_btree_node_remove_data (GtkTextBTreeNode *node,
gint *width,
gint *height);
static GtkTextBTreeNode * gtk_text_btree_node_common_parent (GtkTextBTreeNode *node1,
- GtkTextBTreeNode *node2);
+ GtkTextBTreeNode *node2);
static void get_tree_bounds (GtkTextBTree *tree,
GtkTextIter *start,
GtkTextIter *end);
GtkTextTag *tag,
gboolean size_changed,
GtkTextBTree *tree);
-static void tag_removed_cb (GtkTextTagTable *table,
- GtkTextTag *tag,
- GtkTextBTree *tree);
static void cleanup_line (GtkTextLine *line);
static void recompute_node_counts (GtkTextBTree *tree,
- GtkTextBTreeNode *node);
+ GtkTextBTreeNode *node);
static void inc_count (GtkTextTag *tag,
int inc,
TagInfo *tagInfoPtr);
static void gtk_text_btree_remove_tag_info (GtkTextBTree *tree,
GtkTextTag *tag);
+static void redisplay_region (GtkTextBTree *tree,
+ const GtkTextIter *start,
+ const GtkTextIter *end,
+ gboolean cursors_only);
/* Inline thingies */
static inline void
-segments_changed(GtkTextBTree *tree)
+segments_changed (GtkTextBTree *tree)
{
tree->segments_changed_stamp += 1;
}
static inline void
-chars_changed(GtkTextBTree *tree)
+chars_changed (GtkTextBTree *tree)
{
tree->chars_changed_stamp += 1;
}
*/
GtkTextBTree*
-gtk_text_btree_new (GtkTextTagTable *table,
- GtkTextBuffer *buffer)
+_gtk_text_btree_new (GtkTextTagTable *table,
+ GtkTextBuffer *buffer)
{
GtkTextBTree *tree;
GtkTextBTreeNode *root_node;
GtkTextLine *line, *line2;
- g_return_val_if_fail(GTK_IS_TEXT_TAG_TABLE(table), NULL);
- g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);
-
+ g_return_val_if_fail (GTK_IS_TEXT_TAG_TABLE (table), NULL);
+ g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
+
/*
* The tree will initially have two empty lines. The second line
* isn't actually part of the tree's contents, but its presence
*/
/* Create the root node. */
-
- root_node = gtk_text_btree_node_new();
-
- line = gtk_text_line_new();
- line2 = gtk_text_line_new();
+
+ root_node = gtk_text_btree_node_new ();
+
+ line = gtk_text_line_new ();
+ line2 = gtk_text_line_new ();
root_node->parent = NULL;
root_node->next = NULL;
root_node->num_children = 2;
root_node->num_lines = 2;
root_node->num_chars = 2;
-
+
line->parent = root_node;
line->next = line2;
- line->segments = char_segment_new("\n", 1);
+ line->segments = _gtk_char_segment_new ("\n", 1);
line2->parent = root_node;
line2->next = NULL;
- line2->segments = char_segment_new("\n", 1);
+ line2->segments = _gtk_char_segment_new ("\n", 1);
/* Create the tree itself */
-
+
tree = g_new0(GtkTextBTree, 1);
tree->root_node = root_node;
tree->table = table;
tree->views = NULL;
/* Set these to values that are unlikely to be found
- in random memory garbage. */
- tree->chars_changed_stamp = 49;
- tree->segments_changed_stamp = 243;
+ * in random memory garbage, and also avoid
+ * duplicates between tree instances.
+ */
+ tree->chars_changed_stamp = g_random_int ();
+ tree->segments_changed_stamp = g_random_int ();
+
+ tree->last_line_stamp = tree->chars_changed_stamp - 1;
+ tree->last_line = NULL;
tree->end_iter_line_stamp = tree->chars_changed_stamp - 1;
+ tree->end_iter_segment_stamp = tree->segments_changed_stamp - 1;
tree->end_iter_line = NULL;
+ tree->end_iter_segment_byte_index = 0;
+ tree->end_iter_segment_char_offset = 0;
- gtk_object_ref(GTK_OBJECT(tree->table));
- gtk_object_sink(GTK_OBJECT(tree->table));
-
- tree->tag_changed_handler = gtk_signal_connect(GTK_OBJECT(tree->table),
- "tag_changed",
- GTK_SIGNAL_FUNC(tag_changed_cb),
- tree);
-
- tree->tag_removed_handler = gtk_signal_connect(GTK_OBJECT(tree->table),
- "tag_removed",
- GTK_SIGNAL_FUNC(tag_removed_cb),
- tree);
-
- tree->mark_table = g_hash_table_new(g_str_hash, g_str_equal);
+ g_object_ref (tree->table);
+ tree->tag_changed_handler = g_signal_connect (tree->table,
+ "tag-changed",
+ G_CALLBACK (tag_changed_cb),
+ tree);
+
+ tree->mark_table = g_hash_table_new (g_str_hash, g_str_equal);
+ tree->child_anchor_table = NULL;
+
/* We don't ref the buffer, since the buffer owns us;
- we'd have some circularity issues. The buffer always
- lasts longer than the BTree
- */
+ * we'd have some circularity issues. The buffer always
+ * lasts longer than the BTree
+ */
tree->buffer = buffer;
-
+
{
GtkTextIter start;
+ GtkTextLineSegment *seg;
- gtk_text_btree_get_iter_at_line_char(tree, &start, 0, 0);
-
+ _gtk_text_btree_get_iter_at_line_char (tree, &start, 0, 0);
- tree->insert_mark =
- (GtkTextLineSegment*) gtk_text_btree_set_mark(tree,
- NULL,
- "insert",
- FALSE,
- &start,
- FALSE);
-
- tree->insert_mark->body.mark.not_deleteable = TRUE;
-
- tree->insert_mark->body.mark.visible = TRUE;
-
- tree->selection_bound_mark =
- (GtkTextLineSegment*) gtk_text_btree_set_mark(tree,
- NULL,
- "selection_bound",
- FALSE,
- &start,
- FALSE);
-
- tree->selection_bound_mark->body.mark.not_deleteable = TRUE;
-
- _mark_segment_ref(tree->insert_mark);
- _mark_segment_ref(tree->selection_bound_mark);
+
+ tree->insert_mark = _gtk_text_btree_set_mark (tree,
+ NULL,
+ "insert",
+ FALSE,
+ &start,
+ FALSE);
+
+ seg = tree->insert_mark->segment;
+
+ seg->body.mark.not_deleteable = TRUE;
+ seg->body.mark.visible = TRUE;
+
+ tree->selection_bound_mark = _gtk_text_btree_set_mark (tree,
+ NULL,
+ "selection_bound",
+ FALSE,
+ &start,
+ FALSE);
+
+ seg = tree->selection_bound_mark->segment;
+
+ seg->body.mark.not_deleteable = TRUE;
+
+ g_object_ref (tree->insert_mark);
+ g_object_ref (tree->selection_bound_mark);
}
tree->refcount = 1;
-
+
return tree;
}
void
-gtk_text_btree_ref (GtkTextBTree *tree)
+_gtk_text_btree_ref (GtkTextBTree *tree)
{
- g_return_if_fail(tree != NULL);
- g_return_if_fail(tree->refcount > 0);
-
- tree->refcount += 1;
-}
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (tree->refcount > 0);
-static void
-mark_destroy_foreach (gpointer key, gpointer value, gpointer user_data)
-{
- _mark_segment_unref (value);
+ tree->refcount += 1;
}
void
-gtk_text_btree_unref (GtkTextBTree *tree)
+_gtk_text_btree_unref (GtkTextBTree *tree)
{
- g_return_if_fail(tree != NULL);
- g_return_if_fail(tree->refcount > 0);
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (tree->refcount > 0);
tree->refcount -= 1;
if (tree->refcount == 0)
{
- gtk_text_btree_node_destroy(tree, tree->root_node);
+ g_signal_handler_disconnect (tree->table,
+ tree->tag_changed_handler);
- g_hash_table_foreach(tree->mark_table,
- mark_destroy_foreach,
- NULL);
- g_hash_table_destroy(tree->mark_table);
+ g_object_unref (tree->table);
+ tree->table = NULL;
- _mark_segment_unref(tree->insert_mark);
- _mark_segment_unref(tree->selection_bound_mark);
-
- gtk_signal_disconnect(GTK_OBJECT(tree->table),
- tree->tag_changed_handler);
-
- gtk_signal_disconnect(GTK_OBJECT(tree->table),
- tree->tag_removed_handler);
+ gtk_text_btree_node_destroy (tree, tree->root_node);
+ tree->root_node = NULL;
- gtk_object_unref(GTK_OBJECT(tree->table));
+ g_assert (g_hash_table_size (tree->mark_table) == 0);
+ g_hash_table_destroy (tree->mark_table);
+ tree->mark_table = NULL;
+ if (tree->child_anchor_table != NULL)
+ {
+ g_hash_table_destroy (tree->child_anchor_table);
+ tree->child_anchor_table = NULL;
+ }
- g_free(tree);
+ g_object_unref (tree->insert_mark);
+ tree->insert_mark = NULL;
+ g_object_unref (tree->selection_bound_mark);
+ tree->selection_bound_mark = NULL;
+
+ g_free (tree);
}
}
GtkTextBuffer*
-gtk_text_btree_get_buffer (GtkTextBTree *tree)
+_gtk_text_btree_get_buffer (GtkTextBTree *tree)
{
return tree->buffer;
}
guint
-gtk_text_btree_get_chars_changed_stamp (GtkTextBTree *tree)
+_gtk_text_btree_get_chars_changed_stamp (GtkTextBTree *tree)
{
return tree->chars_changed_stamp;
}
guint
-gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree)
+_gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree)
{
return tree->segments_changed_stamp;
}
void
-gtk_text_btree_segments_changed (GtkTextBTree *tree)
+_gtk_text_btree_segments_changed (GtkTextBTree *tree)
{
- g_return_if_fail(tree != NULL);
- segments_changed(tree);
+ g_return_if_fail (tree != NULL);
+ segments_changed (tree);
}
/*
* Indexable segment mutation
*/
+/*
+ * The following function is responsible for resolving the bidi direction
+ * for the lines between start and end. But it also calculates any
+ * dependent bidi direction for surrounding lines that change as a result
+ * of the bidi direction decisions within the range. The function is
+ * trying to do as little propagation as is needed.
+ */
+static void
+gtk_text_btree_resolve_bidi (GtkTextIter *start,
+ GtkTextIter *end)
+{
+ GtkTextBTree *tree = _gtk_text_iter_get_btree (start);
+ GtkTextLine *start_line, *end_line, *start_line_prev, *end_line_next, *line;
+ PangoDirection last_strong, dir_above_propagated, dir_below_propagated;
+
+ /* Resolve the strong bidi direction for all lines between
+ * start and end.
+ */
+ start_line = _gtk_text_iter_get_text_line (start);
+ start_line_prev = _gtk_text_line_previous (start_line);
+ end_line = _gtk_text_iter_get_text_line (end);
+ end_line_next = _gtk_text_line_next (end_line);
+
+ line = start_line;
+ while (line && line != end_line_next)
+ {
+ /* Loop through the segments and search for a strong character
+ */
+ GtkTextLineSegment *seg = line->segments;
+ line->dir_strong = PANGO_DIRECTION_NEUTRAL;
+
+ while (seg)
+ {
+ if (seg->type == >k_text_char_type && seg->byte_count > 0)
+ {
+ PangoDirection pango_dir;
+
+ pango_dir = pango_find_base_dir (seg->body.chars,
+ seg->byte_count);
+
+ if (pango_dir != PANGO_DIRECTION_NEUTRAL)
+ {
+ line->dir_strong = pango_dir;
+ break;
+ }
+ }
+ seg = seg->next;
+ }
+
+ line = _gtk_text_line_next (line);
+ }
+
+ /* Sweep forward */
+
+ /* The variable dir_above_propagated contains the forward propagated
+ * direction before start. It is neutral if start is in the beginning
+ * of the buffer.
+ */
+ dir_above_propagated = PANGO_DIRECTION_NEUTRAL;
+ if (start_line_prev)
+ dir_above_propagated = start_line_prev->dir_propagated_forward;
+
+ /* Loop forward and propagate the direction of each paragraph
+ * to all neutral lines.
+ */
+ line = start_line;
+ last_strong = dir_above_propagated;
+ while (line != end_line_next)
+ {
+ if (line->dir_strong != PANGO_DIRECTION_NEUTRAL)
+ last_strong = line->dir_strong;
+
+ line->dir_propagated_forward = last_strong;
+
+ line = _gtk_text_line_next (line);
+ }
+
+ /* Continue propagating as long as the previous resolved forward
+ * is different from last_strong.
+ */
+ {
+ GtkTextIter end_propagate;
+
+ while (line &&
+ line->dir_strong == PANGO_DIRECTION_NEUTRAL &&
+ line->dir_propagated_forward != last_strong)
+ {
+ GtkTextLine *prev = line;
+ line->dir_propagated_forward = last_strong;
+
+ line = _gtk_text_line_next(line);
+ if (!line)
+ {
+ line = prev;
+ break;
+ }
+ }
+
+ /* The last line to invalidate is the last line before the
+ * line with the strong character. Or in case of the end of the
+ * buffer, the last line of the buffer. (There seems to be an
+ * extra "virtual" last line in the buffer that must not be used
+ * calling _gtk_text_btree_get_iter_at_line (causes crash). Thus the
+ * _gtk_text_line_previous is ok in that case as well.)
+ */
+ line = _gtk_text_line_previous (line);
+ _gtk_text_btree_get_iter_at_line (tree, &end_propagate, line, 0);
+ _gtk_text_btree_invalidate_region (tree, end, &end_propagate, FALSE);
+ }
+
+ /* Sweep backward */
+
+ /* The variable dir_below_propagated contains the backward propagated
+ * direction after end. It is neutral if end is at the end of
+ * the buffer.
+ */
+ dir_below_propagated = PANGO_DIRECTION_NEUTRAL;
+ if (end_line_next)
+ dir_below_propagated = end_line_next->dir_propagated_back;
+
+ /* Loop backward and propagate the direction of each paragraph
+ * to all neutral lines.
+ */
+ line = end_line;
+ last_strong = dir_below_propagated;
+ while (line != start_line_prev)
+ {
+ if (line->dir_strong != PANGO_DIRECTION_NEUTRAL)
+ last_strong = line->dir_strong;
+
+ line->dir_propagated_back = last_strong;
+
+ line = _gtk_text_line_previous (line);
+ }
+
+ /* Continue propagating as long as the resolved backward dir
+ * is different from last_strong.
+ */
+ {
+ GtkTextIter start_propagate;
+
+ while (line &&
+ line->dir_strong == PANGO_DIRECTION_NEUTRAL &&
+ line->dir_propagated_back != last_strong)
+ {
+ GtkTextLine *prev = line;
+ line->dir_propagated_back = last_strong;
+
+ line = _gtk_text_line_previous (line);
+ if (!line)
+ {
+ line = prev;
+ break;
+ }
+ }
+
+ /* We only need to invalidate for backwards propagation if the
+ * line we ended up on didn't get a direction from forwards
+ * propagation.
+ */
+ if (line && line->dir_propagated_forward == PANGO_DIRECTION_NEUTRAL)
+ {
+ _gtk_text_btree_get_iter_at_line (tree, &start_propagate, line, 0);
+ _gtk_text_btree_invalidate_region (tree, &start_propagate, start, FALSE);
+ }
+ }
+}
+
void
-gtk_text_btree_delete (GtkTextIter *start,
- GtkTextIter *end)
+_gtk_text_btree_delete (GtkTextIter *start,
+ GtkTextIter *end)
{
GtkTextLineSegment *prev_seg; /* The segment just before the start
* of the deletion range. */
GtkTextLineSegment *last_seg; /* The segment just after the end
* of the deletion range. */
- GtkTextLineSegment *seg, *next;
+ GtkTextLineSegment *seg, *next, *next2;
GtkTextLine *curline;
GtkTextBTreeNode *curnode, *node;
GtkTextBTree *tree;
GtkTextLine *start_line;
GtkTextLine *end_line;
- GtkTextLine *deleted_lines = NULL; /* List of lines we've deleted */
+ GtkTextLine *line;
+ GtkTextLine *deleted_lines = NULL; /* List of lines we've deleted */
gint start_byte_offset;
-
- g_return_if_fail(start != NULL);
- g_return_if_fail(end != NULL);
- g_return_if_fail(gtk_text_iter_get_btree(start) ==
- gtk_text_iter_get_btree(end));
-
- gtk_text_iter_reorder(start, end);
-
- tree = gtk_text_iter_get_btree(start);
-
- {
- /*
- * The code below is ugly, but it's needed to make sure there
- * is always a dummy empty line at the end of the text. If the
- * final newline of the file (just before the dummy line) is being
- * deleted, then back up index to just before the newline. If
- * there is a newline just before the first character being deleted,
- * then back up the first index too, so that an even number of lines
- * gets deleted. Furthermore, remove any tags that are present on
- * the newline that isn't going to be deleted after all (this simulates
- * deleting the newline and then adding a "clean" one back again).
- */
-
- gint line1;
- gint line2;
-
- line1 = gtk_text_iter_get_line(start);
- line2 = gtk_text_iter_get_line(end);
-
- if (line2 == gtk_text_btree_line_count(tree))
- {
- GtkTextTag** tags;
- int array_size;
- GtkTextIter orig_end;
-
- orig_end = *end;
- gtk_text_iter_prev_char(end);
-
- --line2;
- if (gtk_text_iter_get_line_offset(start) == 0 &&
- line1 != 0)
- {
- gtk_text_iter_prev_char(start);
- --line1;
- }
-
- tags = gtk_text_btree_get_tags(end,
- &array_size);
-
- if (tags != NULL)
- {
- int i;
+ g_return_if_fail (start != NULL);
+ g_return_if_fail (end != NULL);
+ g_return_if_fail (_gtk_text_iter_get_btree (start) ==
+ _gtk_text_iter_get_btree (end));
- i = 0;
- while (i < array_size)
- {
- gtk_text_btree_tag(end, &orig_end, tags[i], FALSE);
-
- ++i;
- }
+ gtk_text_iter_order (start, end);
- g_free(tags);
- }
- }
- }
+ tree = _gtk_text_iter_get_btree (start);
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
/* Broadcast the need for redisplay before we break the iterators */
- gtk_text_btree_invalidate_region(tree, start, end);
+ DV (g_print ("invalidating due to deleting some text (%s)\n", G_STRLOC));
+ _gtk_text_btree_invalidate_region (tree, start, end, FALSE);
/* Save the byte offset so we can reset the iterators */
- start_byte_offset = gtk_text_iter_get_line_index(start);
-
- start_line = gtk_text_iter_get_text_line(start);
- end_line = gtk_text_iter_get_text_line(end);
-
+ start_byte_offset = gtk_text_iter_get_line_index (start);
+
+ start_line = _gtk_text_iter_get_text_line (start);
+ end_line = _gtk_text_iter_get_text_line (end);
+
/*
* Split the start and end segments, so we have a place
* to insert our new text.
* us to avoid invalidating segments for start.
*/
- last_seg = gtk_text_line_segment_split(end);
+ last_seg = gtk_text_line_segment_split (end);
if (last_seg != NULL)
last_seg = last_seg->next;
else
last_seg = end_line->segments;
- prev_seg = gtk_text_line_segment_split(start);
+ prev_seg = gtk_text_line_segment_split (start);
if (prev_seg != NULL)
{
seg = prev_seg->next;
/* notify iterators that their segments need recomputation,
just for robustness. */
- segments_changed(tree);
-
+ segments_changed (tree);
+
/*
* Delete all of the segments between prev_seg and last_seg.
*/
while (seg != last_seg)
{
gint char_count = 0;
-
+
if (seg == NULL)
{
GtkTextLine *nextline;
* (unless it's the starting line for the range).
*/
- nextline = gtk_text_line_next(curline);
+ nextline = _gtk_text_line_next (curline);
if (curline != start_line)
{
if (curnode == start_line->parent)
start_line->next = curline->next;
else
curnode->children.line = curline->next;
-
+
for (node = curnode; node != NULL;
node = node->parent)
{
+ /* Don't update node->num_chars, because
+ * that was done when we deleted the segments.
+ */
node->num_lines -= 1;
}
-
+
curnode->num_children -= 1;
- curline->next = deleted_lines;
- deleted_lines = curline;
+ curline->next = deleted_lines;
+ deleted_lines = curline;
}
-
+
curline = nextline;
seg = curline->segments;
prevnode->next = curnode->next;
}
parent->num_children--;
- g_free(curnode);
+ gtk_text_btree_node_free_empty (tree, curnode);
curnode = parent;
}
curnode = curline->parent;
next = seg->next;
char_count = seg->char_count;
-
- if ((*seg->type->deleteFunc)(seg, curline, 0) != 0)
+
+ if ((*seg->type->deleteFunc)(seg, curline, FALSE) != 0)
{
/*
* This segment refuses to die. Move it to prev_seg and
* advance prev_seg if the segment has left gravity.
*/
-
+
if (prev_seg == NULL)
{
seg->next = start_line->segments;
start_line->segments = seg;
}
- else
- {
+ else if (prev_seg->next &&
+ prev_seg->next != last_seg &&
+ seg->type == >k_text_toggle_off_type &&
+ prev_seg->next->type == >k_text_toggle_on_type &&
+ seg->body.toggle.info == prev_seg->next->body.toggle.info)
+ {
+ /* Try to match an off toggle with the matching on toggle
+ * if it immediately follows. This is a common case, and
+ * handling it here prevents quadratic blowup in
+ * cleanup_line() below. See bug 317125.
+ */
+ next2 = prev_seg->next->next;
+ g_free ((char *)prev_seg->next);
+ prev_seg->next = next2;
+ g_free ((char *)seg);
+ seg = NULL;
+ }
+ else
+ {
seg->next = prev_seg->next;
prev_seg->next = seg;
}
- if (seg->type->leftGravity)
+
+ if (seg && seg->type->leftGravity)
{
prev_seg = seg;
}
node->num_chars -= char_count;
}
}
-
+
seg = next;
}
{
BTreeView *view;
GtkTextBTreeNode *ancestor_node;
-
GtkTextLine *prevline;
+ int chars_moved;
+ /* last_seg was appended to start_line up at the top of this function */
+ chars_moved = 0;
for (seg = last_seg; seg != NULL;
seg = seg->next)
{
+ chars_moved += seg->char_count;
if (seg->type->lineChangeFunc != NULL)
{
(*seg->type->lineChangeFunc)(seg, end_line);
}
}
+
+ for (node = start_line->parent; node != NULL;
+ node = node->parent)
+ {
+ node->num_chars += chars_moved;
+ }
+
curnode = end_line->parent;
for (node = curnode; node != NULL;
node = node->parent)
{
+ node->num_chars -= chars_moved;
node->num_lines--;
}
curnode->num_children--;
ancestor_node = gtk_text_btree_node_common_parent (curnode, start_line->parent);
view = tree->views;
while (view)
- {
- GtkTextLine *line;
- GtkTextLineData *ld;
-
- gint deleted_width = 0;
- gint deleted_height = 0;
-
- line = deleted_lines;
- while (line)
- {
- GtkTextLine *next_line = line->next;
- ld = gtk_text_line_get_data (line, view->view_id);
+ {
+ GtkTextLineData *ld;
- if (ld)
- {
- deleted_width = MAX (deleted_width, ld->width);
- deleted_height += ld->height;
- }
+ gint deleted_width = 0;
+ gint deleted_height = 0;
- if (!view->next)
- gtk_text_line_destroy(tree, line);
-
- line = next_line;
- }
+ line = deleted_lines;
+ while (line)
+ {
+ GtkTextLine *next_line = line->next;
+ ld = _gtk_text_line_get_data (line, view->view_id);
- if (deleted_width > 0 || deleted_height > 0)
- {
- ld = gtk_text_line_get_data (start_line, view->view_id);
+ if (ld)
+ {
+ deleted_width = MAX (deleted_width, ld->width);
+ deleted_height += ld->height;
+ }
- /* FIXME: ld is _NOT_ necessarily non-null here, but there is currently
- * no way to add ld without also validating the node, which would
- * be improper at this point.
- */
- /* This assertion does actually fail sometimes, must
- fix before stable release -hp */
- g_assert (ld);
+ line = next_line;
+ }
- ld->width = MAX (deleted_width, ld->width);
- ld->height += deleted_height;
- ld->valid = FALSE;
- }
-
- gtk_text_btree_node_check_valid_downward (ancestor_node, view->view_id);
- if (ancestor_node->parent)
- gtk_text_btree_node_check_valid_upward (ancestor_node->parent, view->view_id);
+ if (deleted_width > 0 || deleted_height > 0)
+ {
+ ld = _gtk_text_line_get_data (start_line, view->view_id);
+
+ if (ld == NULL)
+ {
+ /* This means that start_line has never been validated.
+ * We don't really want to do the validation here but
+ * we do need to store our temporary sizes. So we
+ * create the line data and assume a line w/h of 0.
+ */
+ ld = _gtk_text_line_data_new (view->layout, start_line);
+ _gtk_text_line_add_data (start_line, ld);
+ ld->width = 0;
+ ld->height = 0;
+ ld->valid = FALSE;
+ }
+
+ ld->width = MAX (deleted_width, ld->width);
+ ld->height += deleted_height;
+ ld->valid = FALSE;
+ }
- view = view->next;
- }
+ gtk_text_btree_node_check_valid_downward (ancestor_node, view->view_id);
+ if (ancestor_node->parent)
+ gtk_text_btree_node_check_valid_upward (ancestor_node->parent, view->view_id);
+
+ view = view->next;
+ }
+
+ line = deleted_lines;
+ while (line)
+ {
+ GtkTextLine *next_line = line->next;
+
+ gtk_text_line_destroy (tree, line);
+
+ line = next_line;
+ }
+
+ /* avoid dangling pointer */
+ deleted_lines = NULL;
- gtk_text_btree_rebalance(tree, curnode);
+ gtk_text_btree_rebalance (tree, curnode);
}
/*
* Cleanup the segments in the new line.
*/
- cleanup_line(start_line);
+ cleanup_line (start_line);
/*
* Lastly, rebalance the first GtkTextBTreeNode of the range.
*/
- gtk_text_btree_rebalance(tree, start_line->parent);
-
+ gtk_text_btree_rebalance (tree, start_line->parent);
+
/* Notify outstanding iterators that they
are now hosed */
- chars_changed(tree);
- segments_changed(tree);
+ chars_changed (tree);
+ segments_changed (tree);
- if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check(tree);
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
/* Re-initialize our iterators */
- gtk_text_btree_get_iter_at_line(tree, start, start_line, start_byte_offset);
+ _gtk_text_btree_get_iter_at_line (tree, start, start_line, start_byte_offset);
*end = *start;
+
+ gtk_text_btree_resolve_bidi (start, end);
}
void
-gtk_text_btree_insert (GtkTextIter *iter,
- const gchar *text,
- gint len)
+_gtk_text_btree_insert (GtkTextIter *iter,
+ const gchar *text,
+ gint len)
{
GtkTextLineSegment *prev_seg; /* The segment just before the first
* new segment (NULL means new segment
* is at beginning of line). */
GtkTextLineSegment *cur_seg; /* Current segment; new characters
- * are inserted just after this one.
+ * are inserted just after this one.
* NULL means insert at beginning of
* line. */
GtkTextLine *line; /* Current line (new segments are
* added to this line). */
GtkTextLineSegment *seg;
GtkTextLine *newline;
- int chunkSize; /* # characters in current chunk. */
- guint sol; /* start of line */
- guint eol; /* Pointer to character just after last
- * one in current chunk. */
+ int chunk_len; /* # characters in current chunk. */
+ gint sol; /* start of line */
+ gint eol; /* Pointer to character just after last
+ * one in current chunk.
+ */
+ gint delim; /* index of paragraph delimiter */
int line_count_delta; /* Counts change to total number of
- * lines in file. */
+ * lines in file.
+ */
int char_count_delta; /* change to number of chars */
GtkTextBTree *tree;
gint start_byte_index;
GtkTextLine *start_line;
-
- g_return_if_fail(text != NULL);
- g_return_if_fail(iter != NULL);
-
+
+ g_return_if_fail (text != NULL);
+ g_return_if_fail (iter != NULL);
+
if (len < 0)
- len = strlen(text);
+ len = strlen (text);
/* extract iterator info */
- tree = gtk_text_iter_get_btree(iter);
- line = gtk_text_iter_get_text_line(iter);
+ tree = _gtk_text_iter_get_btree (iter);
+ line = _gtk_text_iter_get_text_line (iter);
+
start_line = line;
- start_byte_index = gtk_text_iter_get_line_index(iter);
+ start_byte_index = gtk_text_iter_get_line_index (iter);
- /* Get our insertion segment split */
- prev_seg = gtk_text_line_segment_split(iter);
+ /* Get our insertion segment split. Note this assumes line allows
+ * char insertions, which isn't true of the "last" line. But iter
+ * should not be on that line, as we assert here.
+ */
+ g_assert (!_gtk_text_line_is_last (line, tree));
+ prev_seg = gtk_text_line_segment_split (iter);
cur_seg = prev_seg;
/* Invalidate all iterators */
- chars_changed(tree);
- segments_changed(tree);
+ chars_changed (tree);
+ segments_changed (tree);
/*
* Chop the text up into lines and create a new segment for
char_count_delta = 0;
while (eol < len)
{
- for (; eol < len; eol++)
- {
- if (text[eol] == '\n')
- {
- eol++;
- break;
- }
- }
- chunkSize = eol - sol;
+ sol = eol;
+
+ pango_find_paragraph_boundary (text + sol,
+ len - sol,
+ &delim,
+ &eol);
+
+ /* make these relative to the start of the text */
+ delim += sol;
+ eol += sol;
+
+ g_assert (eol >= sol);
+ g_assert (delim >= sol);
+ g_assert (eol >= delim);
+ g_assert (sol >= 0);
+ g_assert (eol <= len);
+
+ chunk_len = eol - sol;
- seg = char_segment_new(&text[sol], chunkSize);
+ g_assert (g_utf8_validate (&text[sol], chunk_len, NULL));
+ seg = _gtk_char_segment_new (&text[sol], chunk_len);
char_count_delta += seg->char_count;
-
+
if (cur_seg == NULL)
{
seg->next = line->segments;
cur_seg->next = seg;
}
- if (text[eol-1] != '\n')
+ if (delim == eol)
{
+ /* chunk didn't end with a paragraph separator */
+ g_assert (eol == len);
break;
}
* and move the remainder of the old line to it.
*/
- newline = gtk_text_line_new();
- gtk_text_line_set_parent(newline, line->parent);
+ newline = gtk_text_line_new ();
+ gtk_text_line_set_parent (newline, line->parent);
newline->next = line->next;
line->next = newline;
newline->segments = seg->next;
seg->next = NULL;
line = newline;
cur_seg = NULL;
- line_count_delta++;
-
- sol = eol;
+ line_count_delta++;
}
/*
* line if it's different.
*/
- cleanup_line(start_line);
+ cleanup_line (start_line);
if (line != start_line)
{
- cleanup_line(line);
+ cleanup_line (line);
}
- post_insert_fixup(tree, line, line_count_delta, char_count_delta);
-
+ post_insert_fixup (tree, line, line_count_delta, char_count_delta);
+
/* Invalidate our region, and reset the iterator the user
passed in to point to the end of the inserted text. */
{
GtkTextIter end;
- gtk_text_btree_get_iter_at_line(tree,
- &start,
- start_line,
- start_byte_index);
+ _gtk_text_btree_get_iter_at_line (tree,
+ &start,
+ start_line,
+ start_byte_index);
end = start;
/* We could almost certainly be more efficient here
by saving the information from the insertion loop
above. FIXME */
- gtk_text_iter_forward_chars(&end, char_count_delta);
+ gtk_text_iter_forward_chars (&end, char_count_delta);
- gtk_text_btree_invalidate_region(tree,
- &start, &end);
+ DV (g_print ("invalidating due to inserting some text (%s)\n", G_STRLOC));
+ _gtk_text_btree_invalidate_region (tree, &start, &end, FALSE);
/* Convenience for the user */
*iter = end;
+
+ gtk_text_btree_resolve_bidi (&start, &end);
}
}
-void
-gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
- GdkPixbuf *pixbuf)
+static void
+insert_pixbuf_or_widget_segment (GtkTextIter *iter,
+ GtkTextLineSegment *seg)
+
{
- GtkTextLineSegment *seg;
GtkTextIter start;
GtkTextLineSegment *prevPtr;
GtkTextLine *line;
GtkTextBTree *tree;
gint start_byte_offset;
-
- line = gtk_text_iter_get_text_line(iter);
- tree = gtk_text_iter_get_btree(iter);
- start_byte_offset = gtk_text_iter_get_line_index(iter);
-
- seg = _pixbuf_segment_new (pixbuf);
- prevPtr = gtk_text_line_segment_split(iter);
+ line = _gtk_text_iter_get_text_line (iter);
+ tree = _gtk_text_iter_get_btree (iter);
+ start_byte_offset = gtk_text_iter_get_line_index (iter);
+
+ prevPtr = gtk_text_line_segment_split (iter);
if (prevPtr == NULL)
{
seg->next = line->segments;
prevPtr->next = seg;
}
- post_insert_fixup(tree, line, 0, seg->char_count);
+ post_insert_fixup (tree, line, 0, seg->char_count);
- chars_changed(tree);
- segments_changed(tree);
+ chars_changed (tree);
+ segments_changed (tree);
/* reset *iter for the user, and invalidate tree nodes */
-
- gtk_text_btree_get_iter_at_line(tree, &start, line, start_byte_offset);
+
+ _gtk_text_btree_get_iter_at_line (tree, &start, line, start_byte_offset);
*iter = start;
- gtk_text_iter_next_char(iter); /* skip forward past the pixmap */
+ gtk_text_iter_forward_char (iter); /* skip forward past the segment */
+
+ DV (g_print ("invalidating due to inserting pixbuf/widget (%s)\n", G_STRLOC));
+ _gtk_text_btree_invalidate_region (tree, &start, iter, FALSE);
+}
+
+void
+_gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
+ GdkPixbuf *pixbuf)
+{
+ GtkTextLineSegment *seg;
+
+ seg = _gtk_pixbuf_segment_new (pixbuf);
+
+ insert_pixbuf_or_widget_segment (iter, seg);
+}
+
+void
+_gtk_text_btree_insert_child_anchor (GtkTextIter *iter,
+ GtkTextChildAnchor *anchor)
+{
+ GtkTextLineSegment *seg;
+ GtkTextBTree *tree;
- gtk_text_btree_invalidate_region(tree, &start, iter);
+ if (anchor->segment != NULL)
+ {
+ g_warning (G_STRLOC": Same child anchor can't be inserted twice");
+ return;
+ }
+
+ seg = _gtk_widget_segment_new (anchor);
+
+ tree = seg->body.child.tree = _gtk_text_iter_get_btree (iter);
+ seg->body.child.line = _gtk_text_iter_get_text_line (iter);
+
+ insert_pixbuf_or_widget_segment (iter, seg);
+
+ if (tree->child_anchor_table == NULL)
+ tree->child_anchor_table = g_hash_table_new (NULL, NULL);
+
+ g_hash_table_insert (tree->child_anchor_table,
+ seg->body.child.obj,
+ seg->body.child.obj);
}
+void
+_gtk_text_btree_unregister_child_anchor (GtkTextChildAnchor *anchor)
+{
+ GtkTextLineSegment *seg;
+
+ seg = anchor->segment;
+
+ g_hash_table_remove (seg->body.child.tree->child_anchor_table,
+ anchor);
+}
/*
* View stuff
*/
static GtkTextLine*
-find_line_by_y(GtkTextBTree *tree, BTreeView *view,
- GtkTextBTreeNode *node, gint y, gint *line_top,
- GtkTextLine *last_line)
+find_line_by_y (GtkTextBTree *tree, BTreeView *view,
+ GtkTextBTreeNode *node, gint y, gint *line_top,
+ GtkTextLine *last_line)
{
gint current_y = 0;
- if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check(tree);
-
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
+
if (node->level == 0)
{
GtkTextLine *line;
{
GtkTextLineData *ld;
- ld = gtk_text_line_get_data (line, view->view_id);
+ ld = _gtk_text_line_get_data (line, view->view_id);
- if (ld)
- {
- if (y < (current_y + (ld ? ld->height : 0)))
- return line;
+ if (ld)
+ {
+ if (y < (current_y + (ld ? ld->height : 0)))
+ return line;
+
+ current_y += ld->height;
+ *line_top += ld->height;
+ }
- current_y += ld->height;
- *line_top += ld->height;
- }
-
line = line->next;
}
return NULL;
gint width;
gint height;
- gtk_text_btree_node_get_size(child, view->view_id,
- &width, &height);
+ gtk_text_btree_node_get_size (child, view->view_id,
+ &width, &height);
- if (y < (current_y + height))
- return find_line_by_y(tree, view, child,
- y - current_y, line_top,
- last_line);
+ if (y < (current_y + height))
+ return find_line_by_y (tree, view, child,
+ y - current_y, line_top,
+ last_line);
current_y += height;
*line_top += height;
-
+
child = child->next;
}
-
+
return NULL;
}
}
GtkTextLine *
-gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
- gpointer view_id,
- gint ypixel,
- gint *line_top_out)
+_gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
+ gpointer view_id,
+ gint ypixel,
+ gint *line_top_out)
{
GtkTextLine *line;
BTreeView *view;
GtkTextLine *last_line;
gint line_top = 0;
-
+
view = gtk_text_btree_get_view (tree, view_id);
g_return_val_if_fail (view != NULL, NULL);
last_line = get_last_line (tree);
-
+
line = find_line_by_y (tree, view, tree->root_node, ypixel, &line_top,
- last_line);
+ last_line);
if (line_top_out)
*line_top_out = line_top;
}
static gint
-find_line_top_in_line_list(GtkTextBTree *tree,
- BTreeView *view,
- GtkTextLine *line,
- GtkTextLine *target_line,
- gint y)
+find_line_top_in_line_list (GtkTextBTree *tree,
+ BTreeView *view,
+ GtkTextLine *line,
+ GtkTextLine *target_line,
+ gint y)
{
while (line != NULL)
{
GtkTextLineData *ld;
-
+
if (line == target_line)
- return y;
+ return y;
- ld = gtk_text_line_get_data (line, view->view_id);
+ ld = _gtk_text_line_get_data (line, view->view_id);
if (ld)
- y += ld->height;
-
+ y += ld->height;
+
line = line->next;
}
-
- g_assert_not_reached(); /* If we get here, our
- target line didn't exist
- under its parent node */
+
+ g_assert_not_reached (); /* If we get here, our
+ target line didn't exist
+ under its parent node */
return 0;
}
gint
-gtk_text_btree_find_line_top (GtkTextBTree *tree,
+_gtk_text_btree_find_line_top (GtkTextBTree *tree,
GtkTextLine *target_line,
gpointer view_id)
{
GSList *nodes;
GSList *iter;
GtkTextBTreeNode *node;
-
- view = gtk_text_btree_get_view(tree, view_id);
- g_return_val_if_fail(view != NULL, 0);
+ view = gtk_text_btree_get_view (tree, view_id);
+
+ g_return_val_if_fail (view != NULL, 0);
nodes = NULL;
node = target_line->parent;
while (node != NULL)
{
- nodes = g_slist_prepend(nodes, node);
+ nodes = g_slist_prepend (nodes, node);
node = node->parent;
}
iter = nodes;
while (iter != NULL)
- {
+ {
node = iter->data;
-
+
if (node->level == 0)
{
- g_slist_free(nodes);
- return find_line_top_in_line_list(tree, view,
- node->children.line,
- target_line, y);
+ g_slist_free (nodes);
+ return find_line_top_in_line_list (tree, view,
+ node->children.line,
+ target_line, y);
}
else
{
GtkTextBTreeNode *child;
GtkTextBTreeNode *target_node;
- g_assert(iter->next != NULL); /* not at level 0 */
+ g_assert (iter->next != NULL); /* not at level 0 */
target_node = iter->next->data;
-
+
child = node->children.node;
while (child != NULL)
break;
else
{
- gtk_text_btree_node_get_size(child, view->view_id,
- &width, &height);
+ gtk_text_btree_node_get_size (child, view->view_id,
+ &width, &height);
y += height;
}
child = child->next;
}
- g_assert(child != NULL); /* should have broken out before we
- ran out of nodes */
+ g_assert (child != NULL); /* should have broken out before we
+ ran out of nodes */
}
- iter = g_slist_next(iter);
+ iter = g_slist_next (iter);
}
- g_assert_not_reached(); /* we return when we find the target line */
- return 0;
+ g_assert_not_reached (); /* we return when we find the target line */
+ return 0;
}
void
-gtk_text_btree_add_view (GtkTextBTree *tree,
+_gtk_text_btree_add_view (GtkTextBTree *tree,
GtkTextLayout *layout)
{
BTreeView *view;
GtkTextLine *last_line;
GtkTextLineData *line_data;
- g_return_if_fail(tree != NULL);
+ g_return_if_fail (tree != NULL);
- view = g_new(BTreeView, 1);
+ view = g_new (BTreeView, 1);
view->view_id = layout;
view->layout = layout;
-
+
view->next = tree->views;
view->prev = NULL;
+ if (tree->views)
+ {
+ g_assert (tree->views->prev == NULL);
+ tree->views->prev = view;
+ }
+
tree->views = view;
/* The last line in the buffer has identity values for the per-view
* number of loops
*/
last_line = get_last_line (tree);
-
+
line_data = g_new (GtkTextLineData, 1);
line_data->view_id = layout;
line_data->next = NULL;
line_data->width = 0;
line_data->height = 0;
line_data->valid = TRUE;
-
- gtk_text_line_add_data (last_line, line_data);
+
+ _gtk_text_line_add_data (last_line, line_data);
}
void
-gtk_text_btree_remove_view (GtkTextBTree *tree,
- gpointer view_id)
+_gtk_text_btree_remove_view (GtkTextBTree *tree,
+ gpointer view_id)
{
BTreeView *view;
GtkTextLine *last_line;
GtkTextLineData *line_data;
- g_return_if_fail(tree != NULL);
+ g_return_if_fail (tree != NULL);
view = tree->views;
-
+
while (view != NULL)
{
if (view->view_id == view_id)
view = view->next;
}
-
- g_return_if_fail(view != NULL);
+
+ g_return_if_fail (view != NULL);
if (view->next)
view->next->prev = view->prev;
* (Do this first, so that we don't try to call the view's line data destructor on it.)
*/
last_line = get_last_line (tree);
- line_data = gtk_text_line_remove_data (last_line, view_id);
+ line_data = _gtk_text_line_remove_data (last_line, view_id);
g_free (line_data);
+
+ gtk_text_btree_node_remove_view (view, tree->root_node, view_id);
+
+ view->layout = (gpointer) 0xdeadbeef;
+ view->view_id = (gpointer) 0xdeadbeef;
- gtk_text_btree_node_remove_view(view, tree->root_node, view_id);
-
- g_free(view);
+ g_free (view);
}
void
-gtk_text_btree_invalidate_region (GtkTextBTree *tree,
- const GtkTextIter *start,
- const GtkTextIter *end)
+_gtk_text_btree_invalidate_region (GtkTextBTree *tree,
+ const GtkTextIter *start,
+ const GtkTextIter *end,
+ gboolean cursors_only)
{
BTreeView *view;
-
+
view = tree->views;
while (view != NULL)
{
- gtk_text_layout_invalidate(view->layout, start, end);
+ if (cursors_only)
+ gtk_text_layout_invalidate_cursors (view->layout, start, end);
+ else
+ gtk_text_layout_invalidate (view->layout, start, end);
view = view->next;
}
}
void
-gtk_text_btree_get_view_size (GtkTextBTree *tree,
+_gtk_text_btree_get_view_size (GtkTextBTree *tree,
gpointer view_id,
gint *width,
gint *height)
{
- g_return_if_fail(tree != NULL);
- g_return_if_fail(view_id != NULL);
-
- gtk_text_btree_node_get_size(tree->root_node, view_id,
- width, height);
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (view_id != NULL);
+
+ gtk_text_btree_node_get_size (tree->root_node, view_id,
+ width, height);
}
/*
} IterStack;
static IterStack*
-iter_stack_new(void)
+iter_stack_new (void)
{
IterStack *stack;
- stack = g_new(IterStack, 1);
+ stack = g_slice_new (IterStack);
stack->iters = NULL;
stack->count = 0;
stack->alloced = 0;
}
static void
-iter_stack_push(IterStack *stack, const GtkTextIter *iter)
+iter_stack_push (IterStack *stack,
+ const GtkTextIter *iter)
{
stack->count += 1;
if (stack->count > stack->alloced)
{
stack->alloced = stack->count*2;
- stack->iters = g_realloc(stack->iters,
- stack->alloced*sizeof(GtkTextIter));
+ stack->iters = g_realloc (stack->iters,
+ stack->alloced * sizeof (GtkTextIter));
}
stack->iters[stack->count-1] = *iter;
}
static gboolean
-iter_stack_pop(IterStack *stack, GtkTextIter *iter)
+iter_stack_pop (IterStack *stack,
+ GtkTextIter *iter)
{
if (stack->count == 0)
return FALSE;
}
static void
-iter_stack_free(IterStack *stack)
+iter_stack_free (IterStack *stack)
{
- g_free(stack->iters);
- g_free(stack);
+ g_free (stack->iters);
+ g_slice_free (IterStack, stack);
}
static void
-iter_stack_invert(IterStack *stack)
+iter_stack_invert (IterStack *stack)
{
if (stack->count > 0)
{
while (i < j)
{
GtkTextIter tmp;
-
+
tmp = stack->iters[i];
stack->iters[i] = stack->iters[j];
stack->iters[j] = tmp;
}
}
+static void
+queue_tag_redisplay (GtkTextBTree *tree,
+ GtkTextTag *tag,
+ const GtkTextIter *start,
+ const GtkTextIter *end)
+{
+ if (_gtk_text_tag_affects_size (tag))
+ {
+ DV (g_print ("invalidating due to size-affecting tag (%s)\n", G_STRLOC));
+ _gtk_text_btree_invalidate_region (tree, start, end, FALSE);
+ }
+ else if (_gtk_text_tag_affects_nonsize_appearance (tag))
+ {
+ /* We only need to queue a redraw, not a relayout */
+ redisplay_region (tree, start, end, FALSE);
+ }
+
+ /* We don't need to do anything if the tag doesn't affect display */
+}
+
void
-gtk_text_btree_tag (const GtkTextIter *start_orig,
- const GtkTextIter *end_orig,
- GtkTextTag *tag,
- gboolean add)
+_gtk_text_btree_tag (const GtkTextIter *start_orig,
+ const GtkTextIter *end_orig,
+ GtkTextTag *tag,
+ gboolean add)
{
GtkTextLineSegment *seg, *prev;
GtkTextLine *cleanupline;
GtkTextLine *end_line;
GtkTextIter iter;
GtkTextIter start, end;
- GtkTextBTree *tree;
+ GtkTextBTree *tree;
IterStack *stack;
GtkTextTagInfo *info;
-
- g_return_if_fail(start_orig != NULL);
- g_return_if_fail(end_orig != NULL);
- g_return_if_fail(GTK_IS_TEXT_TAG(tag));
- g_return_if_fail(gtk_text_iter_get_btree(start_orig) ==
- gtk_text_iter_get_btree(end_orig));
+ g_return_if_fail (start_orig != NULL);
+ g_return_if_fail (end_orig != NULL);
+ g_return_if_fail (GTK_IS_TEXT_TAG (tag));
+ g_return_if_fail (_gtk_text_iter_get_btree (start_orig) ==
+ _gtk_text_iter_get_btree (end_orig));
+ g_return_if_fail (tag->priv->table == _gtk_text_iter_get_btree (start_orig)->table);
+
#if 0
- printf("%s tag %s from %d to %d\n",
- add ? "Adding" : "Removing",
- tag->name,
- gtk_text_buffer_get_offset(start_orig),
- gtk_text_buffer_get_offset(end_orig));
+ printf ("%s tag %s from %d to %d\n",
+ add ? "Adding" : "Removing",
+ tag->name,
+ gtk_text_buffer_get_offset (start_orig),
+ gtk_text_buffer_get_offset (end_orig));
#endif
-
- if (gtk_text_iter_equal(start_orig, end_orig))
+
+ if (gtk_text_iter_equal (start_orig, end_orig))
return;
-
+
start = *start_orig;
end = *end_orig;
-
- gtk_text_iter_reorder(&start, &end);
-
- tree = gtk_text_iter_get_btree(&start);
- info = gtk_text_btree_get_tag_info(tree, tag);
-
- start_line = gtk_text_iter_get_text_line(&start);
- end_line = gtk_text_iter_get_text_line(&end);
+ gtk_text_iter_order (&start, &end);
+
+ tree = _gtk_text_iter_get_btree (&start);
+
+ queue_tag_redisplay (tree, tag, &start, &end);
+
+ info = gtk_text_btree_get_tag_info (tree, tag);
+
+ start_line = _gtk_text_iter_get_text_line (&start);
+ end_line = _gtk_text_iter_get_text_line (&end);
/* Find all tag toggles in the region; we are going to delete them.
We need to find them in advance, because
- forward_find_tag_toggle() won't work once we start playing around
+ forward_find_tag_toggle () won't work once we start playing around
with the tree. */
- stack = iter_stack_new();
+ stack = iter_stack_new ();
iter = start;
- /* We don't want to delete a toggle that's at the start iterator. */
- gtk_text_iter_next_char(&iter);
- while (gtk_text_iter_forward_to_tag_toggle(&iter, tag))
+
+ /* forward_to_tag_toggle() skips a toggle at the start iterator,
+ * which is deliberate - we don't want to delete a toggle at the
+ * start.
+ */
+ while (gtk_text_iter_forward_to_tag_toggle (&iter, tag))
{
- if (gtk_text_iter_compare(&iter, &end) >= 0)
+ if (gtk_text_iter_compare (&iter, &end) >= 0)
break;
else
- iter_stack_push(stack, &iter);
+ iter_stack_push (stack, &iter);
}
/* We need to traverse the toggles in order. */
- iter_stack_invert(stack);
-
+ iter_stack_invert (stack);
+
/*
* See whether the tag is present at the start of the range. If
* the state doesn't already match what we want then add a toggle
* there.
*/
- toggled_on = gtk_text_iter_has_tag(&start, tag);
+ toggled_on = gtk_text_iter_has_tag (&start, tag);
if ( (add && !toggled_on) ||
(!add && toggled_on) )
{
/* This could create a second toggle at the start position;
- cleanup_line() will remove it if so. */
- seg = toggle_segment_new(info, add);
+ cleanup_line () will remove it if so. */
+ seg = _gtk_toggle_segment_new (info, add);
- prev = gtk_text_line_segment_split(&start);
+ prev = gtk_text_line_segment_split (&start);
if (prev == NULL)
{
seg->next = start_line->segments;
seg->next = prev->next;
prev->next = seg;
}
-
+
/* cleanup_line adds the new toggle to the node counts. */
#if 0
- printf("added toggle at start\n");
+ printf ("added toggle at start\n");
#endif
/* we should probably call segments_changed, but in theory
any still-cached segments in the iters we are about to
use are still valid, since they're in front
of this spot. */
}
-
+
/*
*
* Scan the range of characters and delete any internal tag
*/
cleanupline = start_line;
- while (iter_stack_pop(stack, &iter))
+ while (iter_stack_pop (stack, &iter))
{
GtkTextLineSegment *indexable_seg;
GtkTextLine *line;
-
- line = gtk_text_iter_get_text_line(&iter);
- seg = gtk_text_iter_get_any_segment(&iter);
- indexable_seg = gtk_text_iter_get_indexable_segment(&iter);
- g_assert(seg != NULL);
- g_assert(indexable_seg != NULL);
- g_assert(seg != indexable_seg);
-
+ line = _gtk_text_iter_get_text_line (&iter);
+ seg = _gtk_text_iter_get_any_segment (&iter);
+ indexable_seg = _gtk_text_iter_get_indexable_segment (&iter);
+
+ g_assert (seg != NULL);
+ g_assert (indexable_seg != NULL);
+ g_assert (seg != indexable_seg);
+
prev = line->segments;
/* Find the segment that actually toggles this tag. */
while (seg != indexable_seg)
{
- g_assert(seg != NULL);
- g_assert(indexable_seg != NULL);
- g_assert(seg != indexable_seg);
-
+ g_assert (seg != NULL);
+ g_assert (indexable_seg != NULL);
+ g_assert (seg != indexable_seg);
+
if ( (seg->type == >k_text_toggle_on_type ||
- seg->type == >k_text_toggle_off_type) &&
+ seg->type == >k_text_toggle_off_type) &&
(seg->body.toggle.info == info) )
break;
else
seg = seg->next;
}
- g_assert(seg != NULL);
- g_assert(indexable_seg != NULL);
-
- g_assert(seg != indexable_seg); /* If this happens, then
- forward_to_tag_toggle was
- full of shit. */
- g_assert(seg->body.toggle.info->tag == tag);
+ g_assert (seg != NULL);
+ g_assert (indexable_seg != NULL);
+
+ g_assert (seg != indexable_seg); /* If this happens, then
+ forward_to_tag_toggle was
+ full of shit. */
+ g_assert (seg->body.toggle.info->tag == tag);
/* If this happens, when previously tagging we didn't merge
overlapping tags. */
- g_assert( (toggled_on && seg->type == >k_text_toggle_off_type) ||
- (!toggled_on && seg->type == >k_text_toggle_on_type) );
-
+ g_assert ( (toggled_on && seg->type == >k_text_toggle_off_type) ||
+ (!toggled_on && seg->type == >k_text_toggle_on_type) );
+
toggled_on = !toggled_on;
#if 0
- printf("deleting %s toggle\n",
- seg->type == >k_text_toggle_on_type ? "on" : "off");
-#endif
+ printf ("deleting %s toggle\n",
+ seg->type == >k_text_toggle_on_type ? "on" : "off");
+#endif
/* Remove toggle segment from the list. */
if (prev == seg)
{
the front of the line. Of course we have to do that to get
"prev" anyway, but here we are doing it an additional
time. FIXME */
- segments_changed(tree);
+ segments_changed (tree);
/* Update node counts */
if (seg->body.toggle.inNodeCounts)
{
- change_node_toggle_count(line->parent,
- info, -1);
+ _gtk_change_node_toggle_count (line->parent,
+ info, -1);
seg->body.toggle.inNodeCounts = FALSE;
}
- g_free(seg);
+ g_free (seg);
/* We only clean up lines when we're done with them, saves some
gratuitous line-segment-traversals */
-
+
if (cleanupline != line)
{
- cleanup_line(cleanupline);
+ cleanup_line (cleanupline);
cleanupline = line;
}
}
- iter_stack_free(stack);
-
+ iter_stack_free (stack);
+
/* toggled_on now reflects the toggle state _just before_ the
end iterator. The end iterator could already have a toggle
on or a toggle off. */
(!add && toggled_on) )
{
/* This could create a second toggle at the start position;
- cleanup_line() will remove it if so. */
-
- seg = toggle_segment_new(info, !add);
+ cleanup_line () will remove it if so. */
+
+ seg = _gtk_toggle_segment_new (info, !add);
- prev = gtk_text_line_segment_split(&end);
+ prev = gtk_text_line_segment_split (&end);
if (prev == NULL)
{
seg->next = end_line->segments;
prev->next = seg;
}
/* cleanup_line adds the new toggle to the node counts. */
- g_assert(seg->body.toggle.inNodeCounts == FALSE);
+ g_assert (seg->body.toggle.inNodeCounts == FALSE);
#if 0
- printf("added toggle at end\n");
+ printf ("added toggle at end\n");
#endif
}
* these are different.
*/
- cleanup_line(cleanupline);
+ cleanup_line (cleanupline);
if (cleanupline != end_line)
{
- cleanup_line(end_line);
+ cleanup_line (end_line);
}
- segments_changed(tree);
-
- if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check(tree);
+ segments_changed (tree);
+
+ queue_tag_redisplay (tree, tag, &start, &end);
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
}
* "Getters"
*/
-GtkTextLine*
-gtk_text_btree_get_line (GtkTextBTree *tree,
- gint line_number,
- gint *real_line_number)
+static GtkTextLine*
+get_line_internal (GtkTextBTree *tree,
+ gint line_number,
+ gint *real_line_number,
+ gboolean include_last)
{
GtkTextBTreeNode *node;
GtkTextLine *line;
int lines_left;
int line_count;
- line_count = gtk_text_btree_line_count(tree);
+ line_count = _gtk_text_btree_line_count (tree);
+ if (!include_last)
+ line_count -= 1;
if (line_number < 0)
{
if (real_line_number)
*real_line_number = line_number;
-
+
node = tree->root_node;
lines_left = line_number;
#if 0
if (node == NULL)
{
- g_error("gtk_text_btree_find_line ran out of GtkTextBTreeNodes");
+ g_error ("gtk_text_btree_find_line ran out of GtkTextBTreeNodes");
}
#endif
lines_left -= node->num_lines;
#if 0
if (line == NULL)
{
- g_error("gtk_text_btree_find_line ran out of lines");
+ g_error ("gtk_text_btree_find_line ran out of lines");
}
#endif
lines_left -= 1;
}
- return line;
+ return line;
+}
+
+GtkTextLine*
+_gtk_text_btree_get_end_iter_line (GtkTextBTree *tree)
+{
+ return
+ _gtk_text_btree_get_line (tree,
+ _gtk_text_btree_line_count (tree) - 1,
+ NULL);
+}
+
+GtkTextLine*
+_gtk_text_btree_get_line (GtkTextBTree *tree,
+ gint line_number,
+ gint *real_line_number)
+{
+ return get_line_internal (tree, line_number, real_line_number, TRUE);
+}
+
+GtkTextLine*
+_gtk_text_btree_get_line_no_last (GtkTextBTree *tree,
+ gint line_number,
+ gint *real_line_number)
+{
+ return get_line_internal (tree, line_number, real_line_number, FALSE);
}
GtkTextLine*
-gtk_text_btree_get_line_at_char(GtkTextBTree *tree,
- gint char_index,
- gint *line_start_index,
- gint *real_char_index)
+_gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
+ gint char_index,
+ gint *line_start_index,
+ gint *real_char_index)
{
GtkTextBTreeNode *node;
GtkTextLine *line;
GtkTextLineSegment *seg;
int chars_left;
int chars_in_line;
- int bytes_in_line;
-
+
node = tree->root_node;
- /* Clamp to valid indexes (-1 is magic for "highest index") */
- if (char_index < 0 || char_index >= node->num_chars)
+ /* Clamp to valid indexes (-1 is magic for "highest index"),
+ * node->num_chars includes the two newlines that aren't really
+ * in the buffer.
+ */
+ if (char_index < 0 || char_index >= (node->num_chars - 1))
{
- char_index = node->num_chars - 1;
+ char_index = node->num_chars - 2;
}
*real_char_index = char_index;
-
+
/*
* Work down through levels of the tree until a GtkTextBTreeNode is found at
* level 0.
{
chars_left -= node->num_chars;
- g_assert(chars_left >= 0);
+ g_assert (chars_left >= 0);
}
}
-
+
if (chars_left == 0)
{
/* Start of a line */
*line_start_index = char_index;
return node->children.line;
}
-
+
/*
* Work through the lines attached to the level-0 GtkTextBTreeNode.
*/
chars_in_line = 0;
- bytes_in_line = 0;
seg = NULL;
for (line = node->children.line; line != NULL; line = line->next)
{
{
if (chars_in_line + seg->char_count > chars_left)
goto found; /* found our line/segment */
-
+
chars_in_line += seg->char_count;
-
+
seg = seg->next;
}
chars_left -= chars_in_line;
-
+
chars_in_line = 0;
seg = NULL;
}
found:
-
- g_assert(line != NULL); /* hosage, ran out of lines */
- g_assert(seg != NULL);
+
+ g_assert (line != NULL); /* hosage, ran out of lines */
+ g_assert (seg != NULL);
*line_start_index = char_index - chars_left;
return line;
}
+/* It returns an array sorted by tags priority, ready to pass to
+ * _gtk_text_attributes_fill_from_tags() */
GtkTextTag**
-gtk_text_btree_get_tags (const GtkTextIter *iter,
+_gtk_text_btree_get_tags (const GtkTextIter *iter,
gint *num_tags)
{
GtkTextBTreeNode *node;
int src, dst, index;
TagInfo tagInfo;
GtkTextLine *line;
- GtkTextBTree *tree;
gint byte_index;
#define NUM_TAG_INFOS 10
-
- line = gtk_text_iter_get_text_line(iter);
- tree = gtk_text_iter_get_btree(iter);
- byte_index = gtk_text_iter_get_line_index(iter);
+
+ line = _gtk_text_iter_get_text_line (iter);
+ byte_index = gtk_text_iter_get_line_index (iter);
tagInfo.numTags = 0;
tagInfo.arraySize = NUM_TAG_INFOS;
- tagInfo.tags = g_new(GtkTextTag*, NUM_TAG_INFOS);
- tagInfo.counts = g_new(int, NUM_TAG_INFOS);
+ tagInfo.tags = g_new (GtkTextTag*, NUM_TAG_INFOS);
+ tagInfo.counts = g_new (int, NUM_TAG_INFOS);
/*
* Record tag toggles within the line of indexPtr but preceding
if ((seg->type == >k_text_toggle_on_type)
|| (seg->type == >k_text_toggle_off_type))
{
- inc_count(seg->body.toggle.info->tag, 1, &tagInfo);
+ inc_count (seg->body.toggle.info->tag, 1, &tagInfo);
}
}
if ((seg->type == >k_text_toggle_on_type)
|| (seg->type == >k_text_toggle_off_type))
{
- inc_count(seg->body.toggle.info->tag, 1, &tagInfo);
+ inc_count (seg->body.toggle.info->tag, 1, &tagInfo);
}
}
}
GtkTextBTreeNode *siblingPtr;
Summary *summary;
- for (siblingPtr = node->parent->children.node;
+ for (siblingPtr = node->parent->children.node;
siblingPtr != node; siblingPtr = siblingPtr->next)
{
for (summary = siblingPtr->summary; summary != NULL;
{
if (summary->toggle_count & 1)
{
- inc_count(summary->info->tag, summary->toggle_count,
- &tagInfo);
+ inc_count (summary->info->tag, summary->toggle_count,
+ &tagInfo);
}
}
}
{
if (tagInfo.counts[src] & 1)
{
- g_assert(GTK_IS_TEXT_TAG(tagInfo.tags[src]));
+ g_assert (GTK_IS_TEXT_TAG (tagInfo.tags[src]));
tagInfo.tags[dst] = tagInfo.tags[src];
dst++;
}
}
-
+
*num_tags = dst;
- g_free(tagInfo.counts);
+ g_free (tagInfo.counts);
if (dst == 0)
{
- g_free(tagInfo.tags);
+ g_free (tagInfo.tags);
return NULL;
}
- return tagInfo.tags;
+
+ /* Sort tags in ascending order of priority */
+ _gtk_text_tag_array_sort (tagInfo.tags, dst);
+
+ return tagInfo.tags;
}
static void
-copy_segment(GString *string,
- gboolean include_hidden,
- gboolean include_nonchars,
- const GtkTextIter *start,
- const GtkTextIter *end)
+copy_segment (GString *string,
+ gboolean include_hidden,
+ gboolean include_nonchars,
+ const GtkTextIter *start,
+ const GtkTextIter *end)
{
GtkTextLineSegment *end_seg;
GtkTextLineSegment *seg;
-
- if (gtk_text_iter_equal(start, end))
+
+ if (gtk_text_iter_equal (start, end))
return;
- seg = gtk_text_iter_get_indexable_segment(start);
- end_seg = gtk_text_iter_get_indexable_segment(end);
-
+ seg = _gtk_text_iter_get_indexable_segment (start);
+ end_seg = _gtk_text_iter_get_indexable_segment (end);
+
if (seg->type == >k_text_char_type)
{
gboolean copy = TRUE;
/* Don't copy if we're invisible; segments are invisible/not
as a whole, no need to check each char */
if (!include_hidden &&
- gtk_text_btree_char_is_invisible(start))
+ _gtk_text_btree_char_is_invisible (start))
{
copy = FALSE;
- /* printf(" <invisible>\n"); */
+ /* printf (" <invisible>\n"); */
}
- copy_start = gtk_text_iter_get_segment_byte(start);
+ copy_start = _gtk_text_iter_get_segment_byte (start);
if (seg == end_seg)
{
/* End is in the same segment; need to copy fewer bytes. */
- gint end_byte = gtk_text_iter_get_segment_byte(end);
+ gint end_byte = _gtk_text_iter_get_segment_byte (end);
copy_bytes = end_byte - copy_start;
}
else
copy_bytes = seg->byte_count - copy_start;
- g_assert(copy_bytes != 0); /* Due to iter equality check at
- front of this function. */
+ g_assert (copy_bytes != 0); /* Due to iter equality check at
+ front of this function. */
if (copy)
{
- g_assert((copy_start + copy_bytes) <= seg->byte_count);
-
- g_string_append_len(string,
- seg->body.chars + copy_start,
- copy_bytes);
+ g_assert ((copy_start + copy_bytes) <= seg->byte_count);
+
+ g_string_append_len (string,
+ seg->body.chars + copy_start,
+ copy_bytes);
}
-
- /* printf(" :%s\n", string->str); */
+
+ /* printf (" :%s\n", string->str); */
}
- else if (seg->type == >k_text_pixbuf_type)
+ else if (seg->type == >k_text_pixbuf_type ||
+ seg->type == >k_text_child_type)
{
gboolean copy = TRUE;
copy = FALSE;
}
else if (!include_hidden &&
- gtk_text_btree_char_is_invisible(start))
+ _gtk_text_btree_char_is_invisible (start))
{
copy = FALSE;
}
if (copy)
{
- g_string_append_len(string,
- gtk_text_unknown_char_utf8,
- 3);
+ g_string_append_len (string,
+ _gtk_text_unknown_char_utf8,
+ GTK_TEXT_UNKNOWN_CHAR_UTF8_LEN);
}
}
}
gchar*
-gtk_text_btree_get_text (const GtkTextIter *start_orig,
+_gtk_text_btree_get_text (const GtkTextIter *start_orig,
const GtkTextIter *end_orig,
gboolean include_hidden,
gboolean include_nonchars)
GtkTextLineSegment *seg;
GtkTextLineSegment *end_seg;
GString *retval;
- GtkTextBTree *tree;
gchar *str;
GtkTextIter iter;
GtkTextIter start;
GtkTextIter end;
-
- g_return_val_if_fail(start_orig != NULL, NULL);
- g_return_val_if_fail(end_orig != NULL, NULL);
- g_return_val_if_fail(gtk_text_iter_get_btree(start_orig) ==
- gtk_text_iter_get_btree(end_orig), NULL);
+
+ g_return_val_if_fail (start_orig != NULL, NULL);
+ g_return_val_if_fail (end_orig != NULL, NULL);
+ g_return_val_if_fail (_gtk_text_iter_get_btree (start_orig) ==
+ _gtk_text_iter_get_btree (end_orig), NULL);
start = *start_orig;
end = *end_orig;
- gtk_text_iter_reorder(&start, &end);
-
- retval = g_string_new("");
-
- tree = gtk_text_iter_get_btree(&start);
-
- end_seg = gtk_text_iter_get_indexable_segment(&end);
+ gtk_text_iter_order (&start, &end);
+
+ retval = g_string_new (NULL);
+
+ end_seg = _gtk_text_iter_get_indexable_segment (&end);
iter = start;
- seg = gtk_text_iter_get_indexable_segment(&iter);
+ seg = _gtk_text_iter_get_indexable_segment (&iter);
while (seg != end_seg)
- {
- copy_segment(retval, include_hidden, include_nonchars,
- &iter, &end);
+ {
+ copy_segment (retval, include_hidden, include_nonchars,
+ &iter, &end);
- gtk_text_iter_forward_indexable_segment(&iter);
-
- seg = gtk_text_iter_get_indexable_segment(&iter);
+ _gtk_text_iter_forward_indexable_segment (&iter);
+
+ seg = _gtk_text_iter_get_indexable_segment (&iter);
}
- copy_segment(retval, include_hidden, include_nonchars, &iter, &end);
-
+ copy_segment (retval, include_hidden, include_nonchars, &iter, &end);
+
str = retval->str;
- g_string_free(retval, FALSE);
+ g_string_free (retval, FALSE);
return str;
}
gint
-gtk_text_btree_line_count (GtkTextBTree *tree)
+_gtk_text_btree_line_count (GtkTextBTree *tree)
{
/* Subtract bogus line at the end; we return a count
of usable lines. */
}
gint
-gtk_text_btree_char_count (GtkTextBTree *tree)
+_gtk_text_btree_char_count (GtkTextBTree *tree)
{
- /* Exclude newline in bogus last line */
- return tree->root_node->num_chars - 1;
+ /* Exclude newline in bogus last line and the
+ * one in the last line that is after the end iterator
+ */
+ return tree->root_node->num_chars - 2;
}
#define LOTSA_TAGS 1000
gboolean
-gtk_text_btree_char_is_invisible (const GtkTextIter *iter)
+_gtk_text_btree_char_is_invisible (const GtkTextIter *iter)
{
gboolean invisible = FALSE; /* if nobody says otherwise, it's visible */
- int deftagCnts[LOTSA_TAGS];
+ int deftagCnts[LOTSA_TAGS] = { 0, };
int *tagCnts = deftagCnts;
GtkTextTag *deftags[LOTSA_TAGS];
GtkTextTag **tags = deftags;
GtkTextLine *line;
GtkTextBTree *tree;
gint byte_index;
-
- line = gtk_text_iter_get_text_line(iter);
- tree = gtk_text_iter_get_btree(iter);
- byte_index = gtk_text_iter_get_line_index(iter);
-
- numTags = gtk_text_tag_table_size(tree->table);
-
+
+ line = _gtk_text_iter_get_text_line (iter);
+ tree = _gtk_text_iter_get_btree (iter);
+ byte_index = gtk_text_iter_get_line_index (iter);
+
+ numTags = gtk_text_tag_table_get_size (tree->table);
+
/* almost always avoid malloc, so stay out of system calls */
if (LOTSA_TAGS < numTags)
{
- tagCnts = g_new(int, numTags);
- tags = g_new(GtkTextTag*, numTags);
+ tagCnts = g_new0 (int, numTags);
+ tags = g_new (GtkTextTag*, numTags);
}
-
- for (i=0; i<numTags; i++)
- {
- tagCnts[i] = 0;
- }
-
+
/*
* Record tag toggles within the line of indexPtr but preceding
* indexPtr.
for (index = 0, seg = line->segments;
(index + seg->byte_count) <= byte_index; /* segfault here means invalid index */
index += seg->byte_count, seg = seg->next)
- {
+ {
if ((seg->type == >k_text_toggle_on_type)
|| (seg->type == >k_text_toggle_off_type))
{
tag = seg->body.toggle.info->tag;
- if (tag->invisible_set && tag->values->invisible)
+ if (tag->priv->invisible_set)
{
- tags[tag->priority] = tag;
- tagCnts[tag->priority]++;
+ tags[tag->priv->priority] = tag;
+ tagCnts[tag->priv->priority]++;
}
}
}
|| (seg->type == >k_text_toggle_off_type))
{
tag = seg->body.toggle.info->tag;
- if (tag->invisible_set && tag->values->invisible)
+ if (tag->priv->invisible_set)
{
- tags[tag->priority] = tag;
- tagCnts[tag->priority]++;
+ tags[tag->priv->priority] = tag;
+ tagCnts[tag->priv->priority]++;
}
}
}
GtkTextBTreeNode *siblingPtr;
Summary *summary;
- for (siblingPtr = node->parent->children.node;
+ for (siblingPtr = node->parent->children.node;
siblingPtr != node; siblingPtr = siblingPtr->next)
{
for (summary = siblingPtr->summary; summary != NULL;
if (summary->toggle_count & 1)
{
tag = summary->info->tag;
- if (tag->invisible_set && tag->values->invisible)
+ if (tag->priv->invisible_set)
{
- tags[tag->priority] = tag;
- tagCnts[tag->priority] += summary->toggle_count;
+ tags[tag->priv->priority] = tag;
+ tagCnts[tag->priv->priority] += summary->toggle_count;
}
}
}
}
/*
- * Now traverse from highest priority to lowest,
+ * Now traverse from highest priority to lowest,
* take invisible value from first odd count (= on)
*/
}
#endif
#endif
- invisible = tags[i]->values->invisible;
+ invisible = tags[i]->priv->values->invisible;
break;
}
}
if (LOTSA_TAGS < numTags)
{
- g_free(tagCnts);
- g_free(tags);
+ g_free (tagCnts);
+ g_free (tags);
}
- return invisible;
+ return invisible;
}
static void
redisplay_region (GtkTextBTree *tree,
- const GtkTextIter *start,
- const GtkTextIter *end)
+ const GtkTextIter *start,
+ const GtkTextIter *end,
+ gboolean cursors_only)
{
BTreeView *view;
GtkTextLine *start_line, *end_line;
start = end;
end = tmp;
}
-
- start_line = gtk_text_iter_get_text_line (start);
- end_line = gtk_text_iter_get_text_line (end);
-
+
+ start_line = _gtk_text_iter_get_text_line (start);
+ end_line = _gtk_text_iter_get_text_line (end);
+
view = tree->views;
while (view != NULL)
{
gint start_y, end_y;
GtkTextLineData *ld;
- start_y = gtk_text_btree_find_line_top (tree, start_line, view->view_id);
+ start_y = _gtk_text_btree_find_line_top (tree, start_line, view->view_id);
if (end_line == start_line)
- end_y = start_y;
+ end_y = start_y;
else
- end_y = gtk_text_btree_find_line_top (tree, end_line, view->view_id);
+ end_y = _gtk_text_btree_find_line_top (tree, end_line, view->view_id);
- ld = gtk_text_line_get_data (end_line, view->view_id);
+ ld = _gtk_text_line_get_data (end_line, view->view_id);
if (ld)
- end_y += ld->height;
-
- gtk_text_layout_changed (view->layout, start_y, end_y - start_y, end_y - start_y);
+ end_y += ld->height;
+
+ if (cursors_only)
+ gtk_text_layout_cursors_changed (view->layout, start_y,
+ end_y - start_y,
+ end_y - start_y);
+ else
+ gtk_text_layout_changed (view->layout, start_y,
+ end_y - start_y,
+ end_y - start_y);
view = view->next;
}
}
static void
-redisplay_mark(GtkTextLineSegment *mark)
+redisplay_mark (GtkTextLineSegment *mark)
{
GtkTextIter iter;
GtkTextIter end;
-
- gtk_text_btree_get_iter_at_mark(mark->body.mark.tree,
- &iter,
- (GtkTextMark*)mark);
+ gboolean cursor_only;
+
+ _gtk_text_btree_get_iter_at_mark (mark->body.mark.tree,
+ &iter,
+ mark->body.mark.obj);
end = iter;
- gtk_text_iter_next_char(&end);
+ gtk_text_iter_forward_char (&end);
- gtk_text_btree_invalidate_region(mark->body.mark.tree,
- &iter, &end);
+ DV (g_print ("invalidating due to moving visible mark (%s)\n", G_STRLOC));
+ cursor_only = mark == mark->body.mark.tree->insert_mark->segment;
+ _gtk_text_btree_invalidate_region (mark->body.mark.tree, &iter, &end, cursor_only);
}
static void
-redisplay_mark_if_visible(GtkTextLineSegment *mark)
+redisplay_mark_if_visible (GtkTextLineSegment *mark)
{
if (!mark->body.mark.visible)
return;
else
- redisplay_mark(mark);
+ redisplay_mark (mark);
}
static void
-ensure_not_off_end(GtkTextBTree *tree,
- GtkTextLineSegment *mark,
- GtkTextIter *iter)
+ensure_not_off_end (GtkTextBTree *tree,
+ GtkTextLineSegment *mark,
+ GtkTextIter *iter)
{
- if (gtk_text_iter_get_line(iter) ==
- gtk_text_btree_line_count(tree))
- gtk_text_iter_prev_char(iter);
+ if (gtk_text_iter_get_line (iter) == _gtk_text_btree_line_count (tree))
+ gtk_text_iter_backward_char (iter);
}
static GtkTextLineSegment*
-real_set_mark(GtkTextBTree *tree,
- GtkTextMark *existing_mark,
- const gchar *name,
- gboolean left_gravity,
- const GtkTextIter *where,
- gboolean should_exist,
- gboolean redraw_selections)
+real_set_mark (GtkTextBTree *tree,
+ GtkTextMark *existing_mark,
+ const gchar *name,
+ gboolean left_gravity,
+ const GtkTextIter *where,
+ gboolean should_exist,
+ gboolean redraw_selections)
{
GtkTextLineSegment *mark;
GtkTextIter iter;
-
- g_return_val_if_fail(tree != NULL, NULL);
- g_return_val_if_fail(where != NULL, NULL);
- g_return_val_if_fail(gtk_text_iter_get_btree(where) == tree, NULL);
+
+ g_return_val_if_fail (tree != NULL, NULL);
+ g_return_val_if_fail (where != NULL, NULL);
+ g_return_val_if_fail (_gtk_text_iter_get_btree (where) == tree, NULL);
if (existing_mark)
- mark = (GtkTextLineSegment*) existing_mark;
+ {
+ if (gtk_text_mark_get_buffer (existing_mark) != NULL)
+ mark = existing_mark->segment;
+ else
+ mark = NULL;
+ }
else if (name != NULL)
- mark = g_hash_table_lookup(tree->mark_table,
- name);
+ mark = g_hash_table_lookup (tree->mark_table,
+ name);
else
mark = NULL;
-
+
if (should_exist && mark == NULL)
{
- g_warning("No mark `%s' exists!", name);
+ g_warning ("No mark `%s' exists!", name);
return NULL;
}
/* OK if !should_exist and it does already exist, in that case
- we just move it. */
-
+ * we just move it.
+ */
+
iter = *where;
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_iter_check (&iter);
if (mark != NULL)
{
if (redraw_selections &&
- (mark == tree->insert_mark ||
- mark == tree->selection_bound_mark))
- {
- GtkTextIter old_pos;
+ (mark == tree->insert_mark->segment ||
+ mark == tree->selection_bound_mark->segment))
+ {
+ GtkTextIter old_pos;
+
+ _gtk_text_btree_get_iter_at_mark (tree, &old_pos,
+ mark->body.mark.obj);
+ redisplay_region (tree, &old_pos, where, TRUE);
+ }
- gtk_text_btree_get_iter_at_mark (tree, &old_pos, (GtkTextMark*)mark);
- redisplay_region (tree, &old_pos, where);
- }
-
/*
* don't let visible marks be after the final newline of the
* file.
*/
-
+
if (mark->body.mark.visible)
{
- ensure_not_off_end(tree, mark, &iter);
+ ensure_not_off_end (tree, mark, &iter);
}
/* Redraw the mark's old location. */
- redisplay_mark_if_visible(mark);
-
+ redisplay_mark_if_visible (mark);
+
/* Unlink mark from its current location.
This could hose our iterator... */
- gtk_text_btree_unlink_segment(tree, mark,
- mark->body.mark.line);
- mark->body.mark.line = gtk_text_iter_get_text_line(&iter);
- g_assert(mark->body.mark.line == gtk_text_iter_get_text_line(&iter));
+ gtk_text_btree_unlink_segment (tree, mark,
+ mark->body.mark.line);
+ mark->body.mark.line = _gtk_text_iter_get_text_line (&iter);
+ g_assert (mark->body.mark.line == _gtk_text_iter_get_text_line (&iter));
- segments_changed(tree); /* make sure the iterator recomputes its
- segment */
+ segments_changed (tree); /* make sure the iterator recomputes its
+ segment */
}
else
{
- mark = _mark_segment_new (tree,
- left_gravity,
- name);
+ if (existing_mark)
+ g_object_ref (existing_mark);
+ else
+ existing_mark = gtk_text_mark_new (name, left_gravity);
- mark->body.mark.line = gtk_text_iter_get_text_line(&iter);
+ mark = existing_mark->segment;
+ _gtk_mark_segment_set_tree (mark, tree);
+
+ mark->body.mark.line = _gtk_text_iter_get_text_line (&iter);
if (mark->body.mark.name)
- g_hash_table_insert(tree->mark_table,
- mark->body.mark.name,
- mark);
+ g_hash_table_insert (tree->mark_table,
+ mark->body.mark.name,
+ mark);
}
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_iter_check (&iter);
/* Link mark into new location */
- gtk_text_btree_link_segment(mark, &iter);
-
+ gtk_text_btree_link_segment (mark, &iter);
+
/* Invalidate some iterators. */
- segments_changed(tree);
-
+ segments_changed (tree);
+
/*
* update the screen at the mark's new location.
*/
- redisplay_mark_if_visible(mark);
+ redisplay_mark_if_visible (mark);
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_iter_check (&iter);
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
+
return mark;
}
GtkTextMark*
-gtk_text_btree_set_mark (GtkTextBTree *tree,
+_gtk_text_btree_set_mark (GtkTextBTree *tree,
GtkTextMark *existing_mark,
const gchar *name,
gboolean left_gravity,
const GtkTextIter *iter,
gboolean should_exist)
{
- return (GtkTextMark*)real_set_mark(tree, existing_mark,
- name, left_gravity, iter, should_exist,
- TRUE);
+ GtkTextLineSegment *seg;
+
+ seg = real_set_mark (tree, existing_mark,
+ name, left_gravity, iter, should_exist,
+ TRUE);
+
+ return seg ? seg->body.mark.obj : NULL;
}
gboolean
-gtk_text_btree_get_selection_bounds (GtkTextBTree *tree,
- GtkTextIter *start,
- GtkTextIter *end)
+_gtk_text_btree_get_selection_bounds (GtkTextBTree *tree,
+ GtkTextIter *start,
+ GtkTextIter *end)
{
GtkTextIter tmp_start, tmp_end;
-
- gtk_text_btree_get_iter_at_mark (tree, &tmp_start,
- (GtkTextMark*)tree->insert_mark);
- gtk_text_btree_get_iter_at_mark (tree, &tmp_end,
- (GtkTextMark*)tree->selection_bound_mark);
-
- if (gtk_text_iter_equal(&tmp_start, &tmp_end))
+
+ _gtk_text_btree_get_iter_at_mark (tree, &tmp_start,
+ tree->insert_mark);
+ _gtk_text_btree_get_iter_at_mark (tree, &tmp_end,
+ tree->selection_bound_mark);
+
+ if (gtk_text_iter_equal (&tmp_start, &tmp_end))
{
if (start)
*start = tmp_start;
if (end)
*end = tmp_end;
+
+ return FALSE;
}
else
{
- gtk_text_iter_reorder(&tmp_start, &tmp_end);
+ gtk_text_iter_order (&tmp_start, &tmp_end);
if (start)
*start = tmp_start;
if (end)
*end = tmp_end;
-
+
return TRUE;
}
}
void
-gtk_text_btree_place_cursor(GtkTextBTree *tree,
- const GtkTextIter *iter)
+_gtk_text_btree_place_cursor (GtkTextBTree *tree,
+ const GtkTextIter *iter)
{
- GtkTextIter start, end;
-
- if (gtk_text_btree_get_selection_bounds (tree, &start, &end))
- redisplay_region(tree, &start, &end);
-
- /* Move insert AND selection_bound before we redisplay */
- real_set_mark(tree, (GtkTextMark*) tree->insert_mark,
- "insert", FALSE, iter, TRUE, FALSE);
- real_set_mark(tree, (GtkTextMark*) tree->selection_bound_mark,
- "selection_bound", FALSE, iter, TRUE, FALSE);
+ _gtk_text_btree_select_range (tree, iter, iter);
+}
+
+void
+_gtk_text_btree_select_range (GtkTextBTree *tree,
+ const GtkTextIter *ins,
+ const GtkTextIter *bound)
+{
+ GtkTextIter old_ins, old_bound;
+
+ _gtk_text_btree_get_iter_at_mark (tree, &old_ins,
+ tree->insert_mark);
+ _gtk_text_btree_get_iter_at_mark (tree, &old_bound,
+ tree->selection_bound_mark);
+
+ /* Check if it's no-op since gtk_text_buffer_place_cursor()
+ * also calls this, and this will redraw the cursor line. */
+ if (!gtk_text_iter_equal (&old_ins, ins) ||
+ !gtk_text_iter_equal (&old_bound, bound))
+ {
+ redisplay_region (tree, &old_ins, &old_bound, TRUE);
+
+ /* Move insert AND selection_bound before we redisplay */
+ real_set_mark (tree, tree->insert_mark,
+ "insert", FALSE, ins, TRUE, FALSE);
+ real_set_mark (tree, tree->selection_bound_mark,
+ "selection_bound", FALSE, bound, TRUE, FALSE);
+
+ redisplay_region (tree, ins, bound, TRUE);
+ }
}
+
void
-gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
+_gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
const gchar *name)
{
GtkTextMark *mark;
- g_return_if_fail(tree != NULL);
- g_return_if_fail(name != NULL);
-
- mark = g_hash_table_lookup(tree->mark_table,
- name);
+ g_return_if_fail (tree != NULL);
+ g_return_if_fail (name != NULL);
- gtk_text_btree_remove_mark(tree, mark);
+ mark = g_hash_table_lookup (tree->mark_table,
+ name);
+
+ _gtk_text_btree_remove_mark (tree, mark);
}
void
-gtk_text_btree_remove_mark (GtkTextBTree *tree,
- GtkTextMark *mark)
+_gtk_text_btree_release_mark_segment (GtkTextBTree *tree,
+ GtkTextLineSegment *segment)
{
- GtkTextLineSegment *segment = (GtkTextLineSegment*) mark;
+
+ if (segment->body.mark.name)
+ g_hash_table_remove (tree->mark_table, segment->body.mark.name);
+
+ segment->body.mark.tree = NULL;
+ segment->body.mark.line = NULL;
- g_return_if_fail (segment != NULL);
+ /* Remove the ref on the mark, which frees segment as a side effect
+ * if this is the last reference.
+ */
+ g_object_unref (segment->body.mark.obj);
+}
+
+void
+_gtk_text_btree_remove_mark (GtkTextBTree *tree,
+ GtkTextMark *mark)
+{
+ GtkTextLineSegment *segment;
+
+ g_return_if_fail (mark != NULL);
g_return_if_fail (tree != NULL);
+ segment = mark->segment;
+
if (segment->body.mark.not_deleteable)
{
- g_warning("Can't delete special mark `%s'", segment->body.mark.name);
+ g_warning ("Can't delete special mark `%s'", segment->body.mark.name);
return;
}
/* This calls cleanup_line and segments_changed */
gtk_text_btree_unlink_segment (tree, segment, segment->body.mark.line);
- if (segment->body.mark.name)
- g_hash_table_remove (tree->mark_table, segment->body.mark.name);
-
- _mark_segment_unref (segment);
-
- segment->body.mark.tree = NULL;
- segment->body.mark.line = NULL;
+ _gtk_text_btree_release_mark_segment (tree, segment);
}
gboolean
-gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
- GtkTextMark *segment)
+_gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
+ GtkTextMark *segment)
{
- return segment == (GtkTextMark*) tree->insert_mark;
+ return segment == tree->insert_mark;
}
gboolean
-gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
- GtkTextMark *segment)
+_gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
+ GtkTextMark *segment)
{
- return segment == (GtkTextMark*) tree->selection_bound_mark;
+ return segment == tree->selection_bound_mark;
+}
+
+GtkTextMark *
+_gtk_text_btree_get_insert (GtkTextBTree *tree)
+{
+ return tree->insert_mark;
+}
+
+GtkTextMark *
+_gtk_text_btree_get_selection_bound (GtkTextBTree *tree)
+{
+ return tree->selection_bound_mark;
}
GtkTextMark*
-gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
- const gchar *name)
+_gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
+ const gchar *name)
{
- g_return_val_if_fail(tree != NULL, NULL);
- g_return_val_if_fail(name != NULL, NULL);
+ GtkTextLineSegment *seg;
+
+ g_return_val_if_fail (tree != NULL, NULL);
+ g_return_val_if_fail (name != NULL, NULL);
- return g_hash_table_lookup(tree->mark_table, name);
+ seg = g_hash_table_lookup (tree->mark_table, name);
+
+ return seg ? seg->body.mark.obj : NULL;
}
+/**
+ * gtk_text_mark_set_visible:
+ * @mark: a #GtkTextMark
+ * @setting: visibility of mark
+ *
+ * Sets the visibility of @mark; the insertion point is normally
+ * visible, i.e. you can see it as a vertical bar. Also, the text
+ * widget uses a visible mark to indicate where a drop will occur when
+ * dragging-and-dropping text. Most other marks are not visible.
+ * Marks are not visible by default.
+ *
+ **/
void
gtk_text_mark_set_visible (GtkTextMark *mark,
- gboolean setting)
+ gboolean setting)
{
GtkTextLineSegment *seg;
-
- g_return_if_fail(mark != NULL);
-
- seg = (GtkTextLineSegment*)mark;
+
+ g_return_if_fail (mark != NULL);
+
+ seg = mark->segment;
if (seg->body.mark.visible == setting)
return;
{
seg->body.mark.visible = setting;
- redisplay_mark(seg);
+ if (seg->body.mark.tree)
+ redisplay_mark (seg);
}
}
GtkTextLine*
-gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
+_gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
GtkTextTag *tag)
{
GtkTextBTreeNode *node;
GtkTextTagInfo *info;
-
- g_return_val_if_fail(tree != NULL, NULL);
+
+ g_return_val_if_fail (tree != NULL, NULL);
if (tag != NULL)
- {
- info = gtk_text_btree_get_existing_tag_info(tree, tag);
+ {
+ info = gtk_text_btree_get_existing_tag_info (tree, tag);
if (info == NULL)
return NULL;
-
+
if (info->tag_root == NULL)
return NULL;
-
+
node = info->tag_root;
/* We know the tag root has instances of the given
tag below it */
continue_outer_loop:
- g_assert(node != NULL);
+ g_assert (node != NULL);
while (node->level > 0)
{
- g_assert(node != NULL); /* Failure probably means bad tag summaries. */
+ g_assert (node != NULL); /* Failure probably means bad tag summaries. */
node = node->children.node;
while (node != NULL)
{
- if (gtk_text_btree_node_has_tag(node, tag))
+ if (gtk_text_btree_node_has_tag (node, tag))
goto continue_outer_loop;
-
+
node = node->next;
}
- g_assert(node != NULL);
+ g_assert (node != NULL);
}
-
- g_assert(node != NULL); /* The tag summaries said some node had
- tag toggles... */
-
- g_assert(node->level == 0);
-
+
+ g_assert (node != NULL); /* The tag summaries said some node had
+ tag toggles... */
+
+ g_assert (node->level == 0);
+
return node->children.line;
}
else
Unfortunately this can't be done in a simple and efficient way
right now; so I'm just going to return the
first line in the btree. FIXME */
- return gtk_text_btree_get_line (tree, 0, NULL);
+ return _gtk_text_btree_get_line (tree, 0, NULL);
}
}
GtkTextLine*
-gtk_text_btree_last_could_contain_tag (GtkTextBTree *tree,
+_gtk_text_btree_last_could_contain_tag (GtkTextBTree *tree,
GtkTextTag *tag)
{
GtkTextBTreeNode *node;
GtkTextBTreeNode *last_node;
GtkTextLine *line;
GtkTextTagInfo *info;
-
- g_return_val_if_fail(tree != NULL, NULL);
-
+
+ g_return_val_if_fail (tree != NULL, NULL);
+
if (tag != NULL)
{
- info = gtk_text_btree_get_existing_tag_info(tree, tag);
-
+ info = gtk_text_btree_get_existing_tag_info (tree, tag);
+
if (info->tag_root == NULL)
return NULL;
-
+
node = info->tag_root;
/* We know the tag root has instances of the given
tag below it */
-
+
while (node->level > 0)
{
- g_assert(node != NULL); /* Failure probably means bad tag summaries. */
+ g_assert (node != NULL); /* Failure probably means bad tag summaries. */
last_node = NULL;
node = node->children.node;
while (node != NULL)
{
- if (gtk_text_btree_node_has_tag(node, tag))
+ if (gtk_text_btree_node_has_tag (node, tag))
last_node = node;
node = node->next;
}
node = last_node;
}
- g_assert(node != NULL); /* The tag summaries said some node had
- tag toggles... */
-
- g_assert(node->level == 0);
-
+ g_assert (node != NULL); /* The tag summaries said some node had
+ tag toggles... */
+
+ g_assert (node->level == 0);
+
/* Find the last line in this node */
line = node->children.line;
while (line->next != NULL)
at least not without complexity.
So, we just return the last line.
*/
- return gtk_text_btree_get_line (tree, -1, NULL);
+ return _gtk_text_btree_get_end_iter_line (tree);
}
}
*/
gint
-gtk_text_line_get_number (GtkTextLine *line)
+_gtk_text_line_get_number (GtkTextLine *line)
{
GtkTextLine *line2;
GtkTextBTreeNode *node, *parent, *node2;
{
if (line2 == NULL)
{
- g_error("gtk_text_btree_line_number couldn't find line");
+ g_error ("gtk_text_btree_line_number couldn't find line");
}
index += 1;
}
{
if (node2 == NULL)
{
- g_error("gtk_text_btree_line_number couldn't find GtkTextBTreeNode");
+ g_error ("gtk_text_btree_line_number couldn't find GtkTextBTreeNode");
}
index += node2->num_lines;
}
}
- return index;
+ return index;
}
static GtkTextLineSegment*
-find_toggle_segment_before_char(GtkTextLine *line,
- gint char_in_line,
- GtkTextTag *tag)
+find_toggle_segment_before_char (GtkTextLine *line,
+ gint char_in_line,
+ GtkTextTag *tag)
{
GtkTextLineSegment *seg;
GtkTextLineSegment *toggle_seg;
}
static GtkTextLineSegment*
-find_toggle_segment_before_byte(GtkTextLine *line,
- gint byte_in_line,
- GtkTextTag *tag)
+find_toggle_segment_before_byte (GtkTextLine *line,
+ gint byte_in_line,
+ GtkTextTag *tag)
{
GtkTextLineSegment *seg;
GtkTextLineSegment *toggle_seg;
}
static gboolean
-find_toggle_outside_current_line(GtkTextLine *line,
- GtkTextBTree *tree,
- GtkTextTag *tag)
+find_toggle_outside_current_line (GtkTextLine *line,
+ GtkTextBTree *tree,
+ GtkTextTag *tag)
{
GtkTextBTreeNode *node;
GtkTextLine *sibling_line;
GtkTextLineSegment *toggle_seg;
int toggles;
GtkTextTagInfo *info = NULL;
-
+
/*
* No toggle in this line. Look for toggles for the tag in lines
* that are predecessors of line but under the same
seg = seg->next;
}
-
+
sibling_line = sibling_line->next;
}
if (toggle_seg != NULL)
return (toggle_seg->type == >k_text_toggle_on_type);
-
+
/*
* No toggle in this GtkTextBTreeNode. Scan upwards through the ancestors of
* this GtkTextBTreeNode, counting the number of toggles of the given tag in
* siblings that precede that GtkTextBTreeNode.
*/
- info = gtk_text_btree_get_existing_tag_info(tree, tag);
+ info = gtk_text_btree_get_existing_tag_info (tree, tag);
if (info == NULL)
return FALSE;
-
+
toggles = 0;
node = line->parent;
while (node->parent != NULL)
{
GtkTextBTreeNode *sibling_node;
-
+
sibling_node = node->parent->children.node;
while (sibling_node != node)
{
Summary *summary;
-
+
summary = sibling_node->summary;
while (summary != NULL)
{
sibling_node = sibling_node->next;
}
-
+
if (node == info->tag_root)
break;
* given point.
*/
- return (toggles & 1) != 0;
+ return (toggles & 1) != 0;
}
/* FIXME this function is far too slow, for no good reason. */
gboolean
-gtk_text_line_char_has_tag (GtkTextLine *line,
- GtkTextBTree *tree,
- gint char_in_line,
- GtkTextTag *tag)
+_gtk_text_line_char_has_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ gint char_in_line,
+ GtkTextTag *tag)
{
GtkTextLineSegment *toggle_seg;
- g_return_val_if_fail(line != NULL, FALSE);
-
- /*
+ g_return_val_if_fail (line != NULL, FALSE);
+
+ /*
* Check for toggles for the tag in the line but before
* the char. If there is one, its type indicates whether or
* not the character is tagged.
*/
- toggle_seg = find_toggle_segment_before_char(line, char_in_line, tag);
-
+ toggle_seg = find_toggle_segment_before_char (line, char_in_line, tag);
+
if (toggle_seg != NULL)
return (toggle_seg->type == >k_text_toggle_on_type);
else
- return find_toggle_outside_current_line(line, tree, tag);
+ return find_toggle_outside_current_line (line, tree, tag);
}
gboolean
-gtk_text_line_byte_has_tag (GtkTextLine *line,
- GtkTextBTree *tree,
- gint byte_in_line,
- GtkTextTag *tag)
+_gtk_text_line_byte_has_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ gint byte_in_line,
+ GtkTextTag *tag)
{
GtkTextLineSegment *toggle_seg;
- g_return_val_if_fail(line != NULL, FALSE);
-
- /*
+ g_return_val_if_fail (line != NULL, FALSE);
+
+ /*
* Check for toggles for the tag in the line but before
* the char. If there is one, its type indicates whether or
* not the character is tagged.
*/
- toggle_seg = find_toggle_segment_before_byte(line, byte_in_line, tag);
-
+ toggle_seg = find_toggle_segment_before_byte (line, byte_in_line, tag);
+
if (toggle_seg != NULL)
return (toggle_seg->type == >k_text_toggle_on_type);
else
- return find_toggle_outside_current_line(line, tree, tag);
+ return find_toggle_outside_current_line (line, tree, tag);
}
gboolean
-gtk_text_line_is_last (GtkTextLine *line,
- GtkTextBTree *tree)
+_gtk_text_line_is_last (GtkTextLine *line,
+ GtkTextBTree *tree)
{
return line == get_last_line (tree);
}
+static void
+ensure_end_iter_line (GtkTextBTree *tree)
+{
+ if (tree->end_iter_line_stamp != tree->chars_changed_stamp)
+ {
+ gint real_line;
+
+ /* n_lines is without the magic line at the end */
+ g_assert (_gtk_text_btree_line_count (tree) >= 1);
+
+ tree->end_iter_line = _gtk_text_btree_get_line_no_last (tree, -1, &real_line);
+
+ tree->end_iter_line_stamp = tree->chars_changed_stamp;
+ }
+}
+
+static void
+ensure_end_iter_segment (GtkTextBTree *tree)
+{
+ if (tree->end_iter_segment_stamp != tree->segments_changed_stamp)
+ {
+ GtkTextLineSegment *seg;
+ GtkTextLineSegment *last_with_chars;
+
+ ensure_end_iter_line (tree);
+
+ last_with_chars = NULL;
+
+ seg = tree->end_iter_line->segments;
+ while (seg != NULL)
+ {
+ if (seg->char_count > 0)
+ last_with_chars = seg;
+ seg = seg->next;
+ }
+
+ tree->end_iter_segment = last_with_chars;
+
+ /* We know the last char in the last line is '\n' */
+ tree->end_iter_segment_byte_index = last_with_chars->byte_count - 1;
+ tree->end_iter_segment_char_offset = last_with_chars->char_count - 1;
+
+ tree->end_iter_segment_stamp = tree->segments_changed_stamp;
+
+ g_assert (tree->end_iter_segment->type == >k_text_char_type);
+ g_assert (tree->end_iter_segment->body.chars[tree->end_iter_segment_byte_index] == '\n');
+ }
+}
+
+gboolean
+_gtk_text_line_contains_end_iter (GtkTextLine *line,
+ GtkTextBTree *tree)
+{
+ ensure_end_iter_line (tree);
+
+ return line == tree->end_iter_line;
+}
+
+gboolean
+_gtk_text_btree_is_end (GtkTextBTree *tree,
+ GtkTextLine *line,
+ GtkTextLineSegment *seg,
+ int byte_index,
+ int char_offset)
+{
+ g_return_val_if_fail (byte_index >= 0 || char_offset >= 0, FALSE);
+
+ /* Do this first to avoid walking segments in most cases */
+ if (!_gtk_text_line_contains_end_iter (line, tree))
+ return FALSE;
+
+ ensure_end_iter_segment (tree);
+
+ if (seg != tree->end_iter_segment)
+ return FALSE;
+
+ if (byte_index >= 0)
+ return byte_index == tree->end_iter_segment_byte_index;
+ else
+ return char_offset == tree->end_iter_segment_char_offset;
+}
+
GtkTextLine*
-gtk_text_line_next (GtkTextLine *line)
+_gtk_text_line_next (GtkTextLine *line)
{
GtkTextBTreeNode *node;
node = line->parent;
while (node != NULL && node->next == NULL)
- node = node->parent;
+ node = node->parent;
if (node == NULL)
return NULL;
node = node->children.node;
}
- g_assert(node->children.line != line);
-
+ g_assert (node->children.line != line);
+
return node->children.line;
- }
+ }
+}
+
+GtkTextLine*
+_gtk_text_line_next_excluding_last (GtkTextLine *line)
+{
+ GtkTextLine *next;
+
+ next = _gtk_text_line_next (line);
+
+ /* If we were on the end iter line, we can't go to
+ * the last line
+ */
+ if (next && next->next == NULL && /* these checks are optimization only */
+ _gtk_text_line_next (next) == NULL)
+ return NULL;
+
+ return next;
}
GtkTextLine*
-gtk_text_line_previous (GtkTextLine *line)
+_gtk_text_line_previous (GtkTextLine *line)
{
GtkTextBTreeNode *node;
GtkTextBTreeNode *node2;
prev = prev->next;
if (prev == NULL)
- g_error("gtk_text_btree_previous_line ran out of lines");
+ g_error ("gtk_text_btree_previous_line ran out of lines");
}
/*
else if (node != node->parent->children.node)
break;
}
-
- for (node2 = node->parent->children.node; ;
+
+ for (node2 = node->parent->children.node; ;
node2 = node2->children.node)
{
while (node2->next != node)
return prev;
}
- g_assert_not_reached();
+ g_assert_not_reached ();
return NULL;
}
+
+GtkTextLineData*
+_gtk_text_line_data_new (GtkTextLayout *layout,
+ GtkTextLine *line)
+{
+ GtkTextLineData *line_data;
+
+ line_data = g_new (GtkTextLineData, 1);
+
+ line_data->view_id = layout;
+ line_data->next = NULL;
+ line_data->width = 0;
+ line_data->height = 0;
+ line_data->valid = FALSE;
+
+ return line_data;
+}
+
void
-gtk_text_line_add_data (GtkTextLine *line,
- GtkTextLineData *data)
+_gtk_text_line_add_data (GtkTextLine *line,
+ GtkTextLineData *data)
{
- g_return_if_fail(line != NULL);
- g_return_if_fail(data != NULL);
- g_return_if_fail(data->view_id != NULL);
-
+ g_return_if_fail (line != NULL);
+ g_return_if_fail (data != NULL);
+ g_return_if_fail (data->view_id != NULL);
+
if (line->views)
{
data->next = line->views;
}
gpointer
-gtk_text_line_remove_data (GtkTextLine *line,
+_gtk_text_line_remove_data (GtkTextLine *line,
gpointer view_id)
{
GtkTextLineData *prev;
GtkTextLineData *iter;
-
- g_return_val_if_fail(line != NULL, NULL);
- g_return_val_if_fail(view_id != NULL, NULL);
+
+ g_return_val_if_fail (line != NULL, NULL);
+ g_return_val_if_fail (view_id != NULL, NULL);
prev = NULL;
iter = line->views;
}
gpointer
-gtk_text_line_get_data (GtkTextLine *line,
- gpointer view_id)
+_gtk_text_line_get_data (GtkTextLine *line,
+ gpointer view_id)
{
GtkTextLineData *iter;
-
- g_return_val_if_fail(line != NULL, NULL);
- g_return_val_if_fail(view_id != NULL, NULL);
-
+
+ g_return_val_if_fail (line != NULL, NULL);
+ g_return_val_if_fail (view_id != NULL, NULL);
+
iter = line->views;
while (iter != NULL)
{
}
void
-gtk_text_line_invalidate_wrap (GtkTextLine *line,
- GtkTextLineData *ld)
+_gtk_text_line_invalidate_wrap (GtkTextLine *line,
+ GtkTextLineData *ld)
{
/* For now this is totally unoptimized. FIXME?
-
+
We could probably optimize the case where the width removed
is less than the max width for the parent node,
and the case where the height is unchanged when we re-wrap.
*/
- g_return_if_fail(ld != NULL);
-
+ g_return_if_fail (ld != NULL);
+
ld->valid = FALSE;
- gtk_text_btree_node_invalidate_upward(line->parent, ld->view_id);
+ gtk_text_btree_node_invalidate_upward (line->parent, ld->view_id);
}
gint
-gtk_text_line_char_count (GtkTextLine *line)
+_gtk_text_line_char_count (GtkTextLine *line)
{
GtkTextLineSegment *seg;
gint size;
-
+
size = 0;
seg = line->segments;
while (seg != NULL)
}
gint
-gtk_text_line_byte_count (GtkTextLine *line)
+_gtk_text_line_byte_count (GtkTextLine *line)
{
GtkTextLineSegment *seg;
gint size;
-
+
size = 0;
seg = line->segments;
while (seg != NULL)
size += seg->byte_count;
seg = seg->next;
}
-
+
return size;
}
gint
-gtk_text_line_char_index (GtkTextLine *target_line)
+_gtk_text_line_char_index (GtkTextLine *target_line)
{
GSList *node_stack = NULL;
GtkTextBTreeNode *iter;
GtkTextLine *line;
gint num_chars;
-
+
/* Push all our parent nodes onto a stack */
iter = target_line->parent;
- g_assert(iter != NULL);
-
+ g_assert (iter != NULL);
+
while (iter != NULL)
{
- node_stack = g_slist_prepend(node_stack, iter);
+ node_stack = g_slist_prepend (node_stack, iter);
iter = iter->parent;
}
/* Check that we have the root node on top of the stack. */
- g_assert(node_stack != NULL &&
- node_stack->data != NULL &&
- ((GtkTextBTreeNode*)node_stack->data)->parent == NULL);
+ g_assert (node_stack != NULL &&
+ node_stack->data != NULL &&
+ ((GtkTextBTreeNode*)node_stack->data)->parent == NULL);
/* Add up chars in all nodes before the nodes in our stack.
*/
{
GtkTextBTreeNode *child_iter;
GtkTextBTreeNode *next_node;
-
+
next_node = node_stack->next ?
node_stack->next->data : NULL;
- node_stack = g_slist_remove(node_stack, node_stack->data);
-
+ node_stack = g_slist_remove (node_stack, node_stack->data);
+
if (iter->level == 0)
{
/* stack should be empty when we're on the last node */
- g_assert(node_stack == NULL);
+ g_assert (node_stack == NULL);
break; /* Our children are now lines */
}
- g_assert(next_node != NULL);
- g_assert(iter != NULL);
- g_assert(next_node->parent == iter);
+ g_assert (next_node != NULL);
+ g_assert (iter != NULL);
+ g_assert (next_node->parent == iter);
/* Add up chars before us in the tree */
- child_iter = iter->children.node;
+ child_iter = iter->children.node;
while (child_iter != next_node)
{
- g_assert(child_iter != NULL);
-
+ g_assert (child_iter != NULL);
+
num_chars += child_iter->num_chars;
-
+
child_iter = child_iter->next;
}
iter = next_node;
}
- g_assert(iter != NULL);
- g_assert(iter == target_line->parent);
+ g_assert (iter != NULL);
+ g_assert (iter == target_line->parent);
/* Since we don't store char counts in lines, only in segments, we
have to iterate over the lines adding up segment char counts
line = iter->children.line;
while (line != target_line)
{
- g_assert(line != NULL);
+ g_assert (line != NULL);
- num_chars += gtk_text_line_char_count(line);
+ num_chars += _gtk_text_line_char_count (line);
line = line->next;
}
- g_assert(line == target_line);
+ g_assert (line == target_line);
return num_chars;
}
GtkTextLineSegment*
-gtk_text_line_byte_to_segment (GtkTextLine *line,
+_gtk_text_line_byte_to_segment (GtkTextLine *line,
gint byte_offset,
gint *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
- g_return_val_if_fail(line != NULL, NULL);
-
+ g_return_val_if_fail (line != NULL, NULL);
+
offset = byte_offset;
seg = line->segments;
while (offset >= seg->byte_count)
{
- g_assert(seg != NULL); /* means an invalid byte index */
offset -= seg->byte_count;
seg = seg->next;
+ g_assert (seg != NULL); /* means an invalid byte index */
}
if (seg_offset)
}
GtkTextLineSegment*
-gtk_text_line_char_to_segment (GtkTextLine *line,
+_gtk_text_line_char_to_segment (GtkTextLine *line,
gint char_offset,
gint *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
- g_return_val_if_fail(line != NULL, NULL);
-
+ g_return_val_if_fail (line != NULL, NULL);
+
offset = char_offset;
seg = line->segments;
while (offset >= seg->char_count)
{
- g_assert(seg != NULL); /* means an invalid char index */
offset -= seg->char_count;
seg = seg->next;
+ g_assert (seg != NULL); /* means an invalid char index */
}
if (seg_offset)
*seg_offset = offset;
- return seg;
+ return seg;
}
GtkTextLineSegment*
-gtk_text_line_byte_to_any_segment (GtkTextLine *line,
+_gtk_text_line_byte_to_any_segment (GtkTextLine *line,
gint byte_offset,
gint *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
- g_return_val_if_fail(line != NULL, NULL);
-
+ g_return_val_if_fail (line != NULL, NULL);
+
offset = byte_offset;
seg = line->segments;
while (offset > 0 && offset >= seg->byte_count)
{
- g_assert(seg != NULL); /* means an invalid byte index */
offset -= seg->byte_count;
seg = seg->next;
+ g_assert (seg != NULL); /* means an invalid byte index */
}
if (seg_offset)
}
GtkTextLineSegment*
-gtk_text_line_char_to_any_segment (GtkTextLine *line,
+_gtk_text_line_char_to_any_segment (GtkTextLine *line,
gint char_offset,
gint *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
- g_return_val_if_fail(line != NULL, NULL);
-
+ g_return_val_if_fail (line != NULL, NULL);
+
offset = char_offset;
seg = line->segments;
while (offset > 0 && offset >= seg->char_count)
{
- g_assert(seg != NULL); /* means an invalid byte index */
offset -= seg->char_count;
seg = seg->next;
+ g_assert (seg != NULL); /* means an invalid byte index */
}
if (seg_offset)
}
gint
-gtk_text_line_byte_to_char (GtkTextLine *line,
+_gtk_text_line_byte_to_char (GtkTextLine *line,
gint byte_offset)
{
gint char_offset;
GtkTextLineSegment *seg;
- g_return_val_if_fail(line != NULL, 0);
- g_return_val_if_fail(byte_offset >= 0, 0);
-
+ g_return_val_if_fail (line != NULL, 0);
+ g_return_val_if_fail (byte_offset >= 0, 0);
+
char_offset = 0;
seg = line->segments;
while (byte_offset >= seg->byte_count) /* while (we need to go farther than
the next segment) */
{
- g_assert(seg != NULL); /* our byte_index was bogus if this happens */
-
byte_offset -= seg->byte_count;
char_offset += seg->char_count;
-
seg = seg->next;
+ g_assert (seg != NULL); /* our byte_index was bogus if this happens */
}
- g_assert(seg != NULL);
+ g_assert (seg != NULL);
/* Now byte_offset is the offset into the current segment,
and char_offset is the start of the current segment.
return char_offset + g_utf8_strlen (seg->body.chars, byte_offset);
else
{
- g_assert(seg->char_count == 1);
- g_assert(byte_offset == 0);
+ g_assert (seg->char_count == 1);
+ g_assert (byte_offset == 0);
return char_offset;
}
}
gint
-gtk_text_line_char_to_byte (GtkTextLine *line,
+_gtk_text_line_char_to_byte (GtkTextLine *line,
gint char_offset)
{
- g_warning("FIXME not implemented");
-}
+ g_warning ("FIXME not implemented");
+ return 0;
+}
/* FIXME sync with char_locate (or figure out a clean
way to merge the two functions) */
-void
-gtk_text_line_byte_locate (GtkTextLine *line,
- gint byte_offset,
- GtkTextLineSegment **segment,
- GtkTextLineSegment **any_segment,
- gint *seg_byte_offset,
- gint *line_byte_offset)
+gboolean
+_gtk_text_line_byte_locate (GtkTextLine *line,
+ gint byte_offset,
+ GtkTextLineSegment **segment,
+ GtkTextLineSegment **any_segment,
+ gint *seg_byte_offset,
+ gint *line_byte_offset)
{
GtkTextLineSegment *seg;
- GtkTextLineSegment *after_prev_indexable;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
gint offset;
gint bytes_in_line;
-
- g_return_if_fail(line != NULL);
- if (byte_offset < 0)
- {
- /* -1 means end of line; we here assume no line is
- longer than 1 bazillion bytes, of course we assumed
- that anyway since we'd wrap around... */
+ g_return_val_if_fail (line != NULL, FALSE);
+ g_return_val_if_fail (byte_offset >= 0, FALSE);
- byte_offset = G_MAXINT;
- }
-
*segment = NULL;
*any_segment = NULL;
bytes_in_line = 0;
-
+
offset = byte_offset;
last_indexable = NULL;
after_last_indexable = line->segments;
- after_prev_indexable = line->segments;
seg = line->segments;
/* The loop ends when we're inside a segment;
last_indexable refers to the last segment
we passed entirely. */
while (seg && offset >= seg->byte_count)
- {
+ {
if (seg->char_count > 0)
- {
+ {
offset -= seg->byte_count;
bytes_in_line += seg->byte_count;
last_indexable = seg;
- after_prev_indexable = after_last_indexable;
after_last_indexable = last_indexable->next;
}
-
+
seg = seg->next;
}
if (seg == NULL)
{
/* We went off the end of the line */
- *segment = last_indexable;
- *any_segment = after_prev_indexable;
- /* subtracting 1 is OK, we know it's a newline at the end. */
- offset = (*segment)->byte_count - 1;
- bytes_in_line -= (*segment)->byte_count;
+ if (offset != 0)
+ g_warning ("%s: byte index off the end of the line", G_STRLOC);
+
+ return FALSE;
}
else
{
else
*any_segment = *segment;
}
-
+
/* Override any_segment if we're in the middle of a segment. */
if (offset > 0)
*any_segment = *segment;
*seg_byte_offset = offset;
- g_assert(*segment != NULL);
- g_assert(*any_segment != NULL);
- g_assert(*seg_byte_offset < (*segment)->byte_count);
-
+ g_assert (*segment != NULL);
+ g_assert (*any_segment != NULL);
+ g_assert (*seg_byte_offset < (*segment)->byte_count);
+
*line_byte_offset = bytes_in_line + *seg_byte_offset;
+
+ return TRUE;
}
/* FIXME sync with byte_locate (or figure out a clean
way to merge the two functions) */
-void
-gtk_text_line_char_locate (GtkTextLine *line,
- gint char_offset,
- GtkTextLineSegment **segment,
- GtkTextLineSegment **any_segment,
- gint *seg_char_offset,
- gint *line_char_offset)
+gboolean
+_gtk_text_line_char_locate (GtkTextLine *line,
+ gint char_offset,
+ GtkTextLineSegment **segment,
+ GtkTextLineSegment **any_segment,
+ gint *seg_char_offset,
+ gint *line_char_offset)
{
GtkTextLineSegment *seg;
- GtkTextLineSegment *after_prev_indexable;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
gint offset;
gint chars_in_line;
-
- g_return_if_fail(line != NULL);
- if (char_offset < 0)
- {
- /* -1 means end of line; we here assume no line is
- longer than 1 bazillion chars, of course we assumed
- that anyway since we'd wrap around... */
-
- char_offset = G_MAXINT;
- }
+ g_return_val_if_fail (line != NULL, FALSE);
+ g_return_val_if_fail (char_offset >= 0, FALSE);
*segment = NULL;
*any_segment = NULL;
chars_in_line = 0;
-
+
offset = char_offset;
last_indexable = NULL;
after_last_indexable = line->segments;
- after_prev_indexable = line->segments;
seg = line->segments;
/* The loop ends when we're inside a segment;
last_indexable refers to the last segment
we passed entirely. */
while (seg && offset >= seg->char_count)
- {
+ {
if (seg->char_count > 0)
- {
+ {
offset -= seg->char_count;
chars_in_line += seg->char_count;
last_indexable = seg;
- after_prev_indexable = after_last_indexable;
after_last_indexable = last_indexable->next;
}
-
+
seg = seg->next;
}
if (seg == NULL)
{
- /* We went off the end of the line */
- *segment = last_indexable;
- *any_segment = after_prev_indexable;
- /* subtracting 1 is OK, we know it's a newline at the end. */
- offset = (*segment)->char_count - 1;
- chars_in_line -= (*segment)->char_count;
+ /* end of the line */
+ if (offset != 0)
+ g_warning ("%s: char offset off the end of the line", G_STRLOC);
+
+ return FALSE;
}
else
{
else
*any_segment = *segment;
}
-
+
/* Override any_segment if we're in the middle of a segment. */
if (offset > 0)
*any_segment = *segment;
*seg_char_offset = offset;
- g_assert(*segment != NULL);
- g_assert(*any_segment != NULL);
- g_assert(*seg_char_offset < (*segment)->char_count);
-
+ g_assert (*segment != NULL);
+ g_assert (*any_segment != NULL);
+ g_assert (*seg_char_offset < (*segment)->char_count);
+
*line_char_offset = chars_in_line + *seg_char_offset;
+
+ return TRUE;
}
void
-gtk_text_line_byte_to_char_offsets(GtkTextLine *line,
- gint byte_offset,
- gint *line_char_offset,
- gint *seg_char_offset)
+_gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
+ gint byte_offset,
+ gint *line_char_offset,
+ gint *seg_char_offset)
{
GtkTextLineSegment *seg;
int offset;
- g_return_if_fail(line != NULL);
- g_return_if_fail(byte_offset >= 0);
+ g_return_if_fail (line != NULL);
+ g_return_if_fail (byte_offset >= 0);
*line_char_offset = 0;
-
+
offset = byte_offset;
seg = line->segments;
offset -= seg->byte_count;
*line_char_offset += seg->char_count;
seg = seg->next;
- g_assert(seg != NULL); /* means an invalid char offset */
+ g_assert (seg != NULL); /* means an invalid char offset */
}
- g_assert(seg->char_count > 0); /* indexable. */
-
+ g_assert (seg->char_count > 0); /* indexable. */
+
/* offset is now the number of bytes into the current segment we
- want to go. Count chars into the current segment. */
+ * want to go. Count chars into the current segment.
+ */
if (seg->type == >k_text_char_type)
{
- *seg_char_offset = g_utf8_strlen(seg->body.chars, offset);
+ *seg_char_offset = g_utf8_strlen (seg->body.chars, offset);
+
+ g_assert (*seg_char_offset < seg->char_count);
- g_assert(*seg_char_offset < seg->char_count);
-
*line_char_offset += *seg_char_offset;
}
else
{
- g_assert(offset == 0);
+ g_assert (offset == 0);
*seg_char_offset = 0;
}
}
void
-gtk_text_line_char_to_byte_offsets(GtkTextLine *line,
- gint char_offset,
- gint *line_byte_offset,
- gint *seg_byte_offset)
+_gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
+ gint char_offset,
+ gint *line_byte_offset,
+ gint *seg_byte_offset)
{
GtkTextLineSegment *seg;
int offset;
- g_return_if_fail(line != NULL);
- g_return_if_fail(char_offset >= 0);
+ g_return_if_fail (line != NULL);
+ g_return_if_fail (char_offset >= 0);
*line_byte_offset = 0;
-
+
offset = char_offset;
seg = line->segments;
offset -= seg->char_count;
*line_byte_offset += seg->byte_count;
seg = seg->next;
- g_assert(seg != NULL); /* means an invalid char offset */
+ g_assert (seg != NULL); /* means an invalid char offset */
}
- g_assert(seg->char_count > 0); /* indexable. */
-
+ g_assert (seg->char_count > 0); /* indexable. */
+
/* offset is now the number of chars into the current segment we
want to go. Count bytes into the current segment. */
if (seg->type == >k_text_char_type)
{
- *seg_byte_offset = 0;
- while (offset > 0)
- {
- gint bytes;
- const char * start = seg->body.chars + *seg_byte_offset;
-
- bytes = g_utf8_next_char (start) - start;
- *seg_byte_offset += bytes;
- offset -= 1;
- }
+ const char *p;
+
+ /* if in the last fourth of the segment walk backwards */
+ if (seg->char_count - offset < seg->char_count / 4)
+ p = g_utf8_offset_to_pointer (seg->body.chars + seg->byte_count,
+ offset - seg->char_count);
+ else
+ p = g_utf8_offset_to_pointer (seg->body.chars, offset);
+
+ *seg_byte_offset = p - seg->body.chars;
+
+ g_assert (*seg_byte_offset < seg->byte_count);
- g_assert(*seg_byte_offset < seg->byte_count);
-
*line_byte_offset += *seg_byte_offset;
}
else
{
- g_assert(offset == 0);
+ g_assert (offset == 0);
*seg_byte_offset = 0;
}
}
+static gint
+node_compare (GtkTextBTreeNode *lhs,
+ GtkTextBTreeNode *rhs)
+{
+ GtkTextBTreeNode *iter;
+ GtkTextBTreeNode *node;
+ GtkTextBTreeNode *common_parent;
+ GtkTextBTreeNode *parent_of_lower;
+ GtkTextBTreeNode *parent_of_higher;
+ gboolean lhs_is_lower;
+ GtkTextBTreeNode *lower;
+ GtkTextBTreeNode *higher;
+
+ /* This function assumes that lhs and rhs are not underneath each
+ * other.
+ */
+
+ if (lhs == rhs)
+ return 0;
+
+ if (lhs->level < rhs->level)
+ {
+ lhs_is_lower = TRUE;
+ lower = lhs;
+ higher = rhs;
+ }
+ else
+ {
+ lhs_is_lower = FALSE;
+ lower = rhs;
+ higher = lhs;
+ }
+
+ /* Algorithm: find common parent of lhs/rhs. Save the child nodes
+ * of the common parent we used to reach the common parent; the
+ * ordering of these child nodes in the child list is the ordering
+ * of lhs and rhs.
+ */
+
+ /* Get on the same level (may be on same level already) */
+ node = lower;
+ while (node->level < higher->level)
+ node = node->parent;
+
+ g_assert (node->level == higher->level);
+
+ g_assert (node != higher); /* Happens if lower is underneath higher */
+
+ /* Go up until we have two children with a common parent.
+ */
+ parent_of_lower = node;
+ parent_of_higher = higher;
+
+ while (parent_of_lower->parent != parent_of_higher->parent)
+ {
+ parent_of_lower = parent_of_lower->parent;
+ parent_of_higher = parent_of_higher->parent;
+ }
+
+ g_assert (parent_of_lower->parent == parent_of_higher->parent);
+
+ common_parent = parent_of_lower->parent;
+
+ g_assert (common_parent != NULL);
+
+ /* See which is first in the list of common_parent's children */
+ iter = common_parent->children.node;
+ while (iter != NULL)
+ {
+ if (iter == parent_of_higher)
+ {
+ /* higher is less than lower */
+
+ if (lhs_is_lower)
+ return 1; /* lhs > rhs */
+ else
+ return -1;
+ }
+ else if (iter == parent_of_lower)
+ {
+ /* lower is less than higher */
+
+ if (lhs_is_lower)
+ return -1; /* lhs < rhs */
+ else
+ return 1;
+ }
+
+ iter = iter->next;
+ }
+
+ g_assert_not_reached ();
+ return 0;
+}
+
/* remember that tag == NULL means "any tag" */
GtkTextLine*
-gtk_text_line_next_could_contain_tag(GtkTextLine *line,
- GtkTextBTree *tree,
- GtkTextTag *tag)
+_gtk_text_line_next_could_contain_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ GtkTextTag *tag)
{
GtkTextBTreeNode *node;
GtkTextTagInfo *info;
gboolean below_tag_root;
-
- g_return_val_if_fail(line != NULL, NULL);
- if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
-
+ g_return_val_if_fail (line != NULL, NULL);
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
+
if (tag == NULL)
{
/* Right now we can only offer linear-search if the user wants
- to know about any tag toggle at all. */
- return gtk_text_line_next (line);
+ * to know about any tag toggle at all.
+ */
+ return _gtk_text_line_next_excluding_last (line);
}
-
- /* Our tag summaries only have node precision, not line
- precision. This means that if any line under a node could contain a
- tag, then any of the others could also contain a tag.
- In the future we could have some mechanism to keep track of how
- many toggles we've found under a node so far, since we have a
- count of toggles under the node. But for now I'm going with KISS.
- */
+ /* Our tag summaries only have node precision, not line
+ * precision. This means that if any line under a node could contain a
+ * tag, then any of the others could also contain a tag.
+ *
+ * In the future we could have some mechanism to keep track of how
+ * many toggles we've found under a node so far, since we have a
+ * count of toggles under the node. But for now I'm going with KISS.
+ */
/* return same-node line, if any. */
if (line->next)
return line->next;
- info = gtk_text_btree_get_existing_tag_info(tree, tag);
+ info = gtk_text_btree_get_existing_tag_info (tree, tag);
if (info == NULL)
return NULL;
if (info->tag_root == NULL)
return NULL;
-
+
+ if (info->tag_root == line->parent)
+ return NULL; /* we were at the last line under the tag root */
+
/* We need to go up out of this node, and on to the next one with
toggles for the target tag. If we're below the tag root, we need to
find the next node below the tag root that has tag summaries. If
we're not below the tag root, we need to see if the tag root is
after us in the tree, and if so, return the first line underneath
the tag root. */
-
+
node = line->parent;
below_tag_root = FALSE;
while (node != NULL)
{
node = node->next;
- if (gtk_text_btree_node_has_tag(node, tag))
+ if (gtk_text_btree_node_has_tag (node, tag))
goto found;
}
}
}
else
{
- GtkTextBTreeNode * iter;
- GtkTextBTreeNode * common_parent;
- GtkTextBTreeNode * parent_of_tag_root;
- GtkTextBTreeNode * parent_of_node;
-
- /* Find common parent between our current line, and the tag
- root. Save the child nodes of the common parent we used to get
- to the common parent; we then use these two child nodes to
- determine whether the ordering of the tag root and the current
- line in the tree. (Nice code cleanup: write
- gtk_btree_node_compare() to compute node ordering.)
- */
+ gint ordering;
- /* Get on the same level */
- node = line->parent;
- while (node->level < info->tag_root->level)
- node = node->parent;
+ ordering = node_compare (line->parent, info->tag_root);
+
+ if (ordering < 0)
+ {
+ /* Tag root is ahead of us, so search there. */
+ node = info->tag_root;
+ goto found;
+ }
+ else
+ {
+ /* Tag root is after us, so no more lines that
+ * could contain the tag.
+ */
+ return NULL;
+ }
- common_parent = info->tag_root->parent;
+ g_assert_not_reached ();
+ }
- /* Find common parent, and children of that parent above
- tag root and our current node */
- parent_of_node = node;
- parent_of_tag_root = info->tag_root;
+ found:
- while (node->parent != common_parent)
+ g_assert (node != NULL);
+
+ /* We have to find the first sub-node of this node that contains
+ * the target tag.
+ */
+
+ while (node->level > 0)
+ {
+ g_assert (node != NULL); /* If this fails, it likely means an
+ incorrect tag summary led us on a
+ wild goose chase down this branch of
+ the tree. */
+ node = node->children.node;
+ while (node != NULL)
{
- parent_of_node = node;
- parent_of_tag_root = common_parent;
- node = node->parent;
- common_parent = common_parent->parent;
+ if (gtk_text_btree_node_has_tag (node, tag))
+ break;
+ node = node->next;
}
+ }
- /* See which is first in the list of common_parent's children */
- iter = common_parent->children.node;
- while (iter != NULL)
+ g_assert (node != NULL);
+ g_assert (node->level == 0);
+
+ return node->children.line;
+}
+
+static GtkTextLine*
+prev_line_under_node (GtkTextBTreeNode *node,
+ GtkTextLine *line)
+{
+ GtkTextLine *prev;
+
+ prev = node->children.line;
+
+ g_assert (prev);
+
+ if (prev != line)
+ {
+ while (prev->next != line)
+ prev = prev->next;
+
+ return prev;
+ }
+
+ return NULL;
+}
+
+GtkTextLine*
+_gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ GtkTextTag *tag)
+{
+ GtkTextBTreeNode *node;
+ GtkTextBTreeNode *found_node = NULL;
+ GtkTextTagInfo *info;
+ gboolean below_tag_root;
+ GtkTextLine *prev;
+ GtkTextBTreeNode *line_ancestor;
+ GtkTextBTreeNode *line_ancestor_parent;
+
+ /* See next_could_contain_tag () for more extensive comments
+ * on what's going on here.
+ */
+
+ g_return_val_if_fail (line != NULL, NULL);
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
+
+ if (tag == NULL)
+ {
+ /* Right now we can only offer linear-search if the user wants
+ * to know about any tag toggle at all.
+ */
+ return _gtk_text_line_previous (line);
+ }
+
+ /* Return same-node line, if any. */
+ prev = prev_line_under_node (line->parent, line);
+ if (prev)
+ return prev;
+
+ info = gtk_text_btree_get_existing_tag_info (tree, tag);
+ if (info == NULL)
+ return NULL;
+
+ if (info->tag_root == NULL)
+ return NULL;
+
+ if (info->tag_root == line->parent)
+ return NULL; /* we were at the first line under the tag root */
+
+ /* Are we below the tag root */
+ node = line->parent;
+ below_tag_root = FALSE;
+ while (node != NULL)
+ {
+ if (node == info->tag_root)
{
- if (iter == parent_of_tag_root)
- return NULL; /* Tag root was before us in the tree */
- else if (iter == parent_of_node)
+ below_tag_root = TRUE;
+ break;
+ }
+
+ node = node->parent;
+ }
+
+ if (below_tag_root)
+ {
+ /* Look for a previous node under this tag root that has our
+ * tag.
+ */
+
+ /* this assertion holds because line->parent is not the
+ * tag root, we are below the tag root, and the tag
+ * root exists.
+ */
+ g_assert (line->parent->parent != NULL);
+
+ line_ancestor = line->parent;
+ line_ancestor_parent = line->parent->parent;
+
+ while (line_ancestor != info->tag_root)
+ {
+ GSList *child_nodes = NULL;
+ GSList *tmp;
+
+ /* Create reverse-order list of nodes before
+ * line_ancestor
+ */
+ if (line_ancestor_parent != NULL)
+ node = line_ancestor_parent->children.node;
+ else
+ node = line_ancestor;
+
+ while (node != line_ancestor && node != NULL)
{
- /* We want the first inside-tag-root node,
- since we're before the tag root */
- node = info->tag_root;
- goto found;
+ child_nodes = g_slist_prepend (child_nodes, node);
+
+ node = node->next;
}
- iter = iter->next;
+ /* Try to find a node with our tag on it in the list */
+ tmp = child_nodes;
+ while (tmp != NULL)
+ {
+ GtkTextBTreeNode *this_node = tmp->data;
+
+ g_assert (this_node != line_ancestor);
+
+ if (gtk_text_btree_node_has_tag (this_node, tag))
+ {
+ found_node = this_node;
+ g_slist_free (child_nodes);
+ goto found;
+ }
+
+ tmp = g_slist_next (tmp);
+ }
+
+ g_slist_free (child_nodes);
+
+ /* Didn't find anything on this level; go up one level. */
+ line_ancestor = line_ancestor_parent;
+ line_ancestor_parent = line_ancestor->parent;
}
-
+
+ /* No dice. */
return NULL;
}
+ else
+ {
+ gint ordering;
+
+ ordering = node_compare (line->parent, info->tag_root);
+
+ if (ordering < 0)
+ {
+ /* Tag root is ahead of us, so no more lines
+ * with this tag.
+ */
+ return NULL;
+ }
+ else
+ {
+ /* Tag root is after us, so grab last tagged
+ * line underneath the tag root.
+ */
+ found_node = info->tag_root;
+ goto found;
+ }
+
+ g_assert_not_reached ();
+ }
found:
-
- g_assert(node != NULL);
-
- /* We have to find the first sub-node of this node that contains
- the target tag. */
- continue_outer_loop:
+ g_assert (found_node != NULL);
+
+ /* We have to find the last sub-node of this node that contains
+ * the target tag.
+ */
+ node = found_node;
+
while (node->level > 0)
{
- g_assert(node != NULL); /* If this fails, it likely means an
- incorrect tag summary led us on a
- wild goose chase down this branch of
- the tree. */
+ GSList *child_nodes = NULL;
+ GSList *iter;
+ g_assert (node != NULL); /* If this fails, it likely means an
+ incorrect tag summary led us on a
+ wild goose chase down this branch of
+ the tree. */
+
node = node->children.node;
while (node != NULL)
{
- if (gtk_text_btree_node_has_tag(node, tag))
- goto continue_outer_loop;
+ child_nodes = g_slist_prepend (child_nodes, node);
node = node->next;
}
- g_assert(node != NULL);
+
+ node = NULL; /* detect failure to find a child node. */
+
+ iter = child_nodes;
+ while (iter != NULL)
+ {
+ if (gtk_text_btree_node_has_tag (iter->data, tag))
+ {
+ /* recurse into this node. */
+ node = iter->data;
+ break;
+ }
+
+ iter = g_slist_next (iter);
+ }
+
+ g_slist_free (child_nodes);
+
+ g_assert (node != NULL);
}
- g_assert(node != NULL);
- g_assert(node->level == 0);
-
- return node->children.line;
-}
-
-GtkTextLine*
-gtk_text_line_previous_could_contain_tag(GtkTextLine *line,
- GtkTextBTree *tree,
- GtkTextTag *tag)
-{
- g_warning("FIXME");
+ g_assert (node != NULL);
+ g_assert (node->level == 0);
+
+ /* this assertion is correct, but slow. */
+ /* g_assert (node_compare (node, line->parent) < 0); */
+ /* Return last line in this node. */
+
+ prev = node->children.line;
+ while (prev->next)
+ prev = prev->next;
+
+ return prev;
}
/*
- * Non-public function implementations */
+ * Non-public function implementations
+ */
static void
-summary_list_destroy(Summary *summary)
+summary_list_destroy (Summary *summary)
{
- Summary *next;
- while (summary != NULL)
- {
- next = summary->next;
- summary_destroy (summary);
- summary = next;
- }
+ g_slice_free_chain (Summary, summary, next);
}
static GtkTextLine*
-get_last_line(GtkTextBTree *tree)
+get_last_line (GtkTextBTree *tree)
{
- if (tree->end_iter_line_stamp != tree->chars_changed_stamp)
+ if (tree->last_line_stamp != tree->chars_changed_stamp)
{
gint n_lines;
GtkTextLine *line;
gint real_line;
- n_lines = gtk_text_btree_line_count(tree);
-
- g_assert(n_lines >= 1); /* num_lines doesn't return bogus last line. */
-
- line = gtk_text_btree_get_line(tree, n_lines, &real_line);
+ n_lines = _gtk_text_btree_line_count (tree);
- tree->end_iter_line_stamp = tree->chars_changed_stamp;
- tree->end_iter_line = line;
+ g_assert (n_lines >= 1); /* num_lines doesn't return bogus last line. */
+
+ line = _gtk_text_btree_get_line (tree, n_lines, &real_line);
+
+ tree->last_line_stamp = tree->chars_changed_stamp;
+ tree->last_line = line;
}
-
- return tree->end_iter_line;
+
+ return tree->last_line;
}
/*
*/
static GtkTextLine*
-gtk_text_line_new(void)
+gtk_text_line_new (void)
{
GtkTextLine *line;
- line = g_new0(GtkTextLine, 1);
+ line = g_slice_new0 (GtkTextLine);
+ line->dir_strong = PANGO_DIRECTION_NEUTRAL;
+ line->dir_propagated_forward = PANGO_DIRECTION_NEUTRAL;
+ line->dir_propagated_back = PANGO_DIRECTION_NEUTRAL;
return line;
}
static void
-gtk_text_line_destroy(GtkTextBTree *tree, GtkTextLine *line)
+gtk_text_line_destroy (GtkTextBTree *tree, GtkTextLine *line)
{
GtkTextLineData *ld;
GtkTextLineData *next;
-
- g_return_if_fail(line != NULL);
+
+ g_return_if_fail (line != NULL);
ld = line->views;
while (ld != NULL)
{
BTreeView *view;
-
+
view = gtk_text_btree_get_view (tree, ld->view_id);
- g_assert(view != NULL);
+ g_assert (view != NULL);
next = ld->next;
gtk_text_layout_free_line_data (view->layout, line, ld);
-
+
ld = next;
}
-
- g_free(line);
+
+ g_slice_free (GtkTextLine, line);
}
static void
-gtk_text_line_set_parent(GtkTextLine *line,
- GtkTextBTreeNode *node)
+gtk_text_line_set_parent (GtkTextLine *line,
+ GtkTextBTreeNode *node)
{
if (line->parent == node)
return;
line->parent = node;
- gtk_text_btree_node_invalidate_upward(node, NULL);
+ gtk_text_btree_node_invalidate_upward (node, NULL);
}
static void
-cleanup_line(GtkTextLine *line)
+cleanup_line (GtkTextLine *line)
{
GtkTextLineSegment *seg, **prev_p;
gboolean changed;
while (changed)
{
changed = FALSE;
- for (prev_p = &line->segments, seg = *prev_p;
- seg != NULL;
- prev_p = &(*prev_p)->next, seg = *prev_p)
+ prev_p = &line->segments;
+ for (seg = *prev_p; seg != NULL; seg = *prev_p)
{
if (seg->type->cleanupFunc != NULL)
{
*prev_p = (*seg->type->cleanupFunc)(seg, line);
if (seg != *prev_p)
- changed = TRUE;
+ {
+ changed = TRUE;
+ continue;
+ }
}
+
+ prev_p = &(*prev_p)->next;
}
}
}
*/
static NodeData*
-node_data_new(gpointer view_id)
+node_data_new (gpointer view_id)
{
NodeData *nd;
-
- nd = g_new(NodeData, 1);
+
+ nd = g_slice_new (NodeData);
nd->view_id = view_id;
nd->next = NULL;
}
static void
-node_data_destroy(NodeData *nd)
+node_data_destroy (NodeData *nd)
{
-
- g_free(nd);
+ g_slice_free (NodeData, nd);
}
static void
-node_data_list_destroy(NodeData *nd)
+node_data_list_destroy (NodeData *nd)
{
- NodeData *iter;
- NodeData *next;
-
- iter = nd;
- while (iter != NULL)
- {
- next = iter->next;
- node_data_destroy(iter);
- iter = next;
- }
+ g_slice_free_chain (NodeData, nd, next);
}
static NodeData*
-node_data_find(NodeData *nd, gpointer view_id)
+node_data_find (NodeData *nd,
+ gpointer view_id)
{
while (nd != NULL)
{
summary->info = (void*)0x1;
summary->toggle_count = 567;
summary->next = (void*)0x1;
- g_free (summary);
+ g_slice_free (Summary, summary);
}
static GtkTextBTreeNode*
-gtk_text_btree_node_new(void)
+gtk_text_btree_node_new (void)
{
GtkTextBTreeNode *node;
- node = g_new(GtkTextBTreeNode, 1);
+ node = g_slice_new (GtkTextBTreeNode);
node->node_data = NULL;
-
+
return node;
}
gint adjust)
{
Summary *summary;
-
+
summary = node->summary;
while (summary != NULL)
{
if (summary == NULL)
{
/* didn't find a summary for our tag. */
- g_return_if_fail(adjust > 0);
- summary = g_new(Summary, 1);
+ g_return_if_fail (adjust > 0);
+ summary = g_slice_new (Summary);
summary->info = info;
summary->toggle_count = adjust;
summary->next = node->summary;
gtk_text_btree_node_has_tag (GtkTextBTreeNode *node, GtkTextTag *tag)
{
Summary *summary;
-
+
summary = node->summary;
while (summary != NULL)
{
if (tag == NULL ||
summary->info->tag == tag)
return TRUE;
-
+
summary = summary->next;
}
}
/* Add node and all children to the damage region. */
+#if 0
static void
-gtk_text_btree_node_invalidate_downward(GtkTextBTreeNode *node)
+gtk_text_btree_node_invalidate_downward (GtkTextBTreeNode *node)
{
NodeData *nd;
nd->valid = FALSE;
nd = nd->next;
}
-
+
if (node->level == 0)
{
GtkTextLine *line;
ld->valid = FALSE;
ld = ld->next;
}
-
+
line = line->next;
}
}
else
{
GtkTextBTreeNode *child;
-
+
child = node->children.node;
-
+
while (child != NULL)
{
- gtk_text_btree_node_invalidate_downward(child);
-
+ gtk_text_btree_node_invalidate_downward (child);
+
child = child->next;
}
}
}
+#endif
static void
-gtk_text_btree_node_invalidate_upward(GtkTextBTreeNode *node, gpointer view_id)
+gtk_text_btree_node_invalidate_upward (GtkTextBTreeNode *node, gpointer view_id)
{
GtkTextBTreeNode *iter;
-
+
iter = node;
while (iter != NULL)
{
if (view_id)
{
nd = node_data_find (iter->node_data, view_id);
-
+
if (nd == NULL || !nd->valid)
- break; /* Once a node is invalid, we know its parents are as well. */
-
- nd->valid = FALSE;
+ break; /* Once a node is invalid, we know its parents are as well. */
+
+ nd->valid = FALSE;
}
else
{
gboolean should_continue = FALSE;
-
+
nd = iter->node_data;
while (nd != NULL)
{
if (nd->valid)
- {
- should_continue = TRUE;
- nd->valid = FALSE;
- }
+ {
+ should_continue = TRUE;
+ nd->valid = FALSE;
+ }
nd = nd->next;
}
break; /* This node was totally invalidated, so are its
parents */
}
-
+
iter = iter->parent;
}
}
/**
- * gtk_text_btree_is_valid:
+ * _gtk_text_btree_is_valid:
* @tree: a #GtkTextBTree
* @view_id: ID for the view
- *
+ *
* Check to see if the entire #GtkTextBTree is valid or not for
* the given view.
- *
+ *
* Return value: %TRUE if the entire #GtkTextBTree is valid
**/
gboolean
-gtk_text_btree_is_valid (GtkTextBTree *tree,
- gpointer view_id)
+_gtk_text_btree_is_valid (GtkTextBTree *tree,
+ gpointer view_id)
{
NodeData *nd;
g_return_val_if_fail (tree != NULL, FALSE);
static void
gtk_text_btree_node_validate (BTreeView *view,
- GtkTextBTreeNode *node,
- gpointer view_id,
- ValidateState *state)
+ GtkTextBTreeNode *node,
+ gpointer view_id,
+ ValidateState *state)
{
gint node_valid = TRUE;
gint node_width = 0;
NodeData *nd = gtk_text_btree_node_ensure_data (node, view_id);
g_return_if_fail (!nd->valid);
-
+
if (node->level == 0)
{
GtkTextLine *line = node->children.line;
/* Iterate over leading valid lines */
while (line != NULL)
- {
- ld = gtk_text_line_get_data (line, view_id);
+ {
+ ld = _gtk_text_line_get_data (line, view_id);
- if (!ld || !ld->valid)
- break;
- else if (state->in_validation)
- {
- state->in_validation = FALSE;
- return;
- }
- else
- {
- state->y += ld->height;
- node_width = MAX (ld->width, node_width);
- node_height += ld->height;
- }
-
- line = line->next;
- }
+ if (!ld || !ld->valid)
+ break;
+ else if (state->in_validation)
+ {
+ state->in_validation = FALSE;
+ return;
+ }
+ else
+ {
+ state->y += ld->height;
+ node_width = MAX (ld->width, node_width);
+ node_height += ld->height;
+ }
+
+ line = line->next;
+ }
state->in_validation = TRUE;
-
+
/* Iterate over invalid lines */
while (line != NULL)
- {
- ld = gtk_text_line_get_data (line, view_id);
+ {
+ ld = _gtk_text_line_get_data (line, view_id);
- if (ld && ld->valid)
- break;
- else
- {
- if (ld)
- state->old_height += ld->height;
- ld = gtk_text_layout_wrap (view->layout, line, ld);
- state->new_height += ld->height;
-
- node_width = MAX (ld->width, node_width);
- node_height += ld->height;
-
- state->remaining_pixels -= ld->height;
- if (state->remaining_pixels <= 0)
- {
- line = line->next;
- break;
- }
- }
-
- line = line->next;
- }
+ if (ld && ld->valid)
+ break;
+ else
+ {
+ if (ld)
+ state->old_height += ld->height;
+ ld = gtk_text_layout_wrap (view->layout, line, ld);
+ state->new_height += ld->height;
+
+ node_width = MAX (ld->width, node_width);
+ node_height += ld->height;
+
+ state->remaining_pixels -= ld->height;
+ if (state->remaining_pixels <= 0)
+ {
+ line = line->next;
+ break;
+ }
+ }
+
+ line = line->next;
+ }
/* Iterate over the remaining lines */
while (line != NULL)
- {
- ld = gtk_text_line_get_data (line, view_id);
- state->in_validation = FALSE;
+ {
+ ld = _gtk_text_line_get_data (line, view_id);
+ state->in_validation = FALSE;
- if (!ld || !ld->valid)
- node_valid = FALSE;
+ if (!ld || !ld->valid)
+ node_valid = FALSE;
- if (ld)
- {
- node_width = MAX (ld->width, node_width);
- node_height += ld->height;
- }
-
- line = line->next;
- }
+ if (ld)
+ {
+ node_width = MAX (ld->width, node_width);
+ node_height += ld->height;
+ }
+
+ line = line->next;
+ }
}
else
{
GtkTextBTreeNode *child;
NodeData *child_nd;
-
+
child = node->children.node;
/* Iterate over leading valid nodes */
while (child)
- {
- child_nd = gtk_text_btree_node_ensure_data (child, view_id);
+ {
+ child_nd = gtk_text_btree_node_ensure_data (child, view_id);
+
+ if (!child_nd->valid)
+ break;
+ else if (state->in_validation)
+ {
+ state->in_validation = FALSE;
+ return;
+ }
+ else
+ {
+ state->y += child_nd->height;
+ node_width = MAX (node_width, child_nd->width);
+ node_height += child_nd->height;
+ }
- if (!child_nd->valid)
- break;
- else if (state->in_validation)
- {
- state->in_validation = FALSE;
- return;
- }
- else
- {
- state->y += child_nd->height;
- node_width = MAX (node_width, child_nd->width);
- node_height += child_nd->height;
- }
-
- child = child->next;
- }
+ child = child->next;
+ }
/* Iterate over invalid nodes */
while (child)
- {
- child_nd = gtk_text_btree_node_ensure_data (child, view_id);
+ {
+ child_nd = gtk_text_btree_node_ensure_data (child, view_id);
- if (child_nd->valid)
- break;
- else
- {
- gtk_text_btree_node_validate (view, child, view_id, state);
+ if (child_nd->valid)
+ break;
+ else
+ {
+ gtk_text_btree_node_validate (view, child, view_id, state);
- if (!child_nd->valid)
- node_valid = FALSE;
- node_width = MAX (node_width, child_nd->width);
- node_height += child_nd->height;
-
- if (!state->in_validation || state->remaining_pixels <= 0)
- {
- child = child->next;
- break;
- }
- }
-
- child = child->next;
- }
+ if (!child_nd->valid)
+ node_valid = FALSE;
+ node_width = MAX (node_width, child_nd->width);
+ node_height += child_nd->height;
+
+ if (!state->in_validation || state->remaining_pixels <= 0)
+ {
+ child = child->next;
+ break;
+ }
+ }
+
+ child = child->next;
+ }
/* Iterate over the remaining lines */
while (child)
- {
- child_nd = gtk_text_btree_node_ensure_data (child, view_id);
- state->in_validation = FALSE;
+ {
+ child_nd = gtk_text_btree_node_ensure_data (child, view_id);
+ state->in_validation = FALSE;
- if (!child_nd->valid)
- node_valid = FALSE;
-
- node_width = MAX (child_nd->width, node_width);
- node_height += child_nd->height;
-
- child = child->next;
- }
+ if (!child_nd->valid)
+ node_valid = FALSE;
+
+ node_width = MAX (child_nd->width, node_width);
+ node_height += child_nd->height;
+
+ child = child->next;
+ }
}
nd->width = node_width;
}
/**
- * gtk_text_btree_validate:
+ * _gtk_text_btree_validate:
* @tree: a #GtkTextBTree
* @view_id: view id
* @max_pixels: the maximum number of pixels to validate. (No more
* @y: location to store starting y coordinate of validated region
* @old_height: location to store old height of validated region
* @new_height: location to store new height of validated region
- *
+ *
* Validate a single contiguous invalid region of a #GtkTextBTree for
- * a given view.
- *
+ * a given view.
+ *
* Return value: %TRUE if a region has been validated, %FALSE if the
* entire tree was already valid.
**/
gboolean
-gtk_text_btree_validate (GtkTextBTree *tree,
- gpointer view_id,
- gint max_pixels,
- gint *y,
- gint *old_height,
- gint *new_height)
+_gtk_text_btree_validate (GtkTextBTree *tree,
+ gpointer view_id,
+ gint max_pixels,
+ gint *y,
+ gint *old_height,
+ gint *new_height)
{
BTreeView *view;
g_return_val_if_fail (tree != NULL, FALSE);
-
+
view = gtk_text_btree_get_view (tree, view_id);
g_return_val_if_fail (view != NULL, FALSE);
- if (!gtk_text_btree_is_valid (tree, view_id))
+ if (!_gtk_text_btree_is_valid (tree, view_id))
{
ValidateState state;
state.new_height = 0;
gtk_text_btree_node_validate (view,
- tree->root_node,
- view_id, &state);
+ tree->root_node,
+ view_id, &state);
if (y)
- *y = state.y;
+ *y = state.y;
if (old_height)
- *old_height = state.old_height;
+ *old_height = state.old_height;
if (new_height)
- *new_height = state.new_height;
-
- if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check(tree);
+ *new_height = state.new_height;
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
return TRUE;
}
static void
gtk_text_btree_node_compute_view_aggregates (GtkTextBTreeNode *node,
- gpointer view_id,
- gint *width_out,
- gint *height_out,
- gboolean *valid_out)
+ gpointer view_id,
+ gint *width_out,
+ gint *height_out,
+ gboolean *valid_out)
{
gint width = 0;
gint height = 0;
gboolean valid = TRUE;
-
+
if (node->level == 0)
{
GtkTextLine *line = node->children.line;
-
+
while (line != NULL)
- {
- GtkTextLineData *ld = gtk_text_line_get_data (line, view_id);
-
- if (!ld || !ld->valid)
- valid = FALSE;
+ {
+ GtkTextLineData *ld = _gtk_text_line_get_data (line, view_id);
- if (ld)
- {
- width = MAX (ld->width, width);
- height += ld->height;
- }
-
- line = line->next;
- }
+ if (!ld || !ld->valid)
+ valid = FALSE;
+
+ if (ld)
+ {
+ width = MAX (ld->width, width);
+ height += ld->height;
+ }
+
+ line = line->next;
+ }
}
else
{
GtkTextBTreeNode *child = node->children.node;
while (child)
- {
- NodeData *child_nd = node_data_find (child->node_data, view_id);
-
- if (!child_nd || !child_nd->valid)
- valid = FALSE;
-
- if (child_nd)
- {
- width = MAX (child_nd->width, width);
- height += child_nd->height;
- }
-
- child = child->next;
- }
+ {
+ NodeData *child_nd = node_data_find (child->node_data, view_id);
+
+ if (!child_nd || !child_nd->valid)
+ valid = FALSE;
+
+ if (child_nd)
+ {
+ width = MAX (child_nd->width, width);
+ height += child_nd->height;
+ }
+
+ child = child->next;
+ }
}
*width_out = width;
*height_out = height;
*valid_out = valid;
}
-
+
/* Recompute the validity and size of the view data for a given
* view at this node from the immediate children of the node
*/
static NodeData *
gtk_text_btree_node_check_valid (GtkTextBTreeNode *node,
- gpointer view_id)
+ gpointer view_id)
{
NodeData *nd = gtk_text_btree_node_ensure_data (node, view_id);
gboolean valid;
gint height;
gtk_text_btree_node_compute_view_aggregates (node, view_id,
- &width, &height, &valid);
+ &width, &height, &valid);
nd->width = width;
nd->height = height;
nd->valid = valid;
static void
gtk_text_btree_node_check_valid_upward (GtkTextBTreeNode *node,
- gpointer view_id)
+ gpointer view_id)
{
while (node)
{
static NodeData *
gtk_text_btree_node_check_valid_downward (GtkTextBTreeNode *node,
- gpointer view_id)
+ gpointer view_id)
{
if (node->level == 0)
{
nd->valid = TRUE;
nd->width = 0;
nd->height = 0;
-
+
while (child)
- {
- NodeData *child_nd = gtk_text_btree_node_check_valid_downward (child, view_id);
+ {
+ NodeData *child_nd = gtk_text_btree_node_check_valid_downward (child, view_id);
- if (!child_nd->valid)
- nd->valid = FALSE;
- nd->width = MAX (child_nd->width, nd->width);
- nd->height += child_nd->height;
-
- child = child->next;
- }
+ if (!child_nd->valid)
+ nd->valid = FALSE;
+ nd->width = MAX (child_nd->width, nd->width);
+ nd->height += child_nd->height;
+
+ child = child->next;
+ }
return nd;
}
}
/**
- * gtk_text_btree_validate_line:
+ * _gtk_text_btree_validate_line:
* @tree: a #GtkTextBTree
* @line: line to validate
* @view_id: view ID for the view to validate
- *
+ *
* Revalidate a single line of the btree for the given view, propagate
* results up through the entire tree.
**/
void
-gtk_text_btree_validate_line (GtkTextBTree *tree,
- GtkTextLine *line,
- gpointer view_id)
+_gtk_text_btree_validate_line (GtkTextBTree *tree,
+ GtkTextLine *line,
+ gpointer view_id)
{
GtkTextLineData *ld;
- GtkTextLine *last_line;
BTreeView *view;
g_return_if_fail (tree != NULL);
g_return_if_fail (line != NULL);
-
+
view = gtk_text_btree_get_view (tree, view_id);
g_return_if_fail (view != NULL);
-
- ld = gtk_text_line_get_data(line, view_id);
+
+ ld = _gtk_text_line_get_data (line, view_id);
if (!ld || !ld->valid)
{
ld = gtk_text_layout_wrap (view->layout, line, ld);
- last_line = get_last_line (tree);
gtk_text_btree_node_check_valid_upward (line->parent, view_id);
}
}
static void
-gtk_text_btree_node_remove_view(BTreeView *view, GtkTextBTreeNode *node, gpointer view_id)
+gtk_text_btree_node_remove_view (BTreeView *view, GtkTextBTreeNode *node, gpointer view_id)
{
if (node->level == 0)
{
{
GtkTextLineData *ld;
- ld = gtk_text_line_remove_data(line, view_id);
+ ld = _gtk_text_line_remove_data (line, view_id);
if (ld)
- gtk_text_layout_free_line_data (view->layout, line, ld);
-
+ gtk_text_layout_free_line_data (view->layout, line, ld);
+
line = line->next;
}
}
else
{
GtkTextBTreeNode *child;
-
+
child = node->children.node;
-
+
while (child != NULL)
{
/* recurse */
- gtk_text_btree_node_remove_view(view, child, view_id);
-
+ gtk_text_btree_node_remove_view (view, child, view_id);
+
child = child->next;
}
}
- gtk_text_btree_node_remove_data(node, view_id);
+ gtk_text_btree_node_remove_data (node, view_id);
}
static void
-gtk_text_btree_node_destroy(GtkTextBTree *tree, GtkTextBTreeNode *node)
+gtk_text_btree_node_destroy (GtkTextBTree *tree, GtkTextBTreeNode *node)
{
if (node->level == 0)
{
GtkTextLine *line;
GtkTextLineSegment *seg;
-
+
while (node->children.line != NULL)
{
line = node->children.line;
{
seg = line->segments;
line->segments = seg->next;
- (*seg->type->deleteFunc)(seg, line, 1);
+
+ (*seg->type->deleteFunc) (seg, line, TRUE);
}
- gtk_text_line_destroy(tree, line);
+ gtk_text_line_destroy (tree, line);
}
}
else
{
GtkTextBTreeNode *childPtr;
-
+
while (node->children.node != NULL)
{
childPtr = node->children.node;
node->children.node = childPtr->next;
- gtk_text_btree_node_destroy(tree, childPtr);
+ gtk_text_btree_node_destroy (tree, childPtr);
}
}
- summary_list_destroy(node->summary);
- node_data_list_destroy(node->node_data);
- g_free(node);
+
+ gtk_text_btree_node_free_empty (tree, node);
+}
+
+static void
+gtk_text_btree_node_free_empty (GtkTextBTree *tree,
+ GtkTextBTreeNode *node)
+{
+ g_return_if_fail ((node->level > 0 && node->children.node == NULL) ||
+ (node->level == 0 && node->children.line == NULL));
+
+ summary_list_destroy (node->summary);
+ node_data_list_destroy (node->node_data);
+ g_slice_free (GtkTextBTreeNode, node);
}
static NodeData*
-gtk_text_btree_node_ensure_data(GtkTextBTreeNode *node, gpointer view_id)
+gtk_text_btree_node_ensure_data (GtkTextBTreeNode *node, gpointer view_id)
{
NodeData *nd;
-
+
nd = node->node_data;
while (nd != NULL)
{
nd = nd->next;
}
- if (nd == NULL) {
- nd = node_data_new(view_id);
-
+ if (nd == NULL)
+ {
+ nd = node_data_new (view_id);
+
if (node->node_data)
nd->next = node->node_data;
-
+
node->node_data = nd;
}
}
static void
-gtk_text_btree_node_remove_data(GtkTextBTreeNode *node, gpointer view_id)
+gtk_text_btree_node_remove_data (GtkTextBTreeNode *node, gpointer view_id)
{
NodeData *nd;
NodeData *prev;
prev = nd;
nd = nd->next;
}
-
+
if (nd == NULL)
return;
if (node->node_data == nd)
node->node_data = nd->next;
-
+
nd->next = NULL;
-
- node_data_destroy(nd);
+
+ node_data_destroy (nd);
}
static void
-gtk_text_btree_node_get_size(GtkTextBTreeNode *node, gpointer view_id,
- gint *width, gint *height)
+gtk_text_btree_node_get_size (GtkTextBTreeNode *node, gpointer view_id,
+ gint *width, gint *height)
{
NodeData *nd;
-
- g_return_if_fail(width != NULL);
- g_return_if_fail(height != NULL);
- nd = gtk_text_btree_node_ensure_data(node, view_id);
+ g_return_if_fail (width != NULL);
+ g_return_if_fail (height != NULL);
+
+ nd = gtk_text_btree_node_ensure_data (node, view_id);
if (width)
*width = nd->width;
*/
static GtkTextBTreeNode *
gtk_text_btree_node_common_parent (GtkTextBTreeNode *node1,
- GtkTextBTreeNode *node2)
+ GtkTextBTreeNode *node2)
{
while (node1->level < node2->level)
node1 = node1->parent;
*/
static BTreeView*
-gtk_text_btree_get_view(GtkTextBTree *tree, gpointer view_id)
+gtk_text_btree_get_view (GtkTextBTree *tree, gpointer view_id)
{
BTreeView *view;
break;
view = view->next;
}
-
+
return view;
}
static void
-get_tree_bounds(GtkTextBTree *tree,
- GtkTextIter *start,
- GtkTextIter *end)
+get_tree_bounds (GtkTextBTree *tree,
+ GtkTextIter *start,
+ GtkTextIter *end)
{
- gtk_text_btree_get_iter_at_line_char(tree, start, 0, 0);
- gtk_text_btree_get_last_iter(tree, end);
+ _gtk_text_btree_get_iter_at_line_char (tree, start, 0, 0);
+ _gtk_text_btree_get_end_iter (tree, end);
}
-
+
static void
-tag_changed_cb(GtkTextTagTable *table,
- GtkTextTag *tag,
- gboolean size_changed,
- GtkTextBTree *tree)
+tag_changed_cb (GtkTextTagTable *table,
+ GtkTextTag *tag,
+ gboolean size_changed,
+ GtkTextBTree *tree)
{
if (size_changed)
{
- /* We need to queue a redisplay on all regions that are tagged with
- this tag. */
+ /* We need to queue a relayout on all regions that are tagged with
+ * this tag.
+ */
GtkTextIter start;
GtkTextIter end;
- if (gtk_text_btree_get_iter_at_first_toggle(tree, &start, tag))
+ if (_gtk_text_btree_get_iter_at_first_toggle (tree, &start, tag))
{
/* Must be a last toggle if there was a first one. */
- gtk_text_btree_get_iter_at_last_toggle(tree, &end, tag);
- gtk_text_btree_invalidate_region(tree,
- &start, &end);
-
+ _gtk_text_btree_get_iter_at_last_toggle (tree, &end, tag);
+ DV (g_print ("invalidating due to tag change (%s)\n", G_STRLOC));
+ _gtk_text_btree_invalidate_region (tree, &start, &end, FALSE);
+
}
}
else
{
+ /* We only need to queue a redraw, not a relayout */
BTreeView *view;
-
+
view = tree->views;
-
+
while (view != NULL)
{
- gint width, height;
-
- gtk_text_btree_get_view_size (tree, view->view_id, &width, &height);
+ gint width, height;
+
+ _gtk_text_btree_get_view_size (tree, view->view_id, &width, &height);
gtk_text_layout_changed (view->layout, 0, height, height);
view = view->next;
}
}
-static void
-tag_removed_cb(GtkTextTagTable *table,
- GtkTextTag *tag,
- GtkTextBTree *tree)
+void
+_gtk_text_btree_notify_will_remove_tag (GtkTextBTree *tree,
+ GtkTextTag *tag)
{
/* Remove the tag from the tree */
GtkTextIter start;
GtkTextIter end;
- get_tree_bounds(tree, &start, &end);
+ get_tree_bounds (tree, &start, &end);
- gtk_text_btree_tag(&start, &end, tag, FALSE);
+ _gtk_text_btree_tag (&start, &end, tag, FALSE);
gtk_text_btree_remove_tag_info (tree, tag);
}
/* Rebalance the out-of-whack node "node" */
static void
-gtk_text_btree_rebalance(GtkTextBTree *tree,
- GtkTextBTreeNode *node)
+gtk_text_btree_rebalance (GtkTextBTree *tree,
+ GtkTextBTreeNode *node)
{
/*
* Loop over the entire ancestral chain of the GtkTextBTreeNode, working
* GtkTextBTreeNode, then make a new root GtkTextBTreeNode above
* it first.
*/
-
+
if (node->parent == NULL)
{
- new_node = gtk_text_btree_node_new();
+ new_node = gtk_text_btree_node_new ();
new_node->parent = NULL;
new_node->next = NULL;
new_node->summary = NULL;
new_node->level = node->level + 1;
new_node->children.node = node;
- recompute_node_counts(tree, new_node);
+ recompute_node_counts (tree, new_node);
tree->root_node = new_node;
}
- new_node = gtk_text_btree_node_new();
+ new_node = gtk_text_btree_node_new ();
new_node->parent = node->parent;
new_node->next = node->next;
node->next = new_node;
new_node->summary = NULL;
new_node->level = node->level;
- new_node->num_children = node->num_children - MIN_CHILDREN;
+ new_node->num_children = node->num_children - MIN_CHILDREN;
if (node->level == 0)
{
for (i = MIN_CHILDREN-1,
new_node->children.node = child->next;
child->next = NULL;
}
- recompute_node_counts(tree, node);
+ recompute_node_counts (tree, node);
node->parent->num_children++;
node = new_node;
if (node->num_children <= MAX_CHILDREN)
{
- recompute_node_counts(tree, node);
+ recompute_node_counts (tree, node);
break;
}
}
{
tree->root_node = node->children.node;
tree->root_node->parent = NULL;
- summary_list_destroy(node->summary);
- g_free(node);
+
+ node->children.node = NULL;
+ gtk_text_btree_node_free_empty (tree, node);
}
return;
}
if (node->parent->num_children < 2)
{
- gtk_text_btree_rebalance(tree, node->parent);
+ gtk_text_btree_rebalance (tree, node->parent);
continue;
}
if (total_children <= MAX_CHILDREN)
{
- recompute_node_counts(tree, node);
+ recompute_node_counts (tree, node);
node->next = other->next;
node->parent->num_children--;
- summary_list_destroy(other->summary);
- g_free(other);
+
+ other->children.node = NULL;
+ other->children.line = NULL;
+ gtk_text_btree_node_free_empty (tree, other);
continue;
}
halfwaynode->next = NULL;
}
- recompute_node_counts(tree, node);
- recompute_node_counts(tree, other);
+ recompute_node_counts (tree, node);
+ recompute_node_counts (tree, other);
}
node = node->parent;
}
static void
-post_insert_fixup(GtkTextBTree *tree,
- GtkTextLine *line,
- gint line_count_delta,
- gint char_count_delta)
+post_insert_fixup (GtkTextBTree *tree,
+ GtkTextLine *line,
+ gint line_count_delta,
+ gint char_count_delta)
{
GtkTextBTreeNode *node;
-
+
/*
* Increment the line counts in all the parent GtkTextBTreeNodes of the insertion
* point, then rebalance the tree if necessary.
if (node->num_children > MAX_CHILDREN)
{
- gtk_text_btree_rebalance(tree, node);
+ gtk_text_btree_rebalance (tree, node);
}
- if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check(tree);
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
}
static GtkTextTagInfo*
-gtk_text_btree_get_existing_tag_info(GtkTextBTree *tree,
- GtkTextTag *tag)
+gtk_text_btree_get_existing_tag_info (GtkTextBTree *tree,
+ GtkTextTag *tag)
{
GtkTextTagInfo *info;
GSList *list;
if (info->tag == tag)
return info;
- list = g_slist_next(list);
+ list = g_slist_next (list);
}
return NULL;
}
static GtkTextTagInfo*
-gtk_text_btree_get_tag_info(GtkTextBTree *tree,
- GtkTextTag *tag)
+gtk_text_btree_get_tag_info (GtkTextBTree *tree,
+ GtkTextTag *tag)
{
GtkTextTagInfo *info;
- info = gtk_text_btree_get_existing_tag_info(tree, tag);
+ info = gtk_text_btree_get_existing_tag_info (tree, tag);
if (info == NULL)
{
/* didn't find it, create. */
- info = g_new(GtkTextTagInfo, 1);
+ info = g_slice_new (GtkTextTagInfo);
info->tag = tag;
- gtk_object_ref(GTK_OBJECT(tag));
+ g_object_ref (tag);
info->tag_root = NULL;
info->toggle_count = 0;
- tree->tag_infos = g_slist_prepend(tree->tag_infos, info);
+ tree->tag_infos = g_slist_prepend (tree->tag_infos, info);
+
+#if 0
+ g_print ("Created tag info %p for tag %s(%p)\n",
+ info, info->tag->name ? info->tag->name : "anon",
+ info->tag);
+#endif
}
-
+
return info;
}
static void
-gtk_text_btree_remove_tag_info(GtkTextBTree *tree,
- GtkTextTag *tag)
+gtk_text_btree_remove_tag_info (GtkTextBTree *tree,
+ GtkTextTag *tag)
{
GtkTextTagInfo *info;
GSList *list;
info = list->data;
if (info->tag == tag)
{
+#if 0
+ g_print ("Removing tag info %p for tag %s(%p)\n",
+ info, info->tag->name ? info->tag->name : "anon",
+ info->tag);
+#endif
+
if (prev != NULL)
{
prev->next = list->next;
tree->tag_infos = list->next;
}
list->next = NULL;
- g_slist_free(list);
-
- gtk_object_unref(GTK_OBJECT(info->tag));
+ g_slist_free (list);
+
+ g_object_unref (info->tag);
- g_free(info);
+ g_slice_free (GtkTextTagInfo, info);
return;
}
- list = g_slist_next(list);
+ prev = list;
+ list = g_slist_next (list);
}
-
- g_assert_not_reached();
- return;
}
static void
-recompute_level_zero_counts(GtkTextBTreeNode *node)
+recompute_level_zero_counts (GtkTextBTreeNode *node)
{
GtkTextLine *line;
GtkTextLineSegment *seg;
- g_assert(node->level == 0);
-
+ g_assert (node->level == 0);
+
line = node->children.line;
while (line != NULL)
{
node->num_lines++;
if (line->parent != node)
- gtk_text_line_set_parent(line, node);
+ gtk_text_line_set_parent (line, node);
seg = line->segments;
while (seg != NULL)
{
node->num_chars += seg->char_count;
-
+
if (((seg->type != >k_text_toggle_on_type)
&& (seg->type != >k_text_toggle_off_type))
|| !(seg->body.toggle.inNodeCounts))
else
{
GtkTextTagInfo *info;
-
+
info = seg->body.toggle.info;
- gtk_text_btree_node_adjust_toggle_count(node, info, 1);
+ gtk_text_btree_node_adjust_toggle_count (node, info, 1);
}
-
+
seg = seg->next;
}
}
static void
-recompute_level_nonzero_counts(GtkTextBTreeNode *node)
+recompute_level_nonzero_counts (GtkTextBTreeNode *node)
{
Summary *summary;
GtkTextBTreeNode *child;
- g_assert(node->level > 0);
-
+ g_assert (node->level > 0);
+
child = node->children.node;
while (child != NULL)
{
if (child->parent != node)
{
child->parent = node;
- gtk_text_btree_node_invalidate_upward(node, NULL);
+ gtk_text_btree_node_invalidate_upward (node, NULL);
}
summary = child->summary;
while (summary != NULL)
{
- gtk_text_btree_node_adjust_toggle_count(node,
- summary->info,
- summary->toggle_count);
-
+ gtk_text_btree_node_adjust_toggle_count (node,
+ summary->info,
+ summary->toggle_count);
+
summary = summary->next;
}
*/
static void
-recompute_node_counts(GtkTextBTree *tree, GtkTextBTreeNode *node)
+recompute_node_counts (GtkTextBTree *tree, GtkTextBTreeNode *node)
{
BTreeView *view;
Summary *summary, *summary2;
node->num_children = 0;
node->num_lines = 0;
node->num_chars = 0;
-
+
/*
* Scan through the children, adding the childrens' tag counts into
* the GtkTextBTreeNode's tag counts and adding new Summary structures if
*/
if (node->level == 0)
- recompute_level_zero_counts(node);
+ recompute_level_zero_counts (node);
else
- recompute_level_nonzero_counts(node);
+ recompute_level_nonzero_counts (node);
view = tree->views;
while (view)
summary2 = NULL;
for (summary = node->summary; summary != NULL; )
{
- if (summary->toggle_count > 0 &&
+ if (summary->toggle_count > 0 &&
summary->toggle_count < summary->info->toggle_count)
{
if (node->level == summary->info->tag_root->level)
}
void
-change_node_toggle_count(GtkTextBTreeNode *node,
- GtkTextTagInfo *info,
- gint delta) /* may be negative */
+_gtk_change_node_toggle_count (GtkTextBTreeNode *node,
+ GtkTextTagInfo *info,
+ gint delta) /* may be negative */
{
Summary *summary, *prevPtr;
GtkTextBTreeNode *node2Ptr;
* See if there's already an entry for this tag for this GtkTextBTreeNode. If so,
* perhaps all we have to do is adjust its count.
*/
-
+
for (prevPtr = NULL, summary = node->summary;
summary != NULL;
prevPtr = summary, summary = summary->next)
* first place).
*/
- g_error("change_node_toggle_count: bad toggle count (%d) max (%d)",
- summary->toggle_count, info->toggle_count);
+ g_error ("%s: bad toggle count (%d) max (%d)",
+ G_STRLOC, summary->toggle_count, info->toggle_count);
}
-
+
/*
* Zero toggle count; must remove this tag from the list.
*/
/*
* This tag isn't currently in the summary information list.
*/
-
+
if (rootLevel == node->level)
{
-
+
/*
* The old tag root is at the same level in the tree as this
* GtkTextBTreeNode, but it isn't at this GtkTextBTreeNode. Move the tag root up
* information at the old root and change the root to its
* parent GtkTextBTreeNode.
*/
-
+
GtkTextBTreeNode *rootnode = info->tag_root;
- summary = (Summary *) g_malloc(sizeof(Summary));
+ summary = g_slice_new (Summary);
summary->info = info;
summary->toggle_count = info->toggle_count - delta;
summary->next = rootnode->summary;
rootLevel = rootnode->level;
info->tag_root = rootnode;
}
- summary = (Summary *) g_malloc(sizeof(Summary));
+ summary = g_slice_new (Summary);
summary->info = info;
summary->toggle_count = delta;
summary->next = node->summary;
*
* inc_count --
*
- * This is a utility procedure used by gtk_text_btree_get_tags. It
+ * This is a utility procedure used by _gtk_text_btree_get_tags. It
* increments the count for a particular tag, adding a new
* entry for that tag if there wasn't one previously.
*
*/
static void
-inc_count(GtkTextTag *tag, int inc, TagInfo *tagInfoPtr)
+inc_count (GtkTextTag *tag, int inc, TagInfo *tagInfoPtr)
{
GtkTextTag **tag_p;
int count;
int *newCounts, newSize;
newSize = 2*tagInfoPtr->arraySize;
- newTags = (GtkTextTag **) g_malloc((unsigned)
- (newSize*sizeof(GtkTextTag *)));
- memcpy((void *) newTags, (void *) tagInfoPtr->tags,
- tagInfoPtr->arraySize *sizeof(GtkTextTag *));
- g_free((char *) tagInfoPtr->tags);
+ newTags = (GtkTextTag **) g_malloc ((unsigned)
+ (newSize*sizeof (GtkTextTag *)));
+ memcpy ((void *) newTags, (void *) tagInfoPtr->tags,
+ tagInfoPtr->arraySize *sizeof (GtkTextTag *));
+ g_free ((char *) tagInfoPtr->tags);
tagInfoPtr->tags = newTags;
- newCounts = (int *) g_malloc((unsigned) (newSize*sizeof(int)));
- memcpy((void *) newCounts, (void *) tagInfoPtr->counts,
- tagInfoPtr->arraySize *sizeof(int));
- g_free((char *) tagInfoPtr->counts);
+ newCounts = (int *) g_malloc ((unsigned) (newSize*sizeof (int)));
+ memcpy ((void *) newCounts, (void *) tagInfoPtr->counts,
+ tagInfoPtr->arraySize *sizeof (int));
+ g_free ((char *) tagInfoPtr->counts);
tagInfoPtr->counts = newCounts;
tagInfoPtr->arraySize = newSize;
}
}
static void
-gtk_text_btree_link_segment(GtkTextLineSegment *seg,
- const GtkTextIter *iter)
+gtk_text_btree_link_segment (GtkTextLineSegment *seg,
+ const GtkTextIter *iter)
{
GtkTextLineSegment *prev;
GtkTextLine *line;
GtkTextBTree *tree;
-
- line = gtk_text_iter_get_text_line(iter);
- tree = gtk_text_iter_get_btree(iter);
-
- prev = gtk_text_line_segment_split(iter);
+
+ line = _gtk_text_iter_get_text_line (iter);
+ tree = _gtk_text_iter_get_btree (iter);
+
+ prev = gtk_text_line_segment_split (iter);
if (prev == NULL)
{
seg->next = line->segments;
seg->next = prev->next;
prev->next = seg;
}
- cleanup_line(line);
- segments_changed(tree);
-
- if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check(tree);
+ cleanup_line (line);
+ segments_changed (tree);
+
+ if (gtk_get_debug_flags () & GTK_DEBUG_TEXT)
+ _gtk_text_btree_check (tree);
}
static void
-gtk_text_btree_unlink_segment(GtkTextBTree *tree,
- GtkTextLineSegment *seg,
- GtkTextLine *line)
+gtk_text_btree_unlink_segment (GtkTextBTree *tree,
+ GtkTextLineSegment *seg,
+ GtkTextLine *line)
{
GtkTextLineSegment *prev;
}
prev->next = seg->next;
}
- cleanup_line(line);
- segments_changed(tree);
+ cleanup_line (line);
+ segments_changed (tree);
}
/*
/*
*--------------------------------------------------------------
*
- * toggle_segment_check_func --
+ * _gtk_toggle_segment_check_func --
*
* This procedure is invoked to perform consistency checks
* on toggle segments.
*/
void
-toggle_segment_check_func(GtkTextLineSegment *segPtr,
- GtkTextLine *line)
+_gtk_toggle_segment_check_func (GtkTextLineSegment *segPtr,
+ GtkTextLine *line)
{
Summary *summary;
int needSummary;
if (segPtr->byte_count != 0)
{
- g_error("toggle_segment_check_func: segment had non-zero size");
+ g_error ("toggle_segment_check_func: segment had non-zero size");
}
if (!segPtr->body.toggle.inNodeCounts)
{
- g_error("toggle_segment_check_func: toggle counts not updated in GtkTextBTreeNodes");
+ g_error ("toggle_segment_check_func: toggle counts not updated in GtkTextBTreeNodes");
}
needSummary = (segPtr->body.toggle.info->tag_root != line->parent);
for (summary = line->parent->summary; ;
{
if (needSummary)
{
- g_error("toggle_segment_check_func: tag not present in GtkTextBTreeNode");
+ g_error ("toggle_segment_check_func: tag not present in GtkTextBTreeNode");
}
else
{
{
if (!needSummary)
{
- g_error("toggle_segment_check_func: tag present in root GtkTextBTreeNode summary");
+ g_error ("toggle_segment_check_func: tag present in root GtkTextBTreeNode summary");
}
break;
}
*/
static void
-gtk_text_btree_node_view_check_consistency (GtkTextBTreeNode *node,
- NodeData *nd)
+gtk_text_btree_node_view_check_consistency (GtkTextBTree *tree,
+ GtkTextBTreeNode *node,
+ NodeData *nd)
{
gint width;
gint height;
gboolean valid;
+ BTreeView *view;
+
+ view = tree->views;
+
+ while (view != NULL)
+ {
+ if (view->view_id == nd->view_id)
+ break;
+ view = view->next;
+ }
+
+ if (view == NULL)
+ g_error ("Node has data for a view %p no longer attached to the tree",
+ nd->view_id);
+
gtk_text_btree_node_compute_view_aggregates (node, nd->view_id,
- &width, &height, &valid);
+ &width, &height, &valid);
+
+ /* valid aggregate not checked the same as width/height, because on
+ * btree rebalance we can have invalid nodes where all lines below
+ * them are actually valid, due to moving lines around between
+ * nodes.
+ *
+ * The guarantee is that if there are invalid lines the node is
+ * invalid - we don't guarantee that if the node is invalid there
+ * are invalid lines.
+ */
+
if (nd->width != width ||
nd->height != height ||
- !nd->valid != !valid)
+ (nd->valid && !valid))
{
g_error ("Node aggregates for view %p are invalid:\n"
- "Are (%d,%d,%s), should be (%d,%d,%s)",
- nd->view_id,
- nd->width, nd->height, nd->valid ? "TRUE" : "FALSE",
- width, height, valid ? "TRUE" : "FALSE");
+ "Are (%d,%d,%s), should be (%d,%d,%s)",
+ nd->view_id,
+ nd->width, nd->height, nd->valid ? "TRUE" : "FALSE",
+ width, height, valid ? "TRUE" : "FALSE");
}
}
static void
-gtk_text_btree_node_check_consistency(GtkTextBTreeNode *node)
+gtk_text_btree_node_check_consistency (GtkTextBTree *tree,
+ GtkTextBTreeNode *node)
{
GtkTextBTreeNode *childnode;
Summary *summary, *summary2;
int num_children, num_lines, num_chars, toggle_count, min_children;
GtkTextLineData *ld;
NodeData *nd;
-
+
if (node->parent != NULL)
{
min_children = MIN_CHILDREN;
if ((node->num_children < min_children)
|| (node->num_children > MAX_CHILDREN))
{
- g_error("gtk_text_btree_node_check_consistency: bad child count (%d)",
- node->num_children);
+ g_error ("gtk_text_btree_node_check_consistency: bad child count (%d)",
+ node->num_children);
}
nd = node->node_data;
while (nd != NULL)
{
- gtk_text_btree_node_view_check_consistency (node, nd);
+ gtk_text_btree_node_view_check_consistency (tree, node, nd);
nd = nd->next;
}
-
+
num_children = 0;
num_lines = 0;
num_chars = 0;
{
if (line->parent != node)
{
- g_error("gtk_text_btree_node_check_consistency: line doesn't point to parent");
+ g_error ("gtk_text_btree_node_check_consistency: line doesn't point to parent");
}
if (line->segments == NULL)
{
- g_error("gtk_text_btree_node_check_consistency: line has no segments");
+ g_error ("gtk_text_btree_node_check_consistency: line has no segments");
}
ld = line->views;
while (ld != NULL)
{
/* Just ensuring we don't segv while doing this loop */
-
+
ld = ld->next;
}
-
+
for (segPtr = line->segments; segPtr != NULL; segPtr = segPtr->next)
{
if (segPtr->type->checkFunc != NULL)
&& (segPtr->next->byte_count == 0)
&& (segPtr->next->type->leftGravity))
{
- g_error("gtk_text_btree_node_check_consistency: wrong segment order for gravity");
+ g_error ("gtk_text_btree_node_check_consistency: wrong segment order for gravity");
}
if ((segPtr->next == NULL)
&& (segPtr->type != >k_text_char_type))
{
- g_error("gtk_text_btree_node_check_consistency: line ended with wrong type");
+ g_error ("gtk_text_btree_node_check_consistency: line ended with wrong type");
}
-
+
num_chars += segPtr->char_count;
}
-
+
num_children++;
num_lines++;
}
{
if (childnode->parent != node)
{
- g_error("gtk_text_btree_node_check_consistency: GtkTextBTreeNode doesn't point to parent");
+ g_error ("gtk_text_btree_node_check_consistency: GtkTextBTreeNode doesn't point to parent");
}
if (childnode->level != (node->level-1))
{
- g_error("gtk_text_btree_node_check_consistency: level mismatch (%d %d)",
- node->level, childnode->level);
+ g_error ("gtk_text_btree_node_check_consistency: level mismatch (%d %d)",
+ node->level, childnode->level);
}
- gtk_text_btree_node_check_consistency (childnode);
+ gtk_text_btree_node_check_consistency (tree, childnode);
for (summary = childnode->summary; summary != NULL;
summary = summary->next)
{
{
break;
}
- g_error("gtk_text_btree_node_check_consistency: GtkTextBTreeNode tag \"%s\" not %s",
- summary->info->tag->name,
- "present in parent summaries");
+ g_error ("gtk_text_btree_node_check_consistency: GtkTextBTreeNode tag \"%s\" not %s",
+ summary->info->tag->priv->name,
+ "present in parent summaries");
}
if (summary->info == summary2->info)
{
}
if (num_children != node->num_children)
{
- g_error("gtk_text_btree_node_check_consistency: mismatch in num_children (%d %d)",
- num_children, node->num_children);
+ g_error ("gtk_text_btree_node_check_consistency: mismatch in num_children (%d %d)",
+ num_children, node->num_children);
}
if (num_lines != node->num_lines)
{
- g_error("gtk_text_btree_node_check_consistency: mismatch in num_lines (%d %d)",
- num_lines, node->num_lines);
+ g_error ("gtk_text_btree_node_check_consistency: mismatch in num_lines (%d %d)",
+ num_lines, node->num_lines);
}
if (num_chars != node->num_chars)
{
- g_error("gtk_text_btree_node_check_consistency: mismatch in num_chars (%d %d)",
- num_chars, node->num_chars);
+ g_error ("gtk_text_btree_node_check_consistency: mismatch in num_chars (%d %d)",
+ num_chars, node->num_chars);
}
for (summary = node->summary; summary != NULL;
{
if (summary->info->toggle_count == summary->toggle_count)
{
- g_error("gtk_text_btree_node_check_consistency: found unpruned root for \"%s\"",
- summary->info->tag->name);
+ g_error ("gtk_text_btree_node_check_consistency: found unpruned root for \"%s\"",
+ summary->info->tag->priv->name);
}
toggle_count = 0;
if (node->level == 0)
{
if (!segPtr->body.toggle.inNodeCounts)
g_error ("Toggle segment not in the node counts");
-
+
toggle_count ++;
}
}
}
if (toggle_count != summary->toggle_count)
{
- g_error("gtk_text_btree_node_check_consistency: mismatch in toggle_count (%d %d)",
- toggle_count, summary->toggle_count);
+ g_error ("gtk_text_btree_node_check_consistency: mismatch in toggle_count (%d %d)",
+ toggle_count, summary->toggle_count);
}
for (summary2 = summary->next; summary2 != NULL;
summary2 = summary2->next)
{
if (summary2->info == summary->info)
{
- g_error("gtk_text_btree_node_check_consistency: duplicated GtkTextBTreeNode tag: %s",
- summary->info->tag->name);
+ g_error ("gtk_text_btree_node_check_consistency: duplicated GtkTextBTreeNode tag: %s",
+ summary->info->tag->priv->name);
}
}
}
}
static void
-listify_foreach(GtkTextTag *tag, gpointer user_data)
+listify_foreach (GtkTextTag *tag, gpointer user_data)
{
GSList** listp = user_data;
- *listp = g_slist_prepend(*listp, tag);
+ *listp = g_slist_prepend (*listp, tag);
}
static GSList*
-list_of_tags(GtkTextTagTable *table)
+list_of_tags (GtkTextTagTable *table)
{
GSList *list = NULL;
-
- gtk_text_tag_table_foreach(table, listify_foreach, &list);
-
+
+ gtk_text_tag_table_foreach (table, listify_foreach, &list);
+
return list;
}
void
-gtk_text_btree_check (GtkTextBTree *tree)
+_gtk_text_btree_check (GtkTextBTree *tree)
{
Summary *summary;
GtkTextBTreeNode *node;
GtkTextLine *line;
GtkTextLineSegment *seg;
GtkTextTag *tag;
- GSList *taglist = NULL;
+ GSList *all_tags, *taglist = NULL;
int count;
GtkTextTagInfo *info;
-
+
/*
* Make sure that the tag toggle counts and the tag root pointers are OK.
*/
- for (taglist = list_of_tags(tree->table);
- taglist != NULL ; taglist = taglist->next)
+ all_tags = list_of_tags (tree->table);
+ for (taglist = all_tags; taglist != NULL ; taglist = taglist->next)
{
tag = taglist->data;
- info = gtk_text_btree_get_existing_tag_info(tree, tag);
+ info = gtk_text_btree_get_existing_tag_info (tree, tag);
if (info != NULL)
{
node = info->tag_root;
{
if (info->toggle_count != 0)
{
- g_error("gtk_text_btree_check found \"%s\" with toggles (%d) but no root",
- tag->name, info->toggle_count);
+ g_error ("_gtk_text_btree_check found \"%s\" with toggles (%d) but no root",
+ tag->priv->name, info->toggle_count);
}
continue; /* no ranges for the tag */
}
else if (info->toggle_count == 0)
{
- g_error("gtk_text_btree_check found root for \"%s\" with no toggles",
- tag->name);
+ g_error ("_gtk_text_btree_check found root for \"%s\" with no toggles",
+ tag->priv->name);
}
else if (info->toggle_count & 1)
{
- g_error("gtk_text_btree_check found odd toggle count for \"%s\" (%d)",
- tag->name, info->toggle_count);
+ g_error ("_gtk_text_btree_check found odd toggle count for \"%s\" (%d)",
+ tag->priv->name, info->toggle_count);
}
for (summary = node->summary; summary != NULL;
summary = summary->next)
{
if (summary->info->tag == tag)
{
- g_error("gtk_text_btree_check found root GtkTextBTreeNode with summary info");
+ g_error ("_gtk_text_btree_check found root GtkTextBTreeNode with summary info");
}
}
count = 0;
}
else
{
- GtkTextLineSegmentClass * last = NULL;
-
+ const GtkTextLineSegmentClass *last = NULL;
+
for (line = node->children.line ; line != NULL ;
line = line->next)
{
g_error ("Two consecutive toggles on or off weren't merged");
if (!seg->body.toggle.inNodeCounts)
g_error ("Toggle segment not in the node counts");
-
+
last = seg->type;
-
+
count++;
}
}
}
if (count != info->toggle_count)
{
- g_error("gtk_text_btree_check toggle_count (%d) wrong for \"%s\" should be (%d)",
- info->toggle_count, tag->name, count);
+ g_error ("_gtk_text_btree_check toggle_count (%d) wrong for \"%s\" should be (%d)",
+ info->toggle_count, tag->priv->name, count);
}
}
}
- g_slist_free(taglist);
- taglist = NULL;
+ g_slist_free (all_tags);
/*
* Call a recursive procedure to do the main body of checks.
*/
node = tree->root_node;
- gtk_text_btree_node_check_consistency(tree->root_node);
+ gtk_text_btree_node_check_consistency (tree, tree->root_node);
/*
* Make sure that there are at least two lines in the text and
if (node->num_lines < 2)
{
- g_error("gtk_text_btree_check: less than 2 lines in tree");
+ g_error ("_gtk_text_btree_check: less than 2 lines in tree");
}
if (node->num_chars < 2)
{
- g_error("gtk_text_btree_check: less than 2 chars in tree");
+ g_error ("_gtk_text_btree_check: less than 2 chars in tree");
}
while (node->level > 0)
{
}
if (seg->type != >k_text_char_type)
{
- g_error("gtk_text_btree_check: last line has bogus segment type");
+ g_error ("_gtk_text_btree_check: last line has bogus segment type");
}
if (seg->next != NULL)
{
- g_error("gtk_text_btree_check: last line has too many segments");
+ g_error ("_gtk_text_btree_check: last line has too many segments");
}
if (seg->byte_count != 1)
{
- g_error("gtk_text_btree_check: last line has wrong # characters: %d",
- seg->byte_count);
+ g_error ("_gtk_text_btree_check: last line has wrong # characters: %d",
+ seg->byte_count);
}
if ((seg->body.chars[0] != '\n') || (seg->body.chars[1] != 0))
{
- g_error("gtk_text_btree_check: last line had bad value: %s",
- seg->body.chars);
+ g_error ("_gtk_text_btree_check: last line had bad value: %s",
+ seg->body.chars);
}
}
-void gtk_text_btree_spew_line(GtkTextBTree* tree, GtkTextLine* line);
-void gtk_text_btree_spew_segment(GtkTextBTree* tree, GtkTextLineSegment* seg);
-void gtk_text_btree_spew_node(GtkTextBTreeNode *node, int indent);
-void gtk_text_btree_spew_line_short (GtkTextLine *line, int indent);
+void _gtk_text_btree_spew_line (GtkTextBTree* tree, GtkTextLine* line);
+void _gtk_text_btree_spew_segment (GtkTextBTree* tree, GtkTextLineSegment* seg);
+void _gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent);
+void _gtk_text_btree_spew_line_short (GtkTextLine *line, int indent);
void
-gtk_text_btree_spew (GtkTextBTree *tree)
+_gtk_text_btree_spew (GtkTextBTree *tree)
{
GtkTextLine * line;
int real_line;
-
- printf("%d lines in tree %p\n",
- gtk_text_btree_line_count(tree), tree);
-
- line = gtk_text_btree_get_line(tree, 0, &real_line);
+
+ printf ("%d lines in tree %p\n",
+ _gtk_text_btree_line_count (tree), tree);
+
+ line = _gtk_text_btree_get_line (tree, 0, &real_line);
while (line != NULL)
{
- gtk_text_btree_spew_line(tree, line);
- line = gtk_text_line_next(line);
+ _gtk_text_btree_spew_line (tree, line);
+ line = _gtk_text_line_next (line);
}
- printf("=================== Tag information\n");
+ printf ("=================== Tag information\n");
{
GSList * list;
info = list->data;
printf (" tag `%s': root at %p, toggle count %d\n",
- info->tag->name, info->tag_root, info->toggle_count);
+ info->tag->priv->name, info->tag_root, info->toggle_count);
list = g_slist_next (list);
}
+
+ if (tree->tag_infos == NULL)
+ {
+ printf (" (no tags in the tree)\n");
+ }
}
- printf("=================== Tree nodes\n");
+ printf ("=================== Tree nodes\n");
{
- gtk_text_btree_spew_node (tree->root_node, 0);
+ _gtk_text_btree_spew_node (tree->root_node, 0);
}
}
void
-gtk_text_btree_spew_line_short (GtkTextLine *line, int indent)
+_gtk_text_btree_spew_line_short (GtkTextLine *line, int indent)
{
gchar * spaces;
GtkTextLineSegment *seg;
-
+
spaces = g_strnfill (indent, ' ');
printf ("%sline %p chars %d bytes %d\n",
spaces, line,
- gtk_text_line_char_count (line),
- gtk_text_line_byte_count (line));
+ _gtk_text_line_char_count (line),
+ _gtk_text_line_byte_count (line));
seg = line->segments;
while (seg != NULL)
{
if (seg->type == >k_text_char_type)
{
- gchar* str = g_strndup(seg->body.chars, MIN (seg->byte_count, 10));
+ gchar* str = g_strndup (seg->body.chars, MIN (seg->byte_count, 10));
gchar* s;
s = str;
while (*s)
{
- if (*s == '\n')
+ if (*s == '\n' || *s == '\r')
*s = '\\';
++s;
}
- printf("%s chars `%s'...\n", spaces, str);
- g_free(str);
+ printf ("%s chars `%s'...\n", spaces, str);
+ g_free (str);
}
else if (seg->type == >k_text_right_mark_type)
{
- printf("%s right mark `%s'\n", spaces, seg->body.mark.name);
+ printf ("%s right mark `%s' visible: %d\n",
+ spaces,
+ seg->body.mark.name,
+ seg->body.mark.visible);
}
else if (seg->type == >k_text_left_mark_type)
{
- printf("%s left mark `%s'\n", spaces, seg->body.mark.name);
+ printf ("%s left mark `%s' visible: %d\n",
+ spaces,
+ seg->body.mark.name,
+ seg->body.mark.visible);
}
else if (seg->type == >k_text_toggle_on_type ||
seg->type == >k_text_toggle_off_type)
{
- printf("%s tag `%s' %s\n",
- spaces, seg->body.toggle.info->tag->name,
- seg->type == >k_text_toggle_off_type ? "off" : "on");
+ printf ("%s tag `%s' %s\n",
+ spaces, seg->body.toggle.info->tag->priv->name,
+ seg->type == >k_text_toggle_off_type ? "off" : "on");
}
seg = seg->next;
}
void
-gtk_text_btree_spew_node(GtkTextBTreeNode *node, int indent)
+_gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent)
{
gchar * spaces;
GtkTextBTreeNode *iter;
Summary *s;
-
+
spaces = g_strnfill (indent, ' ');
printf ("%snode %p level %d children %d lines %d chars %d\n",
while (s)
{
printf ("%s %d toggles of `%s' below this node\n",
- spaces, s->toggle_count, s->info->tag->name);
+ spaces, s->toggle_count, s->info->tag->priv->name);
s = s->next;
}
-
+
g_free (spaces);
-
+
if (node->level > 0)
{
iter = node->children.node;
while (iter != NULL)
{
- gtk_text_btree_spew_node (iter, indent + 2);
+ _gtk_text_btree_spew_node (iter, indent + 2);
iter = iter->next;
}
GtkTextLine *line = node->children.line;
while (line != NULL)
{
- gtk_text_btree_spew_line_short (line, indent + 2);
-
+ _gtk_text_btree_spew_line_short (line, indent + 2);
+
line = line->next;
}
}
}
void
-gtk_text_btree_spew_line(GtkTextBTree* tree, GtkTextLine* line)
+_gtk_text_btree_spew_line (GtkTextBTree* tree, GtkTextLine* line)
{
GtkTextLineSegment * seg;
- printf("%4d| line: %p parent: %p next: %p\n",
- gtk_text_line_get_number(line), line, line->parent, line->next);
-
+ printf ("%4d| line: %p parent: %p next: %p\n",
+ _gtk_text_line_get_number (line), line, line->parent, line->next);
+
seg = line->segments;
-
+
while (seg != NULL)
{
- gtk_text_btree_spew_segment(tree, seg);
+ _gtk_text_btree_spew_segment (tree, seg);
seg = seg->next;
}
}
void
-gtk_text_btree_spew_segment(GtkTextBTree* tree, GtkTextLineSegment * seg)
+_gtk_text_btree_spew_segment (GtkTextBTree* tree, GtkTextLineSegment * seg)
{
- printf(" segment: %p type: %s bytes: %d chars: %d\n",
- seg, seg->type->name, seg->byte_count, seg->char_count);
-
+ printf (" segment: %p type: %s bytes: %d chars: %d\n",
+ seg, seg->type->name, seg->byte_count, seg->char_count);
+
if (seg->type == >k_text_char_type)
{
- gchar* str = g_strndup(seg->body.chars, seg->byte_count);
- printf(" `%s'\n", str);
- g_free(str);
+ gchar* str = g_strndup (seg->body.chars, seg->byte_count);
+ printf (" `%s'\n", str);
+ g_free (str);
}
else if (seg->type == >k_text_right_mark_type)
{
- printf(" right mark `%s'\n", seg->body.mark.name);
+ printf (" right mark `%s' visible: %d not_deleteable: %d\n",
+ seg->body.mark.name,
+ seg->body.mark.visible,
+ seg->body.mark.not_deleteable);
}
else if (seg->type == >k_text_left_mark_type)
{
- printf(" left mark `%s'\n", seg->body.mark.name);
+ printf (" left mark `%s' visible: %d not_deleteable: %d\n",
+ seg->body.mark.name,
+ seg->body.mark.visible,
+ seg->body.mark.not_deleteable);
}
else if (seg->type == >k_text_toggle_on_type ||
seg->type == >k_text_toggle_off_type)
{
- printf(" tag `%s' priority %d\n",
- seg->body.toggle.info->tag->name,
- seg->body.toggle.info->tag->priority);
+ printf (" tag `%s' priority %d\n",
+ seg->body.toggle.info->tag->priv->name,
+ seg->body.toggle.info->tag->priv->priority);
}
}
-
-
projects / ~andy / gtk / blobdiff