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;
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,
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);
}
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);
{
/*
/* 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
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)
{
+ sol = eol;
+
pango_find_paragraph_boundary (text + sol,
len - sol,
&delim,
/* 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;
}
if (delim == eol)
- /* chunk didn't end with a paragraph separator */
- break;
+ {
+ /* chunk didn't end with a paragraph separator */
+ g_assert (eol == len);
+ break;
+ }
/*
* The chunk ended with a newline, so create a new GtkTextLine
line = newline;
cur_seg = NULL;
line_count_delta++;
-
- sol = eol;
}
/*
_gtk_text_btree_get_iter_at_line (tree,
- &start,
- start_line,
- start_byte_index);
+ &start,
+ start_line,
+ start_byte_index);
end = start;
/* We could almost certainly be more efficient here
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);
prevPtr = gtk_text_line_segment_split (iter);
}
void
-__gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
+_gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
GdkPixbuf *pixbuf)
{
GtkTextLineSegment *seg;
seg = _gtk_widget_segment_new ();
- tree = seg->body.child.tree = gtk_text_iter_get_btree (iter);
+ tree = seg->body.child.tree = _gtk_text_iter_get_btree (iter);
insert_pixbuf_or_widget_segment (iter, seg);
GtkTextLine *
_gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
- gpointer view_id,
- gint ypixel,
- gint *line_top_out)
+ gpointer view_id,
+ gint ypixel,
+ gint *line_top_out)
{
GtkTextLine *line;
BTreeView *view;
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);
-
}
- 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);
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
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);
}
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)
#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)
{
/* 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;
}
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);
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)
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;
iter = *where;
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_iter_check (&iter);
+ _gtk_text_iter_check (&iter);
if (mark != NULL)
{
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,
}
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_iter_check (&iter);
+ _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);
+ _gtk_text_iter_check (&iter);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
_gtk_text_btree_check (tree);
}
void
-__gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
+_gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
const gchar *name)
{
GtkTextMark *mark;
void
_gtk_text_line_invalidate_wrap (GtkTextLine *line,
- GtkTextLineData *ld)
+ 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);
}
/* FIXME sync with char_locate (or figure out a clean
way to merge the two functions) */
-void
+gboolean
_gtk_text_line_byte_locate (GtkTextLine *line,
- gint byte_offset,
- GtkTextLineSegment **segment,
- GtkTextLineSegment **any_segment,
- gint *seg_byte_offset,
- gint *line_byte_offset)
+ 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
+gboolean
_gtk_text_line_char_locate (GtkTextLine *line,
- gint char_offset,
- GtkTextLineSegment **segment,
- GtkTextLineSegment **any_segment,
- gint *seg_char_offset,
- gint *line_char_offset)
+ 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)
}
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)
{
}
GtkTextLine*
-__gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
+_gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
GtkTextBTree *tree,
GtkTextTag *tag)
{
/**
- * __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);
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);
}
}
GtkTextIter *start,
GtkTextIter *end)
{
- __gtk_text_btree_get_iter_at_line_char (tree, start, 0, 0);
+ _gtk_text_btree_get_iter_at_line_char (tree, start, 0, 0);
_gtk_text_btree_get_last_iter (tree, end);
}
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;
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)