gtktextbuffer.c 55 KB
Newer Older
1 2 3 4 5
/*  gtktextbuffer.c - the "model" in the MVC text widget architecture 
 *  Copyright (c) 2000 Red Hat, Inc.
 *  Developed by Havoc Pennington
 */

6 7
#include <string.h>

8 9 10 11 12 13
#include "gtkinvisible.h"
#include "gtkselection.h"
#include "gtksignal.h"
#include "gtktextbuffer.h"
#include "gtktextbtree.h"
#include "gtktextiterprivate.h"
14
#include <string.h>
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

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_update_clipboard_selection (GtkTextBuffer     *buffer);
static void gtk_text_buffer_real_insert_text           (GtkTextBuffer     *buffer,
                                                        GtkTextIter       *iter,
                                                        const gchar       *text,
51 52
                                                        gint               len,
                                                        gboolean           interactive);
53 54
static void gtk_text_buffer_real_delete_text           (GtkTextBuffer     *buffer,
                                                        GtkTextIter       *start,
55 56
                                                        GtkTextIter       *end,
                                                        gboolean           interactive);
57 58 59 60 61 62 63 64 65
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);

66
static GtkTextBTree* get_btree (GtkTextBuffer *buffer);
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118

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

static GdkAtom clipboard_atom = GDK_NONE;
static GdkAtom text_atom = GDK_NONE;
static GdkAtom ctext_atom = GDK_NONE;
static GdkAtom utf8_atom = GDK_NONE;

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),
119
                    gtk_marshal_NONE__POINTER_POINTER_INT_INT,
120
                    GTK_TYPE_NONE,
121
                    4,
122
                    GTK_TYPE_POINTER,
123
                    GTK_TYPE_POINTER,
124 125
                    GTK_TYPE_INT,
                    GTK_TYPE_BOOL);
126 127 128 129 130 131

  signals[DELETE_TEXT] =
    gtk_signal_new ("delete_text",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, delete_text),
132
                    gtk_marshal_NONE__POINTER_POINTER_INT,
133
                    GTK_TYPE_NONE,
134
                    3,
135
                    GTK_TYPE_POINTER,
136 137
                    GTK_TYPE_POINTER,
                    GTK_TYPE_BOOL);
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182

  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),
183
                    gtk_marshal_NONE__POINTER_POINTER_POINTER,
184 185 186
                    GTK_TYPE_NONE,
                    3,
                    GTK_TYPE_POINTER,
187 188
                    GTK_TYPE_POINTER,
                    GTK_TYPE_POINTER);
189 190 191 192 193 194
    
  signals[REMOVE_TAG] =
    gtk_signal_new ("remove_tag",
                    GTK_RUN_LAST,
                    GTK_CLASS_TYPE (object_class),
                    GTK_SIGNAL_OFFSET (GtkTextBufferClass, remove_tag),
195
                    gtk_marshal_NONE__POINTER_POINTER_POINTER,
196 197 198
                    GTK_TYPE_NONE,
                    3,
                    GTK_TYPE_POINTER,
199 200
                    GTK_TYPE_POINTER,
                    GTK_TYPE_POINTER);
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
  
  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)
{
  static const GtkTargetEntry targets[] = {
    { "STRING", 0, TARGET_STRING },
    { "TEXT",   0, TARGET_TEXT }, 
    { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
    { "UTF8_STRING", 0, TARGET_UTF8_STRING }
  };
  static const gint n_targets = sizeof(targets) / sizeof(targets[0]);

  if (!clipboard_atom)
    clipboard_atom = gdk_atom_intern ("CLIPBOARD", FALSE);

  if (!text_atom)
    text_atom = gdk_atom_intern ("TEXT", FALSE);

  if (!ctext_atom)
    ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE);

  if (!utf8_atom)
    utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE);
  
  buffer->selection_widget = gtk_invisible_new();
  
  gtk_selection_add_targets (buffer->selection_widget,
                             GDK_SELECTION_PRIMARY,
			     targets, n_targets);
  gtk_selection_add_targets (buffer->selection_widget,
                             clipboard_atom,
			     targets, n_targets);
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
271 272 273 274 275 276 277 278
/**
 * 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
 **/
279 280 281 282 283 284 285 286
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)
287 288 289 290 291 292
    {
      text_buffer->tag_table = table;
      
      gtk_object_ref (GTK_OBJECT(text_buffer->tag_table));
      gtk_object_sink (GTK_OBJECT(text_buffer->tag_table));
    } 
293 294 295 296 297 298 299 300 301 302 303 304 305 306
  
  return text_buffer;
}

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

  buffer = GTK_TEXT_BUFFER (object);

  gtk_widget_destroy(buffer->selection_widget);
  buffer->selection_widget = NULL;

307 308 309 310 311 312 313 314 315 316 317
  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;
    }
318 319 320 321 322 323 324 325 326 327 328 329 330 331
  
  (* 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);
}

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 357 358 359 360 361
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
362 363 364 365 366 367 368 369
/**
 * gtk_text_buffer_get_tag_table:
 * @buffer: a #GtkTextBuffer
 * 
 * Get the #GtkTextTagTable associated with this buffer.
 * 
 * Return value: the buffer's tag table
 **/
370 371 372 373 374 375 376 377
GtkTextTagTable*
gtk_text_buffer_get_tag_table (GtkTextBuffer  *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);

  return get_table (buffer);
}

378 379 380 381 382 383 384 385
/*
 * Insertion
 */

static void
gtk_text_buffer_real_insert_text(GtkTextBuffer *buffer,
                                 GtkTextIter *iter,
                                 const gchar *text,
386 387
                                 gint len,
                                 gboolean interactive)
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
{
  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,
403 404
                            gint len,
                            gboolean interactive)
405 406 407 408 409 410 411 412 413 414 415
{
  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],
416
                      iter, text, len, interactive);
417 418 419
    }
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
/**
 * 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.
 * 
 **/
436 437 438 439 440 441 442 443 444 445
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);
  
446
  gtk_text_buffer_emit_insert(buffer, iter, text, len, FALSE);
447 448
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
449 450 451 452 453 454 455 456 457
/**
 * 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.
 **/
458 459 460 461 462 463 464 465 466 467
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);

468 469 470
  gtk_text_buffer_get_iter_at_mark(buffer, &iter,
                                   gtk_text_buffer_get_mark (buffer,
                                                             "insert"));
471 472 473 474

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

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
/**
 * 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
 * @editable_by_default: default editability of buffer
 * 
 * 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
 **/
490 491 492 493 494 495
gboolean
gtk_text_buffer_insert_interactive(GtkTextBuffer *buffer,
                                   GtkTextIter   *iter,
                                   const gchar   *text,
                                   gint           len,
                                   gboolean       editable_by_default)
496
{
497 498
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), FALSE);
  g_return_val_if_fail(text != NULL, FALSE);
499
  
500 501
  if (gtk_text_iter_editable (iter, editable_by_default))
    {
502
      gtk_text_buffer_emit_insert (buffer, iter, text, len, TRUE);
503 504 505 506
      return TRUE;
    }
  else
    return FALSE;
507 508
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
509 510 511 512 513 514 515 516 517 518 519 520
/**
 * 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
 **/
521 522 523 524 525
gboolean
gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer,
                                              const gchar   *text,
                                              gint           len,
                                              gboolean       default_editable)
526
{
527
  GtkTextIter iter;
528

529 530 531 532 533 534
  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"));
535

536 537
  return gtk_text_buffer_insert_interactive (buffer, &iter, text, len,
                                             default_editable);
538 539 540 541 542 543 544 545 546
}

/*
 * Deletion
 */

static void
gtk_text_buffer_real_delete_text(GtkTextBuffer *buffer,
                                 GtkTextIter *start,
547 548
                                 GtkTextIter *end,
                                 gboolean interactive)
549 550 551 552
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);
553
  
554 555 556 557 558 559 560 561 562 563 564 565 566
  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
gtk_text_buffer_emit_delete(GtkTextBuffer *buffer,
                            GtkTextIter *start,
567 568
                            GtkTextIter *end,
                            gboolean interactive)
569 570 571 572 573 574 575 576
{
  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;

577
  gtk_text_iter_reorder (start, end);
Havoc Pennington's avatar
Docs  
Havoc Pennington committed
578 579 580 581 582

  /* FIXME if the final newline is in the deletion range,
   * shorten the range. (i.e. if end is the end iterator,
   * move it backward by one)
   */
583
  
584 585
  gtk_signal_emit(GTK_OBJECT(buffer),
                  signals[DELETE_TEXT],
586 587
                  start, end,
                  interactive);
588 589
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
/**
 * 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.
 * 
 **/
610 611 612 613 614 615 616 617 618
void
gtk_text_buffer_delete (GtkTextBuffer *buffer,
                        GtkTextIter *start,
                        GtkTextIter *end)
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(start != NULL);
  g_return_if_fail(end != NULL);
  
619
  gtk_text_buffer_emit_delete(buffer, start, end, FALSE);
620 621
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
622 623 624 625 626 627 628 629 630 631 632 633 634
/**
 * 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
 * [@start,@end).
 * 
 * Return value: whether some text was actually deleted
 **/
635 636 637 638 639
gboolean
gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer,
                                    GtkTextIter   *start_iter,
                                    GtkTextIter   *end_iter,
                                    gboolean       default_editable)
640
{
641 642 643 644 645 646 647
  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 */
648
  
649 650 651
  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);
652

653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
  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;
668

669 670 671 672 673 674 675 676 677
      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 */
        }
678

679
      new_state = gtk_text_iter_editable (&iter, default_editable);
680

681 682 683 684 685 686 687 688 689 690 691
      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);
                  
692
                  gtk_text_buffer_emit_delete (buffer, &start, &iter, TRUE);
693 694 695 696 697 698 699 700 701
                  
                  deleted_stuff = TRUE;
                }

              break;
            }
          else
            continue;
        }
702

703 704 705 706 707 708 709
      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);
          
710
          gtk_text_buffer_emit_delete (buffer, &start, &iter, TRUE);
711

712 713 714 715 716 717 718 719
          current_state = FALSE;
          deleted_stuff = TRUE;
        }
      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.
           */
720

721 722 723 724
          g_assert (!current_state && new_state);          
          
          gtk_text_buffer_move_mark (buffer, start_mark,
                                     &iter);
725 726


727 728 729 730 731 732 733 734 735 736 737 738
          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;
739 740 741 742 743 744
}

/*
 * Extracting textual buffer contents
 */

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
/**
 * 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
 **/
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
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
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
/**
 * 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
 **/
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
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
gtk_text_buffer_insert_pixmap         (GtkTextBuffer      *buffer,
                                       GtkTextIter *iter,
                                       GdkPixmap           *pixmap,
                                       GdkBitmap           *mask)
{
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
  g_return_if_fail(iter != NULL);
  g_return_if_fail(pixmap != NULL);

  gtk_text_btree_insert_pixmap(iter, pixmap, mask);

  /* FIXME pixmap-specific signal like insert_text */
  
  gtk_signal_emit(GTK_OBJECT(buffer), signals[CHANGED]);
  
  gtk_text_buffer_set_modified(buffer, TRUE);
}

/*
 * Mark manipulation
 */

static void
gtk_text_buffer_mark_set (GtkTextBuffer     *buffer,
			  const GtkTextIter *location,
842
                          GtkTextMark       *mark)
843 844 845 846 847 848 849 850 851 852 853 854
{
  /* 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. */
  gtk_signal_emit(GTK_OBJECT(buffer),
                  signals[MARK_SET],
855
                  location,
856
                  mark);
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875

}

/**
 * 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.
 * 
 * Return value: 
 **/
static GtkTextMark*
gtk_text_buffer_set_mark(GtkTextBuffer *buffer,
876
                         GtkTextMark *existing_mark,
877 878 879 880 881 882
                         const gchar *mark_name,
                         const GtkTextIter *iter,
                         gboolean left_gravity,
                         gboolean should_exist)
{
  GtkTextIter location;
883
  GtkTextMark *mark;
884
  
885
  mark = gtk_text_btree_set_mark(get_btree (buffer),
886
                                 existing_mark,
887 888 889 890 891
                                 mark_name,
                                 left_gravity,
                                 iter,
                                 should_exist);

892 893
  if (gtk_text_btree_mark_is_insert(get_btree (buffer), mark) ||
      gtk_text_btree_mark_is_selection_bound(get_btree (buffer), mark))
894 895 896 897
    {
      gtk_text_buffer_update_primary_selection(buffer);
    }
  
898
  gtk_text_btree_get_iter_at_mark(get_btree (buffer),
899 900
                                  &location,
                                  mark);
901 902
  
  gtk_text_buffer_mark_set (buffer, &location, mark);
903 904 905 906

  return (GtkTextMark*)mark;
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
/**
 * 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
 * if you like.
 * 
 * Return value: the new #GtkTextMark object
 **/
930 931 932 933 934 935
GtkTextMark*
gtk_text_buffer_create_mark(GtkTextBuffer *buffer,
                            const gchar *mark_name,
                            const GtkTextIter *where,
                            gboolean left_gravity)
{
936 937
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);
  
938
  return gtk_text_buffer_set_mark(buffer, NULL, mark_name, where,
939 940 941
                                  left_gravity, FALSE);
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
942 943 944 945 946 947 948 949
/**
 * gtk_text_buffer_move_mark:
 * @buffer: 
 * @mark: 
 * @where: 
 * 
 * 
 **/
950 951
void
gtk_text_buffer_move_mark(GtkTextBuffer *buffer,
952
                          GtkTextMark *mark,
953 954
                          const GtkTextIter *where)
{
955
  g_return_if_fail (mark != NULL);
956 957
  g_return_if_fail (!gtk_text_mark_deleted (mark));
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
958 959
  
  gtk_text_buffer_set_mark(buffer, mark, NULL, where, FALSE, TRUE);
960 961
}

962
void
963 964
gtk_text_buffer_get_iter_at_mark(GtkTextBuffer *buffer,
                                 GtkTextIter *iter,
965
                                 GtkTextMark *mark)
966
{
967 968
  g_return_if_fail (mark != NULL);
  g_return_if_fail (!gtk_text_mark_deleted (mark));
969
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
970

971
  gtk_text_btree_get_iter_at_mark(get_btree (buffer),
972 973
                                  iter,
                                  mark);
974 975 976 977
}

void
gtk_text_buffer_delete_mark(GtkTextBuffer *buffer,
978
                            GtkTextMark *mark)
979
{
980 981
  g_return_if_fail (mark != NULL);
  g_return_if_fail (!gtk_text_mark_deleted (mark));
982 983
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

984
  gtk_text_btree_remove_mark (get_btree (buffer), mark);
985 986 987 988 989

  /* See rationale above for MARK_SET on why we emit this after
     removing the mark, rather than removing the mark in a default
     handler. */
  gtk_signal_emit(GTK_OBJECT(buffer), signals[MARK_DELETED],
990
                  mark);
991 992 993 994 995 996
}

GtkTextMark*
gtk_text_buffer_get_mark (GtkTextBuffer      *buffer,
                          const gchar         *name)
{
997
  GtkTextMark *mark;
998 999 1000 1001

  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), NULL);
  g_return_val_if_fail(name != NULL, NULL);
  
1002
  mark = gtk_text_btree_get_mark_by_name(get_btree (buffer), name);
1003

1004
  return mark;
1005 1006
}

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
/**
 * 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
 * region in between their old and new locations, which marks part of
 * the buffer invalid and can be inefficient. This function moves
 * them as a unit, which can be optimized.
 **/
1019 1020 1021 1022
void
gtk_text_buffer_place_cursor (GtkTextBuffer     *buffer,
                              const GtkTextIter *where)
{
1023 1024
  GtkTextIter real;
  
1025
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
1026 1027 1028 1029 1030

  real = *where;
  
  if (gtk_text_iter_is_last (&real))
    gtk_text_iter_prev_char (&real);
1031
  
1032 1033
  gtk_text_btree_place_cursor(get_btree (buffer), &real);
  gtk_text_buffer_mark_set (buffer, &real,
1034 1035
                            gtk_text_buffer_get_mark (buffer,
                                                      "insert"));
1036
  gtk_text_buffer_mark_set (buffer, &real,
1037 1038
                            gtk_text_buffer_get_mark (buffer,
                                                      "selection_bound"));
1039 1040 1041 1042 1043 1044
}

/*
 * Tags
 */

Havoc Pennington's avatar
Docs  
Havoc Pennington committed
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
/**
 * 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
 **/
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
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);

1069
  gtk_text_tag_table_add(get_table (buffer), tag);
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094

  return tag;
}

static void
gtk_text_buffer_real_apply_tag (GtkTextBuffer *buffer,
                                GtkTextTag *tag,
                                const GtkTextIter *start,
                                const GtkTextIter *end)
{
  gtk_text_btree_tag(start, end, tag, TRUE);
}

static void
gtk_text_buffer_real_remove_tag (GtkTextBuffer *buffer,
                                 GtkTextTag *tag,
                                 const GtkTextIter *start,
                                 const GtkTextIter *end)
{
  gtk_text_btree_tag(start, end, tag, FALSE);
}


static void
gtk_text_buffer_emit_tag(GtkTextBuffer *buffer,
1095
                         GtkTextTag *tag,
1096 1097 1098 1099
                         gboolean apply,
                         const GtkTextIter *start,
                         const GtkTextIter *end)
{
1100
  g_return_if_fail(tag != NULL);
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112

  if (apply)
    gtk_signal_emit(GTK_OBJECT(buffer), signals[APPLY_TAG],
                    tag, start, end);
  else
    gtk_signal_emit(GTK_OBJECT(buffer), signals[REMOVE_TAG],
                    tag, start, end);
}


void
gtk_text_buffer_apply_tag(GtkTextBuffer *buffer,
1113
                          GtkTextTag    *tag,
1114 1115 1116
                          const GtkTextIter *start,
                          const GtkTextIter *end)
{
1117 1118 1119 1120 1121 1122
  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);
1123 1124 1125 1126
}

void
gtk_text_buffer_remove_tag(GtkTextBuffer *buffer,
1127
                           GtkTextTag    *tag,
1128 1129 1130 1131
                           const GtkTextIter *start,
                           const GtkTextIter *end)

{
1132 1133 1134 1135 1136 1137
  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);
1138 1139
}

1140

1141
void
1142
gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer,
1143
                                   const gchar *name,
1144 1145
                                   const GtkTextIter *start,
                                   const GtkTextIter *end)
1146
{
1147 1148 1149 1150 1151 1152
  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);
1153
  
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
  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);
1164 1165 1166
}

void
1167 1168 1169 1170
gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer,
                                    const gchar *name,
                                    const GtkTextIter *start,
                                    const GtkTextIter *end)
1171
{
1172 1173 1174 1175 1176 1177
  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);
1178

1179 1180 1181 1182 1183 1184 1185 1186
  tag = gtk_text_tag_table_lookup(get_table (buffer),
                                  name);

  if (tag == NULL)
    {
      g_warning("Unknown tag `%s'", name);
      return;
    }
1187
  
1188
  gtk_text_buffer_emit_tag(buffer, tag, FALSE, start, end);
1189 1190
}

1191

1192 1193 1194 1195 1196
/*
 * Obtain various iterators
 */

void
1197 1198 1199 1200
gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer      *buffer,
                                         GtkTextIter        *iter,
                                         gint                line_number,
                                         gint                char_offset)
1201 1202 1203 1204
{  
  g_return_if_fail(iter != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1205 1206
  gtk_text_btree_get_iter_at_line_char(get_btree (buffer),
                                       iter, line_number, char_offset);
1207 1208 1209 1210 1211
}

void
gtk_text_buffer_get_iter_at_line    (GtkTextBuffer      *buffer,
                                     GtkTextIter        *iter,
1212
                                     gint                line_number)
1213 1214 1215 1216
{
  g_return_if_fail(iter != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1217
  gtk_text_buffer_get_iter_at_line_offset (buffer, iter, line_number, 0);
1218 1219 1220
}

void
1221 1222 1223
gtk_text_buffer_get_iter_at_offset         (GtkTextBuffer      *buffer,
                                            GtkTextIter        *iter,
                                            gint                char_offset)
1224 1225 1226 1227
{
  g_return_if_fail(iter != NULL);
  g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));

1228
  gtk_text_btree_get_iter_at_char(get_btree (buffer), iter, char_offset);
1229 1230 1231 1232 1233 1234 1235 1236 1237
}

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));

1238
  gtk_text_btree_get_last_iter(get_btree (buffer), iter);
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
}

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));

1250 1251
  gtk_text_btree_get_iter_at_char(get_btree (buffer), start, 0);
  gtk_text_btree_get_last_iter(get_btree (buffer), end);
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 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
}

/*
 * 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]);
    }
}


/*
 * Clipboard
 */

static void
set_clipboard_contents_nocopy(GtkTextBuffer *buffer,
                              gchar *text)
{
  if (text && *text == '\0')
    {
      g_free(text);
      text = NULL;
    }
  
  if (buffer->clipboard_text != NULL)
    g_free(buffer->clipboard_text);  

  buffer->clipboard_text = text;
  
  gtk_text_buffer_update_clipboard_selection(buffer);
}

void
gtk_text_buffer_set_clipboard_contents (GtkTextBuffer      *buffer,
                                        const gchar         *text)
{
  set_clipboard_contents_nocopy(buffer, text ? g_strdup(text) : NULL);
}

const gchar*
gtk_text_buffer_get_clipboard_contents (GtkTextBuffer      *buffer)
{
  return buffer->clipboard_text;
}

/*
 * Assorted other stuff
 */

gint
gtk_text_buffer_get_line_count(GtkTextBuffer *buffer)
{
  g_return_val_if_fail(GTK_IS_TEXT_BUFFER(buffer), 0);
  
1330
  return gtk_text_btree_line_count(get_btree (buffer));
1331 1332 1333 1334 1335 1336 1337
}

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

1338
  return gtk_text_btree_char_count(get_btree (buffer));
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 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 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
}

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;
}

/*
 * Selection
 */

static gboolean
have_primary_x_selection(GtkWidget *widget)
{
  return (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == 
          widget->window);
}

static gboolean
request_primary_x_selection(GtkWidget *widget, guint32 time)
{
  return gtk_selection_owner_set (widget, GDK_SELECTION_PRIMARY, time);
}

static gboolean
release_primary_x_selection(GtkWidget *widget, guint32 time)
{
  if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == 
      widget->window)
    {
      gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY, time);
      return TRUE;
    }
  else
    return FALSE;
}


static gboolean
have_clipboard_x_selection(GtkWidget *widget)
{
  return (gdk_selection_owner_get (clipboard_atom) == 
          widget->window);
}

static gboolean
request_clipboard_x_selection(GtkWidget *widget, guint32 time)
{
  return gtk_selection_owner_set (widget, clipboard_atom, time);
}

static gboolean
release_clipboard_x_selection(GtkWidget *widget, guint32 time)
{
  if (gdk_selection_owner_get (clipboard_atom) == 
      widget->window)
    {
      gtk_selection_owner_set (NULL, clipboard_atom, time);
      return TRUE;
    }
  else
    return FALSE;
}

/* Called when we lose the selection */
static gint
selection_clear_event(GtkWidget *widget, GdkEventSelection *event,
                      gpointer data)
{
  GtkTextBuffer *buffer;
  
  buffer = GTK_TEXT_BUFFER(data);

  /* Let the selection handling code know that the selection
   * has been changed, since we've overriden the default handler */
  if (!gtk_selection_clear (widget, event))
    return FALSE;

  buffer->have_selection = FALSE