/*
* 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 {
GtkTextLine *end_iter_line;
guint end_iter_line_stamp;
+
+ GHashTable *child_anchor_table;
};
*/
GtkTextBTree*
-gtk_text_btree_new (GtkTextTagTable *table,
+_gtk_text_btree_new (GtkTextTagTable *table,
GtkTextBuffer *buffer)
{
GtkTextBTree *tree;
tree->end_iter_line_stamp = tree->chars_changed_stamp - 1;
tree->end_iter_line = NULL;
- gtk_object_ref (GTK_OBJECT (tree->table));
- gtk_object_sink (GTK_OBJECT (tree->table));
+ g_object_ref (G_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_changed_handler = g_signal_connect_data (G_OBJECT (tree->table),
+ "tag_changed",
+ tag_changed_cb,
+ tree,
+ NULL, FALSE, FALSE);
- tree->tag_removed_handler = gtk_signal_connect (GTK_OBJECT (tree->table),
- "tag_removed",
- GTK_SIGNAL_FUNC (tag_removed_cb),
- tree);
+ tree->tag_removed_handler = g_signal_connect_data (G_OBJECT (tree->table),
+ "tag_removed",
+ tag_removed_cb,
+ tree,
+ NULL, FALSE, FALSE);
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
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 = gtk_text_btree_set_mark (tree,
+ tree->insert_mark = _gtk_text_btree_set_mark (tree,
NULL,
"insert",
FALSE,
seg->body.mark.not_deleteable = TRUE;
seg->body.mark.visible = TRUE;
- tree->selection_bound_mark = gtk_text_btree_set_mark (tree,
+ tree->selection_bound_mark = _gtk_text_btree_set_mark (tree,
NULL,
"selection_bound",
FALSE,
}
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);
}
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_object_unref (G_OBJECT (tree->insert_mark));
g_object_unref (G_OBJECT (tree->selection_bound_mark));
- gtk_signal_disconnect (GTK_OBJECT (tree->table),
- tree->tag_changed_handler);
+ g_signal_handler_disconnect (G_OBJECT (tree->table),
+ tree->tag_changed_handler);
- gtk_signal_disconnect (GTK_OBJECT (tree->table),
- tree->tag_removed_handler);
+ g_signal_handler_disconnect (G_OBJECT (tree->table),
+ tree->tag_removed_handler);
- gtk_object_unref (GTK_OBJECT (tree->table));
+ g_object_unref (G_OBJECT (tree->table));
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);
*/
void
-gtk_text_btree_delete (GtkTextIter *start,
+_gtk_text_btree_delete (GtkTextIter *start,
GtkTextIter *end)
{
GtkTextLineSegment *prev_seg; /* The segment just before the start
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));
+ 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);
+ tree = _gtk_text_iter_get_btree (start);
{
/*
line1 = gtk_text_iter_get_line (start);
line2 = gtk_text_iter_get_line (end);
- if (line2 == gtk_text_btree_line_count (tree))
+ 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);
+ gtk_text_iter_backward_char (end);
--line2;
if (gtk_text_iter_get_line_offset (start) == 0 &&
line1 != 0)
{
- gtk_text_iter_prev_char (start);
+ gtk_text_iter_backward_char (start);
--line1;
}
- tags = gtk_text_btree_get_tags (end,
+ tags = _gtk_text_btree_get_tags (end,
&array_size);
if (tags != NULL)
i = 0;
while (i < array_size)
{
- gtk_text_btree_tag (end, &orig_end, tags[i], FALSE);
+ _gtk_text_btree_tag (end, &orig_end, tags[i], FALSE);
++i;
}
}
/* Broadcast the need for redisplay before we break the iterators */
- gtk_text_btree_invalidate_region (tree, start, end);
+ _gtk_text_btree_invalidate_region (tree, start, end);
/* 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_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
* (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)
while (line)
{
GtkTextLine *next_line = line->next;
- ld = gtk_text_line_get_data (line, view->view_id);
+ ld = _gtk_text_line_get_data (line, view->view_id);
if (ld)
{
if (deleted_width > 0 || deleted_height > 0)
{
- ld = gtk_text_line_get_data (start_line, view->view_id);
+ ld = _gtk_text_line_get_data (start_line, view->view_id);
/* FIXME: ld is _NOT_ necessarily non-null here, but there is currently
* no way to add ld without also validating the node, which would
segments_changed (tree);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _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;
}
void
-gtk_text_btree_insert (GtkTextIter *iter,
+_gtk_text_btree_insert (GtkTextIter *iter,
const gchar *text,
gint len)
{
* 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;
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);
chars_changed (tree);
segments_changed (tree);
+ g_assert (g_utf8_validate (text, len, NULL));
+
/*
* Chop the text up into lines and create a new segment for
* each line, plus a new line for the leftovers from the
char_count_delta = 0;
while (eol < len)
{
- for (; eol < len; eol++)
- {
- if (text[eol] == '\n')
- {
- eol++;
- break;
- }
- }
- chunkSize = eol - sol;
-
- seg = _gtk_char_segment_new (&text[sol], chunkSize);
+ 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;
+
+ 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;
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;
}
line = newline;
cur_seg = NULL;
line_count_delta++;
-
- sol = eol;
}
/*
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
above. FIXME */
gtk_text_iter_forward_chars (&end, char_count_delta);
- gtk_text_btree_invalidate_region (tree,
+ _gtk_text_btree_invalidate_region (tree,
&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);
+ 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 = _gtk_pixbuf_segment_new (pixbuf);
-
prevPtr = gtk_text_line_segment_split (iter);
if (prevPtr == NULL)
{
/* 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 */
+
+ _gtk_text_btree_invalidate_region (tree, &start, iter);
+}
+
+void
+_gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
+ GdkPixbuf *pixbuf)
+{
+ GtkTextLineSegment *seg;
+
+ seg = _gtk_pixbuf_segment_new (pixbuf);
- gtk_text_btree_invalidate_region (tree, &start, iter);
+ insert_pixbuf_or_widget_segment (iter, seg);
}
+GtkTextChildAnchor*
+_gtk_text_btree_create_child_anchor (GtkTextIter *iter)
+{
+ GtkTextLineSegment *seg;
+ GtkTextBTree *tree;
+
+ seg = _gtk_widget_segment_new ();
+
+ tree = seg->body.child.tree = _gtk_text_iter_get_btree (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);
+
+ return 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
gint current_y = 0;
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
if (node->level == 0)
{
{
GtkTextLineData *ld;
- ld = gtk_text_line_get_data (line, view->view_id);
+ ld = _gtk_text_line_get_data (line, view->view_id);
if (ld)
{
}
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;
if (line == target_line)
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;
}
gint
-gtk_text_btree_find_line_top (GtkTextBTree *tree,
+_gtk_text_btree_find_line_top (GtkTextBTree *tree,
GtkTextLine *target_line,
gpointer view_id)
{
}
void
-gtk_text_btree_add_view (GtkTextBTree *tree,
+_gtk_text_btree_add_view (GtkTextBTree *tree,
GtkTextLayout *layout)
{
BTreeView *view;
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,
+_gtk_text_btree_remove_view (GtkTextBTree *tree,
gpointer view_id)
{
BTreeView *view;
* (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);
}
void
-gtk_text_btree_invalidate_region (GtkTextBTree *tree,
+_gtk_text_btree_invalidate_region (GtkTextBTree *tree,
const GtkTextIter *start,
const GtkTextIter *end)
{
}
void
-gtk_text_btree_get_view_size (GtkTextBTree *tree,
+_gtk_text_btree_get_view_size (GtkTextBTree *tree,
gpointer view_id,
gint *width,
gint *height)
const GtkTextIter *start,
const GtkTextIter *end)
{
- if (gtk_text_tag_affects_size (tag))
+ if (_gtk_text_tag_affects_size (tag))
{
- gtk_text_btree_invalidate_region (tree, start, end);
-
+ _gtk_text_btree_invalidate_region (tree, start, end);
}
- else if (gtk_text_tag_affects_nonsize_appearance (tag))
+ else if (_gtk_text_tag_affects_nonsize_appearance (tag))
{
/* We only need to queue a redraw, not a relayout */
redisplay_region (tree, start, end);
}
void
-gtk_text_btree_tag (const GtkTextIter *start_orig,
+_gtk_text_btree_tag (const GtkTextIter *start_orig,
const GtkTextIter *end_orig,
GtkTextTag *tag,
gboolean add)
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 (_gtk_text_iter_get_btree (start_orig) ==
+ _gtk_text_iter_get_btree (end_orig));
#if 0
printf ("%s tag %s from %d to %d\n",
gtk_text_iter_reorder (&start, &end);
- tree = gtk_text_iter_get_btree (&start);
+ 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);
+ 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
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);
+ gtk_text_iter_forward_char (&iter);
while (gtk_text_iter_forward_to_tag_toggle (&iter, tag))
{
if (gtk_text_iter_compare (&iter, &end) >= 0)
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);
+ 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);
segments_changed (tree);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
}
*/
GtkTextLine*
-gtk_text_btree_get_line (GtkTextBTree *tree,
+_gtk_text_btree_get_line (GtkTextBTree *tree,
gint line_number,
gint *real_line_number)
{
int lines_left;
int line_count;
- line_count = gtk_text_btree_line_count (tree);
+ line_count = _gtk_text_btree_line_count (tree);
if (line_number < 0)
{
}
GtkTextLine*
-gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
+_gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
gint char_index,
gint *line_start_index,
gint *real_char_index)
}
GtkTextTag**
-gtk_text_btree_get_tags (const GtkTextIter *iter,
+_gtk_text_btree_get_tags (const GtkTextIter *iter,
gint *num_tags)
{
GtkTextBTreeNode *node;
#define NUM_TAG_INFOS 10
- line = gtk_text_iter_get_text_line (iter);
- tree = gtk_text_iter_get_btree (iter);
+ 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;
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)
{
/* 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"); */
}
- 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;
}
/* 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;
}
}
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)
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 (_gtk_text_iter_get_btree (start_orig) ==
+ _gtk_text_iter_get_btree (end_orig), NULL);
start = *start_orig;
end = *end_orig;
retval = g_string_new ("");
- tree = gtk_text_iter_get_btree (&start);
+ tree = _gtk_text_iter_get_btree (&start);
- end_seg = gtk_text_iter_get_indexable_segment (&end);
+ 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);
- gtk_text_iter_forward_indexable_segment (&iter);
+ _gtk_text_iter_forward_indexable_segment (&iter);
- seg = gtk_text_iter_get_indexable_segment (&iter);
+ seg = _gtk_text_iter_get_indexable_segment (&iter);
}
copy_segment (retval, include_hidden, include_nonchars, &iter, &end);
}
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;
#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 */
GtkTextBTree *tree;
gint byte_index;
- line = gtk_text_iter_get_text_line (iter);
- tree = gtk_text_iter_get_btree (iter);
+ 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);
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;
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;
GtkTextIter iter;
GtkTextIter end;
- gtk_text_btree_get_iter_at_mark (mark->body.mark.tree,
+ _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,
+ _gtk_text_btree_invalidate_region (mark->body.mark.tree,
&iter, &end);
}
GtkTextIter *iter)
{
if (gtk_text_iter_get_line (iter) ==
- gtk_text_btree_line_count (tree))
- gtk_text_iter_prev_char (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,
+real_set_mark (GtkTextBTree *tree,
+ GtkTextMark *existing_mark,
+ const gchar *name,
+ gboolean left_gravity,
const GtkTextIter *where,
- gboolean should_exist,
- gboolean redraw_selections)
+ 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 (_gtk_text_iter_get_btree (where) == tree, NULL);
if (existing_mark)
mark = existing_mark->segment;
}
/* OK if !should_exist and it does already exist, in that case
- we just move it. */
-
+ * we just move it.
+ */
+
iter = *where;
+ if (gtk_debug_flags & GTK_DEBUG_TEXT)
+ _gtk_text_iter_check (&iter);
+
if (mark != NULL)
{
if (redraw_selections &&
{
GtkTextIter old_pos;
- gtk_text_btree_get_iter_at_mark (tree, &old_pos,
+ _gtk_text_btree_get_iter_at_mark (tree, &old_pos,
mark->body.mark.obj);
redisplay_region (tree, &old_pos, where);
}
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));
+ 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 */
left_gravity,
name);
- mark->body.mark.line = gtk_text_iter_get_text_line (&iter);
+ mark->body.mark.line = _gtk_text_iter_get_text_line (&iter);
if (mark->body.mark.name)
g_hash_table_insert (tree->mark_table,
mark);
}
+ if (gtk_debug_flags & GTK_DEBUG_TEXT)
+ _gtk_text_iter_check (&iter);
+
/* Link mark into new location */
gtk_text_btree_link_segment (mark, &iter);
redisplay_mark_if_visible (mark);
+ if (gtk_debug_flags & GTK_DEBUG_TEXT)
+ _gtk_text_iter_check (&iter);
+
+ if (gtk_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,
}
gboolean
-gtk_text_btree_get_selection_bounds (GtkTextBTree *tree,
+_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,
+ _gtk_text_btree_get_iter_at_mark (tree, &tmp_start,
tree->insert_mark);
- gtk_text_btree_get_iter_at_mark (tree, &tmp_end,
+ _gtk_text_btree_get_iter_at_mark (tree, &tmp_end,
tree->selection_bound_mark);
if (gtk_text_iter_equal (&tmp_start, &tmp_end))
}
void
-gtk_text_btree_place_cursor (GtkTextBTree *tree,
+_gtk_text_btree_place_cursor (GtkTextBTree *tree,
const GtkTextIter *iter)
{
GtkTextIter start, end;
- if (gtk_text_btree_get_selection_bounds (tree, &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 */
}
void
-gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
+_gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
const gchar *name)
{
GtkTextMark *mark;
mark = g_hash_table_lookup (tree->mark_table,
name);
- gtk_text_btree_remove_mark (tree, mark);
+ _gtk_text_btree_remove_mark (tree, mark);
}
void
-gtk_text_btree_remove_mark (GtkTextBTree *tree,
+_gtk_text_btree_remove_mark (GtkTextBTree *tree,
GtkTextMark *mark)
{
GtkTextLineSegment *segment;
}
gboolean
-gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
+_gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
GtkTextMark *segment)
{
return segment == tree->insert_mark;
}
gboolean
-gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
+_gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
GtkTextMark *segment)
{
return segment == tree->selection_bound_mark;
}
GtkTextMark*
-gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
+_gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
const gchar *name)
{
GtkTextLineSegment *seg;
}
GtkTextLine*
-gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
+_gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
GtkTextTag *tag)
{
GtkTextBTreeNode *node;
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;
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_line (tree, -1, NULL);
}
}
*/
gint
-gtk_text_line_get_number (GtkTextLine *line)
+_gtk_text_line_get_number (GtkTextLine *line)
{
GtkTextLine *line2;
GtkTextBTreeNode *node, *parent, *node2;
/* FIXME this function is far too slow, for no good reason. */
gboolean
-gtk_text_line_char_has_tag (GtkTextLine *line,
+_gtk_text_line_char_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
gint char_in_line,
GtkTextTag *tag)
}
gboolean
-gtk_text_line_byte_has_tag (GtkTextLine *line,
+_gtk_text_line_byte_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
gint byte_in_line,
GtkTextTag *tag)
}
gboolean
-gtk_text_line_is_last (GtkTextLine *line,
+_gtk_text_line_is_last (GtkTextLine *line,
GtkTextBTree *tree)
{
return line == get_last_line (tree);
}
GtkTextLine*
-gtk_text_line_next (GtkTextLine *line)
+_gtk_text_line_next (GtkTextLine *line)
{
GtkTextBTreeNode *node;
}
GtkTextLine*
-gtk_text_line_previous (GtkTextLine *line)
+_gtk_text_line_previous (GtkTextLine *line)
{
GtkTextBTreeNode *node;
GtkTextBTreeNode *node2;
}
void
-gtk_text_line_add_data (GtkTextLine *line,
+_gtk_text_line_add_data (GtkTextLine *line,
GtkTextLineData *data)
{
g_return_if_fail (line != NULL);
}
gpointer
-gtk_text_line_remove_data (GtkTextLine *line,
+_gtk_text_line_remove_data (GtkTextLine *line,
gpointer view_id)
{
GtkTextLineData *prev;
}
gpointer
-gtk_text_line_get_data (GtkTextLine *line,
+_gtk_text_line_get_data (GtkTextLine *line,
gpointer view_id)
{
GtkTextLineData *iter;
}
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?
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);
-
+
ld->valid = FALSE;
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;
}
gint
-gtk_text_line_byte_count (GtkTextLine *line)
+_gtk_text_line_byte_count (GtkTextLine *line)
{
GtkTextLineSegment *seg;
gint size;
}
gint
-gtk_text_line_char_index (GtkTextLine *target_line)
+_gtk_text_line_char_index (GtkTextLine *target_line)
{
GSList *node_stack = NULL;
GtkTextBTreeNode *iter;
{
g_assert (line != NULL);
- num_chars += gtk_text_line_char_count (line);
+ num_chars += _gtk_text_line_char_count (line);
line = line->next;
}
}
GtkTextLineSegment*
-gtk_text_line_byte_to_segment (GtkTextLine *line,
+_gtk_text_line_byte_to_segment (GtkTextLine *line,
gint byte_offset,
gint *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*
-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*
-gtk_text_line_char_to_any_segment (GtkTextLine *line,
+_gtk_text_line_char_to_any_segment (GtkTextLine *line,
gint char_offset,
gint *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;
}
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");
/* 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;
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... */
-
- byte_offset = G_MAXINT;
- }
+ g_return_val_if_fail (line != NULL, FALSE);
+ g_return_val_if_fail (byte_offset >= 0, FALSE);
*segment = NULL;
*any_segment = NULL;
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
{
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;
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;
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
{
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,
+_gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
gint byte_offset,
gint *line_char_offset,
gint *seg_char_offset)
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)
{
}
void
-gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
+_gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
gint char_offset,
gint *line_byte_offset,
gint *seg_byte_offset)
/* remember that tag == NULL means "any tag" */
GtkTextLine*
-gtk_text_line_next_could_contain_tag (GtkTextLine *line,
+_gtk_text_line_next_could_contain_tag (GtkTextLine *line,
GtkTextBTree *tree,
GtkTextTag *tag)
{
g_return_val_if_fail (line != NULL, NULL);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _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);
+ return _gtk_text_line_next (line);
}
/* Our tag summaries only have node precision, not line
}
GtkTextLine*
-gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
+_gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
GtkTextBTree *tree,
GtkTextTag *tag)
{
g_return_val_if_fail (line != NULL, NULL);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _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 _gtk_text_line_previous (line);
}
/* Return same-node line, if any. */
GtkTextLine *line;
gint real_line;
- n_lines = gtk_text_btree_line_count (tree);
+ 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);
+ line = _gtk_text_btree_get_line (tree, n_lines, &real_line);
tree->end_iter_line_stamp = tree->chars_changed_stamp;
tree->end_iter_line = line;
/**
- * gtk_text_btree_is_valid:
+ * _gtk_text_btree_is_valid:
* @tree: a #GtkTextBTree
* @view_id: ID for the view
*
* Return value: %TRUE if the entire #GtkTextBTree is valid
**/
gboolean
-gtk_text_btree_is_valid (GtkTextBTree *tree,
+_gtk_text_btree_is_valid (GtkTextBTree *tree,
gpointer view_id)
{
NodeData *nd;
/* 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;
/* 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;
/* Iterate over the remaining lines */
while (line != NULL)
{
- ld = gtk_text_line_get_data (line, view_id);
+ ld = _gtk_text_line_get_data (line, view_id);
state->in_validation = FALSE;
if (!ld || !ld->valid)
}
/**
- * 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
* entire tree was already valid.
**/
gboolean
-gtk_text_btree_validate (GtkTextBTree *tree,
+_gtk_text_btree_validate (GtkTextBTree *tree,
gpointer view_id,
gint max_pixels,
gint *y,
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;
*new_height = state.new_height;
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
return TRUE;
}
while (line != NULL)
{
- GtkTextLineData *ld = gtk_text_line_get_data (line, view_id);
+ GtkTextLineData *ld = _gtk_text_line_get_data (line, view_id);
if (!ld || !ld->valid)
valid = FALSE;
/**
- * 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
* 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);
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);
}
}
{
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);
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_last_iter (tree, end);
}
static void
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,
+ _gtk_text_btree_get_iter_at_last_toggle (tree, &end, tag);
+ _gtk_text_btree_invalidate_region (tree,
&start, &end);
}
{
gint width, height;
- gtk_text_btree_get_view_size (tree, view->view_id, &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;
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);
}
}
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
}
static GtkTextTagInfo*
info = g_new (GtkTextTagInfo, 1);
info->tag = tag;
- gtk_object_ref (GTK_OBJECT (tag));
+ g_object_ref (G_OBJECT (tag));
info->tag_root = NULL;
info->toggle_count = 0;
list->next = NULL;
g_slist_free (list);
- gtk_object_unref (GTK_OBJECT (info->tag));
+ g_object_unref (G_OBJECT (info->tag));
g_free (info);
return;
*
* 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.
*
GtkTextLine *line;
GtkTextBTree *tree;
- line = gtk_text_iter_get_text_line (iter);
- tree = gtk_text_iter_get_btree (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)
segments_changed (tree);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
}
static void
}
void
-gtk_text_btree_check (GtkTextBTree *tree)
+_gtk_text_btree_check (GtkTextBTree *tree)
{
Summary *summary;
GtkTextBTreeNode *node;
{
if (info->toggle_count != 0)
{
- g_error ("gtk_text_btree_check found \"%s\" with toggles (%d) but no root",
+ g_error ("_gtk_text_btree_check found \"%s\" with toggles (%d) but no root",
tag->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",
+ g_error ("_gtk_text_btree_check found root for \"%s\" with no toggles",
tag->name);
}
else if (info->toggle_count & 1)
{
- g_error ("gtk_text_btree_check found odd toggle count for \"%s\" (%d)",
+ g_error ("_gtk_text_btree_check found odd toggle count for \"%s\" (%d)",
tag->name, info->toggle_count);
}
for (summary = node->summary; summary != NULL;
{
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;
}
if (count != info->toggle_count)
{
- g_error ("gtk_text_btree_check toggle_count (%d) wrong for \"%s\" should be (%d)",
+ g_error ("_gtk_text_btree_check toggle_count (%d) wrong for \"%s\" should be (%d)",
info->toggle_count, tag->name, count);
}
}
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",
+ 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",
+ 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);
+ _gtk_text_btree_line_count (tree), tree);
- line = gtk_text_btree_get_line (tree, 0, &real_line);
+ 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 ("=================== 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;
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)
s = str;
while (*s)
{
- if (*s == '\n')
+ if (*s == '\n' || *s == '\r')
*s = '\\';
++s;
}
}
void
-gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent)
+_gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent)
{
gchar * spaces;
GtkTextBTreeNode *iter;
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);
+ _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);
projects / ~andy / gtk / blobdiff