/*
- * gtktextbtree.c --
+ * Gtktextbtree.c --
*
* This file contains code that manages the B-tree representation
* of text for the text buffer and implements character and
#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
#include <config.h>
-#include "gtkalias.h"
#include "gtktextbtree.h"
#include <string.h>
#include <stdlib.h>
#include "gtktextiterprivate.h"
#include "gtkdebug.h"
#include "gtktextmarkprivate.h"
+#include "gtkalias.h"
/*
* Types
static void redisplay_region (GtkTextBTree *tree,
const GtkTextIter *start,
- const GtkTextIter *end);
+ const GtkTextIter *end,
+ gboolean cursors_only);
/* Inline thingies */
while (seg)
{
- if (seg->byte_count > 0)
+ if (seg->type == >k_text_char_type && seg->byte_count > 0)
{
PangoDirection pango_dir;
*/
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);
+ _gtk_text_btree_invalidate_region (tree, end, &end_propagate, FALSE);
}
/* Sweep backward */
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);
+ _gtk_text_btree_invalidate_region (tree, &start_propagate, start, FALSE);
}
}
}
* 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 *line;
GtkTextLine *deleted_lines = NULL; /* List of lines we've deleted */
gint start_byte_offset;
/* Broadcast the need for redisplay before we break the iterators */
DV (g_print ("invalidating due to deleting some text (%s)\n", G_STRLOC));
- _gtk_text_btree_invalidate_region (tree, start, end);
+ _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);
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;
}
view = tree->views;
while (view)
{
- GtkTextLine *line;
GtkTextLineData *ld;
gint deleted_width = 0;
deleted_height += ld->height;
}
- if (!view->next)
- gtk_text_line_destroy (tree, line);
-
line = next_line;
}
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_iter_forward_chars (&end, char_count_delta);
DV (g_print ("invalidating due to inserting some text (%s)\n", G_STRLOC));
- _gtk_text_btree_invalidate_region (tree,
- &start, &end);
+ _gtk_text_btree_invalidate_region (tree, &start, &end, FALSE);
/* Convenience for the user */
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);
+ _gtk_text_btree_invalidate_region (tree, &start, iter, FALSE);
}
void
void
_gtk_text_btree_invalidate_region (GtkTextBTree *tree,
const GtkTextIter *start,
- const GtkTextIter *end)
+ const GtkTextIter *end,
+ gboolean cursors_only)
{
BTreeView *view;
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;
}
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->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;
iter_stack_free (IterStack *stack)
{
g_free (stack->iters);
- g_free (stack);
+ g_slice_free (IterStack, stack);
}
static void
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);
+ _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);
+ redisplay_region (tree, start, end, FALSE);
}
/* We don't need to do anything if the tag doesn't affect display */
segments_changed (tree);
+ queue_tag_redisplay (tree, tag, &start, &end);
+
if (gtk_debug_flags & GTK_DEBUG_TEXT)
_gtk_text_btree_check (tree);
}
GtkTextLineSegment *seg;
int chars_left;
int chars_in_line;
- int bytes_in_line;
node = tree->root_node;
*/
chars_in_line = 0;
- bytes_in_line = 0;
seg = NULL;
for (line = node->children.line; line != NULL; line = line->next)
{
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,
gint *num_tags)
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);
tagInfo.numTags = 0;
g_free (tagInfo.tags);
return NULL;
}
+
+ /* Sort tags in ascending order of priority */
+ _gtk_text_tag_array_sort (tagInfo.tags, dst);
+
return tagInfo.tags;
}
GtkTextLineSegment *seg;
GtkTextLineSegment *end_seg;
GString *retval;
- GtkTextBTree *tree;
gchar *str;
GtkTextIter iter;
GtkTextIter start;
retval = g_string_new (NULL);
- tree = _gtk_text_iter_get_btree (&start);
-
end_seg = _gtk_text_iter_get_indexable_segment (&end);
iter = start;
seg = _gtk_text_iter_get_indexable_segment (&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;
/* almost always avoid malloc, so stay out of system calls */
if (LOTSA_TAGS < numTags)
{
- tagCnts = g_new (int, 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.
|| (seg->type == >k_text_toggle_off_type))
{
tag = seg->body.toggle.info->tag;
- if (tag->invisible_set && tag->values->invisible)
+ if (tag->invisible_set)
{
tags[tag->priority] = tag;
tagCnts[tag->priority]++;
|| (seg->type == >k_text_toggle_off_type))
{
tag = seg->body.toggle.info->tag;
- if (tag->invisible_set && tag->values->invisible)
+ if (tag->invisible_set)
{
tags[tag->priority] = tag;
tagCnts[tag->priority]++;
if (summary->toggle_count & 1)
{
tag = summary->info->tag;
- if (tag->invisible_set && tag->values->invisible)
+ if (tag->invisible_set)
{
tags[tag->priority] = tag;
tagCnts[tag->priority] += summary->toggle_count;
static void
redisplay_region (GtkTextBTree *tree,
const GtkTextIter *start,
- const GtkTextIter *end)
+ const GtkTextIter *end,
+ gboolean cursors_only)
{
BTreeView *view;
GtkTextLine *start_line, *end_line;
if (ld)
end_y += ld->height;
- gtk_text_layout_changed (view->layout, start_y,
- end_y - start_y,
- end_y - start_y);
+ 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;
}
gtk_text_iter_forward_char (&end);
DV (g_print ("invalidating due to moving visible mark (%s)\n", G_STRLOC));
- _gtk_text_btree_invalidate_region (mark->body.mark.tree,
- &iter, &end);
+ _gtk_text_btree_invalidate_region (mark->body.mark.tree, &iter, &end, TRUE);
}
static void
GtkTextLineSegment *mark,
GtkTextIter *iter)
{
- if (gtk_text_iter_get_line (iter) ==
- _gtk_text_btree_line_count (tree))
+ if (gtk_text_iter_get_line (iter) == _gtk_text_btree_line_count (tree))
gtk_text_iter_backward_char (iter);
}
g_return_val_if_fail (_gtk_text_iter_get_btree (where) == tree, NULL);
if (existing_mark)
- mark = existing_mark->segment;
+ {
+ 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);
_gtk_text_btree_get_iter_at_mark (tree, &old_pos,
mark->body.mark.obj);
- redisplay_region (tree, &old_pos, where);
+ redisplay_region (tree, &old_pos, where, TRUE);
}
/*
}
else
{
- mark = _gtk_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 = existing_mark->segment;
+ _gtk_mark_segment_set_tree (mark, tree);
mark->body.mark.line = _gtk_text_iter_get_text_line (&iter);
const GtkTextIter *ins,
const GtkTextIter *bound)
{
- GtkTextIter start, end;
+ 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);
- 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, tree->insert_mark,
+ "insert", FALSE, ins, TRUE, FALSE);
+ real_set_mark (tree, tree->selection_bound_mark,
+ "selection_bound", FALSE, bound, TRUE, FALSE);
- /* 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);
+ }
}
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)
{
seg->body.mark.visible = setting;
- redisplay_mark (seg);
+ if (seg->body.mark.tree)
+ redisplay_mark (seg);
}
}
{
if (tree->end_iter_line_stamp != tree->chars_changed_stamp)
{
- int n_lines;
- int real_line;
-
- /* n_lines is without the magic line at the end */
- n_lines = _gtk_text_btree_line_count (tree);
-
- g_assert (n_lines >= 1);
+ 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);
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)
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)
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)
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)
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);
gint *line_byte_offset)
{
GtkTextLineSegment *seg;
- GtkTextLineSegment *after_prev_indexable;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
gint 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;
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;
}
gint *line_char_offset)
{
GtkTextLineSegment *seg;
- GtkTextLineSegment *after_prev_indexable;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
gint 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;
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;
}
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;
+ const char *p;
- bytes = g_utf8_next_char (start) - start;
- *seg_byte_offset += bytes;
- offset -= 1;
- }
+ /* 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);
static void
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*
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;
}
}
}
{
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)
{
- g_free (nd);
+ g_slice_free (NodeData, nd);
}
static void
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*
{
/* didn't find a summary for our tag. */
g_return_if_fail (adjust > 0);
- summary = g_new (Summary, 1);
+ summary = g_slice_new (Summary);
summary->info = info;
summary->toggle_count = adjust;
summary->next = node->summary;
/* Must be a last toggle if there was a first one. */
_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);
+ _gtk_text_btree_invalidate_region (tree, &start, &end, FALSE);
}
}
{
/* didn't find it, create. */
- info = g_new (GtkTextTagInfo, 1);
+ info = g_slice_new (GtkTextTagInfo);
info->tag = tag;
g_object_ref (tag);
g_object_unref (info->tag);
- g_free (info);
+ g_slice_free (GtkTextTagInfo, info);
return;
}
*/
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;
}
else
{
- GtkTextLineSegmentClass * last = NULL;
+ const GtkTextLineSegmentClass *last = NULL;
for (line = node->children.line ; line != NULL ;
line = line->next)
}
}
-
+#define __GTK_TEXT_BTREE_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff