static VALUE
rg_modify_cursor(VALUE self, VALUE primary, VALUE seconday)
{
    gtk_widget_modify_cursor(_SELF(self),
                             RVAL2BOXED(primary, GDK_TYPE_COLOR),
                             RVAL2BOXED(seconday, GDK_TYPE_COLOR));
    return self;
}

static VALUE
rg_draw_glyphs_transformed(VALUE self, VALUE gc, VALUE matrix, VALUE font, VALUE x, VALUE y, VALUE glyphs)
{
    gdk_draw_glyphs_transformed(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), 
                                NIL_P(matrix) ? (PangoMatrix*)NULL : (PangoMatrix*)(RVAL2BOXED(matrix, PANGO_TYPE_MATRIX)),
                                PANGO_FONT(RVAL2GOBJ(font)),
                                NUM2INT(x), NUM2INT(y), 
                                (PangoGlyphString*)(RVAL2BOXED(glyphs, PANGO_TYPE_GLYPH_STRING)));
    return self;
}

static VALUE
rg_set_color(VALUE self, VALUE part, VALUE color)
{
#ifdef HAVE_PANGO_RENDER_PART_GET_TYPE
    pango_renderer_set_color(_SELF(self), RVAL2GENUM(part, PANGO_TYPE_RENDER_PART),
                             (PangoColor*)(NIL_P(color) ? NULL : RVAL2BOXED(color, PANGO_TYPE_COLOR)));
#else
    pango_renderer_set_color(_SELF(self), NUM2INT(part),
                             (PangoColor*)(NIL_P(color) ? NULL : RVAL2BOXED(color, PANGO_TYPE_COLOR)));
#endif
    return self;
}

static VALUE
gdkwin_begin_paint(VALUE self, VALUE area)
{
    if (rb_obj_is_kind_of(area, GTYPE2CLASS(GDK_TYPE_RECTANGLE))){
        gdk_window_begin_paint_rect(_SELF(self), 
                                    (GdkRectangle*)RVAL2BOXED(area, GDK_TYPE_RECTANGLE));
    } else {
        gdk_window_begin_paint_region(_SELF(self),
                                      (GdkRegion*)RVAL2BOXED(area, GDK_TYPE_REGION));
    }
    return self;
}

static VALUE
gdkwin_invalidate(VALUE self, VALUE area, VALUE invalidate_children)
{
    if (rb_obj_is_kind_of(area, GTYPE2CLASS(GDK_TYPE_REGION))){
        gdk_window_invalidate_region(_SELF(self),
                                     RVAL2BOXED(area, GDK_TYPE_REGION),
                                     RVAL2CBOOL(invalidate_children));
    } else {
        gdk_window_invalidate_rect(_SELF(self),
                                   RVAL2BOXED(area, GDK_TYPE_RECTANGLE),
                                   RVAL2CBOOL(invalidate_children));
    }
    return self;
}

static VALUE
rg_set_matrix(VALUE self, VALUE matrix)
{
    pango_renderer_set_matrix(_SELF(self), 
                              (PangoMatrix*)(NIL_P(matrix) ? NULL : RVAL2BOXED(matrix, PANGO_TYPE_MATRIX)));
    return self;
}

static VALUE
rg_modify_font(VALUE self, VALUE font_desc)
{
    gtk_widget_modify_font(_SELF(self),
                           (PangoFontDescription*)RVAL2BOXED(font_desc, PANGO_TYPE_FONT_DESCRIPTION));
    return self;
}

static VALUE
rg_set_attributes(VALUE self, VALUE attrs)
{
    pango_layout_set_attributes(_SELF(self), 
                                (PangoAttrList*)(RVAL2BOXED(attrs, PANGO_TYPE_ATTR_LIST)));
    return self;
}

static VALUE
rg_invalidate(VALUE self)
{
    GClosure* closure = RVAL2BOXED(self, G_TYPE_CLOSURE);
    g_closure_invalidate(closure);
    return self;
}

static VALUE
rb_cogl_color (int argc, VALUE *argv, VALUE self)
{
  /* Accept either a single ClutterColor argument or up to four
     components */
  if (argc == 1
      && RTEST (rb_obj_is_kind_of (argv[0], GTYPE2CLASS (CLUTTER_TYPE_COLOR))))
    {
      const ClutterColor *color
        = (const ClutterColor *) RVAL2BOXED (argv[0], CLUTTER_TYPE_COLOR);

      cogl_color (color);
    }
  else
    {
      VALUE r, g, b, a;
      ClutterColor color;

      rb_scan_args (argc, argv, "04", &r, &g, &b, &a);

      color.red = NIL_P (r) ? 0 : rbclt_num_to_guint8 (r);
      color.green = NIL_P (g) ? 0 : rbclt_num_to_guint8 (g);
      color.blue = NIL_P (b) ? 0 : rbclt_num_to_guint8 (b);
      color.alpha = NIL_P (a) ? 255 : rbclt_num_to_guint8 (a);

      cogl_color (&color);
    }

  return Qnil;
}

static VALUE
rg_add(VALUE self, VALUE id, VALUE icon_set)
{
    gtk_icon_factory_add(_SELF(self), RVAL2CSTR(id),
                         (GtkIconSet*)RVAL2BOXED(icon_set, GTK_TYPE_ICON_SET));
    return self;
}

static VALUE
rg_set_clip_region(VALUE self, VALUE region)
{
    gdk_gc_set_clip_region(_SELF(self),
                           (GdkRegion*)RVAL2BOXED(region, GDK_TYPE_REGION));
    return self;
}

static VALUE
rg_set_clip_rectangle(VALUE self, VALUE rectangle)
{
    gdk_gc_set_clip_rectangle(_SELF(self),
                              (GdkRectangle*)RVAL2BOXED(rectangle, GDK_TYPE_RECTANGLE));
    return self;
}

static VALUE
rg_set_cursor(VALUE self, VALUE cursor)
{
    gdk_window_set_cursor(_SELF(self),
                          RVAL2BOXED(cursor, GDK_TYPE_CURSOR));
    return self;
}

static VALUE
rbclt_stage_set_fog (int argc, VALUE *argv, VALUE self)
{
  ClutterStage *stage = CLUTTER_STAGE (RVAL2GOBJ (self));

  if (argc == 1)
    {
      ClutterFog *fog = (ClutterFog *) RVAL2BOXED (argv[0], CLUTTER_TYPE_FOG);
      clutter_stage_set_fogx (stage, fog);
    }
  else
    {
      VALUE density, z_near, z_far;
      ClutterFog *fog = (ClutterFog*) g_malloc(sizeof(ClutterFog));

      rb_scan_args (argc, argv, "03", &density, &z_near, &z_far);

      fog->z_near = NUM2FLOAT (z_near);
      fog->z_far = NUM2FLOAT (z_far);

      clutter_stage_set_fog (stage, fog);
      /* FIXME: g_free(fog); # argh, once again can't do this. another leak...? */
    }

  return self;
}

static VALUE
rpango_break(VALUE self, VALUE text, VALUE analysis)
{
    gint i, len;
    glong attrs_len;
    PangoLogAttr *attrs;
    const gchar *gtext;
    VALUE ret;

    gtext = StringValuePtr(text);
    len = RSTRING_LEN(text);
    attrs_len = g_utf8_strlen(gtext, (gssize)len) + 1l;
    attrs = g_new0(PangoLogAttr, attrs_len);

    pango_break(gtext, len,
                NIL_P(analysis) ? NULL : RVAL2BOXED(analysis, PANGO_TYPE_ANALYSIS),
                attrs, attrs_len);

    ret = rb_ary_new();
    for (i = 0; i < attrs_len; i++){
        rb_ary_push(ret, BOXED2RVAL(&attrs[i], PANGO_TYPE_LOG_ATTR));
    }
    g_free(attrs);
    return ret;
}

static VALUE
rbclt_text_initialize (int argc, VALUE *argv, VALUE self)
{
  VALUE font_name, text, color;
  gchar *font_name_s = NULL, *text_s = NULL;
  ClutterColor *color_s = NULL;
  ClutterActor *actor;

  rb_scan_args (argc, argv, "03", &font_name, &text, &color);

  if (!NIL_P (font_name))
    font_name_s = StringValuePtr (font_name);
  if (!NIL_P (text))
    text_s = StringValuePtr (text);
  if (!NIL_P (color))
    color_s = (ClutterColor *) RVAL2BOXED (color, CLUTTER_TYPE_COLOR);

  actor = clutter_text_new ();

  if (font_name_s)
    clutter_text_set_font_name (CLUTTER_TEXT (actor), font_name_s);
  if (text_s)
    clutter_text_set_text (CLUTTER_TEXT (actor), text_s);
  if (color_s)
    clutter_text_set_color (CLUTTER_TEXT (actor), color_s);

  rbclt_initialize_unowned (self, actor);

  return Qnil;
}

static VALUE
rg_set_tabs(VALUE self, VALUE tabs)
{
    pango_layout_set_tabs(_SELF(self), 
                          (PangoTabArray*)RVAL2BOXED(tabs, PANGO_TYPE_TAB_ARRAY));
    return self;
}

static VALUE
rpango_get_log_attrs(VALUE self, VALUE text, VALUE level, VALUE language)
{
    gint i, len;
    glong attrs_len;
    PangoLogAttr *attrs;
    const gchar *gtext;
    VALUE ret;

    gtext = StringValuePtr(text);
    len = RSTRING_LEN(text);
    attrs_len = g_utf8_strlen(gtext, (gssize)len) + 1l;
    attrs = g_new0(PangoLogAttr, attrs_len);

    pango_get_log_attrs(gtext, len, NUM2INT(level),
                        RVAL2BOXED(language, PANGO_TYPE_LANGUAGE),
                        attrs, attrs_len);

    ret = rb_ary_new();
    for (i = 0; i < attrs_len; i++){
        rb_ary_push(ret, BOXED2RVAL(&attrs[i], PANGO_TYPE_LOG_ATTR));
    }
    g_free(attrs);
    return ret;
}

static VALUE
rbclt_stage_set_perspective (int argc, VALUE *argv, VALUE self)
{
  ClutterStage *stage = CLUTTER_STAGE (RVAL2GOBJ (self));

  if (argc == 1)
    {
      ClutterPerspective *persp
        = (ClutterPerspective *) RVAL2BOXED (argv[0], CLUTTER_TYPE_PERSPECTIVE);
      clutter_stage_set_perspective (stage, persp);
    }
  else if (argc == 4) {
    ClutterPerspective *persp = (ClutterPerspective*) g_malloc(sizeof(ClutterPerspective));
    persp->fovy = NUM2FLOAT (argv[0]);
    persp->aspect = NUM2FLOAT (argv[1]);
    persp->z_near = NUM2FLOAT (argv[2]);
    persp->z_far =  NUM2DBL (argv[3]);
    clutter_stage_set_perspective (stage, persp);
    /* FIXME: g_free(persp); # I can't do this!  It has to be a leak.  Really, support for
       inline perspective values should just go away. */
  }
  else
    rb_raise (rb_eArgError, "wrong number of arguments (%d for 1 or 4)", argc);

  return self;
}