Handling an expose event

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

gboolean
expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
  GdkPixbuf *dest;

  dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, event->area.width, event->area.height);

  gdk_pixbuf_composite_color (pixbuf, dest,
                              0, 0, event->area.width, event->area.height,
                              -event->area.x, -event->area.y,
                              (double) widget->allocation.width / gdk_pixbuf_get_width (pixbuf),
                              (double) widget->allocation.height / gdk_pixbuf_get_height (pixbuf),
                              GDK_INTERP_BILINEAR, 255,
                              event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);

  gdk_draw_pixbuf (widget->window, widget->style->fg_gc[GTK_STATE_NORMAL], dest,
                   0, 0, event->area.x, event->area.y,
                   event->area.width, event->area.height,
                   GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
  
  gdk_pixbuf_unref (dest);
  
  return TRUE;
}

gdk_pixbuf_scale_simple ()

GdkPixbuf *
gdk_pixbuf_scale_simple (const GdkPixbuf *src,
                         int dest_width,
                         int dest_height,
                         GdkInterpType interp_type);

Create a new GdkPixbuf containing a copy of src scaled to dest_width x dest_height . Leaves src unaffected. interp_type should be GDK_INTERP_NEAREST if you want maximum speed (but when scaling down GDK_INTERP_NEAREST is usually unusably ugly). The default interp_type should be GDK_INTERP_BILINEAR which offers reasonable quality and speed.

You can scale a sub-portion of src by creating a sub-pixbuf pointing into src ; see gdk_pixbuf_new_subpixbuf().

If dest_width and dest_height are equal to the src width and height, a copy of src is returned, avoiding any scaling.

For more complicated scaling/alpha blending see gdk_pixbuf_scale() and gdk_pixbuf_composite().

gdk_pixbuf_scale ()

void
gdk_pixbuf_scale (const GdkPixbuf *src,
                  GdkPixbuf *dest,
                  int dest_x,
                  int dest_y,
                  int dest_width,
                  int dest_height,
                  double offset_x,
                  double offset_y,
                  double scale_x,
                  double scale_y,
                  GdkInterpType interp_type);

Creates a transformation of the source image src by scaling by scale_x and scale_y then translating by offset_x and offset_y , then renders the rectangle (dest_x , dest_y , dest_width , dest_height ) of the resulting image onto the destination image replacing the previous contents.

Try to use gdk_pixbuf_scale_simple() first, this function is the industrial-strength power tool you can fall back to if gdk_pixbuf_scale_simple() isn't powerful enough.

If the source rectangle overlaps the destination rectangle on the same pixbuf, it will be overwritten during the scaling which results in rendering artifacts.

gdk_pixbuf_composite_color_simple ()

GdkPixbuf *
gdk_pixbuf_composite_color_simple (const GdkPixbuf *src,
                                   int dest_width,
                                   int dest_height,
                                   GdkInterpType interp_type,
                                   int overall_alpha,
                                   int check_size,
                                   guint32 color1,
                                   guint32 color2);

Creates a new GdkPixbuf by scaling src to dest_width x dest_height and alpha blending the result with a checkboard of colors color1 and color2 .

gdk_pixbuf_composite ()

void
gdk_pixbuf_composite (const GdkPixbuf *src,
                      GdkPixbuf *dest,
                      int dest_x,
                      int dest_y,
                      int dest_width,
                      int dest_height,
                      double offset_x,
                      double offset_y,
                      double scale_x,
                      double scale_y,
                      GdkInterpType interp_type,
                      int overall_alpha);

Creates a transformation of the source image src by scaling by scale_x and scale_y then translating by offset_x and offset_y . This gives an image in the coordinates of the destination pixbuf. The rectangle (dest_x , dest_y , dest_width , dest_height ) is then alpha blended onto the corresponding rectangle of the original destination image.

When the destination rectangle contains parts not in the source image, the data at the edges of the source image is replicated to infinity.

gdk_pixbuf_composite_color ()

void
gdk_pixbuf_composite_color (const GdkPixbuf *src,
                            GdkPixbuf *dest,
                            int dest_x,
                            int dest_y,
                            int dest_width,
                            int dest_height,
                            double offset_x,
                            double offset_y,
                            double scale_x,
                            double scale_y,
                            GdkInterpType interp_type,
                            int overall_alpha,
                            int check_x,
                            int check_y,
                            int check_size,
                            guint32 color1,
                            guint32 color2);

Creates a transformation of the source image src by scaling by scale_x and scale_y then translating by offset_x and offset_y , then alpha blends the rectangle (dest_x ,dest_y , dest_width , dest_height ) of the resulting image with a checkboard of the colors color1 and color2 and renders it onto the destination image.

If the source image has no alpha channel, and overall_alpha is 255, a fast path is used which omits the alpha blending and just performs the scaling.

See gdk_pixbuf_composite_color_simple() for a simpler variant of this function suitable for many tasks.

gdk_pixbuf_rotate_simple ()

GdkPixbuf *
gdk_pixbuf_rotate_simple (const GdkPixbuf *src,
                          GdkPixbufRotation angle);

Rotates a pixbuf by a multiple of 90 degrees, and returns the result in a new pixbuf.

If angle is 0, a copy of src is returned, avoiding any rotation.

Since: 2.6

gdk_pixbuf_flip ()

GdkPixbuf *
gdk_pixbuf_flip (const GdkPixbuf *src,
                 gboolean horizontal);

Flips a pixbuf horizontally or vertically and returns the result in a new pixbuf.

Since: 2.6

enum GdkInterpType

This enumeration describes the different interpolation modes that can be used with the scaling functions. GDK_INTERP_NEAREST is the fastest scaling method, but has horrible quality when scaling down. GDK_INTERP_BILINEAR is the best choice if you aren't sure what to choose, it has a good speed/quality balance.

<note> Cubic filtering is missing from the list; hyperbolic interpolation is just as fast and results in higher quality. </note>

enum GdkPixbufRotation

The possible rotations which can be passed to gdk_pixbuf_rotate_simple(). To make them easier to use, their numerical values are the actual degrees.