struct GdkPoint

struct GdkPoint {
  gint x;
  gint y;
};

Defines the x and y coordinates of a point.

struct GdkRectangle

struct GdkRectangle {
  gint x;
  gint y;
  gint width;
  gint height;
};

Defines the position and size of a rectangle.

gdk_rectangle_intersect ()

gboolean            gdk_rectangle_intersect             (const GdkRectangle *src1,
                                                         const GdkRectangle *src2,
                                                         GdkRectangle *dest);

Calculates the intersection of two rectangles. It is allowed for dest to be the same as either src1 or src2. If the rectangles do not intersect, dest's width and height is set to 0 and its x and y values are undefined. If you are only interested in whether the rectangles intersect, but not in the intersecting area itself, pass NULL for dest.

gdk_rectangle_union ()

void                gdk_rectangle_union                 (const GdkRectangle *src1,
                                                         const GdkRectangle *src2,
                                                         GdkRectangle *dest);

Calculates the union of two rectangles. The union of rectangles src1 and src2 is the smallest rectangle which includes both src1 and src2 within it. It is allowed for dest to be the same as either src1 or src2.

GdkRegion

typedef struct _GdkRegion GdkRegion;

A GdkRegion represents a set of pixels on the screen.

In GTK3, GdkRegion will be replaced by cairo_region_t. All the functions listed in this section will go away and you will have to use the relevant Cairo functions. The conversion can be done using simple serch and replace.

gdk_region_new ()

GdkRegion *         gdk_region_new                      (void);

Creates a new empty GdkRegion.

gdk_region_polygon ()

GdkRegion *         gdk_region_polygon                  (const GdkPoint *points,
                                                         gint n_points,
                                                         GdkFillRule fill_rule);

Creates a new GdkRegion using the polygon defined by a number of points.

enum GdkFillRule

typedef enum
{
  GDK_EVEN_ODD_RULE,
  GDK_WINDING_RULE
} GdkFillRule;

The method for determining which pixels are included in a region, when creating a GdkRegion from a polygon. The fill rule is only relevant for polygons which overlap themselves.

gdk_region_copy ()

GdkRegion *         gdk_region_copy                     (const GdkRegion *region);

Copies region, creating an identical new region.

gdk_region_rectangle ()

GdkRegion *         gdk_region_rectangle                (const GdkRectangle *rectangle);

Creates a new region containing the area rectangle.

gdk_region_destroy ()

void                gdk_region_destroy                  (GdkRegion *region);

Destroys a GdkRegion.

gdk_region_get_clipbox ()

void                gdk_region_get_clipbox              (const GdkRegion *region,
                                                         GdkRectangle *rectangle);

Obtains the smallest rectangle which includes the entire GdkRegion.

gdk_region_get_rectangles ()

void                gdk_region_get_rectangles           (const GdkRegion *region,
                                                         GdkRectangle **rectangles,
                                                         gint *n_rectangles);

Obtains the area covered by the region as a list of rectangles. The array returned in rectangles must be freed with g_free().

gdk_region_empty ()

gboolean            gdk_region_empty                    (const GdkRegion *region);

Finds out if the GdkRegion is empty.

gdk_region_equal ()

gboolean            gdk_region_equal                    (const GdkRegion *region1,
                                                         const GdkRegion *region2);

Finds out if the two regions are the same.

gdk_region_rect_equal ()

gboolean            gdk_region_rect_equal               (const GdkRegion *region,
                                                         const GdkRectangle *rectangle);

Finds out if a regions is the same as a rectangle.

Since 2.18

gdk_region_point_in ()

gboolean            gdk_region_point_in                 (const GdkRegion *region,
                                                         int x,
                                                         int y);

Finds out if a point is in a region.

gdk_region_rect_in ()

GdkOverlapType      gdk_region_rect_in                  (const GdkRegion *region,
                                                         const GdkRectangle *rectangle);

Tests whether a rectangle is within a region.

enum GdkOverlapType

typedef enum
{
  GDK_OVERLAP_RECTANGLE_IN,
  GDK_OVERLAP_RECTANGLE_OUT,
  GDK_OVERLAP_RECTANGLE_PART
} GdkOverlapType;

Specifies the possible values returned by gdk_region_rect_in().

gdk_region_offset ()

void                gdk_region_offset                   (GdkRegion *region,
                                                         gint dx,
                                                         gint dy);

Moves a region the specified distance.

gdk_region_shrink ()

void                gdk_region_shrink                   (GdkRegion *region,
                                                         gint dx,
                                                         gint dy);

Resizes a region by the specified amount. Positive values shrink the region. Negative values expand it.

gdk_region_union_with_rect ()

void                gdk_region_union_with_rect          (GdkRegion *region,
                                                         const GdkRectangle *rect);

Sets the area of region to the union of the areas of region and rect. The resulting area is the set of pixels contained in either region or rect.

gdk_region_intersect ()

void                gdk_region_intersect                (GdkRegion *source1,
                                                         const GdkRegion *source2);

Sets the area of source1 to the intersection of the areas of source1 and source2. The resulting area is the set of pixels contained in both source1 and source2.

gdk_region_union ()

void                gdk_region_union                    (GdkRegion *source1,
                                                         const GdkRegion *source2);

Sets the area of source1 to the union of the areas of source1 and source2. The resulting area is the set of pixels contained in either source1 or source2.

gdk_region_subtract ()

void                gdk_region_subtract                 (GdkRegion *source1,
                                                         const GdkRegion *source2);

Subtracts the area of source2 from the area source1. The resulting area is the set of pixels contained in source1 but not in source2.

gdk_region_xor ()

void                gdk_region_xor                      (GdkRegion *source1,
                                                         const GdkRegion *source2);

Sets the area of source1 to the exclusive-OR of the areas of source1 and source2. The resulting area is the set of pixels contained in one or the other of the two sources but not in both.

struct GdkSpan

struct GdkSpan {
  gint x;
  gint y;
  gint width;
};

A GdkSpan represents a horizontal line of pixels starting at the pixel with coordinates x, y and ending before x + width, y.

GdkSpanFunc ()

void                (*GdkSpanFunc)                      (GdkSpan *span,
                                                         gpointer data);

This defines the type of the function passed to gdk_region_spans_intersect_foreach().

gdk_region_spans_intersect_foreach ()

void                gdk_region_spans_intersect_foreach  (GdkRegion *region,
                                                         const GdkSpan *spans,
                                                         int n_spans,
                                                         gboolean sorted,
                                                         GdkSpanFunc function,
                                                         gpointer data);

Calls a function on each span in the intersection of region and spans.