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
927
928
929
930
931
932
933
934
935
936
937
                                             * NULL means insert at beginning of
                                             * line. */
  GtkTextLine *line;           /* Current line (new segments are
                                * added to this line). */
  GtkTextLineSegment *seg;
  GtkTextLine *newline;
  int chunkSize;                        /* # characters in current chunk. */
  guint sol; /* start of line */
  guint eol;                      /* Pointer to character just after last
                                   * one in current chunk. */
  int line_count_delta;                /* Counts change to total number of
                                        * lines in file. */

  int char_count_delta;                /* change to number of chars */
  GtkTextBTree *tree;
  gint start_byte_index;
  GtkTextLine *start_line;
938
939
940
941

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

942
  if (len < 0)
943
    len = strlen (text);
944
945

  /* extract iterator info */
946
947
  tree = gtk_text_iter_get_btree (iter);
  line = gtk_text_iter_get_text_line (iter);
948
  start_line = line;
949
  start_byte_index = gtk_text_iter_get_line_index (iter);
950
951

  /* Get our insertion segment split */
952
  prev_seg = gtk_text_line_segment_split (iter);
953
954
955
  cur_seg = prev_seg;

  /* Invalidate all iterators */
956
957
958
  chars_changed (tree);
  segments_changed (tree);

959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
  /*
   * 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)
    {
      for (; eol < len; eol++)
        {
          if (text[eol] == '\n')
            {
              eol++;
              break;
            }
        }
      chunkSize = eol - sol;

Havoc Pennington's avatar
Havoc Pennington committed
981
      seg = _gtk_char_segment_new (&text[sol], chunkSize);
982
983

      char_count_delta += seg->char_count;
984

985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
      if (cur_seg == NULL)
        {
          seg->next = line->segments;
          line->segments = seg;
        }
      else
        {
          seg->next = cur_seg->next;
          cur_seg->next = seg;
        }

      if (text[eol-1] != '\n')
        {
          break;
        }

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

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

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

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

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

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

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


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

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

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


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

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

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

  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);
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
  if (prevPtr == NULL)
    {
      seg->next = line->segments;
      line->segments = seg;
    }
  else
    {
      seg->next = prevPtr->next;
      prevPtr->next = seg;
    }

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

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

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

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

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

1098
  gtk_text_btree_invalidate_region (tree, &start, iter);
1099
}
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
     
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 ();

  insert_pixbuf_or_widget_segment (iter, seg);

  tree = seg->body.child.tree;

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

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

/*
 * View stuff
 */

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

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

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

      line = node->children.line;

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

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

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

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

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

      child = node->children.node;

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

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

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

          current_y += height;
          *line_top += height;
1205

1206
1207
          child = child->next;
        }
1208

1209
1210
1211
1212
1213
1214
      return NULL;
    }
}

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

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

  last_line = get_last_line (tree);
1228

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

  if (line_top_out)
    *line_top_out = line_top;

  return line;
}

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

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

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

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

  g_assert_not_reached (); /* If we get here, our
                              target line didn't exist
                              under its parent node */
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
  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;

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

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

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

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

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

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

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

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

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

1329
      iter = g_slist_next (iter);
1330
1331
    }

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

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

1344
1345
1346
  g_return_if_fail (tree != NULL);

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

  view->view_id = layout;
  view->layout = layout;
1350

1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
  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);
1361

1362
1363
1364
1365
1366
1367
  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;
1368

1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
  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;

1380
1381
  g_return_if_fail (tree != NULL);

1382
  view = tree->views;
1383

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

      view = view->next;
    }
1391
1392

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

  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);
1409
1410
1411
1412

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

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

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

1422
1423
1424
1425
  view = tree->views;

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

      view = view->next;
    }
}

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

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

/*
 * Tag
 */

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

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

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

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

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

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

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

          ++i;
          --j;
        }
    }
}

Havoc Pennington's avatar
Havoc Pennington committed
1520
1521
1522
1523
1524
1525
1526
1527
1528
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);
1529

Havoc Pennington's avatar
Havoc Pennington committed
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
    }
  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 */
}

1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
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;
1553
  GtkTextBTree *tree;
1554
1555
  IterStack *stack;
  GtkTextTagInfo *info;
1556
1557
1558
1559
1560
1561

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

#if 0
1564
1565
1566
1567
1568
  printf ("%s tag %s from %d to %d\n",
          add ? "Adding" : "Removing",
          tag->name,
          gtk_text_buffer_get_offset (start_orig),
          gtk_text_buffer_get_offset (end_orig));
1569
#endif
1570
1571

  if (gtk_text_iter_equal (start_orig, end_orig))
1572
    return;
1573

1574
1575
  start = *start_orig;
  end = *end_orig;
1576
1577
1578
1579

  gtk_text_iter_reorder (&start, &end);

  tree = gtk_text_iter_get_btree (&start);