gtktextbuffer.c 59.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/* GTK - The GIMP Toolkit
 * gtktextbuffer.c Copyright (C) 2000 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
25
26
 */

27

28
29
#include <string.h>

30
#include "gtkclipboard.h"
31
32
33
34
35
#include "gtkinvisible.h"
#include "gtksignal.h"
#include "gtktextbuffer.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
36
#include <string.h>
37

38
39
40
41
42
43
44
45
46
47
typedef struct _ClipboardRequest ClipboardRequest;

struct _ClipboardRequest
{
  GtkTextBuffer *buffer;
  gboolean interactive;
  gboolean default_editable;
  gboolean is_clipboard;
};

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
enum {
  INSERT_TEXT,
  DELETE_TEXT,
  CHANGED,
  MODIFIED_CHANGED,
  MARK_SET,
  MARK_DELETED,
  APPLY_TAG,
  REMOVE_TAG,
  LAST_SIGNAL
};

enum {
  ARG_0,
  LAST_ARG
};

enum {
  TARGET_STRING,
  TARGET_TEXT,
  TARGET_COMPOUND_TEXT,
  TARGET_UTF8_STRING
};

static void gtk_text_buffer_init       (GtkTextBuffer      *tkxt_buffer);
static void gtk_text_buffer_class_init (GtkTextBufferClass *klass);
static void gtk_text_buffer_destroy    (GtkObject          *object);
static void gtk_text_buffer_finalize   (GObject            *object);


static void gtk_text_buffer_update_primary_selection   (GtkTextBuffer     *buffer);
static void gtk_text_buffer_real_insert_text           (GtkTextBuffer     *buffer,
                                                        GtkTextIter       *iter,
                                                        const gchar       *text,
82
83
                                                        gint               len,
                                                        gboolean           interactive);
84
85
static void gtk_text_buffer_real_delete_text           (GtkTextBuffer     *buffer,
                                                        GtkTextIter       *start,
86
87
                                                        GtkTextIter       *end,
                                                        gboolean           interactive);
88
89
90
91
92
93
94
95
96
static void gtk_text_buffer_real_apply_tag             (GtkTextBuffer     *buffer,
                                                        GtkTextTag        *tag,
                                                        const GtkTextIter *start_char,
                                                        const GtkTextIter *end_char);
static void gtk_text_buffer_real_remove_tag            (GtkTextBuffer     *buffer,
                                                        GtkTextTag        *tag,
                                                        const GtkTextIter *start_char,
                                                        const GtkTextIter *end_char);

97
static GtkTextBTree* get_btree (GtkTextBuffer *buffer);
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

void gtk_marshal_NONE__INT_POINTER_INT (GtkObject  *object,
                                        GtkSignalFunc func,
                                        gpointer func_data,
                                        GtkArg  *args);

static GtkObjectClass *parent_class = NULL;
static guint signals[LAST_SIGNAL] = { 0 };

GtkType
gtk_text_buffer_get_type (void)
{
  static GtkType our_type = 0;

  if (our_type == 0)
    {
      static const GtkTypeInfo our_info =
      {
        "GtkTextBuffer",
        sizeof (GtkTextBuffer),
        sizeof (GtkTextBufferClass),
        (GtkClassInitFunc) gtk_text_buffer_class_init,
        (GtkObjectInitFunc) gtk_text_buffer_init,
        /* reserved_1 */ NULL,
        /* reserved_2 */ NULL,
        (GtkClassInitFunc) NULL
      };

      our_type = gtk_type_unique (GTK_TYPE_OBJECT, &our_info);
    }

  return our_type;
}

static void
gtk_text_buffer_class_init (GtkTextBufferClass *klass)
{
  GtkObjectClass *object_class = (GtkObjectClass*) klass;
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  parent_class = gtk_type_class (GTK_TYPE_OBJECT);
  
  signals[INSERT_TEXT] =
    gtk_signal_new ("insert_text",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, insert_text),
145
                    gtk_marshal_NONE__POINTER_POINTER_INT_INT,
146
                    GTK_TYPE_NONE,
147
                    4,
148
                    GTK_TYPE_POINTER,
149
                    GTK_TYPE_POINTER,
150
151
                    GTK_TYPE_INT,
                    GTK_TYPE_BOOL);
152
153
154
155
156
157

  signals[DELETE_TEXT] =
    gtk_signal_new ("delete_text",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, delete_text),
158
                    gtk_marshal_NONE__POINTER_POINTER_INT,
159
                    GTK_TYPE_NONE,
160
                    3,
161
                    GTK_TYPE_POINTER,
162
163
                    GTK_TYPE_POINTER,
                    GTK_TYPE_BOOL);
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
201
202
203
204
205
206
207
208

  signals[CHANGED] =
    gtk_signal_new ("changed",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, changed),
                    gtk_marshal_NONE__NONE,
                    GTK_TYPE_NONE,
                    0);

  signals[MODIFIED_CHANGED] =
    gtk_signal_new ("modified_changed",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, modified_changed),
                    gtk_marshal_NONE__NONE,
                    GTK_TYPE_NONE,
                    0);
  
  signals[MARK_SET] =
    gtk_signal_new ("mark_set",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, mark_set),
                    gtk_marshal_NONE__POINTER_POINTER,
                    GTK_TYPE_NONE,
                    2,
                    GTK_TYPE_POINTER,
                    GTK_TYPE_POINTER);

  signals[MARK_DELETED] =
    gtk_signal_new ("mark_deleted",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, mark_deleted),
                    gtk_marshal_NONE__POINTER,
                    GTK_TYPE_NONE,
                    1,
                    GTK_TYPE_POINTER);

  signals[APPLY_TAG] =
    gtk_signal_new ("apply_tag",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, apply_tag),
209
                    gtk_marshal_NONE__POINTER_POINTER_POINTER,
210
211
212
                    GTK_TYPE_NONE,
                    3,
                    GTK_TYPE_POINTER,
213
214
                    GTK_TYPE_POINTER,
                    GTK_TYPE_POINTER);
215
216
217
218
219
220
    
  signals[REMOVE_TAG] =
    gtk_signal_new ("remove_tag",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, remove_tag),
221
                    gtk_marshal_NONE__POINTER_POINTER_POINTER,
222
223
224
                    GTK_TYPE_NONE,
                    3,
                    GTK_TYPE_POINTER,
225
226
                    GTK_TYPE_POINTER,
                    GTK_TYPE_POINTER);
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
  
  gtk_object_class_add_signals (object_class, signals, LAST_SIGNAL);

  object_class->destroy = gtk_text_buffer_destroy;

  gobject_class->finalize = gtk_text_buffer_finalize;

  klass->insert_text = gtk_text_buffer_real_insert_text;
  klass->delete_text = gtk_text_buffer_real_delete_text;
  klass->apply_tag = gtk_text_buffer_real_apply_tag;
  klass->remove_tag = gtk_text_buffer_real_remove_tag;
}


typedef gint (*GtkSignal_NONE__INT_POINTER_INT) (GtkObject  *object,
                                                 gint pos,
                                                 const gchar *text,
                                                 gint len,
                                                 gpointer user_data);

void 
gtk_marshal_NONE__INT_POINTER_INT (GtkObject  *object,
                                   GtkSignalFunc func,
                                   gpointer func_data,
                                   GtkArg  *args)
{
  GtkSignal_NONE__INT_POINTER_INT rfunc;

  rfunc = (GtkSignal_NONE__INT_POINTER_INT) func;

  (*rfunc) (object,
            GTK_VALUE_INT (args[0]),
            GTK_VALUE_POINTER (args[1]),
            GTK_VALUE_INT (args[2]),
            func_data);
}

void
gtk_text_buffer_init (GtkTextBuffer *buffer)
{
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
269
270
271
272
273
274
275
276
/**
 * gtk_text_buffer_new:
 * @table: a tag table, or NULL to create a new one
 * 
 * Creates a new text buffer.
 * 
 * Return value: a new text buffer
 **/
277
278
279
280
281
282
283
284
GtkTextBuffer*
gtk_text_buffer_new (GtkTextTagTable *table)
{
  GtkTextBuffer *text_buffer;
  
  text_buffer = GTK_TEXT_BUFFER (gtk_type_new (gtk_text_buffer_get_type ()));

  if (table)
285
286
287
288
289
290
    {
      text_buffer->tag_table = table;
      
      gtk_object_ref (GTK_OBJECT(text_buffer->tag_table));
      gtk_object_sink (GTK_OBJECT(text_buffer->tag_table));
    } 
291
292
293
294
295
296
297
298
299
300
301
  
  return text_buffer;
}

static void
gtk_text_buffer_destroy (GtkObject *object)
{
  GtkTextBuffer *buffer;

  buffer = GTK_TEXT_BUFFER (object);

302
303
304
305
306
307
308
309
310
311
312
  if (buffer->tag_table)
    {
      gtk_object_unref(GTK_OBJECT(buffer->tag_table));
      buffer->tag_table = NULL;
    }

  if (buffer->btree)
    {
      gtk_text_btree_unref(buffer->btree);
      buffer->btree = NULL;
    }
313
314
315
316
317
318
319
320
321
322
323
324
325
326
  
  (* parent_class->destroy) (object);
}

static void
gtk_text_buffer_finalize (GObject *object)
{
  GtkTextBuffer *tkxt_buffer;

  tkxt_buffer = GTK_TEXT_BUFFER (object);

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
static GtkTextTagTable*
get_table (GtkTextBuffer *buffer)
{
  if (buffer->tag_table == NULL)
    {
      buffer->tag_table = gtk_text_tag_table_new ();

      gtk_object_ref (GTK_OBJECT(buffer->tag_table));
      gtk_object_sink (GTK_OBJECT(buffer->tag_table));
    }

  return buffer->tag_table;
}

static GtkTextBTree*
get_btree (GtkTextBuffer *buffer)
{
  if (buffer->btree == NULL)
    buffer->btree = gtk_text_btree_new(gtk_text_buffer_get_tag_table (buffer),
                                       buffer);
  
  return buffer->btree;
}

GtkTextBTree*
_gtk_text_buffer_get_btree (GtkTextBuffer *buffer)
{
  return get_btree (buffer);
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
357
358
359
360
361
362
363
364
/**
 * gtk_text_buffer_get_tag_table:
 * @buffer: a #GtkTextBuffer
 * 
 * Get the #GtkTextTagTable associated with this buffer.
 * 
 * Return value: the buffer's tag table
 **/
365
366
367
368
369
370
371
372
GtkTextTagTable*
gtk_text_buffer_get_tag_table (GtkTextBuffer  *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);

  return get_table (buffer);
}

373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
/**
 * gtk_text_buffer_set_text:
 * @buffer: a #GtkTextBuffer
 * @text: UTF-8 text to insert
 * @len: length of @text in bytes
 * 
 * Deletes current contents of @buffer, and inserts @text instead.  If
 * @text doesn't end with a newline, a newline is added;
 * #GtkTextBuffer contents must always end with a newline. If @text
 * ends with a newline, the new buffer contents will be exactly
 * @text. If @len is -1, @text must be nul-terminated.
 **/
void
gtk_text_buffer_set_text (GtkTextBuffer *buffer,
                          const gchar   *text,
                          gint           len)
{
  GtkTextIter start, end;
  
  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail (text != NULL);

  if (len < 0)
    len = strlen (text);

  /* Chop newline, since the buffer will already have one
   * in it.
   */
  if (len > 0 && text[len-1] == '\n')
    len -= 1;

  gtk_text_buffer_get_bounds (buffer, &start, &end);
  
  gtk_text_buffer_delete (buffer, &start, &end);

  if (len > 0)
    {
      gtk_text_buffer_get_iter_at_offset (buffer, &start, 0);
      gtk_text_buffer_insert (buffer, &start, text, len);
    }
}

415
416
417
418
419
420
421
422
/*
 * Insertion
 */

static void
gtk_text_buffer_real_insert_text(GtkTextBuffer *buffer,
                                 GtkTextIter *iter,
                                 const gchar *text,
423
424
                                 gint len,
                                 gboolean interactive)
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(iter != NULL);

  gtk_text_btree_insert(iter, text, len);
  
  gtk_signal_emit(GTK_OBJECT(buffer), signals[CHANGED]);

  gtk_text_buffer_set_modified(buffer, TRUE);
}

static void
gtk_text_buffer_emit_insert(GtkTextBuffer *buffer,
                            GtkTextIter *iter,
                            const gchar *text,
440
441
                            gint len,
                            gboolean interactive)
442
443
444
445
446
447
448
449
450
451
452
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(iter != NULL);
  g_return_if_fail(text != NULL);

  if (len < 0)
    len = strlen(text);
  
  if (len > 0)
    {
      gtk_signal_emit(GTK_OBJECT(buffer), signals[INSERT_TEXT],
453
                      iter, text, len, interactive);
454
455
456
    }
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
/**
 * gtk_text_buffer_insert:
 * @buffer: a #GtkTextBuffer
 * @iter: a position in the buffer
 * @text: UTF-8 format text to insert
 * @len: length of text in bytes, or -1
 * 
 * Inserts @len bytes of @text at position @iter.  If @len is -1,
 * @text must be nul-terminated and will be inserted in its
 * entirety. Emits the "insert_text" signal; insertion actually occurs
 * in the default handler for the signal. @iter is invalidated when
 * insertion occurs (because the buffer contents change), but the
 * default signal handler revalidates it to point to the end of the
 * inserted text.
 * 
 **/
473
474
475
476
477
478
479
480
481
482
void
gtk_text_buffer_insert (GtkTextBuffer *buffer,
                        GtkTextIter *iter,
                        const gchar *text,
                        gint len)
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(iter != NULL);
  g_return_if_fail(text != NULL);
  
483
  gtk_text_buffer_emit_insert(buffer, iter, text, len, FALSE);
484
485
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
486
487
488
489
490
491
492
493
494
/**
 * gtk_text_buffer_insert_at_cursor:
 * @buffer: a #GtkTextBuffer
 * @text: some text in UTF-8 format
 * @len: length of text, in bytes
 * 
 * Simply calls gtk_text_buffer_insert(), using the current
 * cursor position as the insertion point.
 **/
495
496
497
498
499
500
501
502
503
504
void
gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer,
                                  const gchar *text,
                                  gint len)
{
  GtkTextIter iter;

  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(text != NULL);

505
506
507
  gtk_text_buffer_get_iter_at_mark(buffer, &iter,
                                   gtk_text_buffer_get_mark (buffer,
                                                             "insert"));
508
509
510
511

  gtk_text_buffer_insert(buffer, &iter, text, len);
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
512
513
514
515
516
517
/**
 * gtk_text_buffer_insert_interactive:
 * @buffer: a #GtkTextBuffer
 * @iter: a position in @buffer
 * @text: some UTF-8 text
 * @len: length of text in bytes, or -1
518
 * @default_editable: default editability of buffer
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
519
520
521
522
523
524
525
526
 * 
 * Like gtk_text_buffer_insert(), but the insertion will not occur if
 * @iter is at a non-editable location in the buffer.  Usually you
 * want to prevent insertions at ineditable locations if the insertion
 * results from a user action (is interactive).
 * 
 * Return value: whether text was actually inserted
 **/
527
528
529
530
531
gboolean
gtk_text_buffer_insert_interactive(GtkTextBuffer *buffer,
                                   GtkTextIter   *iter,
                                   const gchar   *text,
                                   gint           len,
532
                                   gboolean       default_editable)
533
{
534
535
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), FALSE);
  g_return_val_if_fail(text != NULL, FALSE);
536
  
537
  if (gtk_text_iter_editable (iter, default_editable))
538
    {
539
      gtk_text_buffer_emit_insert (buffer, iter, text, len, TRUE);
540
541
542
543
      return TRUE;
    }
  else
    return FALSE;
544
545
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
546
547
548
549
550
551
552
553
554
555
556
557
/**
 * gtk_text_buffer_insert_interactive_at_cursor:
 * @buffer: a #GtkTextBuffer
 * @text: text in UTF-8 format
 * @len: length of text in bytes, or -1
 * @default_editable: default editability of buffer
 * 
 * Calls gtk_text_buffer_insert_interactive() at the cursor
 * position.
 * 
 * Return value: whether text was actually inserted
 **/
558
559
560
561
562
gboolean
gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer,
                                              const gchar   *text,
                                              gint           len,
                                              gboolean       default_editable)
563
{
564
  GtkTextIter iter;
565

566
567
568
569
570
571
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), FALSE);
  g_return_val_if_fail(text != NULL, FALSE);
  
  gtk_text_buffer_get_iter_at_mark(buffer, &iter,
                                   gtk_text_buffer_get_mark (buffer,
                                                             "insert"));
572

573
574
  return gtk_text_buffer_insert_interactive (buffer, &iter, text, len,
                                             default_editable);
575
576
}

577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748

/**
 * gtk_text_buffer_insert_range:
 * @buffer: a #GtkTextBuffer
 * @iter: a position in @buffer
 * @start: a position in a #GtkTextBuffer
 * @end: another position in the same buffer as @start
 *
 * Copies text, tags, and pixbufs between @start and @end (the order
 * of @start and @end doesn't matter) and inserts the copy at @iter.
 * Used instead of simply getting/inserting text because it preserves
 * images and tags. If @start and @end are in a different buffer
 * from @buffer, the two buffers must share the same tag table.
 *
 * Implemented via multiple emissions of the insert_text and
 * apply_tag signals, so expect those.
 **/
void
gtk_text_buffer_insert_range (GtkTextBuffer     *buffer,
                              GtkTextIter       *iter,
                              const GtkTextIter *start,
                              const GtkTextIter *end)
{
  g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
  g_return_if_fail (iter != NULL);
  g_return_if_fail (start != NULL);
  g_return_if_fail (end != NULL);
  g_return_if_fail (gtk_text_iter_get_buffer (start) !=
                    gtk_text_iter_get_buffer (end));
  g_return_if_fail (gtk_text_iter_get_buffer (start)->tag_table !=
                    buffer->tag_table);

  /* FIXME */
}

gboolean
gtk_text_buffer_insert_range_interactive (GtkTextBuffer     *buffer,
                                          GtkTextIter       *iter,
                                          const GtkTextIter *start,
                                          const GtkTextIter *end,
                                          gboolean           default_editable)
{
  g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
  g_return_val_if_fail (iter != NULL, FALSE);
  g_return_val_if_fail (start != NULL, FALSE);
  g_return_val_if_fail (end != NULL, FALSE);
  g_return_val_if_fail (gtk_text_iter_get_buffer (start) !=
                        gtk_text_iter_get_buffer (end), FALSE);
  g_return_val_if_fail (gtk_text_iter_get_buffer (start)->tag_table !=
                        buffer->tag_table, FALSE);


  /* FIXME */
  
  return FALSE;
}

/**
 * gtk_text_buffer_insert_with_tags:
 * @buffer: a #GtkTextBuffer
 * @iter: an iterator in @buffer
 * @text: UTF-8 text
 * @len: length of @text, or -1 
 * @first_tag: first tag to apply to @text
 * @Varargs: NULL-terminated list of tags to apply 
 * 
 * Inserts @text into @buffer at @iter, applying the list of tags to
 * the newly-inserted text. The last tag specified must be NULL to
 * terminate the list. Equivalent to calling gtk_text_buffer_insert(),
 * then gtk_text_buffer_apply_tag() on the inserted text;
 * gtk_text_buffer_insert_with_tags() is just a convenience function.
 **/
void
gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer,
                                  GtkTextIter   *iter,
                                  const gchar   *text,
                                  gint           len,
                                  GtkTextTag    *first_tag,
                                  ...)
{
  gint start_offset;
  GtkTextIter start;
  va_list args;
  GtkTextTag *tag;
  
  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail (iter != NULL);
  g_return_if_fail (text != NULL);

  start_offset = gtk_text_iter_get_offset (iter);
  
  gtk_text_buffer_insert (buffer, iter, text, len);

  if (first_tag == NULL)
    return;
  
  gtk_text_buffer_get_iter_at_offset (buffer, &start, start_offset);
  
  va_start (args, first_tag);
  tag = first_tag;
  while (tag)
    {
      gtk_text_buffer_apply_tag (buffer, tag, &start, iter);

      tag = va_arg (args, GtkTextTag*);
    }

  va_end (args);
}

/**
 * gtk_text_buffer_insert_with_tags_by_name:
 * @buffer: a #GtkTextBuffer
 * @iter: position in @buffer
 * @text: UTF-8 text
 * @len: length of @text, or -1
 * @first_tag_name: name of a tag to apply to @text
 * @Varargs: more tag names
 * 
 * Same as gtk_text_buffer_insert_with_tags(), but allows you
 * to pass in tag names instead of tag objects.
 **/
void
gtk_text_buffer_insert_with_tags_by_name  (GtkTextBuffer *buffer,
                                           GtkTextIter   *iter,
                                           const gchar   *text,
                                           gint           len,
                                           const gchar   *first_tag_name,
                                           ...)
{
  gint start_offset;
  GtkTextIter start;
  va_list args;
  const gchar *tag_name;
  
  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail (iter != NULL);
  g_return_if_fail (text != NULL);

  start_offset = gtk_text_iter_get_offset (iter);
  
  gtk_text_buffer_insert (buffer, iter, text, len);

  if (first_tag_name == NULL)
    return;
  
  gtk_text_buffer_get_iter_at_offset (buffer, &start, start_offset);
  
  va_start (args, first_tag_name);
  tag_name = first_tag_name;
  while (tag_name)
    {
      GtkTextTag *tag;

      tag = gtk_text_tag_table_lookup (buffer->tag_table,
                                       tag_name);

      if (tag == NULL)
        {
          g_warning ("%s: no tag with name '%s'!", G_STRLOC, tag_name);
          return;
        }
      
      gtk_text_buffer_apply_tag (buffer, tag, &start, iter);

      tag_name = va_arg (args, const gchar*);
    }

  va_end (args);
}


749
750
751
752
753
754
755
/*
 * Deletion
 */

static void
gtk_text_buffer_real_delete_text(GtkTextBuffer *buffer,
                                 GtkTextIter *start,
756
757
                                 GtkTextIter *end,
                                 gboolean interactive)
758
759
760
761
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);
762
  
763
764
765
766
767
768
769
770
771
772
773
  gtk_text_btree_delete(start, end);

  /* may have deleted the selection... */
  gtk_text_buffer_update_primary_selection(buffer);
  
  gtk_signal_emit(GTK_OBJECT(buffer), signals[CHANGED]);
  
  gtk_text_buffer_set_modified(buffer, TRUE);
}

static void
774
775
776
777
gtk_text_buffer_emit_delete (GtkTextBuffer *buffer,
                             GtkTextIter *start,
                             GtkTextIter *end,
                             gboolean interactive)
778
779
780
781
782
783
784
785
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);

  if (gtk_text_iter_equal(start, end))
    return;

786
  gtk_text_iter_reorder (start, end);
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
787

788
789
790
791
792
793
794
  /* Somewhat annoyingly, if you try to delete the final newline
   * the BTree will put it back; which means you can't deduce the
   * final contents of the buffer purely by monitoring insert/delete
   * signals on the buffer. But if you delete the final newline, any
   * tags on the newline will go away, oddly. See comment in
   * gtktextbtree.c. This is all sort of annoying, but really hard
   * to fix.
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
795
   */
796
797
  gtk_signal_emit(GTK_OBJECT(buffer),
                  signals[DELETE_TEXT],
798
799
                  start, end,
                  interactive);
800
801
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
/**
 * gtk_text_buffer_delete:
 * @buffer: a #GtkTextBuffer
 * @start: a position in @buffer
 * @end: another position in @buffer
 *
 * Deletes text between @start and @end. The order of @start and @end
 * is not actually relevant; gtk_text_buffer_delete() will reorder
 * them. This function actually emits the "delete_text" signal, and
 * the default handler of that signal deletes the text. Because the
 * buffer is modified, all outstanding iterators become invalid after
 * calling this function; however, the @start and @end will be
 * re-initialized to point to the location where text was deleted.
 *
 * Note that the final newline in the buffer may not be deleted; a
 * #GtkTextBuffer always contains at least one newline.  You can
 * safely include the final newline in the range [@start,@end) but it
 * won't be affected by the deletion.
 * 
 **/
822
823
void
gtk_text_buffer_delete (GtkTextBuffer *buffer,
824
825
                        GtkTextIter   *start,
                        GtkTextIter   *end)
826
827
828
829
830
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);
  
831
  gtk_text_buffer_emit_delete(buffer, start, end, FALSE);
832
833
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
834
835
836
837
838
839
840
841
842
/**
 * gtk_text_buffer_delete_interactive:
 * @buffer: a #GtkTextBuffer
 * @start_iter: start of range to delete
 * @end_iter: end of range
 * @default_editable: whether the buffer is editable by default 
 * 
 * Deletes all <emphasis>editable</emphasis> text in the given range.
 * Calls gtk_text_buffer_delete() for each editable sub-range of
843
844
845
 * [@start,@end). @start and @end are revalidated to point to
 * the location of the last deleted range, or left untouched if
 * no text was deleted.
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
846
847
848
 * 
 * Return value: whether some text was actually deleted
 **/
849
850
851
852
853
gboolean
gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer,
                                    GtkTextIter   *start_iter,
                                    GtkTextIter   *end_iter,
                                    gboolean       default_editable)
854
{
855
856
857
858
859
860
861
  GtkTextMark *end_mark;
  GtkTextMark *start_mark;
  GtkTextIter iter;
  gboolean current_state;
  gboolean deleted_stuff = FALSE;

  /* Delete all editable text in the range start_iter, end_iter */
862
  
863
864
865
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), FALSE);
  g_return_val_if_fail (start_iter != NULL, FALSE);
  g_return_val_if_fail (end_iter != NULL, FALSE);
866

867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
  gtk_text_iter_reorder (start_iter, end_iter);
  
  start_mark = gtk_text_buffer_create_mark (buffer, NULL, 
                                            start_iter, TRUE);
  end_mark = gtk_text_buffer_create_mark (buffer, NULL, 
                                          end_iter, FALSE);
  iter = *start_iter;
  
  current_state = gtk_text_iter_editable (&iter, default_editable);
  
  while (TRUE)
    {
      gboolean new_state;
      gboolean done = FALSE;
      GtkTextIter end;
882

883
884
885
886
887
888
889
890
891
      gtk_text_iter_forward_to_tag_toggle (&iter, NULL);
      
      gtk_text_buffer_get_iter_at_mark (buffer, &end, end_mark);
      
      if (gtk_text_iter_compare (&iter, &end) >= 0)
        {
          done = TRUE;
          iter = end; /* clamp to the last boundary */
        }
892

893
      new_state = gtk_text_iter_editable (&iter, default_editable);
894

895
896
897
898
899
900
901
902
903
904
905
      if (current_state == new_state)
        {
          if (done)
            {
              if (current_state)
                {
                  /* We're ending an editable region. Delete said region. */
                  GtkTextIter start;
                  
                  gtk_text_buffer_get_iter_at_mark (buffer, &start, start_mark);
                  
906
                  gtk_text_buffer_emit_delete (buffer, &start, &iter, TRUE);
907
908
                  
                  deleted_stuff = TRUE;
909
910
911
912

                  /* revalidate user's iterators. */
                  *start_iter = start;
                  *end_iter = iter;
913
914
915
916
917
918
919
                }

              break;
            }
          else
            continue;
        }
920

921
922
923
924
925
926
927
      if (current_state && !new_state)
        {
          /* End of an editable region. Delete it. */
          GtkTextIter start;
          
          gtk_text_buffer_get_iter_at_mark (buffer, &start, start_mark);
          
928
          gtk_text_buffer_emit_delete (buffer, &start, &iter, TRUE);
929

930
931
          current_state = FALSE;
          deleted_stuff = TRUE;
932
933
934
935

          /* revalidate user's iterators. */
          *start_iter = start;
          *end_iter = iter;
936
937
938
939
940
941
        }
      else
        {
          /* We are at the start of an editable region. We won't be deleting
           * the previous region. Move start mark to start of this region.
           */
942

943
944
945
946
          g_assert (!current_state && new_state);          
          
          gtk_text_buffer_move_mark (buffer, start_mark,
                                     &iter);
947
948


949
950
951
952
953
954
955
956
957
958
959
960
          current_state = TRUE;
        }

      if (done)
        break;
    }

  
  gtk_text_buffer_delete_mark (buffer, start_mark);
  gtk_text_buffer_delete_mark (buffer, end_mark);
  
  return deleted_stuff;
961
962
963
964
965
966
}

/*
 * Extracting textual buffer contents
 */

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
/**
 * gtk_text_buffer_get_text:
 * @buffer: a #GtkTextBuffer
 * @start: start of a range
 * @end: end of a range
 * @include_hidden_chars: whether to include invisible text
 * 
 * Returns the text in the range [@start,@end). Excludes undisplayed
 * text (text marked with tags that set the invisibility attribute) if
 * @include_hidden_chars is FALSE. Does not include characters
 * representing embedded images, so byte and character indexes into
 * the returned string do <emphasis>not</emphasis> correspond to byte
 * and character indexes into the buffer. Contrast with
 * gtk_text_buffer_get_slice().
 * 
 * Return value: an allocated UTF-8 string
 **/
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
gchar*
gtk_text_buffer_get_text (GtkTextBuffer      *buffer,
                          const GtkTextIter *start,
                          const GtkTextIter *end,
                          gboolean             include_hidden_chars)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);
  g_return_val_if_fail(start != NULL, NULL);
  g_return_val_if_fail(end != NULL, NULL);

  if (include_hidden_chars)
    return gtk_text_iter_get_text(start, end);
  else
    return gtk_text_iter_get_visible_text(start, end);
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
/**
 * gtk_text_buffer_get_slice:
 * @buffer: a #GtkTextBuffer
 * @start: start of a range
 * @end: end of a range
 * @include_hidden_chars: whether to include invisible text 
 *
 * Returns the text in the range [@start,@end). Excludes undisplayed
 * text (text marked with tags that set the invisibility attribute) if
 * @include_hidden_chars is FALSE. The returned string includes a
 * 0xFFFD character whenever the buffer contains
 * embedded images, so byte and character indexes into
 * the returned string <emphasis>do</emphasis> correspond to byte
 * and character indexes into the buffer. Contrast with
 * gtk_text_buffer_get_text().
 * 
 * Return value: an allocated UTF-8 string
 **/
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
gchar*
gtk_text_buffer_get_slice (GtkTextBuffer      *buffer,
                           const GtkTextIter *start,
                           const GtkTextIter *end,
                           gboolean             include_hidden_chars)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);
  g_return_val_if_fail(start != NULL, NULL);
  g_return_val_if_fail(end != NULL, NULL);

  if (include_hidden_chars)
    return gtk_text_iter_get_slice(start, end);
  else
    return gtk_text_iter_get_visible_slice(start, end);
}

/*
 * Pixmaps
 */

void
Havoc Pennington's avatar
Havoc Pennington committed
1039
1040
1041
gtk_text_buffer_insert_pixbuf         (GtkTextBuffer      *buffer,
                                       GtkTextIter        *iter,
                                       GdkPixbuf          *pixbuf)
1042
{
Havoc Pennington's avatar
Havoc Pennington committed
1043
1044
1045
1046
1047
  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail (iter != NULL);
  g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
  
  gtk_text_btree_insert_pixbuf (iter, pixbuf);
1048

Havoc Pennington's avatar
Havoc Pennington committed
1049
  /* FIXME pixbuf-specific signal like insert_text */
1050
  
Havoc Pennington's avatar
Havoc Pennington committed
1051
  gtk_signal_emit (GTK_OBJECT(buffer), signals[CHANGED]);
1052
  
Havoc Pennington's avatar
Havoc Pennington committed
1053
  gtk_text_buffer_set_modified (buffer, TRUE);
1054
1055
1056
1057
1058
1059
1060
1061
1062
}

/*
 * Mark manipulation
 */

static void
gtk_text_buffer_mark_set (GtkTextBuffer     *buffer,
			  const GtkTextIter *location,
1063
                          GtkTextMark       *mark)
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
{
  /* IMO this should NOT work like insert_text and delete_text,
     where the real action happens in the default handler.

     The reason is that the default handler would be _required_,
     i.e. the whole widget would start breaking and segfaulting
     if the default handler didn't get run. So you can't really
     override the default handler or stop the emission; that is,
     this signal is purely for notification, and not to allow users
     to modify the default behavior. */
1074
1075
1076

  gtk_text_mark_ref (mark);
  
1077
1078
  gtk_signal_emit(GTK_OBJECT(buffer),
                  signals[MARK_SET],
1079
                  location,
1080
                  mark);
1081

1082
  gtk_text_mark_unref (mark);
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
}

/**
 * gtk_text_buffer_set_mark:
 * @buffer:       a #GtkTextBuffer
 * @mark_name:    name of the mark
 * @iter:         location for the mark.
 * @left_gravity: if the mark is created by this function, gravity for the new
 *                mark.
 * @should_exist: if %TRUE, warn if the mark does not exist, and return
 *                immediately.
 * 
 * Move the mark to the given position, if not @should_exist, create the mark.
 * 
1097
 * Return value: mark
1098
1099
 **/
static GtkTextMark*
1100
1101
1102
1103
1104
1105
gtk_text_buffer_set_mark (GtkTextBuffer *buffer,
                          GtkTextMark *existing_mark,
                          const gchar *mark_name,
                          const GtkTextIter *iter,
                          gboolean left_gravity,
                          gboolean should_exist)
1106
1107
{
  GtkTextIter location;
1108
  GtkTextMark *mark;
1109
  
1110
  mark = gtk_text_btree_set_mark(get_btree (buffer),
1111
                                 existing_mark,
1112
1113
1114
1115
1116
                                 mark_name,
                                 left_gravity,
                                 iter,
                                 should_exist);

1117
  if (gtk_text_btree_mark_is_insert(get_btree (buffer), mark) ||
1118
      gtk_text_btree_mark_is_selection_bound (get_btree (buffer), mark))
1119
    {
1120
      gtk_text_buffer_update_primary_selection (buffer);
1121
1122
    }
  
1123
1124
1125
  gtk_text_btree_get_iter_at_mark (get_btree (buffer),
                                   &location,
                                   mark);
1126
1127
  
  gtk_text_buffer_mark_set (buffer, &location, mark);
1128
1129
1130
1131

  return (GtkTextMark*)mark;
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
/**
 * gtk_text_buffer_create_mark:
 * @buffer: a #GtkTextBuffer
 * @mark_name: name for mark, or %NULL
 * @where: location to place mark
 * @left_gravity: whether the mark has left gravity
 * 
 * Creates a mark at position @where. If @mark_name is %NULL, the mark
 * is anonymous; otherwise, the mark can be retrieved by name using
 * gtk_text_buffer_get_mark(). If a mark has left gravity, and text is
 * inserted at the mark's current location, the mark will be moved to
 * the left of the newly-inserted text. If the mark has right gravity
 * (@left_gravity = %FALSE), the mark will end up on the right of
 * newly-inserted text. The standard left-to-right cursor is a mark
 * with right gravity (when you type, the cursor stays on the right
 * side of the text you're typing).
 *
 * The caller of this function does <emphasis>not</emphasis> own a reference
 * to the returned #GtkTextMark, so you can ignore the return value
1151
1152
1153
1154
1155
 * if you like. Marks are owned by the buffer and go away when the
 * buffer does.
 *
 * Emits the "mark_set" signal as notification of the mark's initial
 * placement.
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1156
1157
1158
 * 
 * Return value: the new #GtkTextMark object
 **/
1159
1160
1161
1162
1163
1164
GtkTextMark*
gtk_text_buffer_create_mark(GtkTextBuffer *buffer,
                            const gchar *mark_name,
                            const GtkTextIter *where,
                            gboolean left_gravity)
{
1165
  g_return_val_if_fail (GTK_IS_TEXT_BUFFER(buffer), NULL);
1166
  
1167
1168
  return gtk_text_buffer_set_mark (buffer, NULL, mark_name, where,
                                   left_gravity, FALSE);
1169
1170
}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1171
1172
/**
 * gtk_text_buffer_move_mark:
1173
1174
1175
 * @buffer: a #GtkTextBuffer
 * @mark: a #GtkTextMark
 * @where: new location for @mark in @buffer
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1176
 * 
1177
1178
 * Moves @mark to the new location @where. Emits the "mark_set" signal
 * as notification of the move.
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1179
 **/
1180
void
1181
1182
1183
gtk_text_buffer_move_mark (GtkTextBuffer *buffer,
                           GtkTextMark *mark,
                           const GtkTextIter *where)
1184
{
1185
  g_return_if_fail (mark != NULL);
1186
1187
  g_return_if_fail (!gtk_text_mark_get_deleted (mark));
  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
1188
  
1189
  gtk_text_buffer_set_mark (buffer, mark, NULL, where, FALSE, TRUE);
1190
1191
}

1192
1193
1194
1195
1196
1197
1198
1199
/**
 * gtk_text_buffer_get_iter_at_mark:
 * @buffer: a #GtkTextBuffer
 * @iter: iterator to initialize
 * @mark: a #GtkTextMark in @buffer
 * 
 * Initializes @iter with the current position of @mark.
 **/
1200
void
1201
1202
1203
gtk_text_buffer_get_iter_at_mark (GtkTextBuffer *buffer,
                                  GtkTextIter *iter,
                                  GtkTextMark *mark)
1204
{
1205
  g_return_if_fail (mark != NULL);
1206
1207
  g_return_if_fail (!gtk_text_mark_get_deleted (mark));
  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
1208

1209
1210
1211
  gtk_text_btree_get_iter_at_mark (get_btree (buffer),
                                   iter,
                                   mark);
1212
1213
}

1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
/**
 * gtk_text_buffer_delete_mark:
 * @buffer: a #GtkTextBuffer
 * @mark: a #GtkTextMark in @buffer 
 * 
 * Deletes @mark, so that it's no longer located anywhere in the
 * buffer. Removes the reference the buffer holds to the mark, so if
 * you haven't called gtk_text_mark_ref() the mark will be freed. Even
 * if the mark isn't freed, most operations on @mark become
 * invalid. There is no way to undelete a
 * mark. gtk_text_mark_get_deleted() will return TRUE after this
 * function has been called on a mark; gtk_text_mark_get_deleted()
 * indicates that a mark no longer belongs to a buffer. The "mark_deleted"
 * signal will be emitted as notification after the mark is deleted.
 **/
1229
1230
void
gtk_text_buffer_delete_mark(GtkTextBuffer *buffer,
1231
                            GtkTextMark   *mark)
1232
{
1233
  g_return_if_fail (mark != NULL);
1234
1235
1236
1237
1238
  g_return_if_fail (!gtk_text_mark_get_deleted (mark));
  g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
  
  gtk_text_mark_ref (mark);
  
1239
  gtk_text_btree_remove_mark (get_btree (buffer), mark);
1240
1241

  /* See rationale above for MARK_SET on why we emit this after
1242
1243
1244
1245
1246
1247
1248
   * removing the mark, rather than removing the mark in a default
   * handler.
   */
  gtk_signal_emit (GTK_OBJECT(buffer), signals[MARK_DELETED],
                   mark);

  gtk_text_mark_unref (mark);
1249
1250
}

1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
/**
 * gtk_text_buffer_get_mark:
 * @buffer: a #GtkTextBuffer
 * @name: a mark name
 * 
 * Returns the mark named @name in buffer @buffer, or NULL if no such
 * mark exists in the buffer.
 * 
 * Return value: a #GtkTextMark, or NULL
 **/
1261
1262
1263
1264
GtkTextMark*
gtk_text_buffer_get_mark (GtkTextBuffer      *buffer,
                          const gchar         *name)
{
1265
  GtkTextMark *mark;
1266

1267
1268
  g_return_val_if_fail (GTK_IS_TEXT_BUFFER(buffer), NULL);
  g_return_val_if_fail (name != NULL, NULL);
1269
  
1270
  mark = gtk_text_btree_get_mark_by_name (get_btree (buffer), name);
1271

1272
  return mark;
1273
1274
}

1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344

/**
 * gtk_text_buffer_move_mark_by_name:
 * @buffer: a #GtkTextBuffer 
 * @name: name of a mark
 * @where: new location for mark
 * 
 * Moves the mark named @name (which must exist) to location @where.
 * See gtk_text_buffer_move_mark() for details.
 **/
void
gtk_text_buffer_move_mark_by_name (GtkTextBuffer     *buffer,
                                   const gchar       *name,
                                   const GtkTextIter *where)
{
  GtkTextMark *mark;

  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail (name != NULL);
  
  mark = gtk_text_btree_get_mark_by_name (get_btree (buffer), name);  

  if (mark == NULL)
    {
      g_warning ("%s: no mark named '%s'", G_STRLOC, name);
      return;
    }
  
  gtk_text_buffer_move_mark (buffer, mark, where);
}

/**
 * gtk_text_buffer_delete_mark_by_name:
 * @buffer: a #GtkTextBuffer
 * @name: name of a mark in @buffer
 * 
 * Deletes the mark named @name; the mark must exist. See
 * gtk_text_buffer_delete_mark() for details.
 **/
void
gtk_text_buffer_delete_mark_by_name (GtkTextBuffer     *buffer,
                                     const gchar       *name)
{
  GtkTextMark *mark;

  g_return_if_fail (GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail (name != NULL);
  
  mark = gtk_text_btree_get_mark_by_name (get_btree (buffer), name);  

  if (mark == NULL)
    {
      g_warning ("%s: no mark named '%s'", G_STRLOC, name);
      return;
    }
  
  gtk_text_buffer_delete_mark (buffer, mark);
}

/**
 * gtk_text_buffer_get_insert:
 * @buffer: a #GtkTextBuffer
 * 
 * Returns the mark that represents the cursor (insertion point).
 * Equivalent to calling gtk_text_buffer_get_mark() to get the mark
 * name "insert," but very slightly more efficient, and involves less
 * typing.
 * 
 * Return value: insertion point mark
 **/
Havoc Pennington's avatar
Havoc Pennington committed
1345
1346
1347
1348
1349
GtkTextMark*
gtk_text_buffer_get_insert (GtkTextBuffer *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);

1350
  /* FIXME use struct member in btree */
Havoc Pennington's avatar
Havoc Pennington committed
1351
1352
1353
  return gtk_text_buffer_get_mark (buffer, "insert");
}

1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
/**
 * gtk_text_buffer_get_selection_bound:
 * @buffer: a #GtkTextBuffer
 * 
 * Returns the mark that represents the selection bound.  Equivalent
 * to calling gtk_text_buffer_get_mark() to get the mark name
 * "selection_bound," but very slightly more efficient, and involves
 * less typing.
 *
 * The currently-selected text in @buffer is the region between the
 * "selection_bound" and "insert" marks. If "selection_bound" and
 * "insert" are in the same place, then there is no current selection.
 * gtk_text_buffer_get_selection_bounds() is another convenient function
 * for handling the selection, if you just want to know whether there's a
 * selection and what its bounds are.
 * 
 * Return value: selection bound mark
 **/
Havoc Pennington's avatar
Havoc Pennington committed
1372
1373
1374
1375
1376
GtkTextMark*
gtk_text_buffer_get_selection_bound (GtkTextBuffer *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);

1377
  /* FIXME use struct member in btree */
Havoc Pennington's avatar
Havoc Pennington committed
1378
1379
1380
  return gtk_text_buffer_get_mark (buffer, "selection_bound");
}

1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416

GtkTextChildAnchor*
gtk_text_buffer_create_child_anchor (GtkTextBuffer      *buffer,
                                     const GtkTextIter  *where)
{
  

}

void
gtk_text_buffer_move_child_anchor (GtkTextBuffer      *buffer,
                                   GtkTextChildAnchor *anchor,
                                   GtkTextIter        *where)
{
  
  
}

void
gtk_text_buffer_delete_child_anchor (GtkTextBuffer      *buffer,
                                     GtkTextChildAnchor *anchor)
{



}

void
gtk_text_buffer_get_iter_at_child_anchor (GtkTextBuffer      *buffer,
                                          GtkTextIter        *iter,
                                          GtkTextChildAnchor *anchor)
{
  

}

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1417
1418
1419
1420
1421
1422
1423
1424
/**
 * gtk_text_buffer_place_cursor:
 * @buffer: a #GtkTextBuffer 
 * @where: where to put the cursor
 * 
 * This function moves the "insert" and "selection_bound" marks
 * simultaneously.  If you move them to the same place in two steps
 * with gtk_text_buffer_move_mark(), you will temporarily select a
1425
1426
1427
1428
 * region in between their old and new locations, which can be pretty
 * inefficient since the temporarily-selected region will force stuff
 * to be recalculated. This function moves them as a unit, which can
 * be optimized.
Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1429
 **/
1430
1431
1432
1433
void
gtk_text_buffer_place_cursor (GtkTextBuffer     *buffer,
                              const GtkTextIter *where)
{
1434
1435
  GtkTextIter real;
  
1436
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
1437
1438
1439
1440
1441

  real = *where;
  
  if (gtk_text_iter_is_last (&real))
    gtk_text_iter_prev_char (&real);
1442
  
1443
  gtk_text_btree_place_cursor (get_btree (buffer), &real);
1444
  gtk_text_buffer_mark_set (buffer, &real,
1445
1446
                            gtk_text_buffer_get_mark (buffer,
                                                      "insert"));
1447
  gtk_text_buffer_mark_set (buffer, &real,
1448
1449
                            gtk_text_buffer_get_mark (buffer,
                                                      "selection_bound"));
1450
1451
1452
1453
1454
1455
}

/*
 * Tags
 */

Havoc Pennington's avatar
Docs    
Havoc Pennington committed
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
/**
 * gtk_text_buffer_create_tag:
 * @buffer: a #GtkTextBuffer
 * @tag_name: name of the new tag, or %NULL
 * 
 * Creates a tag and adds it to the tag table for @buffer.
 * Equivalent to calling gtk_text_tag_new() and then adding the
 * tag to the buffer's tag table. The returned tag has its refcount
 * incremented, as if you'd called gtk_text_tag_new().
 *
 * If @tag_name is %NULL, the tag is anonymous.
 * 
 * Return value: a new tag
 **/
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
GtkTextTag*
gtk_text_buffer_create_tag(GtkTextBuffer *buffer,
                           const gchar *tag_name)
{
  GtkTextTag *tag;
  
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);
  
  tag = gtk_text_tag_new(tag_name);

1480
  gtk_text_tag_table_add(get_table (buffer), tag);
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490

  return tag;
}

static void
gtk_text_buffer_real_apply_tag (GtkTextBuffer *buffer,
                                GtkTextTag *tag,
                                const GtkTextIter *start,
                                const GtkTextIter *end)
{
1491
  gtk_text_btree_tag (start, end, tag, TRUE);
1492
1493
1494
1495
1496
1497
1498
1499
}

static void
gtk_text_buffer_real_remove_tag (GtkTextBuffer *buffer,
                                 GtkTextTag *tag,
                                 const GtkTextIter *start,
                                 const GtkTextIter *end)
{
1500
  gtk_text_btree_tag (start, end, tag, FALSE);
1501
1502
1503
1504
1505
}


static void
gtk_text_buffer_emit_tag(GtkTextBuffer *buffer,
1506
                         GtkTextTag *tag,
1507
1508
1509
1510
                         gboolean apply,
                         const GtkTextIter *start,
                         const GtkTextIter *end)
{
1511
  g_return_if_fail(tag != NULL);
1512

1513
1514
  gtk_text_iter_reorder (start, end);
  
1515
  if (apply)
1516
1517
    gtk_signal_emit (GTK_OBJECT(buffer), signals[APPLY_TAG],
                     tag, start, end);
1518
  else
1519
1520
    gtk_signal_emit (GTK_OBJECT(buffer), signals[REMOVE_TAG],
                     tag, start, end);
1521
1522
1523
1524
1525
}


void
gtk_text_buffer_apply_tag(GtkTextBuffer *buffer,
1526
                          GtkTextTag    *tag,
1527
1528
1529
                          const GtkTextIter *start,
                          const GtkTextIter *end)
{
1530
1531
1532
1533
1534
1535
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(GTK_IS_TEXT_TAG (tag));
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);  

  gtk_text_buffer_emit_tag(buffer, tag, TRUE, start, end);
1536
1537
1538
1539
}

void
gtk_text_buffer_remove_tag(GtkTextBuffer *buffer,
1540
                           GtkTextTag    *tag,
1541
1542
1543
1544
                           const GtkTextIter *start,
                           const GtkTextIter *end)

{
1545
1546
1547
1548
1549
1550
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(GTK_IS_TEXT_TAG (tag));
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);

  gtk_text_buffer_emit_tag(buffer, tag, FALSE, start, end);
1551
1552
}

1553

1554
void
1555
gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer,
1556
                                   const gchar *name,
1557
1558
                                   const GtkTextIter *start,
                                   const GtkTextIter *end)
1559
{
1560
1561
1562
1563
1564
1565
  GtkTextTag *tag;
  
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(name != NULL);
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);
1566
  
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
  tag = gtk_text_tag_table_lookup(get_table (buffer),
                                  name);

  if (tag == NULL)
    {
      g_warning("Unknown tag `%s'", name);
      return;
    }

  gtk_text_buffer_emit_tag(buffer, tag, TRUE, start, end);
1577
1578
1579
}

void
1580
1581
1582
1583
gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer,
                                    const gchar *name,
                                    const GtkTextIter *start,
                                    const GtkTextIter *end)
1584
{
1585
1586
1587
1588
1589
1590
  GtkTextTag *tag;
  
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(name != NULL);
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);
1591

1592
1593
1594
1595
1596
1597
1598
1599
  tag = gtk_text_tag_table_lookup(get_table (buffer),
                                  name);

  if (tag == NULL)
    {
      g_warning("Unknown tag `%s'", name);
      return;
    }
1600
  
1601
  gtk_text_buffer_emit_tag(buffer, tag, FALSE, start, end);
1602
1603
}

1604

1605
1606
1607
1608
1609
/*
 * Obtain various iterators
 */

void
1610
1611
1612
1613
gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer      *buffer,
                                         GtkTextIter        *iter,
                                         gint                line_number,
                                         gint                char_offset)
1614
1615
1616
1617
{  
  g_return_if_fail(iter != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1618
1619
  gtk_text_btree_get_iter_at_line_char(get_btree (buffer),
                                       iter, line_number, char_offset);
1620
1621
1622
1623
1624
}

void
gtk_text_buffer_get_iter_at_line    (GtkTextBuffer      *buffer,
                                     GtkTextIter        *iter,
1625
                                     gint                line_number)
1626
1627
1628
1629
{
  g_return_if_fail(iter != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1630
  gtk_text_buffer_get_iter_at_line_offset (buffer, iter, line_number, 0);
1631
1632
1633
}

void
1634
1635
1636
gtk_text_buffer_get_iter_at_offset         (GtkTextBuffer      *buffer,
                                            GtkTextIter        *iter,
                                            gint                char_offset)
1637
1638
1639
1640
{
  g_return_if_fail(iter != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1641
  gtk_text_btree_get_iter_at_char(get_btree (buffer), iter, char_offset);
1642
1643
1644
1645
1646
1647
1648
1649
1650
}

void
gtk_text_buffer_get_last_iter         (GtkTextBuffer      *buffer,
                                       GtkTextIter        *iter)
{  
  g_return_if_fail(iter != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1651
  gtk_text_btree_get_last_iter(get_btree (buffer), iter);
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
}

void
gtk_text_buffer_get_bounds (GtkTextBuffer *buffer,
                            GtkTextIter   *start,
                            GtkTextIter   *end)
{
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1663
1664
  gtk_text_btree_get_iter_at_char(get_btree (buffer), start, 0);
  gtk_text_btree_get_last_iter(get_btree (buffer), end);
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
}

/*
 * Modified flag
 */

gboolean
gtk_text_buffer_modified (GtkTextBuffer      *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), FALSE);
  
  return buffer->modified;
}

void
gtk_text_buffer_set_modified (GtkTextBuffer      *buffer,
                              gboolean             setting)
{
  gboolean fixed_setting;
  
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

  fixed_setting = setting != FALSE;
  
  if (buffer->modified == fixed_setting)
    return;
  else
    {
      buffer->modified = fixed_setting;
      gtk_signal_emit(GTK_OBJECT(buffer), signals[MODIFIED_CHANGED]);
    }
}


/*
 * Assorted other stuff
 */

gint
gtk_text_buffer_get_line_count(GtkTextBuffer *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), 0);
  
1708
  return gtk_text_btree_line_count(get_btree (buffer));
1709
1710
1711
1712
1713
1714
1715
}

gint
gtk_text_buffer_get_char_count(GtkTextBuffer *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), 0);

1716
  return gtk_text_btree_char_count(get_btree (buffer));
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
}

GSList*
gtk_text_buffer_get_tags               (GtkTextBuffer      *buffer,
                                        const GtkTextIter  *iter)
{
  GSList *retval = NULL;
  GtkTextTag** tags;
  gint count = 0;
  
  tags = gtk_text_btree_get_tags(iter, &count);

  if (count > 0)
    {
      gint i;

      gtk_text_tag_array_sort(tags, count);
      
      i = 0;
      while (i < count)
        {
          retval = g_slist_prepend(retval, tags[i]);
          ++i;
        }

      retval = g_slist_reverse(retval);
    }

  if (tags)
    g_free(tags);

  return retval;
}

1751
/* Called when we lose the primary selection.
1752
 */
1753
1754
1755
static void
clipboard_clear_cb (GtkClipboard *clipboard,
		    gpointer      data)
1756
{