← Back to branch summary

~ubuntu-branches/debian/sid/bijiben/sid

« back to all changes in this revision

Viewing changes to libgd/libgd/gd-two-lines-renderer.c

  • Committer: Package Import Robot
  • Author(s): Vincent Cheng
  • Date: 2013-03-26 21:19:36 UTC
  • Revision ID: package-import@ubuntu.com-20130326211936-tu8mpy82juohw8m2
Tags: upstream-3.8.0
Import upstream version 3.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgd/libgd/gd-two-lines-renderer.c
 
1
/*
 
2
 * Copyright (c) 2011 Red Hat, Inc.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU Lesser General Public License as published by 
 
6
 * the Free Software Foundation; either version 2 of the License, or (at your
 
7
 * option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful, but
 
10
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
11
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public 
 
12
 * License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public License 
 
15
 * along with this program; if not, write to the Free Software Foundation,
 
16
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 *
 
18
 * Author: Cosimo Cecchi <cosimoc@redhat.com>
 
19
 *
 
20
 */
 
21
 
 
22
#include "gd-two-lines-renderer.h"
 
23
#include <string.h>
 
24
 
 
25
G_DEFINE_TYPE (GdTwoLinesRenderer, gd_two_lines_renderer, GTK_TYPE_CELL_RENDERER_TEXT)
 
26
 
 
27
struct _GdTwoLinesRendererPrivate {
 
28
  gchar *line_two;
 
29
  gint text_lines;
 
30
};
 
31
 
 
32
enum {
 
33
  PROP_TEXT_LINES = 1,
 
34
  PROP_LINE_TWO,
 
35
  NUM_PROPERTIES
 
36
};
 
37
 
 
38
static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
 
39
 
 
40
static PangoLayout *
 
41
create_layout_with_attrs (GtkWidget *widget,
 
42
                          const GdkRectangle *cell_area,
 
43
                          GdTwoLinesRenderer *self,
 
44
                          PangoEllipsizeMode ellipsize)
 
45
{
 
46
  PangoLayout *layout;
 
47
  gint wrap_width, xpad;
 
48
  PangoWrapMode wrap_mode;
 
49
  PangoAlignment alignment;
 
50
 
 
51
  g_object_get (self,
 
52
                "wrap-width", &wrap_width,
 
53
                "wrap-mode", &wrap_mode,
 
54
                "alignment", &alignment,
 
55
                "xpad", &xpad,
 
56
                NULL);
 
57
 
 
58
  layout = pango_layout_new (gtk_widget_get_pango_context (widget));
 
59
 
 
60
  pango_layout_set_ellipsize (layout, ellipsize);
 
61
  pango_layout_set_alignment (layout, alignment);
 
62
 
 
63
  if (wrap_width != -1)
 
64
    {
 
65
      pango_layout_set_width (layout, wrap_width * PANGO_SCALE);
 
66
      pango_layout_set_wrap (layout, wrap_mode);
 
67
    }
 
68
  else
 
69
    {
 
70
      if (cell_area != NULL)
 
71
        pango_layout_set_width (layout, (cell_area->width - 2 * xpad) * PANGO_SCALE);
 
72
      else
 
73
        pango_layout_set_width (layout, -1);
 
74
 
 
75
      pango_layout_set_wrap (layout, PANGO_WRAP_CHAR);
 
76
    }
 
77
 
 
78
  return layout;
 
79
}
 
80
 
 
81
static void
 
82
gd_two_lines_renderer_prepare_layouts (GdTwoLinesRenderer *self,
 
83
                                       const GdkRectangle *cell_area,
 
84
                                       GtkWidget *widget,
 
85
                                       PangoLayout **layout_one,
 
86
                                       PangoLayout **layout_two)
 
87
{
 
88
  PangoLayout *line_one;
 
89
  PangoLayout *line_two = NULL;
 
90
  gchar *text = NULL;
 
91
 
 
92
  g_object_get (self,
 
93
                "text", &text,
 
94
                NULL);
 
95
 
 
96
  line_one = create_layout_with_attrs (widget, cell_area,
 
97
                                       self, PANGO_ELLIPSIZE_MIDDLE);
 
98
 
 
99
  if (self->priv->line_two == NULL ||
 
100
      g_strcmp0 (self->priv->line_two, "") == 0)
 
101
    {
 
102
      pango_layout_set_height (line_one, - (self->priv->text_lines));
 
103
 
 
104
      if (text != NULL)
 
105
        pango_layout_set_text (line_one, text, -1);
 
106
    }
 
107
  else
 
108
    {
 
109
      line_two = create_layout_with_attrs (widget, cell_area,
 
110
                                           self, PANGO_ELLIPSIZE_END);
 
111
 
 
112
      pango_layout_set_height (line_one, - (self->priv->text_lines - 1));
 
113
      pango_layout_set_height (line_two, -1);
 
114
      pango_layout_set_text (line_two, self->priv->line_two, -1);
 
115
 
 
116
      if (text != NULL)
 
117
        pango_layout_set_text (line_one, text, -1);
 
118
    }
 
119
 
 
120
  if (layout_one)
 
121
    *layout_one = line_one;
 
122
  if (layout_two)
 
123
    *layout_two = line_two;
 
124
 
 
125
  g_free (text);
 
126
}
 
127
 
 
128
static void
 
129
gd_two_lines_renderer_get_size (GtkCellRenderer *cell,
 
130
                                GtkWidget *widget,
 
131
                                PangoLayout *layout_1,
 
132
                                PangoLayout *layout_2,
 
133
                                gint *width,
 
134
                                gint *height,
 
135
                                const GdkRectangle *cell_area,
 
136
                                gint *x_offset_1,
 
137
                                gint *x_offset_2,
 
138
                                gint *y_offset)
 
139
{
 
140
  GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell);
 
141
  gint xpad, ypad;
 
142
  PangoLayout *layout_one, *layout_two;
 
143
  GdkRectangle layout_one_rect, layout_two_rect, layout_union;
 
144
 
 
145
  if (layout_1 == NULL)
 
146
    {
 
147
      gd_two_lines_renderer_prepare_layouts (self, cell_area, widget, &layout_one, &layout_two);
 
148
    }
 
149
  else
 
150
    {
 
151
      layout_one = g_object_ref (layout_1);
 
152
 
 
153
      if (layout_2 != NULL)
 
154
        layout_two = g_object_ref (layout_2);
 
155
      else
 
156
        layout_two = NULL;
 
157
    }
 
158
 
 
159
  gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
 
160
  pango_layout_get_pixel_extents (layout_one, NULL, (PangoRectangle *) &layout_one_rect);
 
161
 
 
162
  if (layout_two != NULL)
 
163
    {
 
164
      pango_layout_get_pixel_extents (layout_two, NULL, (PangoRectangle *) &layout_two_rect);
 
165
 
 
166
      layout_union.width = MAX (layout_one_rect.width, layout_two_rect.width);
 
167
      layout_union.height = layout_one_rect.height + layout_two_rect.height;
 
168
    }
 
169
  else
 
170
    {
 
171
      layout_union = layout_one_rect;
 
172
    }
 
173
 
 
174
  if (cell_area)
 
175
    {
 
176
      gfloat xalign, yalign;
 
177
 
 
178
      gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
 
179
 
 
180
      layout_union.width  = MIN (layout_union.width, cell_area->width - 2 * xpad);
 
181
      layout_union.height = MIN (layout_union.height, cell_area->height - 2 * ypad);
 
182
 
 
183
      if (x_offset_1)
 
184
        {
 
185
          if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
 
186
            *x_offset_1 = (1.0 - xalign) * (cell_area->width - (layout_one_rect.width + (2 * xpad)));
 
187
          else 
 
188
            *x_offset_1 = xalign * (cell_area->width - (layout_one_rect.width + (2 * xpad)));
 
189
 
 
190
          *x_offset_1 = MAX (*x_offset_1, 0);
 
191
        }
 
192
      if (x_offset_2)
 
193
        {
 
194
          if (layout_two != NULL)
 
195
            {
 
196
              if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
 
197
                *x_offset_2 = (1.0 - xalign) * (cell_area->width - (layout_two_rect.width + (2 * xpad)));
 
198
              else 
 
199
                *x_offset_2 = xalign * (cell_area->width - (layout_two_rect.width + (2 * xpad)));
 
200
 
 
201
              *x_offset_2 = MAX (*x_offset_2, 0);
 
202
            }
 
203
          else
 
204
            {
 
205
              *x_offset_2 = 0;
 
206
            }
 
207
        }
 
208
 
 
209
      if (y_offset)
 
210
        {
 
211
          *y_offset = yalign * (cell_area->height - (layout_union.height + (2 * ypad)));
 
212
          *y_offset = MAX (*y_offset, 0);
 
213
        }
 
214
    }
 
215
  else
 
216
    {
 
217
      if (x_offset_1) *x_offset_1 = 0;
 
218
      if (x_offset_2) *x_offset_2 = 0;
 
219
      if (y_offset) *y_offset = 0;
 
220
    }
 
221
 
 
222
  g_clear_object (&layout_one);
 
223
  g_clear_object (&layout_two);
 
224
 
 
225
  if (height)
 
226
    *height = ypad * 2 + layout_union.height;
 
227
 
 
228
  if (width)
 
229
    *width = xpad * 2 + layout_union.width;
 
230
}
 
231
 
 
232
static void
 
233
gd_two_lines_renderer_render (GtkCellRenderer      *cell,
 
234
                              cairo_t              *cr,
 
235
                              GtkWidget            *widget,
 
236
                              const GdkRectangle   *background_area,
 
237
                              const GdkRectangle   *cell_area,
 
238
                              GtkCellRendererState  flags)
 
239
{
 
240
  GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell);
 
241
  GtkStyleContext *context;
 
242
  gint line_one_height;
 
243
  GtkStateFlags state;
 
244
  GdkRectangle area, render_area = *cell_area;
 
245
  gint xpad, ypad, x_offset_1, x_offset_2, y_offset;
 
246
  PangoLayout *layout_one, *layout_two;
 
247
  PangoRectangle layout_rect;
 
248
 
 
249
  /* fetch common information */
 
250
  context = gtk_widget_get_style_context (widget);
 
251
  gd_two_lines_renderer_prepare_layouts (self, cell_area, widget, &layout_one, &layout_two);
 
252
  gd_two_lines_renderer_get_size (cell, widget,
 
253
                                  layout_one, layout_two,
 
254
                                  NULL, NULL,
 
255
                                  cell_area,
 
256
                                  &x_offset_1, &x_offset_2, &y_offset);
 
257
  gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
 
258
 
 
259
  area = *cell_area;
 
260
  area.x += xpad;
 
261
  area.y += ypad;
 
262
 
 
263
  /* now render the first layout */
 
264
  pango_layout_get_pixel_extents (layout_one, NULL, &layout_rect);
 
265
 
 
266
  render_area = area;
 
267
  render_area.x += x_offset_1 - layout_rect.x;
 
268
 
 
269
  gtk_render_layout (context, cr,
 
270
                     render_area.x,
 
271
                     render_area.y,
 
272
                     layout_one);
 
273
 
 
274
  /* render the second layout */
 
275
  if (layout_two != NULL)
 
276
    {
 
277
      pango_layout_get_pixel_size (layout_one,
 
278
                                   NULL, &line_one_height);
 
279
 
 
280
      gtk_style_context_save (context);
 
281
      gtk_style_context_add_class (context, "dim-label");
 
282
 
 
283
      state = gtk_cell_renderer_get_state (cell, widget, flags);
 
284
      gtk_style_context_set_state (context, state);
 
285
 
 
286
      pango_layout_get_pixel_extents (layout_two, NULL, &layout_rect);
 
287
 
 
288
      render_area = area;
 
289
      render_area.x += x_offset_2 - layout_rect.x;
 
290
      render_area.y += line_one_height;
 
291
 
 
292
      gtk_render_layout (context, cr,
 
293
                         render_area.x,
 
294
                         render_area.y,
 
295
                         layout_two);
 
296
 
 
297
      gtk_style_context_restore (context);
 
298
    }
 
299
 
 
300
  g_clear_object (&layout_one);
 
301
  g_clear_object (&layout_two);
 
302
}
 
303
 
 
304
static void
 
305
gd_two_lines_renderer_get_preferred_width (GtkCellRenderer *cell,
 
306
                                           GtkWidget       *widget,
 
307
                                           gint            *minimum_size,
 
308
                                           gint            *natural_size)
 
309
{
 
310
  PangoContext *context;
 
311
  PangoFontMetrics *metrics;
 
312
  const PangoFontDescription *font_desc;
 
313
  GtkStyleContext *style_context;
 
314
  gint nat_width, min_width;
 
315
  gint xpad, char_width, wrap_width, text_width;
 
316
  gint width_chars, ellipsize_chars;
 
317
 
 
318
  g_object_get (cell,
 
319
                "xpad", &xpad,
 
320
                "width-chars", &width_chars,
 
321
                "wrap-width", &wrap_width,
 
322
                NULL);
 
323
  style_context = gtk_widget_get_style_context (widget);
 
324
  gtk_cell_renderer_get_padding (cell, &xpad, NULL);
 
325
 
 
326
  gd_two_lines_renderer_get_size (cell, widget,
 
327
                                  NULL, NULL,
 
328
                                  &text_width, NULL,
 
329
                                  NULL, 
 
330
                                  NULL, NULL, NULL);
 
331
 
 
332
  /* Fetch the average size of a charachter */
 
333
  context = gtk_widget_get_pango_context (widget);
 
334
  font_desc = gtk_style_context_get_font (style_context, 0);
 
335
  metrics = pango_context_get_metrics (context, font_desc,
 
336
                                       pango_context_get_language (context));
 
337
 
 
338
  char_width = pango_font_metrics_get_approximate_char_width (metrics);
 
339
 
 
340
  pango_font_metrics_unref (metrics);
 
341
 
 
342
  /* enforce minimum width for ellipsized labels at ~3 chars */
 
343
  ellipsize_chars = 3;
 
344
 
 
345
  /* If no width-chars set, minimum for wrapping text will be the wrap-width */
 
346
  if (wrap_width > -1)
 
347
    min_width = xpad * 2 + MIN (text_width, wrap_width);
 
348
  else
 
349
    min_width = xpad * 2 +
 
350
      MIN (text_width,
 
351
           (PANGO_PIXELS (char_width) * MAX (width_chars, ellipsize_chars)));
 
352
 
 
353
  if (width_chars > 0)
 
354
    nat_width = xpad * 2 +
 
355
      MAX ((PANGO_PIXELS (char_width) * width_chars), text_width);
 
356
  else
 
357
    nat_width = xpad * 2 + text_width;
 
358
 
 
359
  nat_width = MAX (nat_width, min_width);
 
360
 
 
361
  if (minimum_size)
 
362
    *minimum_size = min_width;
 
363
 
 
364
  if (natural_size)
 
365
    *natural_size = nat_width;
 
366
}
 
367
 
 
368
static void
 
369
gd_two_lines_renderer_get_preferred_height_for_width (GtkCellRenderer *cell,
 
370
                                                      GtkWidget       *widget,
 
371
                                                      gint             width,
 
372
                                                      gint            *minimum_size,
 
373
                                                      gint            *natural_size)
 
374
{
 
375
  GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell);
 
376
  PangoLayout *layout_one, *layout_two;
 
377
  gint text_height, wrap_width;
 
378
  gint xpad, ypad;
 
379
 
 
380
  gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
 
381
  g_object_get (cell, "wrap-width", &wrap_width, NULL);
 
382
  gd_two_lines_renderer_prepare_layouts (self, NULL, widget, &layout_one, &layout_two);
 
383
 
 
384
  if (wrap_width != -1)
 
385
    wrap_width = MIN (width - 2 * xpad, wrap_width);
 
386
  else
 
387
    wrap_width = width - 2 * xpad;
 
388
 
 
389
  pango_layout_set_width (layout_one, wrap_width);
 
390
  if (layout_two != NULL)
 
391
    pango_layout_set_width (layout_two, wrap_width);
 
392
 
 
393
  gd_two_lines_renderer_get_size (cell, widget,
 
394
                                  layout_one, layout_two,
 
395
                                  NULL, &text_height,
 
396
                                  NULL, 
 
397
                                  NULL, NULL, NULL);
 
398
 
 
399
  text_height += 2 * ypad;
 
400
 
 
401
  if (minimum_size != NULL)
 
402
    *minimum_size = text_height;
 
403
 
 
404
  if (natural_size != NULL)
 
405
    *natural_size = text_height;
 
406
 
 
407
  g_clear_object (&layout_one);
 
408
  g_clear_object (&layout_two);
 
409
}
 
410
 
 
411
static void
 
412
gd_two_lines_renderer_get_preferred_height (GtkCellRenderer *cell,
 
413
                                            GtkWidget       *widget,
 
414
                                            gint            *minimum_size,
 
415
                                            gint            *natural_size)
 
416
{
 
417
  gint min_width;
 
418
 
 
419
  gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, NULL);
 
420
  gd_two_lines_renderer_get_preferred_height_for_width (cell, widget, min_width,
 
421
                                                        minimum_size, natural_size);
 
422
}
 
423
 
 
424
static void
 
425
gd_two_lines_renderer_get_aligned_area (GtkCellRenderer      *cell,
 
426
                                        GtkWidget            *widget,
 
427
                                        GtkCellRendererState  flags,
 
428
                                        const GdkRectangle   *cell_area,
 
429
                                        GdkRectangle         *aligned_area)
 
430
{
 
431
  GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (cell);
 
432
  gint x_offset, x_offset_1, x_offset_2, y_offset;
 
433
  PangoLayout *layout_one, *layout_two;
 
434
 
 
435
  /* fetch common information */
 
436
  gd_two_lines_renderer_prepare_layouts (self, cell_area, widget, &layout_one, &layout_two);
 
437
  gd_two_lines_renderer_get_size (cell, widget,
 
438
                                  layout_one, layout_two,
 
439
                                  &aligned_area->width, &aligned_area->height,
 
440
                                  cell_area,
 
441
                                  &x_offset_1, &x_offset_2, &y_offset);
 
442
 
 
443
  x_offset = MIN (x_offset_1, x_offset_2);
 
444
 
 
445
  aligned_area->x = cell_area->x + x_offset;
 
446
  aligned_area->y = cell_area->y;
 
447
 
 
448
  g_clear_object (&layout_one);
 
449
  g_clear_object (&layout_two);
 
450
}
 
451
 
 
452
static void
 
453
gd_two_lines_renderer_set_line_two (GdTwoLinesRenderer *self,
 
454
                                    const gchar *line_two)
 
455
{
 
456
  if (g_strcmp0 (self->priv->line_two, line_two) == 0)
 
457
    return;
 
458
 
 
459
  g_free (self->priv->line_two);
 
460
  self->priv->line_two = g_strdup (line_two);
 
461
 
 
462
  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LINE_TWO]);
 
463
}
 
464
 
 
465
static void
 
466
gd_two_lines_renderer_set_text_lines (GdTwoLinesRenderer *self,
 
467
                                      gint text_lines)
 
468
{
 
469
  if (self->priv->text_lines == text_lines)
 
470
    return;
 
471
 
 
472
  self->priv->text_lines = text_lines;
 
473
  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TEXT_LINES]);
 
474
}
 
475
 
 
476
static void
 
477
gd_two_lines_renderer_set_property (GObject    *object,
 
478
                                    guint       property_id,
 
479
                                    const GValue     *value,
 
480
                                    GParamSpec *pspec)
 
481
{
 
482
  GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (object);
 
483
 
 
484
  switch (property_id)
 
485
    {
 
486
    case PROP_TEXT_LINES:
 
487
      gd_two_lines_renderer_set_text_lines (self, g_value_get_int (value));
 
488
      break;
 
489
    case PROP_LINE_TWO:
 
490
      gd_two_lines_renderer_set_line_two (self, g_value_get_string (value));
 
491
      break;
 
492
    default:
 
493
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
494
      break;
 
495
    }
 
496
}
 
497
 
 
498
static void
 
499
gd_two_lines_renderer_get_property (GObject    *object,
 
500
                                    guint       property_id,
 
501
                                    GValue     *value,
 
502
                                    GParamSpec *pspec)
 
503
{
 
504
  GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (object);
 
505
 
 
506
  switch (property_id)
 
507
    {
 
508
    case PROP_TEXT_LINES:
 
509
      g_value_set_int (value, self->priv->text_lines);
 
510
      break;
 
511
    case PROP_LINE_TWO:
 
512
      g_value_set_string (value, self->priv->line_two);
 
513
      break;
 
514
    default:
 
515
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
516
      break;
 
517
    }
 
518
}
 
519
 
 
520
static void
 
521
gd_two_lines_renderer_finalize (GObject *object)
 
522
{
 
523
  GdTwoLinesRenderer *self = GD_TWO_LINES_RENDERER (object);
 
524
 
 
525
  g_free (self->priv->line_two);
 
526
 
 
527
  G_OBJECT_CLASS (gd_two_lines_renderer_parent_class)->finalize (object);
 
528
}
 
529
 
 
530
static void
 
531
gd_two_lines_renderer_class_init (GdTwoLinesRendererClass *klass)
 
532
{
 
533
  GtkCellRendererClass *cclass = GTK_CELL_RENDERER_CLASS (klass);
 
534
  GObjectClass *oclass = G_OBJECT_CLASS (klass);
 
535
 
 
536
  cclass->render = gd_two_lines_renderer_render;
 
537
  cclass->get_preferred_width = gd_two_lines_renderer_get_preferred_width;
 
538
  cclass->get_preferred_height = gd_two_lines_renderer_get_preferred_height;
 
539
  cclass->get_preferred_height_for_width = gd_two_lines_renderer_get_preferred_height_for_width;
 
540
  cclass->get_aligned_area = gd_two_lines_renderer_get_aligned_area;
 
541
 
 
542
  oclass->set_property = gd_two_lines_renderer_set_property;
 
543
  oclass->get_property = gd_two_lines_renderer_get_property;
 
544
  oclass->finalize = gd_two_lines_renderer_finalize;
 
545
  
 
546
  properties[PROP_TEXT_LINES] =
 
547
    g_param_spec_int ("text-lines",
 
548
                      "Lines of text",
 
549
                      "The total number of lines to be displayed",
 
550
                      2, G_MAXINT, 2,
 
551
                      G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
552
 
 
553
  properties[PROP_LINE_TWO] =
 
554
    g_param_spec_string ("line-two",
 
555
                         "Second line",
 
556
                         "Second line",
 
557
                         NULL,
 
558
                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
559
 
 
560
  g_type_class_add_private (klass, sizeof (GdTwoLinesRendererPrivate));
 
561
  g_object_class_install_properties (oclass, NUM_PROPERTIES, properties);
 
562
}
 
563
 
 
564
static void
 
565
gd_two_lines_renderer_init (GdTwoLinesRenderer *self)
 
566
{
 
567
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GD_TYPE_TWO_LINES_RENDERER,
 
568
                                            GdTwoLinesRendererPrivate);
 
569
}
 
570
 
 
571
GtkCellRenderer *
 
572
gd_two_lines_renderer_new (void)
 
573
{
 
574
  return g_object_new (GD_TYPE_TWO_LINES_RENDERER, NULL);
 
575
}