gtktextchild.c 16.1 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
#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
51
#include <config.h>
52
#include "gtkalias.h"
53 54
#include "gtktextchild.h"
#include "gtktextbtree.h"
55
#include "gtktextlayout.h"
56

57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
#define CHECK_IN_BUFFER(anchor)                                                            \
  G_STMT_START {                                                                           \
    if ((anchor)->segment == NULL)                                                         \
      {                                                                                    \
        g_warning ("%s: GtkTextChildAnchor hasn't been in a buffer yet", G_GNUC_FUNCTION); \
      }                                                                                    \
  } G_STMT_END

#define CHECK_IN_BUFFER_RETURN(anchor, val)                                                \
  G_STMT_START {                                                                           \
    if ((anchor)->segment == NULL)                                                         \
      {                                                                                    \
        g_warning ("%s: GtkTextChildAnchor hasn't been in a buffer yet", G_GNUC_FUNCTION); \
        return (val);                                                                      \
      }                                                                                    \
  } G_STMT_END
73

74
static GtkTextLineSegment *
Havoc Pennington's avatar
Havoc Pennington committed
75 76
pixbuf_segment_cleanup_func (GtkTextLineSegment *seg,
                             GtkTextLine        *line)
77 78 79 80 81 82
{
  /* nothing */
  return seg;
}

static int
83 84 85
pixbuf_segment_delete_func (GtkTextLineSegment *seg,
                            GtkTextLine        *line,
                            gboolean            tree_gone)
86
{
Havoc Pennington's avatar
Havoc Pennington committed
87
  if (seg->body.pixbuf.pixbuf)
Manish Singh's avatar
Manish Singh committed
88
    g_object_unref (seg->body.pixbuf.pixbuf);
89

90
  g_free (seg);
91 92 93 94 95

  return 0;
}

static void
96 97
pixbuf_segment_check_func (GtkTextLineSegment *seg,
                           GtkTextLine        *line)
98 99
{
  if (seg->next == NULL)
100
    g_error ("pixbuf segment is the last segment in a line");
101 102

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

105
  if (seg->char_count != 1)
106
    g_error ("pixbuf segment has char count of %d", seg->char_count);
107 108 109
}


Havoc Pennington's avatar
Havoc Pennington committed
110 111
GtkTextLineSegmentClass gtk_text_pixbuf_type = {
  "pixbuf",                          /* name */
112
  FALSE,                                            /* leftGravity */
113
  NULL,                                          /* splitFunc */
Havoc Pennington's avatar
Havoc Pennington committed
114 115
  pixbuf_segment_delete_func,                             /* deleteFunc */
  pixbuf_segment_cleanup_func,                            /* cleanupFunc */
116
  NULL,                                                    /* lineChangeFunc */
Havoc Pennington's avatar
Havoc Pennington committed
117
  pixbuf_segment_check_func                               /* checkFunc */
118 119 120

};

121 122
#define PIXBUF_SEG_SIZE ((unsigned) (G_STRUCT_OFFSET (GtkTextLineSegment, body) \
        + sizeof (GtkTextPixbuf)))
123 124

GtkTextLineSegment *
Havoc Pennington's avatar
Havoc Pennington committed
125
_gtk_pixbuf_segment_new (GdkPixbuf *pixbuf)
126 127 128
{
  GtkTextLineSegment *seg;

129
  seg = g_malloc (PIXBUF_SEG_SIZE);
130

Havoc Pennington's avatar
Havoc Pennington committed
131
  seg->type = &gtk_text_pixbuf_type;
132 133 134

  seg->next = NULL;

135 136 137
  seg->byte_count = 3; /* We convert to the 0xFFFC "unknown character",
                        * a 3-byte sequence in UTF-8
                        */
138
  seg->char_count = 1;
139

Havoc Pennington's avatar
Havoc Pennington committed
140
  seg->body.pixbuf.pixbuf = pixbuf;
141

Manish Singh's avatar
Manish Singh committed
142
  g_object_ref (pixbuf);
143

144 145
  return seg;
}
146 147 148 149 150 151 152


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

154 155 156 157 158 159 160 161
  return seg;
}

static int
child_segment_delete_func (GtkTextLineSegment *seg,
                           GtkTextLine       *line,
                           gboolean           tree_gone)
{
162 163
  GSList *tmp_list;
  GSList *copy;
164

165
  _gtk_text_btree_unregister_child_anchor (seg->body.child.obj);
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
  
  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);  
  
191 192 193 194 195 196 197 198
  return 0;
}

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

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

204
  if (seg->char_count != 1)
205
    g_error ("child segment has char count of %d", seg->char_count);
206 207 208 209 210 211 212 213 214 215 216 217 218
}

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) \
219
        + sizeof (GtkTextChildBody)))
220 221

GtkTextLineSegment *
222
_gtk_widget_segment_new (GtkTextChildAnchor *anchor)
223 224 225 226 227 228 229 230 231
{
  GtkTextLineSegment *seg;

  seg = g_malloc (WIDGET_SEG_SIZE);

  seg->type = &gtk_text_child_type;

  seg->next = NULL;

232
  seg->byte_count = 3; /* We convert to the 0xFFFC "unknown character",
233 234 235
                        * a 3-byte sequence in UTF-8
                        */
  seg->char_count = 1;
236

237
  seg->body.child.obj = anchor;
238
  seg->body.child.obj->segment = seg;
239 240 241
  seg->body.child.widgets = NULL;
  seg->body.child.tree = NULL;
  seg->body.child.line = NULL;
242

Manish Singh's avatar
Manish Singh committed
243
  g_object_ref (anchor);
244
  
245 246 247 248
  return seg;
}

void
Havoc Pennington's avatar
Havoc Pennington committed
249
_gtk_widget_segment_add    (GtkTextLineSegment *widget_segment,
250
                            GtkWidget          *child)
251
{
252
  g_return_if_fail (widget_segment->type == &gtk_text_child_type);
253
  g_return_if_fail (widget_segment->body.child.tree != NULL);
254

Manish Singh's avatar
Manish Singh committed
255
  g_object_ref (child);
256
  
257 258 259 260 261 262
  widget_segment->body.child.widgets =
    g_slist_prepend (widget_segment->body.child.widgets,
                     child);
}

void
Havoc Pennington's avatar
Havoc Pennington committed
263
_gtk_widget_segment_remove (GtkTextLineSegment *widget_segment,
264
                            GtkWidget          *child)
265
{
266
  g_return_if_fail (widget_segment->type == &gtk_text_child_type);
267
  
268 269 270 271
  widget_segment->body.child.widgets =
    g_slist_remove (widget_segment->body.child.widgets,
                    child);

Manish Singh's avatar
Manish Singh committed
272
  g_object_unref (child);
273 274 275
}

void
Havoc Pennington's avatar
Havoc Pennington committed
276
_gtk_widget_segment_ref (GtkTextLineSegment *widget_segment)
277
{
278
  g_assert (widget_segment->type == &gtk_text_child_type);
279

Manish Singh's avatar
Manish Singh committed
280
  g_object_ref (widget_segment->body.child.obj);
281 282 283
}

void
Havoc Pennington's avatar
Havoc Pennington committed
284
_gtk_widget_segment_unref (GtkTextLineSegment *widget_segment)
285
{
286
  g_assert (widget_segment->type == &gtk_text_child_type);
287

Manish Singh's avatar
Manish Singh committed
288
  g_object_unref (widget_segment->body.child.obj);
289
}
290

291 292 293
GtkTextLayout*
_gtk_anchored_child_get_layout (GtkWidget *child)
{
294
  return g_object_get_data (G_OBJECT (child), "gtk-text-child-anchor-layout");  
295
}
296

297 298 299 300
static void
_gtk_anchored_child_set_layout (GtkWidget     *child,
                                GtkTextLayout *layout)
{
301 302 303
  g_object_set_data (G_OBJECT (child),
                     "gtk-text-child-anchor-layout",
                     layout);  
304 305 306 307 308
}
     
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);
309

310
static gpointer parent_class = NULL;
311

312 313 314 315
GType
gtk_text_child_anchor_get_type (void)
{
  static GType object_type = 0;
316

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
  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,
      };

Manish Singh's avatar
Manish Singh committed
332
      object_type = g_type_register_static (G_TYPE_OBJECT, "GtkTextChildAnchor",
333
                                            &object_info, 0);
334
    }
335 336

  return object_type;
337 338
}

339 340
static void
gtk_text_child_anchor_init (GtkTextChildAnchor *child_anchor)
341
{
342 343
  child_anchor->segment = NULL;
}
344

345 346 347 348
static void
gtk_text_child_anchor_class_init (GtkTextChildAnchorClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
349

350 351 352
  parent_class = g_type_class_peek_parent (klass);

  object_class->finalize = gtk_text_child_anchor_finalize;
353 354
}

355 356 357 358 359 360 361 362 363 364
/**
 * gtk_text_child_anchor_new:
 * 
 * Creates a new #GtkTextChildAnchor. Usually you would then insert
 * it into a #GtkTextBuffer with gtk_text_buffer_insert_child_anchor().
 * To perform the creation and insertion in one step, use the
 * convenience function gtk_text_buffer_create_child_anchor().
 * 
 * Return value: a new #GtkTextChildAnchor
 **/
365 366 367
GtkTextChildAnchor*
gtk_text_child_anchor_new (void)
{
Manish Singh's avatar
Manish Singh committed
368
  return g_object_new (GTK_TYPE_TEXT_CHILD_ANCHOR, NULL);
369 370
}

371 372
static void
gtk_text_child_anchor_finalize (GObject *obj)
373
{
374 375 376 377 378
  GtkTextChildAnchor *anchor;
  GSList *tmp_list;
  GtkTextLineSegment *seg;
  
  anchor = GTK_TEXT_CHILD_ANCHOR (obj);
379

380 381
  seg = anchor->segment;
  
382
  if (seg)
383
    {
384 385 386 387 388 389 390
      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;
        }
391
      
392 393 394 395 396 397
      tmp_list = seg->body.child.widgets;
      while (tmp_list)
        {
          g_object_unref (tmp_list->data);
          tmp_list = g_slist_next (tmp_list);
        }
398
  
399
      g_slist_free (seg->body.child.widgets);
400
  
401 402
      g_free (seg);
    }
403

404
  anchor->segment = NULL;
405 406

  G_OBJECT_CLASS (parent_class)->finalize (obj);
407 408
}

409 410 411 412 413 414 415 416 417 418
/**
 * gtk_text_child_anchor_get_widgets:
 * @anchor: a #GtkTextChildAnchor
 * 
 * Gets a list of all widgets anchored at this child anchor.
 * The returned list should be freed with g_list_free().
 * 
 * 
 * Return value: list of widgets anchored at @anchor
 **/
419 420 421
GList*
gtk_text_child_anchor_get_widgets (GtkTextChildAnchor *anchor)
{
422
  GtkTextLineSegment *seg = anchor->segment;
423 424
  GList *list = NULL;
  GSList *iter;
425

426 427
  CHECK_IN_BUFFER_RETURN (anchor, NULL);
  
428
  g_return_val_if_fail (seg->type == &gtk_text_child_type, NULL);
429

430 431 432 433 434 435 436 437 438 439 440 441 442 443
  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;
}

444 445 446 447 448 449 450 451 452 453 454 455 456
/**
 * gtk_text_child_anchor_get_deleted:
 * @anchor: a #GtkTextChildAnchor
 * 
 * Determines whether a child anchor has been deleted from
 * the buffer. Keep in mind that the child anchor will be
 * unreferenced when removed from the buffer, so you need to
 * hold your own reference (with g_object_ref()) if you plan
 * to use this function &mdash; otherwise all deleted child anchors
 * will also be finalized.
 * 
 * Return value: %TRUE if the child anchor has been deleted from its buffer
 **/
457 458 459
gboolean
gtk_text_child_anchor_get_deleted (GtkTextChildAnchor *anchor)
{
460
  GtkTextLineSegment *seg = anchor->segment;
461

462 463
  CHECK_IN_BUFFER_RETURN (anchor, TRUE);
  
464
  g_return_val_if_fail (seg->type == &gtk_text_child_type, TRUE);
465 466 467 468

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

469 470 471 472 473 474 475
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));
476

477 478
  CHECK_IN_BUFFER (anchor);
  
479 480 481 482 483 484 485 486 487 488 489 490 491
  _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));
492

493 494
  CHECK_IN_BUFFER (anchor);
  
495 496 497 498 499
  if (_gtk_anchored_child_get_layout (child))
    {
      gtk_text_child_anchor_queue_resize (anchor,
                                          _gtk_anchored_child_get_layout (child));
    }
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
  
  _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));
515
  g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
516 517

  CHECK_IN_BUFFER (anchor);
518
  
519 520
  seg = anchor->segment;

521
  if (seg->body.child.tree == NULL)
522
    return;
523 524 525 526
  
  gtk_text_buffer_get_iter_at_child_anchor (layout->buffer,
                                            &start, anchor);
  end = start;
527
  gtk_text_iter_forward_char (&end);
528 529 530
  
  gtk_text_layout_invalidate (layout, &start, &end);
}
531

532 533 534 535 536 537 538 539 540 541 542
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);
}