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   /* Text currently pasted to the clipboard */
  36   gchar *clipboard_text;
  37
  38   /* Whether the buffer has been modified since last save */
  39   gboolean modified;
  40
  41   /* We use this for selections */
  42   GtkWidget *selection_widget;
  43   gboolean have_selection;
  44   gboolean selection_handlers_installed;
  45   gboolean paste_interactive;
  46   gboolean paste_default_editable;
  47 };
  48
  49 struct _GtkTextBufferClass {
  50   GtkObjectClass parent_class;
  51
  52   void (* insert_text)     (GtkTextBuffer *buffer,
  53                             GtkTextIter *pos,
  54                             const gchar *text,
  55                             gint length);
  56
  57
  58   void (* delete_text)     (GtkTextBuffer *buffer,
  59                             GtkTextIter *start,
  60                             GtkTextIter *end);
  61
  62   /* Only for text changed, marks/tags don't cause this
  63      to be emitted */
  64   void (* changed)         (GtkTextBuffer *buffer);
  65
  66
  67   /* New value for the modified flag */
  68   void (* modified_changed)   (GtkTextBuffer *buffer);
  69
  70   /* Mark moved or created */
  71   void (* mark_set)           (GtkTextBuffer *buffer,
  72                                const GtkTextIter *location,
  73                                GtkTextMark *mark);
  74
  75   void (* mark_deleted)       (GtkTextBuffer *buffer,
  76                                GtkTextMark *mark);
  77
  78   void (* apply_tag)          (GtkTextBuffer *buffer,
  79                                GtkTextTag *tag,
  80                                const GtkTextIter *start_char,
  81                                const GtkTextIter *end_char);
  82
  83   void (* remove_tag)         (GtkTextBuffer *buffer,
  84                                GtkTextTag *tag,
  85                                const GtkTextIter *start_char,
  86                                const GtkTextIter *end_char);
  87
  88 };
  89
  90 GtkType        gtk_text_buffer_get_type       (void) G_GNUC_CONST;
  91
  92
  93
  94 /* table is NULL to create a new one */
  95 GtkTextBuffer *gtk_text_buffer_new            (GtkTextTagTable *table);
  96 gint           gtk_text_buffer_get_line_count (GtkTextBuffer   *buffer);
  97 gint           gtk_text_buffer_get_char_count (GtkTextBuffer   *buffer);
  98
  99
 100 GtkTextTagTable* gtk_text_buffer_get_tag_table (GtkTextBuffer  *buffer);
 101
 102 /* Insert into the buffer */
 103 void gtk_text_buffer_insert            (GtkTextBuffer *buffer,
 104                                         GtkTextIter   *iter,
 105                                         const gchar   *text,
 106                                         gint           len);
 107 void gtk_text_buffer_insert_at_cursor  (GtkTextBuffer *buffer,
 108                                         const gchar   *text,
 109                                         gint           len);
 110
 111 gboolean gtk_text_buffer_insert_interactive           (GtkTextBuffer *buffer,
 112                                                        GtkTextIter   *iter,
 113                                                        const gchar   *text,
 114                                                        gint           len,
 115                                                        gboolean       default_editable);
 116 gboolean gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer,
 117                                                        const gchar   *text,
 118                                                        gint           len,
 119                                                        gboolean       default_editable);
 120
 121
 122 /* Delete from the buffer */
 123 void     gtk_text_buffer_delete             (GtkTextBuffer *buffer,
 124                                              GtkTextIter   *start_iter,
 125                                              GtkTextIter   *end_iter);
 126 gboolean gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer,
 127                                              GtkTextIter   *start_iter,
 128                                              GtkTextIter   *end_iter,
 129                                              gboolean       default_editable);
 130
 131
 132
 133 /* Obtain strings from the buffer */
 134 gchar          *gtk_text_buffer_get_text            (GtkTextBuffer     *buffer,
 135                                                      const GtkTextIter *start_iter,
 136                                                      const GtkTextIter *end_iter,
 137                                                      gboolean           include_hidden_chars);
 138
 139 gchar          *gtk_text_buffer_get_slice           (GtkTextBuffer     *buffer,
 140                                                      const GtkTextIter *start_iter,
 141                                                      const GtkTextIter *end_iter,
 142                                                      gboolean           include_hidden_chars);
 143
 144 /* Insert a pixmap */
 145 void gtk_text_buffer_insert_pixmap         (GtkTextBuffer *buffer,
 146                                             GtkTextIter   *iter,
 147                                             GdkPixmap     *pixmap,
 148                                             GdkBitmap     *mask);
 149
 150 /* Mark manipulation */
 151 GtkTextMark   *gtk_text_buffer_create_mark (GtkTextBuffer     *buffer,
 152                                             const gchar       *mark_name,
 153                                             const GtkTextIter *where,
 154                                             gboolean           left_gravity);
 155 void           gtk_text_buffer_move_mark   (GtkTextBuffer     *buffer,
 156                                             GtkTextMark       *mark,
 157                                             const GtkTextIter *where);
 158 void           gtk_text_buffer_delete_mark (GtkTextBuffer     *buffer,
 159                                             GtkTextMark       *mark);
 160 GtkTextMark   *gtk_text_buffer_get_mark    (GtkTextBuffer     *buffer,
 161                                             const gchar       *name);
 162
 163
 164 /* efficiently move insert and selection_bound to same location */
 165 void gtk_text_buffer_place_cursor (GtkTextBuffer     *buffer,
 166                                    const GtkTextIter *where);
 167
 168
 169
 170 /* Tag manipulation */
 171 void gtk_text_buffer_apply_tag             (GtkTextBuffer     *buffer,
 172                                             GtkTextTag        *tag,
 173                                             const GtkTextIter *start_index,
 174                                             const GtkTextIter *end_index);
 175 void gtk_text_buffer_remove_tag            (GtkTextBuffer     *buffer,
 176                                             GtkTextTag        *tag,
 177                                             const GtkTextIter *start_index,
 178                                             const GtkTextIter *end_index);
 179 void gtk_text_buffer_apply_tag_by_name     (GtkTextBuffer     *buffer,
 180                                             const gchar       *name,
 181                                             const GtkTextIter *start_index,
 182                                             const GtkTextIter *end_index);
 183 void gtk_text_buffer_remove_tag_by_name    (GtkTextBuffer     *buffer,
 184                                             const gchar       *name,
 185                                             const GtkTextIter *start_index,
 186                                             const GtkTextIter *end_index);
 187
 188
 189 /* You can either ignore the return value, or use it to
 190  * set the attributes of the tag. tag_name can be NULL
 191  */
 192 GtkTextTag    *gtk_text_buffer_create_tag (GtkTextBuffer *buffer,
 193                                            const gchar   *tag_name);
 194
 195 /* Obtain iterators pointed at various places, then you can move the
 196    iterator around using the GtkTextIter operators */
 197 void gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer,
 198                                               GtkTextIter   *iter,
 199                                               gint           line_number,
 200                                               gint           char_offset);
 201 void gtk_text_buffer_get_iter_at_offset      (GtkTextBuffer *buffer,
 202                                               GtkTextIter   *iter,
 203                                               gint           char_offset);
 204 void gtk_text_buffer_get_iter_at_line        (GtkTextBuffer *buffer,
 205                                               GtkTextIter   *iter,
 206                                               gint           line_number);
 207 void gtk_text_buffer_get_last_iter           (GtkTextBuffer *buffer,
 208                                               GtkTextIter   *iter);
 209 void gtk_text_buffer_get_bounds              (GtkTextBuffer *buffer,
 210                                               GtkTextIter   *start,
 211                                               GtkTextIter   *end);
 212 void gtk_text_buffer_get_iter_at_mark        (GtkTextBuffer *buffer,
 213                                               GtkTextIter   *iter,
 214                                               GtkTextMark   *mark);
 215
 216
 217
 218 /* There's no get_first_iter because you just get the iter for
 219    line or char 0 */
 220
 221 GSList         *gtk_text_buffer_get_tags (GtkTextBuffer     *buffer,
 222                                           const GtkTextIter *iter);
 223
 224
 225 /* Used to keep track of whether the buffer needs saving; anytime the
 226    buffer contents change, the modified flag is turned on. Whenever
 227    you save, turn it off. Tags and marks do not affect the modified
 228    flag, but if you would like them to you can connect a handler to
 229    the tag/mark signals and call set_modified in your handler */
 230
 231 gboolean        gtk_text_buffer_modified                (GtkTextBuffer *buffer);
 232 void            gtk_text_buffer_set_modified            (GtkTextBuffer *buffer,
 233                                                          gboolean       setting);
 234 void            gtk_text_buffer_set_clipboard_contents  (GtkTextBuffer *buffer,
 235                                                          const gchar   *text);
 236 const gchar    *gtk_text_buffer_get_clipboard_contents  (GtkTextBuffer *buffer);
 237
 238
 239 void            gtk_text_buffer_paste_primary_selection (GtkTextBuffer *buffer,
 240                                                          GtkTextIter   *override_location,
 241                                                          guint32        time,
 242                                                          gboolean       interactive,
 243                                                          gboolean       default_editable);
 244 gboolean        gtk_text_buffer_delete_selection        (GtkTextBuffer *buffer,
 245                                                          gboolean       interactive,
 246                                                          gboolean       default_editable);
 247 void            gtk_text_buffer_cut                     (GtkTextBuffer *buffer,
 248                                                          guint32        time,
 249                                                          gboolean       interactive,
 250                                                          gboolean       default_editable);
 251 void            gtk_text_buffer_copy                    (GtkTextBuffer *buffer,
 252                                                          guint32        time);
 253 void            gtk_text_buffer_paste_clipboard         (GtkTextBuffer *buffer,
 254                                                          guint32        time,
 255                                                          gboolean       interactive,
 256                                                          gboolean       default_editable);
 257 gboolean        gtk_text_buffer_get_selection_bounds    (GtkTextBuffer *buffer,
 258                                                          GtkTextIter   *start,
 259                                                          GtkTextIter   *end);
 260
 261
 262 /* This function is not implemented. */
 263 gboolean gtk_text_buffer_find_string(GtkTextBuffer *buffer,
 264                                      GtkTextIter *iter,
 265                                      const gchar *str,
 266                                      const GtkTextIter *start,
 267                                      const GtkTextIter *end);
 268
 269 #if 0
 270 /* Waiting on glib 1.4 regexp facility */
 271 gboolean gtk_text_buffer_find_regexp(GtkTextBuffer *buffer,
 272                                      GRegexp *regexp,
 273                                      const GtkTextIter *start,
 274                                      const GtkTextIter *end);
 275 #endif
 276
 277 /* INTERNAL private stuff */
 278 void            gtk_text_buffer_spew                   (GtkTextBuffer      *buffer);
 279
 280 GtkTextBTree*   _gtk_text_buffer_get_btree             (GtkTextBuffer      *buffer);
 281
 282 #ifdef __cplusplus
 283 }
 284 #endif /* __cplusplus */
 285
 286 #endif