gtktextbtree.h 15.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
#ifndef GTK_TEXT_BTREE_H
#define GTK_TEXT_BTREE_H

#include <gtk/gtktextbuffer.h>
#include <gtk/gtktexttag.h>
#include <gtk/gtktextmark.h>
#include <gtk/gtktextchild.h>
#include <gtk/gtktextsegment.h>
#include <gtk/gtktextiter.h>

11
12
13
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

GtkTextBTree  *gtk_text_btree_new        (GtkTextTagTable *table,
                                          GtkTextBuffer   *buffer);
void           gtk_text_btree_ref        (GtkTextBTree    *tree);
void           gtk_text_btree_unref      (GtkTextBTree    *tree);
GtkTextBuffer *gtk_text_btree_get_buffer (GtkTextBTree    *tree);


guint gtk_text_btree_get_chars_changed_stamp    (GtkTextBTree *tree);
guint gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree);
void  gtk_text_btree_segments_changed           (GtkTextBTree *tree);


/* Indexable segment mutation */

void gtk_text_btree_delete        (GtkTextIter *start,
                                   GtkTextIter *end);
void gtk_text_btree_insert        (GtkTextIter *iter,
                                   const gchar *text,
                                   gint         len);
void gtk_text_btree_insert_pixmap (GtkTextIter *iter,
                                   GdkPixmap   *pixmap,
                                   GdkBitmap   *mask);



/* View stuff */
GtkTextLine *gtk_text_btree_find_line_by_y    (GtkTextBTree      *tree,
					       gpointer           view_id,
					       gint               ypixel,
					       gint              *line_top_y);
gint         gtk_text_btree_find_line_top     (GtkTextBTree      *tree,
					       GtkTextLine       *line,
					       gpointer           view_id);
void         gtk_text_btree_add_view          (GtkTextBTree      *tree,
					       GtkTextLayout     *layout);
void         gtk_text_btree_remove_view       (GtkTextBTree      *tree,
					       gpointer           view_id);
void         gtk_text_btree_invalidate_region (GtkTextBTree      *tree,
					       const GtkTextIter *start,
					       const GtkTextIter *end);
void         gtk_text_btree_get_view_size     (GtkTextBTree      *tree,
					       gpointer           view_id,
					       gint              *width,
					       gint              *height);
gboolean     gtk_text_btree_is_valid          (GtkTextBTree      *tree,
					       gpointer           view_id);
gboolean     gtk_text_btree_validate          (GtkTextBTree      *tree,
					       gpointer           view_id,
					       gint               max_pixels,
					       gint              *y,
					       gint              *old_height,
					       gint              *new_height);
void         gtk_text_btree_validate_line     (GtkTextBTree      *tree,
					       GtkTextLine       *line,
					       gpointer           view_id);

/* Tag */

void gtk_text_btree_tag (const GtkTextIter *start,
                         const GtkTextIter *end,
                         GtkTextTag        *tag,
                         gboolean           apply);

/* "Getters" */

GtkTextLine * gtk_text_btree_get_line          (GtkTextBTree      *tree,
                                                gint               line_number,
                                                gint              *real_line_number);
GtkTextLine * 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,
                                                gint              *num_tags);
gchar        *gtk_text_btree_get_text          (const GtkTextIter *start,
                                                const GtkTextIter *end,
                                                gboolean           include_hidden,
                                                gboolean           include_nonchars);
gint          gtk_text_btree_line_count        (GtkTextBTree      *tree);
gint          gtk_text_btree_char_count        (GtkTextBTree      *tree);
gboolean      gtk_text_btree_char_is_invisible (const GtkTextIter *iter);



/* Get iterators (these are implemented in gtktextiter.c) */
void     gtk_text_btree_get_iter_at_char         (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  gint                char_index);
void     gtk_text_btree_get_iter_at_line_char    (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  gint                line_number,
                                                  gint                char_index);
void     gtk_text_btree_get_iter_at_line_byte    (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  gint                line_number,
                                                  gint                byte_index);
gboolean gtk_text_btree_get_iter_from_string     (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  const gchar        *string);
gboolean gtk_text_btree_get_iter_at_mark_name    (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  const gchar        *mark_name);
void     gtk_text_btree_get_iter_at_mark         (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
119
                                                  GtkTextMark        *mark);
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
void     gtk_text_btree_get_last_iter            (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter);
void     gtk_text_btree_get_iter_at_line         (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  GtkTextLine        *line,
                                                  gint                byte_offset);
gboolean gtk_text_btree_get_iter_at_first_toggle (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  GtkTextTag         *tag);
gboolean gtk_text_btree_get_iter_at_last_toggle  (GtkTextBTree       *tree,
                                                  GtkTextIter        *iter,
                                                  GtkTextTag         *tag);


/* Manipulate marks */
135
136
GtkTextMark        *gtk_text_btree_set_mark                (GtkTextBTree       *tree,
                                                            GtkTextMark         *existing_mark,
137
138
139
							    const gchar        *name,
							    gboolean            left_gravity,
							    const GtkTextIter  *index,
140
                                                            gboolean           should_exist);
141
142
143
void                gtk_text_btree_remove_mark_by_name     (GtkTextBTree       *tree,
							    const gchar        *name);
void                gtk_text_btree_remove_mark             (GtkTextBTree       *tree,
144
							    GtkTextMark        *segment);
145
146
147
148
149
150
gboolean            gtk_text_btree_get_selection_bounds    (GtkTextBTree       *tree,
							    GtkTextIter        *start,
							    GtkTextIter        *end);
void                gtk_text_btree_place_cursor            (GtkTextBTree       *tree,
							    const GtkTextIter  *where);
gboolean            gtk_text_btree_mark_is_insert          (GtkTextBTree       *tree,
151
							    GtkTextMark        *segment);
152
gboolean            gtk_text_btree_mark_is_selection_bound (GtkTextBTree       *tree,
153
154
							    GtkTextMark        *segment);
GtkTextMark        *gtk_text_btree_get_mark_by_name        (GtkTextBTree       *tree,
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
							    const gchar        *name);
GtkTextLine *       gtk_text_btree_first_could_contain_tag (GtkTextBTree       *tree,
							    GtkTextTag         *tag);
GtkTextLine *       gtk_text_btree_last_could_contain_tag  (GtkTextBTree       *tree,
							    GtkTextTag         *tag);

/* Lines */

/* Chunk of data associated with a line; views can use this to store
   info at the line. They should "subclass" the header struct here. */
struct _GtkTextLineData {
  gpointer view_id;
  GtkTextLineData *next;
  gint height;
  gint width : 24;
  gint valid : 8;
};

/*
 * The data structure below defines a single line of text (from newline
 * to newline, not necessarily what appears on one line of the screen).
 *
 * You can consider this line a "paragraph" also
 */

struct _GtkTextLine {
  GtkTextBTreeNode *parent;		/* Pointer to parent node containing
                                 * line. */
  GtkTextLine *next;		/* Next in linked list of lines with
                                 * same parent node in B-tree.  NULL
                                 * means end of list. */
  GtkTextLineSegment *segments;	/* First in ordered list of segments
                                 * that make up the line. */
  GtkTextLineData *views;      /* data stored here by views */
};


gint                gtk_text_line_get_number                 (GtkTextLine         *line);
gboolean            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,
                                                              GtkTextBTree        *tree,
                                                              gint                 byte_in_line,
                                                              GtkTextTag          *tag);
201
gboolean            gtk_text_line_is_last                    (GtkTextLine *line);
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
GtkTextLine *       gtk_text_line_next                       (GtkTextLine         *line);
GtkTextLine *       gtk_text_line_previous                   (GtkTextLine         *line);
void                gtk_text_line_add_data                   (GtkTextLine         *line,
                                                              GtkTextLineData     *data);
gpointer            gtk_text_line_remove_data                (GtkTextLine         *line,
                                                              gpointer             view_id);
gpointer            gtk_text_line_get_data                   (GtkTextLine         *line,
                                                              gpointer             view_id);
void                gtk_text_line_invalidate_wrap            (GtkTextLine         *line,
                                                              GtkTextLineData     *ld);
gint                gtk_text_line_char_count                 (GtkTextLine         *line);
gint                gtk_text_line_byte_count                 (GtkTextLine         *line);
gint                gtk_text_line_char_index                 (GtkTextLine         *line);
GtkTextLineSegment *gtk_text_line_byte_to_segment            (GtkTextLine         *line,
                                                              gint                 byte_offset,
                                                              gint                *seg_offset);
GtkTextLineSegment *gtk_text_line_char_to_segment            (GtkTextLine         *line,
                                                              gint                 char_offset,
                                                              gint                *seg_offset);
void                gtk_text_line_byte_locate                (GtkTextLine         *line,
                                                              gint                 byte_offset,
                                                              GtkTextLineSegment **segment,
                                                              GtkTextLineSegment **any_segment,
                                                              gint                *seg_byte_offset,
                                                              gint                *line_byte_offset);
void                gtk_text_line_char_locate                (GtkTextLine         *line,
                                                              gint                 char_offset,
                                                              GtkTextLineSegment **segment,
                                                              GtkTextLineSegment **any_segment,
                                                              gint                *seg_char_offset,
                                                              gint                *line_char_offset);
void                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,
                                                              gint                 char_offset,
                                                              gint                *line_byte_offset,
                                                              gint                *seg_byte_offset);
GtkTextLineSegment *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,
                                                              gint                 char_offset,
                                                              gint                *seg_offset);
gint                gtk_text_line_byte_to_char               (GtkTextLine         *line,
                                                              gint                 byte_offset);
gint                gtk_text_line_char_to_byte               (GtkTextLine         *line,
                                                              gint                 char_offset);
GtkTextLine    *    gtk_text_line_next_could_contain_tag     (GtkTextLine         *line,
                                                              GtkTextBTree        *tree,
                                                              GtkTextTag          *tag);
GtkTextLine    *    gtk_text_line_previous_could_contain_tag (GtkTextLine         *line,
                                                              GtkTextBTree        *tree,
                                                              GtkTextTag          *tag);


/* Debug */
void gtk_text_btree_check (GtkTextBTree *tree);
void gtk_text_btree_spew (GtkTextBTree *tree);
extern gboolean gtk_text_view_debug_btree;

/* ignore, exported only for gtktextsegment.c */
void toggle_segment_check_func (GtkTextLineSegment *segPtr,
                                GtkTextLine        *line);
void change_node_toggle_count  (GtkTextBTreeNode   *node,
                                GtkTextTagInfo     *info,
                                gint                delta);


#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif