Pileus Git - ~andy/gtk/blob - gtk/gtktextbuffer.h

   1 #ifndef GTK_TEXT_BUFFER_H
   2 #define GTK_TEXT_BUFFER_H
   3
   4 #include <gtk/gtkwidget.h>
   5 #include <gtk/gtktexttagtable.h>
   6 #include <gtk/gtktextiter.h>
   7 #include <gtk/gtktextmark.h>
   8
   9 #ifdef __cplusplus
  10 extern "C" {
  11 #endif /* __cplusplus */
  12
  13 /*
  14  * This is the PUBLIC representation of a text buffer.
  15  * GtkTextBTree is the PRIVATE internal representation of it.
  16  */
  17
  18 typedef struct _GtkTextBTree GtkTextBTree;
  19
  20 #define GTK_TYPE_TEXT_BUFFER            (gtk_text_buffer_get_type())
  21 #define GTK_TEXT_BUFFER(obj)            (GTK_CHECK_CAST ((obj), GTK_TYPE_TEXT_BUFFER, GtkTextBuffer))
  22 #define GTK_TEXT_BUFFER_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_BUFFER, GtkTextBufferClass))
  23 #define GTK_IS_TEXT_BUFFER(obj)         (GTK_CHECK_TYPE ((obj), GTK_TYPE_TEXT_BUFFER))
  24 #define GTK_IS_TEXT_BUFFER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_BUFFER))
  25 #define GTK_TEXT_BUFFER_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_TEXT_BUFFER, GtkTextBufferClass))
  26
  27 typedef struct _GtkTextBufferClass GtkTextBufferClass;
  28
  29 struct _GtkTextBuffer {
  30   GtkObject parent_instance;
  31
  32   GtkTextTagTable *tag_table;
  33   GtkTextBTree *btree;
  34
  35   /* Whether the buffer has been modified since last save */
  36   gboolean modified;
  37 };
  38
  39 struct _GtkTextBufferClass {
  40   GtkObjectClass parent_class;
  41
  42   void (* insert_text)     (GtkTextBuffer *buffer,
  43                             GtkTextIter *pos,
  44                             const gchar *text,
  45                             gint length,
  46                             gboolean interactive);
  47
  48
  49   void (* delete_text)     (GtkTextBuffer *buffer,
  50                             GtkTextIter *start,
  51                             GtkTextIter *end,
  52                             gboolean interactive);
  53
  54   /* Only for text changed, marks/tags don't cause this
  55      to be emitted */
  56   void (* changed)         (GtkTextBuffer *buffer);
  57
  58
  59   /* New value for the modified flag */
  60   void (* modified_changed)   (GtkTextBuffer *buffer);
  61
  62   /* Mark moved or created */
  63   void (* mark_set)           (GtkTextBuffer *buffer,
  64                                const GtkTextIter *location,
  65                                GtkTextMark *mark);
  66
  67   void (* mark_deleted)       (GtkTextBuffer *buffer,
  68                                GtkTextMark *mark);
  69
  70   void (* apply_tag)          (GtkTextBuffer *buffer,
  71                                GtkTextTag *tag,
  72                                const GtkTextIter *start_char,
  73                                const GtkTextIter *end_char);
  74
  75   void (* remove_tag)         (GtkTextBuffer *buffer,
  76                                GtkTextTag *tag,
  77                                const GtkTextIter *start_char,
  78                                const GtkTextIter *end_char);
  79
  80 };
  81
  82 GtkType        gtk_text_buffer_get_type       (void) G_GNUC_CONST;
  83
  84
  85
  86 /* table is NULL to create a new one */
  87 GtkTextBuffer *gtk_text_buffer_new            (GtkTextTagTable *table);
  88 gint           gtk_text_buffer_get_line_count (GtkTextBuffer   *buffer);
  89 gint           gtk_text_buffer_get_char_count (GtkTextBuffer   *buffer);
  90
  91
  92 GtkTextTagTable* gtk_text_buffer_get_tag_table (GtkTextBuffer  *buffer);
  93
  94 /* Delete whole buffer, then insert */
  95 void gtk_text_buffer_set_text          (GtkTextBuffer *buffer,
  96                                         const gchar   *text,
  97                                         gint           len);
  98
  99 /* Insert into the buffer */
 100 void gtk_text_buffer_insert            (GtkTextBuffer *buffer,
 101                                         GtkTextIter   *iter,
 102                                         const gchar   *text,
 103                                         gint           len);
 104 void gtk_text_buffer_insert_at_cursor  (GtkTextBuffer *buffer,
 105                                         const gchar   *text,
 106                                         gint           len);
 107
 108 gboolean gtk_text_buffer_insert_interactive           (GtkTextBuffer *buffer,
 109                                                        GtkTextIter   *iter,
 110                                                        const gchar   *text,
 111                                                        gint           len,
 112                                                        gboolean       default_editable);
 113 gboolean gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer,
 114                                                        const gchar   *text,
 115                                                        gint           len,
 116                                                        gboolean       default_editable);
 117
 118 void     gtk_text_buffer_insert_range             (GtkTextBuffer     *buffer,
 119                                                    GtkTextIter       *iter,
 120                                                    const GtkTextIter *start,
 121                                                    const GtkTextIter *end);
 122 gboolean gtk_text_buffer_insert_range_interactive (GtkTextBuffer     *buffer,
 123                                                    GtkTextIter       *iter,
 124                                                    const GtkTextIter *start,
 125                                                    const GtkTextIter *end,
 126                                                    gboolean           default_editable);
 127
 128 void    gtk_text_buffer_insert_with_tags          (GtkTextBuffer     *buffer,
 129                                                    GtkTextIter       *iter,
 130                                                    const gchar       *text,
 131                                                    gint               len,
 132                                                    GtkTextTag        *first_tag,
 133                                                    ...);
 134
 135 void    gtk_text_buffer_insert_with_tags_by_name  (GtkTextBuffer     *buffer,
 136                                                    GtkTextIter       *iter,
 137                                                    const gchar       *text,
 138                                                    gint               len,
 139                                                    const gchar       *first_tag_name,
 140                                                    ...);
 141
 142 /* Delete from the buffer */
 143 void     gtk_text_buffer_delete             (GtkTextBuffer *buffer,
 144                                              GtkTextIter   *start,
 145                                              GtkTextIter   *end);
 146 gboolean gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer,
 147                                              GtkTextIter   *start_iter,
 148                                              GtkTextIter   *end_iter,
 149                                              gboolean       default_editable);
 150
 151
 152
 153 /* Obtain strings from the buffer */
 154 gchar          *gtk_text_buffer_get_text            (GtkTextBuffer     *buffer,
 155                                                      const GtkTextIter *start,
 156                                                      const GtkTextIter *end,
 157                                                      gboolean           include_hidden_chars);
 158
 159 gchar          *gtk_text_buffer_get_slice           (GtkTextBuffer     *buffer,
 160                                                      const GtkTextIter *start,
 161                                                      const GtkTextIter *end,
 162                                                      gboolean           include_hidden_chars);
 163
 164 /* Insert a pixbuf */
 165 void gtk_text_buffer_insert_pixbuf         (GtkTextBuffer *buffer,
 166                                             GtkTextIter   *iter,
 167                                             GdkPixbuf     *pixbuf);
 168
 169 /* Mark manipulation */
 170 GtkTextMark   *gtk_text_buffer_create_mark (GtkTextBuffer     *buffer,
 171                                             const gchar       *mark_name,
 172                                             const GtkTextIter *where,
 173                                             gboolean           left_gravity);
 174 void           gtk_text_buffer_move_mark   (GtkTextBuffer     *buffer,
 175                                             GtkTextMark       *mark,
 176                                             const GtkTextIter *where);
 177 void           gtk_text_buffer_delete_mark (GtkTextBuffer     *buffer,
 178                                             GtkTextMark       *mark);
 179 GtkTextMark*   gtk_text_buffer_get_mark    (GtkTextBuffer     *buffer,
 180                                             const gchar       *name);
 181
 182 void gtk_text_buffer_move_mark_by_name   (GtkTextBuffer     *buffer,
 183                                           const gchar       *name,
 184                                           const GtkTextIter *where);
 185 void gtk_text_buffer_delete_mark_by_name (GtkTextBuffer     *buffer,
 186                                           const gchar       *name);
 187
 188 GtkTextMark* gtk_text_buffer_get_insert          (GtkTextBuffer *buffer);
 189 GtkTextMark* gtk_text_buffer_get_selection_bound (GtkTextBuffer *buffer);
 190
 191
 192 /* efficiently move insert and selection_bound to same location */
 193 void gtk_text_buffer_place_cursor (GtkTextBuffer     *buffer,
 194                                    const GtkTextIter *where);
 195
 196
 197
 198 /* Tag manipulation */
 199 void gtk_text_buffer_apply_tag             (GtkTextBuffer     *buffer,
 200                                             GtkTextTag        *tag,
 201                                             const GtkTextIter *start_index,
 202                                             const GtkTextIter *end_index);
 203 void gtk_text_buffer_remove_tag            (GtkTextBuffer     *buffer,
 204                                             GtkTextTag        *tag,
 205                                             const GtkTextIter *start_index,
 206                                             const GtkTextIter *end_index);
 207 void gtk_text_buffer_apply_tag_by_name     (GtkTextBuffer     *buffer,
 208                                             const gchar       *name,
 209                                             const GtkTextIter *start_index,
 210                                             const GtkTextIter *end_index);
 211 void gtk_text_buffer_remove_tag_by_name    (GtkTextBuffer     *buffer,
 212                                             const gchar       *name,
 213                                             const GtkTextIter *start_index,
 214                                             const GtkTextIter *end_index);
 215
 216
 217 /* You can either ignore the return value, or use it to
 218  * set the attributes of the tag. tag_name can be NULL
 219  */
 220 GtkTextTag    *gtk_text_buffer_create_tag (GtkTextBuffer *buffer,
 221                                            const gchar   *tag_name);
 222
 223 /* Obtain iterators pointed at various places, then you can move the
 224    iterator around using the GtkTextIter operators */
 225 void gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer,
 226                                               GtkTextIter   *iter,
 227                                               gint           line_number,
 228                                               gint           char_offset);
 229 void gtk_text_buffer_get_iter_at_offset      (GtkTextBuffer *buffer,
 230                                               GtkTextIter   *iter,
 231                                               gint           char_offset);
 232 void gtk_text_buffer_get_iter_at_line        (GtkTextBuffer *buffer,
 233                                               GtkTextIter   *iter,
 234                                               gint           line_number);
 235 void gtk_text_buffer_get_last_iter           (GtkTextBuffer *buffer,
 236                                               GtkTextIter   *iter);
 237 void gtk_text_buffer_get_bounds              (GtkTextBuffer *buffer,
 238                                               GtkTextIter   *start,
 239                                               GtkTextIter   *end);
 240 void gtk_text_buffer_get_iter_at_mark        (GtkTextBuffer *buffer,
 241                                               GtkTextIter   *iter,
 242                                               GtkTextMark   *mark);
 243
 244
 245
 246 /* There's no get_first_iter because you just get the iter for
 247    line or char 0 */
 248
 249 GSList         *gtk_text_buffer_get_tags (GtkTextBuffer     *buffer,
 250                                           const GtkTextIter *iter);
 251
 252
 253 /* Used to keep track of whether the buffer needs saving; anytime the
 254    buffer contents change, the modified flag is turned on. Whenever
 255    you save, turn it off. Tags and marks do not affect the modified
 256    flag, but if you would like them to you can connect a handler to
 257    the tag/mark signals and call set_modified in your handler */
 258
 259 gboolean        gtk_text_buffer_modified                (GtkTextBuffer *buffer);
 260 void            gtk_text_buffer_set_modified            (GtkTextBuffer *buffer,
 261                                                          gboolean       setting);
 262
 263 void            gtk_text_buffer_paste_primary           (GtkTextBuffer *buffer,
 264                                                          GtkTextIter   *override_location,
 265                                                          gboolean       default_editable);
 266 void            gtk_text_buffer_cut_clipboard           (GtkTextBuffer *buffer,
 267                                                          gboolean       default_editable);
 268 void            gtk_text_buffer_copy_clipboard          (GtkTextBuffer *buffer);
 269 void            gtk_text_buffer_paste_clipboard         (GtkTextBuffer *buffer,
 270                                                          gboolean       default_editable);
 271
 272 gboolean        gtk_text_buffer_get_selection_bounds    (GtkTextBuffer *buffer,
 273                                                          GtkTextIter   *start,
 274                                                          GtkTextIter   *end);
 275 gboolean        gtk_text_buffer_delete_selection        (GtkTextBuffer *buffer,
 276                                                          gboolean       interactive,
 277                                                          gboolean       default_editable);
 278
 279 /* INTERNAL private stuff */
 280 void            _gtk_text_buffer_spew                  (GtkTextBuffer      *buffer);
 281
 282 GtkTextBTree*   _gtk_text_buffer_get_btree             (GtkTextBuffer      *buffer);
 283
 284 #ifdef __cplusplus
 285 }
 286 #endif /* __cplusplus */
 287
 288 #endif