class Cairo::Region - cairo-1.12.9 Documentation

# class Cairo::Region

### Public Class Methods

new(*args) click to toggle source

    static VALUE
    cr_region_initialize (int argc, VALUE *argv, VALUE self)
    {
      cairo_region_t *region;

      if (argc == 0)
        {
          region = cairo_region_create ();
        }
      else
        {
          int i;
          cairo_rectangle_int_t *rectangles;

          rectangles = ALLOCA_N (cairo_rectangle_int_t, argc);
          for (i = 0; i < argc; i++)
            {
              VALUE rb_rectangle;

              rb_rectangle = rb_check_array_type (argv[i]);
              if (RARRAY_LEN (rb_rectangle) != 4)
                rb_raise (rb_eArgError,
                          "invalid argument (expect "
                          "() or ([x, y, width, height], ...): %s",
                          rb_cairo__inspect (rb_ary_new4 (argc, argv)));
              rectangles[i].x = NUM2INT (RARRAY_PTR (rb_rectangle)[0]);
              rectangles[i].y = NUM2INT (RARRAY_PTR (rb_rectangle)[1]);
              rectangles[i].width = NUM2INT (RARRAY_PTR (rb_rectangle)[2]);
              rectangles[i].height = NUM2INT (RARRAY_PTR (rb_rectangle)[3]);
            }
          region = cairo_region_create_rectangles (rectangles, argc);
        }
      cr_region_check_status (region);
      DATA_PTR (self) = region;
      return Qnil;
    }

### Public Instance Methods

==(p1) click to toggle source

    static VALUE
    cr_region_equal (VALUE self, VALUE other)
    {
      cairo_region_t *region, *other_region;

      if (!rb_cairo__is_kind_of (other, rb_cCairo_Region))
        return Qfalse;

      region = _SELF;
      other_region = RVAL2CRREGION (other);
      return CBOOL2RVAL (cairo_region_equal (region, other_region));
    }

[](p1) click to toggle source

    static VALUE
    cr_region_get_rectangle (VALUE self, VALUE index)
    {
      cairo_region_t *region;
      cairo_rectangle_int_t extents;

      region = _SELF;
      cairo_region_get_rectangle (region, NUM2INT (index), &extents);
      cr_region_check_status (region);
      return rb_ary_new3 (4,
                          INT2NUM (extents.x), INT2NUM (extents.y),
                          INT2NUM (extents.width), INT2NUM (extents.height));
    }

contains_point?(*args) click to toggle source

    static VALUE
    cr_region_containts_point (int argc, VALUE *argv, VALUE self)
    {
      cairo_region_t *region;
      int x, y;
      VALUE arg1, arg2;
      const char *error_message =
        "invalid argument (expect "
        "(x, y) or ([x, y])): %s";

      rb_scan_args (argc, argv, "11", &arg1, &arg2);

      region = _SELF;
      if (argc == 1)
        {
          VALUE point;

          point = rb_check_array_type (arg1);
          if (RARRAY_LEN (point) != 4)
            rb_raise (rb_eArgError, error_message,
                      rb_cairo__inspect (rb_ary_new4 (argc, argv)));
          x = NUM2INT (RARRAY_PTR (point)[0]);
          y = NUM2INT (RARRAY_PTR (point)[1]);
        }
      else
        {
          x = NUM2INT (arg1);
          y = NUM2INT (arg2);
        }
      return CBOOL2RVAL (cairo_region_contains_point (region, x, y));
    }

contains_rectangle(*args) click to toggle source

    static VALUE
    cr_region_containts_rectangle (int argc, VALUE *argv, VALUE self)
    {
      cairo_region_t *region;
      cairo_rectangle_int_t rectangle;
      cairo_region_overlap_t overlap;
      VALUE arg1, arg2, arg3, arg4;
      const char *error_message =
        "invalid argument (expect "
        "(x, y, width, height) or ([x, y, width, height])): %s";

      rb_scan_args (argc, argv, "13", &arg1, &arg2, &arg3, &arg4);

      region = _SELF;
      if (argc == 1)
        {
          VALUE rb_rectangle;

          rb_rectangle = rb_check_array_type (arg1);
          if (RARRAY_LEN (rb_rectangle) != 4)
            rb_raise (rb_eArgError, error_message,
                      rb_cairo__inspect (rb_ary_new4 (argc, argv)));
          rectangle.x = NUM2INT (RARRAY_PTR (rb_rectangle)[0]);
          rectangle.y = NUM2INT (RARRAY_PTR (rb_rectangle)[1]);
          rectangle.width = NUM2INT (RARRAY_PTR (rb_rectangle)[2]);
          rectangle.height = NUM2INT (RARRAY_PTR (rb_rectangle)[3]);
        }
      else if (argc == 4)
        {
          rectangle.x = NUM2INT (arg1);
          rectangle.y = NUM2INT (arg2);
          rectangle.width = NUM2INT (arg3);
          rectangle.height = NUM2INT (arg4);
        }
      else
        {
          rb_raise (rb_eArgError, error_message,
                    rb_cairo__inspect (rb_ary_new4 (argc, argv)));
        }

      overlap = cairo_region_contains_rectangle (region, &rectangle);
      cr_region_check_status (region);
      return INT2NUM (overlap);
    }

dup() click to toggle source

    static VALUE
    cr_region_dup (VALUE self)
    {
      cairo_region_t *copied_region;
      VALUE rb_copied_region;

      copied_region = cairo_region_copy (_SELF);
      cr_region_check_status (copied_region);
      rb_copied_region = CRREGION2RVAL (copied_region);
      cairo_region_destroy (copied_region);
      return rb_copied_region;
    }

empty?() click to toggle source

    static VALUE
    cr_region_is_empty (VALUE self)
    {
      return CBOOL2RVAL (cairo_region_is_empty (_SELF));
    }

extents() click to toggle source

    static VALUE
    cr_region_get_extents (VALUE self)
    {
      cairo_region_t *region;
      cairo_rectangle_int_t extents;

      region = _SELF;
      cairo_region_get_extents (region, &extents);
      cr_region_check_status (region);
      return rb_ary_new3 (4,
                          INT2NUM (extents.x), INT2NUM (extents.y),
                          INT2NUM (extents.width), INT2NUM (extents.height));
    }

num_rectangles() click to toggle source

    static VALUE
    cr_region_num_rectangles (VALUE self)
    {
      cairo_region_t *region;
      int num_rectangles;

      region = _SELF;
      num_rectangles = cairo_region_num_rectangles (region);
      cr_region_check_status (region);
      return INT2NUM (num_rectangles);
    }

translate!(*args) click to toggle source

    static VALUE
    cr_region_translate (int argc, VALUE *argv, VALUE self)
    {
      cairo_region_t *region;
      int x, y;
      VALUE arg1, arg2;
      const char *error_message =
        "invalid argument (expect "
        "(x, y) or ([x, y])): %s";

      rb_scan_args (argc, argv, "11", &arg1, &arg2);

      region = _SELF;
      if (argc == 1)
        {
          VALUE point;

          point = rb_check_array_type (arg1);
          if (RARRAY_LEN (point) != 4)
            rb_raise (rb_eArgError, error_message,
                      rb_cairo__inspect (rb_ary_new4 (argc, argv)));
          x = NUM2INT (RARRAY_PTR (point)[0]);
          y = NUM2INT (RARRAY_PTR (point)[1]);
        }
      else
        {
          x = NUM2INT (arg1);
          y = NUM2INT (arg2);
        }

      cairo_region_translate (region, x, y);
      cr_region_check_status (region);
      return Qnil;
    }