gtktextchild.c 13.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
/* gtktextchild.c - child pixmaps and widgets
 *
 * Copyright (c) 1994 The Regents of the University of California.
 * Copyright (c) 1994-1997 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.
12
 *
13
14
15
16
17
18
19
20
21
 * 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.
22
 *
23
24
25
26
27
 * 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.
28
 *
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 * 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.
47
 *
48
49
50
51
 */

#include "gtktextchild.h"
#include "gtktextbtree.h"
52
#include "gtktextlayout.h"
53
54

static GtkTextLineSegment *
Havoc Pennington's avatar
Havoc Pennington committed
55
56
pixbuf_segment_cleanup_func (GtkTextLineSegment *seg,
                             GtkTextLine        *line)
57
58
59
60
61
62
{
  /* nothing */
  return seg;
}

static int
63
64
65
pixbuf_segment_delete_func (GtkTextLineSegment *seg,
                            GtkTextLine        *line,
                            gboolean            tree_gone)
66
{
Havoc Pennington's avatar
Havoc Pennington committed
67
  if (seg->body.pixbuf.pixbuf)
68
    g_object_unref (G_OBJECT (seg->body.pixbuf.pixbuf));
69

70
  g_free (seg);
71
72
73
74
75

  return 0;
}

static void
76
77
pixbuf_segment_check_func (GtkTextLineSegment *seg,
                           GtkTextLine        *line)
78
79
{
  if (seg->next == NULL)
80
    g_error ("pixbuf segment is the last segment in a line");
81
82

  if (seg->byte_count != 3)
83
84
    g_error ("pixbuf segment has byte count of %d", seg->byte_count);

85
  if (seg->char_count != 1)
86
    g_error ("pixbuf segment has char count of %d", seg->char_count);
87
88
89
}


Havoc Pennington's avatar
Havoc Pennington committed
90
91
GtkTextLineSegmentClass gtk_text_pixbuf_type = {
  "pixbuf",                          /* name */
92
  FALSE,                                            /* leftGravity */
93
  NULL,                                          /* splitFunc */
Havoc Pennington's avatar
Havoc Pennington committed
94
95
  pixbuf_segment_delete_func,                             /* deleteFunc */
  pixbuf_segment_cleanup_func,                            /* cleanupFunc */
96
  NULL,                                                    /* lineChangeFunc */
Havoc Pennington's avatar
Havoc Pennington committed
97
  pixbuf_segment_check_func                               /* checkFunc */
98
99
100

};

101
102
#define PIXBUF_SEG_SIZE ((unsigned) (G_STRUCT_OFFSET (GtkTextLineSegment, body) \
        + sizeof (GtkTextPixbuf)))
103
104

GtkTextLineSegment *
Havoc Pennington's avatar
Havoc Pennington committed
105
_gtk_pixbuf_segment_new (GdkPixbuf *pixbuf)
106
107
108
{
  GtkTextLineSegment *seg;

109
  seg = g_malloc (PIXBUF_SEG_SIZE);
110

Havoc Pennington's avatar
Havoc Pennington committed
111
  seg->type = &gtk_text_pixbuf_type;
112
113
114

  seg->next = NULL;

Havoc Pennington's avatar
Havoc Pennington committed
115
116
117
  seg->byte_count = 3; /* We convert to the 0xFFFC "unknown character",
                        * a 3-byte sequence in UTF-8
                        */
118
  seg->char_count = 1;
119

Havoc Pennington's avatar
Havoc Pennington committed
120
  seg->body.pixbuf.pixbuf = pixbuf;
121

Havoc Pennington's avatar
Havoc Pennington committed
122
  g_object_ref (G_OBJECT (pixbuf));
123

124
125
  return seg;
}
126
127
128
129
130
131
132


static GtkTextLineSegment *
child_segment_cleanup_func (GtkTextLineSegment *seg,
                            GtkTextLine        *line)
{
  seg->body.child.line = line;
133

134
135
136
137
138
139
140
141
  return seg;
}

static int
child_segment_delete_func (GtkTextLineSegment *seg,
                           GtkTextLine       *line,
                           gboolean           tree_gone)
{
142
143
  GSList *tmp_list;
  GSList *copy;
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
  gtk_text_btree_unregister_child_anchor (seg->body.child.obj);
  
  seg->body.child.tree = NULL;
  seg->body.child.line = NULL;

  /* avoid removing widgets while walking the list */
  copy = g_slist_copy (seg->body.child.widgets);
  tmp_list = copy;
  while (tmp_list != NULL)
    {
      GtkWidget *child = tmp_list->data;

      gtk_widget_destroy (child);
      
      tmp_list = g_slist_next (tmp_list);
    }

  /* On removal from the widget's parents (GtkTextView),
   * the widget should have been removed from the anchor.
   */
  g_assert (seg->body.child.widgets == NULL);

  g_slist_free (copy);
  
  _gtk_widget_segment_unref (seg);  
  
171
172
173
174
175
176
177
178
  return 0;
}

static void
child_segment_check_func (GtkTextLineSegment *seg,
                          GtkTextLine        *line)
{
  if (seg->next == NULL)
179
    g_error ("child segment is the last segment in a line");
180
181

  if (seg->byte_count != 3)
182
183
    g_error ("child segment has byte count of %d", seg->byte_count);

184
  if (seg->char_count != 1)
185
    g_error ("child segment has char count of %d", seg->char_count);
186
187
188
189
190
191
192
193
194
195
196
197
198
}

GtkTextLineSegmentClass gtk_text_child_type = {
  "child-widget",                                        /* name */
  FALSE,                                                 /* leftGravity */
  NULL,                                                  /* splitFunc */
  child_segment_delete_func,                             /* deleteFunc */
  child_segment_cleanup_func,                            /* cleanupFunc */
  NULL,                                                  /* lineChangeFunc */
  child_segment_check_func                               /* checkFunc */
};

#define WIDGET_SEG_SIZE ((unsigned) (G_STRUCT_OFFSET (GtkTextLineSegment, body) \
199
        + sizeof (GtkTextChildBody)))
200
201

GtkTextLineSegment *
Havoc Pennington's avatar
Havoc Pennington committed
202
_gtk_widget_segment_new (void)
203
204
205
206
207
208
209
210
211
{
  GtkTextLineSegment *seg;

  seg = g_malloc (WIDGET_SEG_SIZE);

  seg->type = &gtk_text_child_type;

  seg->next = NULL;

Havoc Pennington's avatar
Havoc Pennington committed
212
  seg->byte_count = 3; /* We convert to the 0xFFFC "unknown character",
213
214
215
                        * a 3-byte sequence in UTF-8
                        */
  seg->char_count = 1;
216

217
218
  seg->body.child.obj = g_object_new (GTK_TYPE_TEXT_CHILD_ANCHOR, NULL);
  seg->body.child.obj->segment = seg;
219
220
221
  seg->body.child.widgets = NULL;
  seg->body.child.tree = NULL;
  seg->body.child.line = NULL;
222

223
224
225
226
  return seg;
}

void
Havoc Pennington's avatar
Havoc Pennington committed
227
_gtk_widget_segment_add    (GtkTextLineSegment *widget_segment,
228
                            GtkWidget          *child)
229
{
230
231
  g_return_if_fail (widget_segment->type = &gtk_text_child_type);
  g_return_if_fail (widget_segment->body.child.tree != NULL);
232

233
234
  g_object_ref (G_OBJECT (child));
  
235
236
237
238
239
240
  widget_segment->body.child.widgets =
    g_slist_prepend (widget_segment->body.child.widgets,
                     child);
}

void
Havoc Pennington's avatar
Havoc Pennington committed
241
_gtk_widget_segment_remove (GtkTextLineSegment *widget_segment,
242
                            GtkWidget          *child)
243
{
244
245
  g_return_if_fail (widget_segment->type = &gtk_text_child_type);
  
246
247
248
249
250
251
252
253
  widget_segment->body.child.widgets =
    g_slist_remove (widget_segment->body.child.widgets,
                    child);

  g_object_unref (G_OBJECT (child));
}

void
Havoc Pennington's avatar
Havoc Pennington committed
254
_gtk_widget_segment_ref (GtkTextLineSegment *widget_segment)
255
256
257
{
  g_assert (widget_segment->type = &gtk_text_child_type);

258
  g_object_ref (G_OBJECT (widget_segment->body.child.obj));
259
260
261
}

void
Havoc Pennington's avatar
Havoc Pennington committed
262
_gtk_widget_segment_unref (GtkTextLineSegment *widget_segment)
263
264
265
{
  g_assert (widget_segment->type = &gtk_text_child_type);

266
267
  g_object_unref (G_OBJECT (widget_segment->body.child.obj));
}
268

269
270
271
272
273
GtkTextLayout*
_gtk_anchored_child_get_layout (GtkWidget *child)
{
  return gtk_object_get_data (GTK_OBJECT (child), "gtk-text-child-anchor-layout");  
}
274

275
276
277
278
279
280
281
282
283
284
285
286
static void
_gtk_anchored_child_set_layout (GtkWidget     *child,
                                GtkTextLayout *layout)
{
  gtk_object_set_data (GTK_OBJECT (child),
                       "gtk-text-child-anchor-layout",
                       layout);  
}
     
static void gtk_text_child_anchor_init       (GtkTextChildAnchor      *child_anchor);
static void gtk_text_child_anchor_class_init (GtkTextChildAnchorClass *klass);
static void gtk_text_child_anchor_finalize   (GObject                 *obj);
287

288
static gpointer parent_class = NULL;
289

290
291
292
293
GType
gtk_text_child_anchor_get_type (void)
{
  static GType object_type = 0;
294

295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
  if (!object_type)
    {
      static const GTypeInfo object_info =
      {
        sizeof (GtkTextChildAnchorClass),
        (GBaseInitFunc) NULL,
        (GBaseFinalizeFunc) NULL,
        (GClassInitFunc) gtk_text_child_anchor_class_init,
        NULL,           /* class_finalize */
        NULL,           /* class_data */
        sizeof (GtkTextChildAnchor),
        0,              /* n_preallocs */
        (GInstanceInitFunc) gtk_text_child_anchor_init,
      };

      object_type = g_type_register_static (G_TYPE_OBJECT,
                                            "GtkTextChildAnchor",
                                            &object_info, 0);
313
    }
314
315

  return object_type;
316
317
}

318
319
static void
gtk_text_child_anchor_init (GtkTextChildAnchor *child_anchor)
320
{
321
322
  child_anchor->segment = NULL;
}
323

324
325
326
327
static void
gtk_text_child_anchor_class_init (GtkTextChildAnchorClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
328

329
330
331
  parent_class = g_type_class_peek_parent (klass);

  object_class->finalize = gtk_text_child_anchor_finalize;
332
333
}

334
335
static void
gtk_text_child_anchor_finalize (GObject *obj)
336
{
337
338
339
340
341
  GtkTextChildAnchor *anchor;
  GSList *tmp_list;
  GtkTextLineSegment *seg;
  
  anchor = GTK_TEXT_CHILD_ANCHOR (obj);
342

343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
  seg = anchor->segment;
  
  if (seg->body.child.tree != NULL)
    {
      g_warning ("Someone removed a reference to a GtkTextChildAnchor "
                 "they didn't own; the anchor is still in the text buffer "
                 "and the refcount is 0.");
      return;
    }
      
  tmp_list = seg->body.child.widgets;
  while (tmp_list)
    {
      g_object_unref (G_OBJECT (tmp_list->data));
      
      tmp_list = g_slist_next (tmp_list);
    }
  
  g_slist_free (seg->body.child.widgets);
  
  g_free (seg);
364

365
  anchor->segment = NULL;
366
367
368
369
370
}

GList*
gtk_text_child_anchor_get_widgets (GtkTextChildAnchor *anchor)
{
371
  GtkTextLineSegment *seg = anchor->segment;
372
373
  GList *list = NULL;
  GSList *iter;
374

375
  g_return_val_if_fail (seg->type = &gtk_text_child_type, NULL);
376

377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
  iter = seg->body.child.widgets;
  while (iter != NULL)
    {
      list = g_list_prepend (list, iter->data);

      iter = g_slist_next (iter);
    }

  /* Order is not relevant, so we don't need to reverse the list
   * again.
   */
  return list;
}

gboolean
gtk_text_child_anchor_get_deleted (GtkTextChildAnchor *anchor)
{
394
  GtkTextLineSegment *seg = anchor->segment;
395

396
397
398
399
400
  g_return_val_if_fail (seg->type = &gtk_text_child_type, TRUE);

  return seg->body.child.tree == NULL;
}

401
402
403
404
405
406
407
void
gtk_text_child_anchor_register_child (GtkTextChildAnchor *anchor,
                                      GtkWidget          *child,
                                      GtkTextLayout      *layout)
{
  g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
  g_return_if_fail (GTK_IS_WIDGET (child));
408

409
410
411
412
413
414
415
416
417
418
419
420
421
  _gtk_anchored_child_set_layout (child, layout);
  
  _gtk_widget_segment_add (anchor->segment, child);

  gtk_text_child_anchor_queue_resize (anchor, layout);
}

void
gtk_text_child_anchor_unregister_child (GtkTextChildAnchor *anchor,
                                        GtkWidget          *child)
{
  g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
  g_return_if_fail (GTK_IS_WIDGET (child));
422
423
424
425
426
427

  if (_gtk_anchored_child_get_layout (child))
    {
      gtk_text_child_anchor_queue_resize (anchor,
                                          _gtk_anchored_child_get_layout (child));
    }
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
  
  _gtk_anchored_child_set_layout (child, NULL);
  
  _gtk_widget_segment_remove (anchor->segment, child);
}

void
gtk_text_child_anchor_queue_resize (GtkTextChildAnchor *anchor,
                                    GtkTextLayout      *layout)
{
  GtkTextIter start;
  GtkTextIter end;
  GtkTextLineSegment *seg;
  
  g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
443
444
  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
  
445
446
  seg = anchor->segment;

447
  if (seg->body.child.tree == NULL)
448
    return;
449
450
451
452
  
  gtk_text_buffer_get_iter_at_child_anchor (layout->buffer,
                                            &start, anchor);
  end = start;
453
  gtk_text_iter_forward_char (&end);
454
455
456
  
  gtk_text_layout_invalidate (layout, &start, &end);
}
457

458
459
460
461
462
463
464
465
466
467
468
void
gtk_text_anchored_child_set_layout (GtkWidget     *child,
                                    GtkTextLayout *layout)
{
  g_return_if_fail (GTK_IS_WIDGET (child));
  g_return_if_fail (layout == NULL || GTK_IS_TEXT_LAYOUT (layout));
  
  _gtk_anchored_child_set_layout (child, layout);
}