gtktextbtree.c 176 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
 * gtktextbtree.c --
 *
 *      This file contains code that manages the B-tree representation
 *      of text for the text buffer and implements character and
 *      toggle segment types.
 *
 * Copyright (c) 1992-1994 The Regents of the University of California.
 * Copyright (c) 1994-1995 Sun Microsystems, Inc.
 * Copyright (c) 2000      Red Hat, Inc.
 * Tk -> Gtk port by Havoc Pennington <hp@redhat.com>
 *
 * This software is copyrighted by the Regents of the University of
 * California, Sun Microsystems, Inc., and other parties.  The
 * following terms apply to all files associated with the software
 * unless explicitly disclaimed in individual files.
17
 *
18
19
20
21
22
23
24
25
26
 * The authors hereby grant permission to use, copy, modify,
 * distribute, and license this software and its documentation for any
 * purpose, provided that existing copyright notices are retained in
 * all copies and that this notice is included verbatim in any
 * distributions. No written agreement, license, or royalty fee is
 * required for any of the authorized uses.  Modifications to this
 * software may be copyrighted by their authors and need not follow
 * the licensing terms described here, provided that the new terms are
 * clearly indicated on the first page of each file where they apply.
27
 *
28
29
30
31
32
 * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY
 * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
 * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION,
 * OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
33
 *
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
 * NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,
 * AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
 * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * GOVERNMENT USE: If you are acquiring this software on behalf of the
 * U.S. government, the Government shall have only "Restricted Rights"
 * in the software and related documentation as defined in the Federal
 * Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
 * are acquiring the software on behalf of the Department of Defense,
 * the software shall be classified as "Commercial Computer Software"
 * and the Government shall have only "Restricted Rights" as defined
 * in Clause 252.227-7013 (c) (1) of DFARs.  Notwithstanding the
 * foregoing, the authors grant the U.S. Government and others acting
 * in its behalf permission to use and distribute the software in
 * accordance with the terms specified in this license.
52
 *
53
54
55
56
57
58
59
60
61
62
63
64
65
 */

#include "gtktextbtree.h"
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include "gtksignal.h"
#include "gtktexttag.h"
#include "gtktexttagtable.h"
#include "gtktextlayout.h"
#include "gtktextiterprivate.h"
#include "gtkdebug.h"
66
#include "gtktextmarkprivate.h"
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

/*
 * Types
 */


/*
 * The structure below is used to pass information between
 * gtk_text_btree_get_tags and inc_count:
 */

typedef struct TagInfo {
  int numTags;                  /* Number of tags for which there
                                 * is currently information in
                                 * tags and counts. */
  int arraySize;                        /* Number of entries allocated for
                                         * tags and counts. */
  GtkTextTag **tags;           /* Array of tags seen so far.
                                * Malloc-ed. */
  int *counts;                  /* Toggle count (so far) for each
                                 * entry in tags.  Malloc-ed. */
} TagInfo;


/*
 * This is used to store per-view width/height info at the tree nodes.
 */

typedef struct _NodeData NodeData;

struct _NodeData {
  gpointer view_id;
  NodeData *next;

  /* Height and width of this node */
  gint height;
  gint width : 24;
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
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
  /* boolean indicating whether the height/width need to be recomputed */
  gint valid : 8;
};


/*
 * The data structure below keeps summary information about one tag as part
 * of the tag information in a node.
 */

typedef struct Summary {
  GtkTextTagInfo *info;                     /* Handle for tag. */
  int toggle_count;                     /* Number of transitions into or
                                         * out of this tag that occur in
                                         * the subtree rooted at this node. */
  struct Summary *next;         /* Next in list of all tags for same
                                 * node, or NULL if at end of list. */
} Summary;

/*
 * The data structure below defines a node in the B-tree.
 */

struct _GtkTextBTreeNode {
  GtkTextBTreeNode *parent;         /* Pointer to parent node, or NULL if
                                     * this is the root. */
  GtkTextBTreeNode *next;           /* Next in list of siblings with the
                                     * same parent node, or NULL for end
                                     * of list. */
  Summary *summary;             /* First in malloc-ed list of info
                                 * about tags in this subtree (NULL if
                                 * no tag info in the subtree). */
  int level;                            /* Level of this node in the B-tree.
                                         * 0 refers to the bottom of the tree
                                         * (children are lines, not nodes). */
  union {                               /* First in linked list of children. */
    struct _GtkTextBTreeNode *node;         /* Used if level > 0. */
    GtkTextLine *line;         /* Used if level == 0. */
  } children;
  int num_children;                     /* Number of children of this node. */
  int num_lines;                        /* Total number of lines (leaves) in
                                         * the subtree rooted here. */
  int num_chars;                        /* Number of chars below here */

  NodeData *node_data;
};


/*
 * Used to store the list of views in our btree
 */

typedef struct _BTreeView BTreeView;

struct _BTreeView {
  gpointer view_id;
  GtkTextLayout *layout;
  BTreeView *next;
  BTreeView *prev;
};

/*
 * And the tree itself
 */

struct _GtkTextBTree {
  GtkTextBTreeNode *root_node;          /* Pointer to root of B-tree. */
  GtkTextTagTable *table;
  GHashTable *mark_table;
  guint refcount;
Havoc Pennington's avatar
Havoc Pennington committed
175
176
  GtkTextMark *insert_mark;
  GtkTextMark *selection_bound_mark;
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
  GtkTextBuffer *buffer;
  BTreeView *views;
  GSList *tag_infos;
  guint tag_changed_handler;
  guint tag_removed_handler;
  /* Incremented when a segment with a byte size > 0
     is added to or removed from the tree (i.e. the
     length of a line may have changed, and lines may
     have been added or removed). This invalidates
     all outstanding iterators.
  */
  guint chars_changed_stamp;
  /* Incremented when any segments are added or deleted;
     this makes outstanding iterators recalculate their
     pointed-to segment and segment offset.
  */
  guint segments_changed_stamp;
194
195

  GtkTextLine *end_iter_line;
196

197
  guint end_iter_line_stamp;
198
199

  GHashTable *child_anchor_table;
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
};


/*
 * Upper and lower bounds on how many children a node may have:
 * rebalance when either of these limits is exceeded.  MAX_CHILDREN
 * should be twice MIN_CHILDREN and MIN_CHILDREN must be >= 2.
 */

/* Tk used MAX of 12 and MIN of 6. This makes the tree wide and
   shallow. It appears to be faster to locate a particular line number
   if the tree is narrow and deep, since it is more finely sorted.  I
   guess this may increase memory use though, and make it slower to
   walk the tree in order, or locate a particular byte index (which
   is done by walking the tree in order).
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
   There's basically a tradeoff here. However I'm thinking we want to
   add pixels, byte counts, and char counts to the tree nodes,
   at that point narrow and deep should speed up all operations,
   not just the line number searches.
*/

#if 1
#define MAX_CHILDREN 12
#define MIN_CHILDREN 6
#else
#define MAX_CHILDREN 6
#define MIN_CHILDREN 3
#endif

/*
 * Prototypes
 */

static BTreeView        *gtk_text_btree_get_view                 (GtkTextBTree     *tree,
                                                                  gpointer          view_id);
static void              gtk_text_btree_rebalance                (GtkTextBTree     *tree,
                                                                  GtkTextBTreeNode *node);
static GtkTextLine     * get_last_line                           (GtkTextBTree     *tree);
static void              post_insert_fixup                       (GtkTextBTree     *tree,
                                                                  GtkTextLine      *insert_line,
                                                                  gint              char_count_delta,
                                                                  gint              line_count_delta);
static void              gtk_text_btree_node_adjust_toggle_count (GtkTextBTreeNode *node,
                                                                  GtkTextTagInfo   *info,
                                                                  gint              adjust);
static gboolean          gtk_text_btree_node_has_tag             (GtkTextBTreeNode *node,
                                                                  GtkTextTag       *tag);

static void             segments_changed                (GtkTextBTree     *tree);
static void             chars_changed                   (GtkTextBTree     *tree);
static void             summary_list_destroy            (Summary          *summary);
static GtkTextLine     *gtk_text_line_new               (void);
static void             gtk_text_line_destroy           (GtkTextBTree     *tree,
                                                         GtkTextLine      *line);
static void             gtk_text_line_set_parent        (GtkTextLine      *line,
                                                         GtkTextBTreeNode *node);
static void             gtk_text_btree_node_remove_data (GtkTextBTreeNode *node,
                                                         gpointer          view_id);


static NodeData         *node_data_new          (gpointer  view_id);
static void              node_data_destroy      (NodeData *nd);
static void              node_data_list_destroy (NodeData *nd);
static NodeData         *node_data_find         (NodeData *nd,
                                                 gpointer  view_id);

static GtkTextBTreeNode     *gtk_text_btree_node_new                  (void);
static void                  gtk_text_btree_node_invalidate_downward  (GtkTextBTreeNode *node);
static void                  gtk_text_btree_node_invalidate_upward    (GtkTextBTreeNode *node,
270
                                                                       gpointer          view_id);
271
static NodeData *            gtk_text_btree_node_check_valid          (GtkTextBTreeNode *node,
272
                                                                       gpointer          view_id);
273
static NodeData *            gtk_text_btree_node_check_valid_downward (GtkTextBTreeNode *node,
274
                                                                       gpointer          view_id);
275
static void                  gtk_text_btree_node_check_valid_upward   (GtkTextBTreeNode *node,
276
                                                                       gpointer          view_id);
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291

static void                  gtk_text_btree_node_remove_view         (BTreeView        *view,
                                                                      GtkTextBTreeNode *node,
                                                                      gpointer          view_id);
static void                  gtk_text_btree_node_destroy             (GtkTextBTree     *tree,
                                                                      GtkTextBTreeNode *node);
static NodeData         *    gtk_text_btree_node_ensure_data         (GtkTextBTreeNode *node,
                                                                      gpointer          view_id);
static void                  gtk_text_btree_node_remove_data         (GtkTextBTreeNode *node,
                                                                      gpointer          view_id);
static void                  gtk_text_btree_node_get_size            (GtkTextBTreeNode *node,
                                                                      gpointer          view_id,
                                                                      gint             *width,
                                                                      gint             *height);
static GtkTextBTreeNode *    gtk_text_btree_node_common_parent       (GtkTextBTreeNode *node1,
292
                                                                      GtkTextBTreeNode *node2);
293
294
295
296
297
298
299
300
301
302
303
304
static void get_tree_bounds       (GtkTextBTree     *tree,
                                   GtkTextIter      *start,
                                   GtkTextIter      *end);
static void tag_changed_cb        (GtkTextTagTable  *table,
                                   GtkTextTag       *tag,
                                   gboolean          size_changed,
                                   GtkTextBTree     *tree);
static void tag_removed_cb        (GtkTextTagTable  *table,
                                   GtkTextTag       *tag,
                                   GtkTextBTree     *tree);
static void cleanup_line          (GtkTextLine      *line);
static void recompute_node_counts (GtkTextBTree     *tree,
305
                                   GtkTextBTreeNode *node);
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
static void inc_count             (GtkTextTag       *tag,
                                   int               inc,
                                   TagInfo          *tagInfoPtr);

static void summary_destroy       (Summary          *summary);

static void gtk_text_btree_link_segment   (GtkTextLineSegment *seg,
                                           const GtkTextIter  *iter);
static void gtk_text_btree_unlink_segment (GtkTextBTree       *tree,
                                           GtkTextLineSegment *seg,
                                           GtkTextLine        *line);


static GtkTextTagInfo *gtk_text_btree_get_tag_info          (GtkTextBTree   *tree,
                                                             GtkTextTag     *tag);
static GtkTextTagInfo *gtk_text_btree_get_existing_tag_info (GtkTextBTree   *tree,
                                                             GtkTextTag     *tag);
static void            gtk_text_btree_remove_tag_info       (GtkTextBTree   *tree,
                                                             GtkTextTag     *tag);

Havoc Pennington's avatar
Havoc Pennington committed
326
327
328
static void redisplay_region (GtkTextBTree      *tree,
                              const GtkTextIter *start,
                              const GtkTextIter *end);
329
330
331
332

/* Inline thingies */

static inline void
333
segments_changed (GtkTextBTree *tree)
334
335
336
337
338
{
  tree->segments_changed_stamp += 1;
}

static inline void
339
chars_changed (GtkTextBTree *tree)
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
{
  tree->chars_changed_stamp += 1;
}

/*
 * BTree operations
 */

GtkTextBTree*
gtk_text_btree_new (GtkTextTagTable *table,
                    GtkTextBuffer *buffer)
{
  GtkTextBTree *tree;
  GtkTextBTreeNode *root_node;
  GtkTextLine *line, *line2;

356
357
358
  g_return_val_if_fail (GTK_IS_TEXT_TAG_TABLE (table), NULL);
  g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);

359
360
361
362
363
364
365
366
  /*
   * The tree will initially have two empty lines.  The second line
   * isn't actually part of the tree's contents, but its presence
   * makes several operations easier.  The tree will have one GtkTextBTreeNode,
   * which is also the root of the tree.
   */

  /* Create the root node. */
367
368
369
370
371

  root_node = gtk_text_btree_node_new ();

  line = gtk_text_line_new ();
  line2 = gtk_text_line_new ();
372
373
374
375
376
377
378
379
380

  root_node->parent = NULL;
  root_node->next = NULL;
  root_node->summary = NULL;
  root_node->level = 0;
  root_node->children.line = line;
  root_node->num_children = 2;
  root_node->num_lines = 2;
  root_node->num_chars = 2;
381

382
383
384
  line->parent = root_node;
  line->next = line2;

385
  line->segments = _gtk_char_segment_new ("\n", 1);
386
387
388

  line2->parent = root_node;
  line2->next = NULL;
389
  line2->segments = _gtk_char_segment_new ("\n", 1);
390
391

  /* Create the tree itself */
392

393
394
395
396
397
398
  tree = g_new0(GtkTextBTree, 1);
  tree->root_node = root_node;
  tree->table = table;
  tree->views = NULL;

  /* Set these to values that are unlikely to be found
399
400
401
402
403
   * in random memory garbage, and also avoid
   * duplicates between tree instances.
   */
  tree->chars_changed_stamp = g_random_int ();
  tree->segments_changed_stamp = g_random_int ();
404
405
406

  tree->end_iter_line_stamp = tree->chars_changed_stamp - 1;
  tree->end_iter_line = NULL;
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421

  gtk_object_ref (GTK_OBJECT (tree->table));
  gtk_object_sink (GTK_OBJECT (tree->table));

  tree->tag_changed_handler = gtk_signal_connect (GTK_OBJECT (tree->table),
                                                  "tag_changed",
                                                  GTK_SIGNAL_FUNC (tag_changed_cb),
                                                  tree);

  tree->tag_removed_handler = gtk_signal_connect (GTK_OBJECT (tree->table),
                                                  "tag_removed",
                                                  GTK_SIGNAL_FUNC (tag_removed_cb),
                                                  tree);

  tree->mark_table = g_hash_table_new (g_str_hash, g_str_equal);
422
423
  tree->child_anchor_table = NULL;
  
424
  /* We don't ref the buffer, since the buffer owns us;
425
426
427
   * we'd have some circularity issues. The buffer always
   * lasts longer than the BTree
   */
428
  tree->buffer = buffer;
429

430
431
  {
    GtkTextIter start;
Havoc Pennington's avatar
Havoc Pennington committed
432
    GtkTextLineSegment *seg;
433
434
435

    gtk_text_btree_get_iter_at_line_char (tree, &start, 0, 0);

436

Havoc Pennington's avatar
Havoc Pennington committed
437
438
439
440
441
442
443
444
    tree->insert_mark = gtk_text_btree_set_mark (tree,
                                                 NULL,
                                                 "insert",
                                                 FALSE,
                                                 &start,
                                                 FALSE);

    seg = tree->insert_mark->segment;
445

Havoc Pennington's avatar
Havoc Pennington committed
446
447
    seg->body.mark.not_deleteable = TRUE;
    seg->body.mark.visible = TRUE;
448

Havoc Pennington's avatar
Havoc Pennington committed
449
450
451
452
453
454
455
456
    tree->selection_bound_mark = gtk_text_btree_set_mark (tree,
                                                          NULL,
                                                          "selection_bound",
                                                          FALSE,
                                                          &start,
                                                          FALSE);

    seg = tree->selection_bound_mark->segment;
457

Havoc Pennington's avatar
Havoc Pennington committed
458
459
460
461
    seg->body.mark.not_deleteable = TRUE;

    g_object_ref (G_OBJECT (tree->insert_mark));
    g_object_ref (G_OBJECT (tree->selection_bound_mark));
462
463
464
  }

  tree->refcount = 1;
465

466
467
468
469
470
471
  return tree;
}

void
gtk_text_btree_ref (GtkTextBTree *tree)
{
472
473
474
  g_return_if_fail (tree != NULL);
  g_return_if_fail (tree->refcount > 0);

475
476
477
478
  tree->refcount += 1;
}

static void
479
mark_destroy_foreach (gpointer key, gpointer value, gpointer user_data)
480
{
Havoc Pennington's avatar
Havoc Pennington committed
481
482
483
  GtkTextLineSegment *seg = value;

  g_return_if_fail (seg->body.mark.tree == NULL);
484

Havoc Pennington's avatar
Havoc Pennington committed
485
  g_object_unref (G_OBJECT (seg->body.mark.obj));
486
487
488
489
490
}

void
gtk_text_btree_unref (GtkTextBTree *tree)
{
491
492
  g_return_if_fail (tree != NULL);
  g_return_if_fail (tree->refcount > 0);
493
494
495
496

  tree->refcount -= 1;

  if (tree->refcount == 0)
Havoc Pennington's avatar
Havoc Pennington committed
497
498
    {
      gtk_text_btree_node_destroy (tree, tree->root_node);
499

Havoc Pennington's avatar
Havoc Pennington committed
500
501
502
503
      g_hash_table_foreach (tree->mark_table,
                            mark_destroy_foreach,
                            NULL);
      g_hash_table_destroy (tree->mark_table);
504

Havoc Pennington's avatar
Havoc Pennington committed
505
506
      g_object_unref (G_OBJECT (tree->insert_mark));
      g_object_unref (G_OBJECT (tree->selection_bound_mark));
507

508
      gtk_signal_disconnect (GTK_OBJECT (tree->table),
Havoc Pennington's avatar
Havoc Pennington committed
509
                             tree->tag_changed_handler);
510

511
      gtk_signal_disconnect (GTK_OBJECT (tree->table),
Havoc Pennington's avatar
Havoc Pennington committed
512
                             tree->tag_removed_handler);
513
514

      gtk_object_unref (GTK_OBJECT (tree->table));
515

Havoc Pennington's avatar
Havoc Pennington committed
516
      g_free (tree);
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
    }
}

GtkTextBuffer*
gtk_text_btree_get_buffer (GtkTextBTree *tree)
{
  return tree->buffer;
}

guint
gtk_text_btree_get_chars_changed_stamp (GtkTextBTree *tree)
{
  return tree->chars_changed_stamp;
}

guint
gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree)
{
  return tree->segments_changed_stamp;
}

void
gtk_text_btree_segments_changed (GtkTextBTree *tree)
{
541
542
  g_return_if_fail (tree != NULL);
  segments_changed (tree);
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
}

/*
 * Indexable segment mutation
 */

void
gtk_text_btree_delete (GtkTextIter *start,
                       GtkTextIter *end)
{
  GtkTextLineSegment *prev_seg;             /* The segment just before the start
                                             * of the deletion range. */
  GtkTextLineSegment *last_seg;             /* The segment just after the end
                                             * of the deletion range. */
  GtkTextLineSegment *seg, *next;
  GtkTextLine *curline;
  GtkTextBTreeNode *curnode, *node;
  GtkTextBTree *tree;
  GtkTextLine *start_line;
  GtkTextLine *end_line;
563
  GtkTextLine *deleted_lines = NULL;        /* List of lines we've deleted */
564
  gint start_byte_offset;
565
566
567
568
569
570
571
572
573
574

  g_return_if_fail (start != NULL);
  g_return_if_fail (end != NULL);
  g_return_if_fail (gtk_text_iter_get_btree (start) ==
                    gtk_text_iter_get_btree (end));

  gtk_text_iter_reorder (start, end);

  tree = gtk_text_iter_get_btree (start);

575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
  {
    /*
     * The code below is ugly, but it's needed to make sure there
     * is always a dummy empty line at the end of the text.  If the
     * final newline of the file (just before the dummy line) is being
     * deleted, then back up index to just before the newline.  If
     * there is a newline just before the first character being deleted,
     * then back up the first index too, so that an even number of lines
     * gets deleted.  Furthermore, remove any tags that are present on
     * the newline that isn't going to be deleted after all (this simulates
     * deleting the newline and then adding a "clean" one back again).
     */

    gint line1;
    gint line2;
590
591
592
593
594

    line1 = gtk_text_iter_get_line (start);
    line2 = gtk_text_iter_get_line (end);

    if (line2 == gtk_text_btree_line_count (tree))
595
596
597
598
      {
        GtkTextTag** tags;
        int array_size;
        GtkTextIter orig_end;
599

600
        orig_end = *end;
601
602
        gtk_text_iter_prev_char (end);

603
604
        --line2;

605
        if (gtk_text_iter_get_line_offset (start) == 0 &&
606
607
            line1 != 0)
          {
608
            gtk_text_iter_prev_char (start);
609
610
            --line1;
          }
611
612
613
614

        tags = gtk_text_btree_get_tags (end,
                                        &array_size);

615
616
617
618
619
620
621
        if (tags != NULL)
          {
            int i;

            i = 0;
            while (i < array_size)
              {
622
623
                gtk_text_btree_tag (end, &orig_end, tags[i], FALSE);

624
625
626
                ++i;
              }

627
            g_free (tags);
628
629
630
          }
      }
  }
631

632
  /* Broadcast the need for redisplay before we break the iterators */
633
  gtk_text_btree_invalidate_region (tree, start, end);
634
635

  /* Save the byte offset so we can reset the iterators */
636
637
638
639
640
  start_byte_offset = gtk_text_iter_get_line_index (start);

  start_line = gtk_text_iter_get_text_line (start);
  end_line = gtk_text_iter_get_text_line (end);

641
642
643
644
645
646
647
648
649
  /*
   * Split the start and end segments, so we have a place
   * to insert our new text.
   *
   * Tricky point:  split at end first;  otherwise the split
   * at end may invalidate seg and/or prev_seg. This allows
   * us to avoid invalidating segments for start.
   */

650
  last_seg = gtk_text_line_segment_split (end);
651
652
653
654
655
  if (last_seg != NULL)
    last_seg = last_seg->next;
  else
    last_seg = end_line->segments;

656
  prev_seg = gtk_text_line_segment_split (start);
657
658
659
660
661
662
663
664
665
666
667
668
669
  if (prev_seg != NULL)
    {
      seg = prev_seg->next;
      prev_seg->next = last_seg;
    }
  else
    {
      seg = start_line->segments;
      start_line->segments = last_seg;
    }

  /* notify iterators that their segments need recomputation,
     just for robustness. */
670
671
  segments_changed (tree);

672
673
674
675
676
677
678
679
680
  /*
   * Delete all of the segments between prev_seg and last_seg.
   */

  curline = start_line;
  curnode = curline->parent;
  while (seg != last_seg)
    {
      gint char_count = 0;
681

682
683
684
685
686
687
688
689
690
691
      if (seg == NULL)
        {
          GtkTextLine *nextline;

          /*
           * We just ran off the end of a line.  First find the
           * next line, then go back to the old line and delete it
           * (unless it's the starting line for the range).
           */

692
          nextline = gtk_text_line_next (curline);
693
694
695
696
697
698
          if (curline != start_line)
            {
              if (curnode == start_line->parent)
                start_line->next = curline->next;
              else
                curnode->children.line = curline->next;
699

700
701
702
703
704
              for (node = curnode; node != NULL;
                   node = node->parent)
                {
                  node->num_lines -= 1;
                }
705

706
              curnode->num_children -= 1;
707
708
              curline->next = deleted_lines;
              deleted_lines = curline;
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
          curline = nextline;
          seg = curline->segments;

          /*
           * If the GtkTextBTreeNode is empty then delete it and its parents,
           * recursively upwards until a non-empty GtkTextBTreeNode is found.
           */

          while (curnode->num_children == 0)
            {
              GtkTextBTreeNode *parent;

              parent = curnode->parent;
              if (parent->children.node == curnode)
                {
                  parent->children.node = curnode->next;
                }
              else
                {
                  GtkTextBTreeNode *prevnode = parent->children.node;
                  while (prevnode->next != curnode)
                    {
                      prevnode = prevnode->next;
                    }
                  prevnode->next = curnode->next;
                }
              parent->num_children--;
738
              g_free (curnode);
739
740
741
742
743
744
745
746
              curnode = parent;
            }
          curnode = curline->parent;
          continue;
        }

      next = seg->next;
      char_count = seg->char_count;
747

748
749
750
751
752
753
      if ((*seg->type->deleteFunc)(seg, curline, 0) != 0)
        {
          /*
           * This segment refuses to die.  Move it to prev_seg and
           * advance prev_seg if the segment has left gravity.
           */
754

755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
          if (prev_seg == NULL)
            {
              seg->next = start_line->segments;
              start_line->segments = seg;
            }
          else
            {
              seg->next = prev_seg->next;
              prev_seg->next = seg;
            }
          if (seg->type->leftGravity)
            {
              prev_seg = seg;
            }
        }
      else
        {
          /* Segment is gone. Decrement the char count of the node and
             all its parents. */
          for (node = curnode; node != NULL;
               node = node->parent)
            {
              node->num_chars -= char_count;
            }
        }
780

781
782
783
784
785
786
787
788
789
790
791
792
      seg = next;
    }

  /*
   * If the beginning and end of the deletion range are in different
   * lines, join the two lines together and discard the ending line.
   */

  if (start_line != end_line)
    {
      BTreeView *view;
      GtkTextBTreeNode *ancestor_node;
793

794
795
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
      GtkTextLine *prevline;

      for (seg = last_seg; seg != NULL;
           seg = seg->next)
        {
          if (seg->type->lineChangeFunc != NULL)
            {
              (*seg->type->lineChangeFunc)(seg, end_line);
            }
        }
      curnode = end_line->parent;
      for (node = curnode; node != NULL;
           node = node->parent)
        {
          node->num_lines--;
        }
      curnode->num_children--;
      prevline = curnode->children.line;
      if (prevline == end_line)
        {
          curnode->children.line = end_line->next;
        }
      else
        {
          while (prevline->next != end_line)
            {
              prevline = prevline->next;
            }
          prevline->next = end_line->next;
        }
      end_line->next = deleted_lines;
      deleted_lines = end_line;

      /* We now fix up the per-view aggregates. We add all the height and
       * width for the deleted lines to the start line, so that when revalidation
       * occurs, the correct change in size is seen.
       */
      ancestor_node = gtk_text_btree_node_common_parent (curnode, start_line->parent);
      view = tree->views;
      while (view)
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
        {
          GtkTextLine *line;
          GtkTextLineData *ld;

          gint deleted_width = 0;
          gint deleted_height = 0;

          line = deleted_lines;
          while (line)
            {
              GtkTextLine *next_line = line->next;
              ld = gtk_text_line_get_data (line, view->view_id);

              if (ld)
                {
                  deleted_width = MAX (deleted_width, ld->width);
                  deleted_height += ld->height;
                }

              if (!view->next)
                gtk_text_line_destroy (tree, line);

              line = next_line;
            }

          if (deleted_width > 0 || deleted_height > 0)
            {
              ld = gtk_text_line_get_data (start_line, view->view_id);

              /* FIXME: ld is _NOT_ necessarily non-null here, but there is currently
               * no way to add ld without also validating the node, which would
               * be improper at this point.
               */
867
868
              /* This assertion does actually fail sometimes, must
                 fix before stable release -hp */
869
              g_assert (ld);
870

871
872
873
874
875
876
877
878
              ld->width = MAX (deleted_width, ld->width);
              ld->height += deleted_height;
              ld->valid = FALSE;
            }

          gtk_text_btree_node_check_valid_downward (ancestor_node, view->view_id);
          if (ancestor_node->parent)
            gtk_text_btree_node_check_valid_upward (ancestor_node->parent, view->view_id);
879

880
881
882
883
          view = view->next;
        }

      gtk_text_btree_rebalance (tree, curnode);
884
885
886
887
888
889
    }

  /*
   * Cleanup the segments in the new line.
   */

890
  cleanup_line (start_line);
891
892
893
894
895

  /*
   * Lastly, rebalance the first GtkTextBTreeNode of the range.
   */

896
897
  gtk_text_btree_rebalance (tree, start_line->parent);

898
899
  /* Notify outstanding iterators that they
     are now hosed */
900
901
  chars_changed (tree);
  segments_changed (tree);
902
903

  if (gtk_debug_flags & GTK_DEBUG_TEXT)
904
    gtk_text_btree_check (tree);
905
906

  /* Re-initialize our iterators */
907
  gtk_text_btree_get_iter_at_line (tree, start, start_line, start_byte_offset);
908
909
910
911
912
913
914
915
916
917
918
919
  *end = *start;
}

void
gtk_text_btree_insert (GtkTextIter *iter,
                       const gchar *text,
                       gint len)
{
  GtkTextLineSegment *prev_seg;     /* The segment just before the first
                                     * new segment (NULL means new segment
                                     * is at beginning of line). */
  GtkTextLineSegment *cur_seg;              /* Current segment;  new characters
920
                                             * are inserted just after this one.
921
922
923
924
925
926
                                             * NULL means insert at beginning of
                                             * line. */
  GtkTextLine *line;           /* Current line (new segments are
                                * added to this line). */
  GtkTextLineSegment *seg;
  GtkTextLine *newline;
Havoc Pennington's avatar
Havoc Pennington committed
927
928
929
930
931
932
  int chunk_len;                        /* # characters in current chunk. */
  gint sol;                           /* start of line */
  gint eol;                           /* Pointer to character just after last
                                       * one in current chunk.
                                       */
  gint delim;                          /* index of paragraph delimiter */
933
  int line_count_delta;                /* Counts change to total number of
Havoc Pennington's avatar
Havoc Pennington committed
934
935
                                        * lines in file.
                                        */
936
937
938
939
940

  int char_count_delta;                /* change to number of chars */
  GtkTextBTree *tree;
  gint start_byte_index;
  GtkTextLine *start_line;
941
942
943
944

  g_return_if_fail (text != NULL);
  g_return_if_fail (iter != NULL);

945
  if (len < 0)
946
    len = strlen (text);
947
948

  /* extract iterator info */
949
950
  tree = gtk_text_iter_get_btree (iter);
  line = gtk_text_iter_get_text_line (iter);
951
  start_line = line;
952
  start_byte_index = gtk_text_iter_get_line_index (iter);
953
954

  /* Get our insertion segment split */
955
  prev_seg = gtk_text_line_segment_split (iter);
956
957
958
  cur_seg = prev_seg;

  /* Invalidate all iterators */
959
960
961
  chars_changed (tree);
  segments_changed (tree);

962
963
964
965
966
967
968
969
970
971
972
973
  /*
   * Chop the text up into lines and create a new segment for
   * each line, plus a new line for the leftovers from the
   * previous line.
   */

  eol = 0;
  sol = 0;
  line_count_delta = 0;
  char_count_delta = 0;
  while (eol < len)
    {
Havoc Pennington's avatar
Havoc Pennington committed
974
975
976
977
      pango_find_paragraph_boundary (text + sol,
                                     len - sol,
                                     &delim,
                                     &eol);      
978

Havoc Pennington's avatar
Havoc Pennington committed
979
980
981
      chunk_len = eol - sol;

      seg = _gtk_char_segment_new (&text[sol], chunk_len);
982
983

      char_count_delta += seg->char_count;
984

985
986
987
988
989
990
991
992
993
994
995
      if (cur_seg == NULL)
        {
          seg->next = line->segments;
          line->segments = seg;
        }
      else
        {
          seg->next = cur_seg->next;
          cur_seg->next = seg;
        }

Havoc Pennington's avatar
Havoc Pennington committed
996
997
998
      if (delim == eol)
        /* chunk didn't end with a paragraph separator */
        break;
999
1000
1001
1002
1003
1004

      /*
       * The chunk ended with a newline, so create a new GtkTextLine
       * and move the remainder of the old line to it.
       */

1005
1006
      newline = gtk_text_line_new ();
      gtk_text_line_set_parent (newline, line->parent);
1007
1008
1009
1010
1011
1012
      newline->next = line->next;
      line->next = newline;
      newline->segments = seg->next;
      seg->next = NULL;
      line = newline;
      cur_seg = NULL;
1013
1014
      line_count_delta++;

1015
1016
1017
1018
1019
1020
1021
1022
      sol = eol;
    }

  /*
   * Cleanup the starting line for the insertion, plus the ending
   * line if it's different.
   */

1023
  cleanup_line (start_line);
1024
1025
  if (line != start_line)
    {
1026
      cleanup_line (line);
1027
1028
    }

1029
1030
  post_insert_fixup (tree, line, line_count_delta, char_count_delta);

1031
1032
1033
1034
1035
1036
1037
  /* Invalidate our region, and reset the iterator the user
     passed in to point to the end of the inserted text. */
  {
    GtkTextIter start;
    GtkTextIter end;


1038
1039
1040
1041
    gtk_text_btree_get_iter_at_line (tree,
                                     &start,
                                     start_line,
                                     start_byte_index);
1042
1043
1044
1045
1046
    end = start;

    /* We could almost certainly be more efficient here
       by saving the information from the insertion loop
       above. FIXME */
1047
    gtk_text_iter_forward_chars (&end, char_count_delta);
1048

1049
1050
    gtk_text_btree_invalidate_region (tree,
                                      &start, &end);
1051
1052
1053
1054
1055
1056
1057


    /* Convenience for the user */
    *iter = end;
  }
}

1058
1059
1060
1061
static void
insert_pixbuf_or_widget_segment (GtkTextIter        *iter,
                                 GtkTextLineSegment *seg)

1062
1063
1064
1065
1066
1067
{
  GtkTextIter start;
  GtkTextLineSegment *prevPtr;
  GtkTextLine *line;
  GtkTextBTree *tree;
  gint start_byte_offset;
1068
1069
1070
1071
1072
1073

  line = gtk_text_iter_get_text_line (iter);
  tree = gtk_text_iter_get_btree (iter);
  start_byte_offset = gtk_text_iter_get_line_index (iter);

  prevPtr = gtk_text_line_segment_split (iter);
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
  if (prevPtr == NULL)
    {
      seg->next = line->segments;
      line->segments = seg;
    }
  else
    {
      seg->next = prevPtr->next;
      prevPtr->next = seg;
    }

1085
  post_insert_fixup (tree, line, 0, seg->char_count);
1086

1087
1088
  chars_changed (tree);
  segments_changed (tree);
1089
1090

  /* reset *iter for the user, and invalidate tree nodes */
1091
1092

  gtk_text_btree_get_iter_at_line (tree, &start, line, start_byte_offset);
1093
1094

  *iter = start;
1095
  gtk_text_iter_next_char (iter); /* skip forward past the segment */
1096

1097
  gtk_text_btree_invalidate_region (tree, &start, iter);
1098
}
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
     
void
gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
                              GdkPixbuf   *pixbuf)
{
  GtkTextLineSegment *seg;
  
  seg = _gtk_pixbuf_segment_new (pixbuf);

  insert_pixbuf_or_widget_segment (iter, seg);
}

GtkTextChildAnchor*
gtk_text_btree_create_child_anchor (GtkTextIter *iter)
{
  GtkTextLineSegment *seg;
  GtkTextBTree *tree;
  
  seg = _gtk_widget_segment_new ();

1119
1120
  tree = seg->body.child.tree = gtk_text_iter_get_btree (iter);
  
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
  insert_pixbuf_or_widget_segment (iter, seg);

  if (tree->child_anchor_table == NULL)
    tree->child_anchor_table = g_hash_table_new (NULL, NULL);

  g_hash_table_insert (tree->child_anchor_table,
                       seg->body.child.obj,
                       seg->body.child.obj);
  
  return seg->body.child.obj;
}

void
gtk_text_btree_unregister_child_anchor (GtkTextChildAnchor *anchor)
{
  GtkTextLineSegment *seg;
1137

1138
1139
1140
1141
1142
  seg = anchor->segment;
  
  g_hash_table_remove (seg->body.child.tree->child_anchor_table,
                       anchor);
}
1143
1144
1145
1146
1147
1148

/*
 * View stuff
 */

static GtkTextLine*
1149
1150
1151
find_line_by_y (GtkTextBTree *tree, BTreeView *view,
                GtkTextBTreeNode *node, gint y, gint *line_top,
                GtkTextLine *last_line)
1152
1153
1154
1155
{
  gint current_y = 0;

  if (gtk_debug_flags & GTK_DEBUG_TEXT)
1156
1157
    gtk_text_btree_check (tree);

1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
  if (node->level == 0)
    {
      GtkTextLine *line;

      line = node->children.line;

      while (line != NULL && line != last_line)
        {
          GtkTextLineData *ld;

1168
          ld = gtk_text_line_get_data (line, view->view_id);
1169

1170
1171
1172
1173
1174
1175
1176
1177
          if (ld)
            {
              if (y < (current_y + (ld ? ld->height : 0)))
                return line;

              current_y += ld->height;
              *line_top += ld->height;
            }
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193

          line = line->next;
        }
      return NULL;
    }
  else
    {
      GtkTextBTreeNode *child;

      child = node->children.node;

      while (child != NULL)
        {
          gint width;
          gint height;

1194
1195
          gtk_text_btree_node_get_size (child, view->view_id,
                                        &width, &height);
1196

1197
1198
1199
1200
          if (y < (current_y + height))
            return find_line_by_y (tree, view, child,
                                   y - current_y, line_top,
                                   last_line);
1201
1202
1203

          current_y += height;
          *line_top += height;
1204

1205
1206
          child = child->next;
        }
1207

1208
1209
1210
1211
1212
1213
      return NULL;
    }
}

GtkTextLine *
gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
1214
1215
1216
                               gpointer      view_id,
                               gint          ypixel,
                               gint         *line_top_out)
1217
1218
1219
1220
1221
{
  GtkTextLine *line;
  BTreeView *view;
  GtkTextLine *last_line;
  gint line_top = 0;
1222

1223
1224
1225
1226
  view = gtk_text_btree_get_view (tree, view_id);
  g_return_val_if_fail (view != NULL, NULL);

  last_line = get_last_line (tree);
1227

1228
  line = find_line_by_y (tree, view, tree->root_node, ypixel, &line_top,
1229
                         last_line);
1230
1231
1232
1233
1234
1235
1236
1237

  if (line_top_out)
    *line_top_out = line_top;

  return line;
}

static gint
1238
1239
1240
1241
1242
find_line_top_in_line_list (GtkTextBTree *tree,
                            BTreeView *view,
                            GtkTextLine *line,
                            GtkTextLine *target_line,
                            gint y)
1243
1244
1245
1246
{
  while (line != NULL)
    {
      GtkTextLineData *ld;
1247

1248
      if (line == target_line)
1249
        return y;
1250
1251
1252

      ld = gtk_text_line_get_data (line, view->view_id);
      if (ld)
1253
1254
        y += ld->height;

1255
1256
      line = line->next;
    }
1257
1258
1259
1260

  g_assert_not_reached (); /* If we get here, our
                              target line didn't exist
                              under its parent node */
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
  return 0;
}

gint
gtk_text_btree_find_line_top (GtkTextBTree *tree,
                              GtkTextLine *target_line,
                              gpointer view_id)
{
  gint y = 0;
  BTreeView *view;
  GSList *nodes;
  GSList *iter;
  GtkTextBTreeNode *node;

1275
1276
1277
  view = gtk_text_btree_get_view (tree, view_id);

  g_return_val_if_fail (view != NULL, 0);
1278
1279
1280
1281
1282

  nodes = NULL;
  node = target_line->parent;
  while (node != NULL)
    {
1283
      nodes = g_slist_prepend (nodes, node);
1284
1285
1286
1287
1288
      node = node->parent;
    }

  iter = nodes;
  while (iter != NULL)
1289
    {
1290
      node = iter->data;
1291

1292
1293
      if (node->level == 0)
        {
1294
1295
1296
1297
          g_slist_free (nodes);
          return find_line_top_in_line_list (tree, view,
                                             node->children.line,
                                             target_line, y);
1298
1299
1300
1301
1302
1303
        }
      else
        {
          GtkTextBTreeNode *child;
          GtkTextBTreeNode *target_node;

1304
          g_assert (iter->next != NULL); /* not at level 0 */
1305
          target_node = iter->next->data;
1306

1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
          child = node->children.node;

          while (child != NULL)
            {
              gint width;
              gint height;

              if (child == target_node)
                break;
              else
                {
1318
1319
                  gtk_text_btree_node_get_size (child, view->view_id,
                                                &width, &height);
1320
1321
1322
1323
                  y += height;
                }
              child = child->next;
            }
1324
1325
          g_assert (child != NULL); /* should have broken out before we
                                       ran out of nodes */
1326
1327
        }

1328
      iter = g_slist_next (iter);
1329
1330
    }

1331
1332
  g_assert_not_reached (); /* we return when we find the target line */
  return 0;
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
}

void
gtk_text_btree_add_view (GtkTextBTree *tree,
                         GtkTextLayout *layout)
{
  BTreeView *view;
  GtkTextLine *last_line;
  GtkTextLineData *line_data;

1343
1344
1345
  g_return_if_fail (tree != NULL);

  view = g_new (BTreeView, 1);
1346
1347
1348

  view->view_id = layout;
  view->layout = layout;
1349

1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
  view->next = tree->views;
  view->prev = NULL;

  tree->views = view;

  /* The last line in the buffer has identity values for the per-view
   * data so that we can avoid special case checks for it in a large
   * number of loops
   */
  last_line = get_last_line (tree);
1360

1361
1362
1363
1364
1365
1366
  line_data = g_new (GtkTextLineData, 1);
  line_data->view_id = layout;
  line_data->next = NULL;
  line_data->width = 0;
  line_data->height = 0;
  line_data->valid = TRUE;
1367

1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
  gtk_text_line_add_data (last_line, line_data);
}

void
gtk_text_btree_remove_view (GtkTextBTree *tree,
                            gpointer view_id)
{
  BTreeView *view;
  GtkTextLine *last_line;
  GtkTextLineData *line_data;

1379
1380
  g_return_if_fail (tree != NULL);

1381
  view = tree->views;
1382

1383
1384
1385
1386
1387
1388
1389
  while (view != NULL)
    {
      if (view->view_id == view_id)
        break;

      view = view->next;
    }
1390
1391

  g_return_if_fail (view != NULL);
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407

  if (view->next)
    view->next->prev = view->prev;

  if (view->prev)
    view->prev->next = view->next;

  if (view == tree->views)
    tree->views = view->next;

  /* Remove the line data for the last line which we added ourselves.
   * (Do this first, so that we don't try to call the view's line data destructor on it.)
   */
  last_line = get_last_line (tree);
  line_data = gtk_text_line_remove_data (last_line, view_id);
  g_free (line_data);
1408
1409
1410
1411

  gtk_text_btree_node_remove_view (view, tree->root_node, view_id);

  g_free (view);
1412
1413
1414
1415
1416
1417
1418
1419
}

void
gtk_text_btree_invalidate_region (GtkTextBTree *tree,
                                  const GtkTextIter *start,
                                  const GtkTextIter *end)
{
  BTreeView *view;
1420

1421
1422
1423
1424
  view = tree->views;

  while (view != NULL)
    {
1425
      gtk_text_layout_invalidate (view->layout, start, end);
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436

      view = view->next;
    }
}

void
gtk_text_btree_get_view_size (GtkTextBTree *tree,
                              gpointer view_id,
                              gint *width,
                              gint *height)
{
1437
1438
1439
  g_return_if_fail (tree != NULL);
  g_return_if_fail (view_id != NULL);

Havoc Pennington's avatar
Havoc Pennington committed
1440
  gtk_text_btree_node_get_size (tree->root_node, view_id,
1441
                                width, height);
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
}

/*
 * Tag
 */

typedef struct {
  GtkTextIter *iters;
  guint count;
  guint alloced;
} IterStack;

static IterStack*
1455
iter_stack_new (void)
1456
1457
{
  IterStack *stack;
1458
  stack = g_new (IterStack, 1);
1459
1460
1461
1462
1463
1464
1465
  stack->iters = NULL;
  stack->count = 0;
  stack->alloced = 0;
  return stack;
}

static void
1466
iter_stack_push (IterStack *stack, const GtkTextIter *iter)
1467
1468
1469
1470
1471
{
  stack->count += 1;
  if (stack->count > stack->alloced)
    {
      stack->alloced = stack->count*2;
1472
1473
      stack->iters = g_realloc (stack->iters,
                                stack->alloced*sizeof (GtkTextIter));
1474
1475
1476
1477
1478
    }
  stack->iters[stack->count-1] = *iter;
}

static gboolean
1479
iter_stack_pop (IterStack *stack, GtkTextIter *iter)
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
{
  if (stack->count == 0)
    return FALSE;
  else
    {
      stack->count -= 1;
      *iter = stack->iters[stack->count];
      return TRUE;
    }
}

static void
1492
iter_stack_free (IterStack *stack)
1493
{
1494
1495
  g_free (stack->iters);
  g_free (stack);
1496
1497
1498
}

static void
1499
iter_stack_invert (IterStack *stack)
1500
1501
1502
1503
1504
1505
1506
1507
{
  if (stack->count > 0)
    {
      guint i = 0;
      guint j = stack->count - 1;
      while (i < j)
        {
          GtkTextIter tmp;
1508

1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
          tmp = stack->iters[i];
          stack->iters[i] = stack->iters[j];
          stack->iters[j] = tmp;

          ++i;
          --j;
        }
    }
}

Havoc Pennington's avatar
Havoc Pennington committed
1519
1520
1521
1522
1523
1524
1525
1526
1527
static void
queue_tag_redisplay (GtkTextBTree      *tree,
                     GtkTextTag        *tag,
                     const GtkTextIter *start,
                     const GtkTextIter *end)
{
  if (gtk_text_tag_affects_size (tag))
    {
      gtk_text_btree_invalidate_region (tree, start, end);
1528

Havoc Pennington's avatar
Havoc Pennington committed
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
    }
  else if (gtk_text_tag_affects_nonsize_appearance (tag))
    {
      /* We only need to queue a redraw, not a relayout */
      redisplay_region (tree, start, end);
    }

  /* We don't need to do anything if the tag doesn't affect display */
}

1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
void
gtk_text_btree_tag (const GtkTextIter *start_orig,
                    const GtkTextIter *end_orig,
                    GtkTextTag *tag,
                    gboolean add)
{
  GtkTextLineSegment *seg, *prev;
  GtkTextLine *cleanupline;
  gboolean toggled_on;
  GtkTextLine *start_line;
  GtkTextLine *end_line;
  GtkTextIter iter;
  GtkTextIter start, end;
1552
  GtkTextBTree *tree;
1553
1554
  IterStack *stack;
  GtkTextTagInfo *info;
1555
1556
1557
1558
1559
1560

  g_return_if_fail (start_orig != NULL);
  g_return_if_fail (end_orig != NULL);
  g_return_if_fail (GTK_IS_TEXT_TAG (tag));
  g_return_if_fail (gtk_text_iter_get_btree (start_orig) ==
                    gtk_text_iter_get_btree (end_orig));
1561
1562

#if 0