X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gdk%2Fgdkdraw.c;h=7d77eaed01c6daacea0d466701fa2a52cdd9e4f6;hb=08580edf1687bcbb5715166846d671c709d42ff7;hp=1139bf461f2f4288f49810db05b32f92c750ed6e;hpb=083c3aef5146ace40284f662feaba2ce3bc20977;p=~andy%2Fgtk diff --git a/gdk/gdkdraw.c b/gdk/gdkdraw.c index 1139bf461..7d77eaed0 100644 --- a/gdk/gdkdraw.c +++ b/gdk/gdkdraw.c @@ -24,6 +24,7 @@ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ +#include #include "gdkdrawable.h" #include "gdkinternals.h" #include "gdkwindow.h" @@ -96,7 +97,7 @@ gdk_drawable_class_init (GdkDrawableClass *klass) /* Default implementation for clip and visible region is the same */ klass->get_clip_region = gdk_drawable_real_get_visible_region; klass->get_visible_region = gdk_drawable_real_get_visible_region; - klass->_draw_pixbuf = gdk_drawable_real_draw_pixbuf; + klass->draw_pixbuf = gdk_drawable_real_draw_pixbuf; } /* Manipulation of drawables @@ -211,6 +212,8 @@ gdk_drawable_get_depth (GdkDrawable *drawable) * Gets the #GdkScreen associated with a #GdkDrawable. * * Return value: the #GdkScreen associated with @drawable + * + * Since: 2.2 **/ GdkScreen* gdk_drawable_get_screen(GdkDrawable *drawable) @@ -227,6 +230,8 @@ gdk_drawable_get_screen(GdkDrawable *drawable) * Gets the #GdkDisplay associated with a #GdkDrawable. * * Return value: the #GdkDisplay associated with @drawable + * + * Since: 2.2 **/ GdkDisplay* gdk_drawable_get_display (GdkDrawable *drawable) @@ -291,7 +296,7 @@ gdk_drawable_get_colormap (GdkDrawable *drawable) GdkDrawable* gdk_drawable_ref (GdkDrawable *drawable) { - return (GdkDrawable *) g_object_ref (G_OBJECT (drawable)); + return (GdkDrawable *) g_object_ref (drawable); } /** @@ -306,11 +311,22 @@ gdk_drawable_unref (GdkDrawable *drawable) { g_return_if_fail (GDK_IS_DRAWABLE (drawable)); - g_object_unref (G_OBJECT (drawable)); + g_object_unref (drawable); } /* Drawing */ + +/** + * gdk_draw_point: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @x: the x coordinate of the point. + * @y: the y coordinate of the point. + * + * Draws a point, using the foreground color and other attributes of + * the #GdkGC. + **/ void gdk_draw_point (GdkDrawable *drawable, GdkGC *gc, @@ -328,6 +344,18 @@ gdk_draw_point (GdkDrawable *drawable, GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc, &point, 1); } +/** + * gdk_draw_line: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @x1_: the x coordinate of the start point. + * @y1_: the y coordinate of the start point. + * @x2_: the x coordinate of the end point. + * @y2_: the y coordinate of the end point. + * + * Draws a line, using the foreground color and other attributes of + * the #GdkGC. + **/ void gdk_draw_line (GdkDrawable *drawable, GdkGC *gc, @@ -350,10 +378,31 @@ gdk_draw_line (GdkDrawable *drawable, GDK_DRAWABLE_GET_CLASS (drawable)->draw_segments (drawable, gc, &segment, 1); } +/** + * gdk_draw_rectangle: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @filled: %TRUE if the rectangle should be filled. + * @x: the x coordinate of the left edge of the rectangle. + * @y: the y coordinate of the top edge of the rectangle. + * @width: the width of the rectangle. + * @height: the height of the rectangle. + * + * Draws a rectangular outline or filled rectangle, using the foreground color + * and other attributes of the #GdkGC. + * + * A rectangle drawn filled is 1 pixel smaller in both dimensions than a + * rectangle outlined. Calling + * gdk_draw_rectangle (window, gc, TRUE, 0, 0, 20, 20) + * results in a filled rectangle 20 pixels wide and 20 pixels high. Calling + * gdk_draw_rectangle (window, gc, FALSE, 0, 0, 20, 20) + * results in an outlined rectangle with corners at (0, 0), (0, 20), (20, 20), + * and (20, 0), which makes it 21 pixels wide and 21 pixels high. + **/ void gdk_draw_rectangle (GdkDrawable *drawable, GdkGC *gc, - gint filled, + gboolean filled, gint x, gint y, gint width, @@ -379,10 +428,28 @@ gdk_draw_rectangle (GdkDrawable *drawable, width, height); } +/** + * gdk_draw_arc: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @filled: %TRUE if the arc should be filled, producing a 'pie slice'. + * @x: the x coordinate of the left edge of the bounding rectangle. + * @y: the y coordinate of the top edge of the bounding rectangle. + * @width: the width of the bounding rectangle. + * @height: the height of the bounding rectangle. + * @angle1: the start angle of the arc, relative to the 3 o'clock position, + * counter-clockwise, in 1/64ths of a degree. + * @angle2: the end angle of the arc, relative to @angle1, in 1/64ths + * of a degree. + * + * Draws an arc or a filled 'pie slice'. The arc is defined by the bounding + * rectangle of the entire ellipse, and the start and end angles of the part + * of the ellipse to be drawn. + **/ void gdk_draw_arc (GdkDrawable *drawable, GdkGC *gc, - gint filled, + gboolean filled, gint x, gint y, gint width, @@ -410,10 +477,23 @@ gdk_draw_arc (GdkDrawable *drawable, x, y, width, height, angle1, angle2); } +/** + * gdk_draw_polygon: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @filled: %TRUE if the polygon should be filled. The polygon is closed + * automatically, connecting the last point to the first point if + * necessary. + * @points: an array of #GdkPoint structures specifying the points making + * up the polygon. + * @npoints: the number of points. + * + * Draws an outlined or filled polygon. + **/ void gdk_draw_polygon (GdkDrawable *drawable, GdkGC *gc, - gint filled, + gboolean filled, GdkPoint *points, gint npoints) { @@ -430,6 +510,19 @@ gdk_draw_polygon (GdkDrawable *drawable, * * Interface changed: add "GdkFont *font" to specify font or fontset explicitely */ +/** + * gdk_draw_string: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @font: a #GdkFont. + * @gc: a #GdkGC. + * @x: the x coordinate of the left edge of the text. + * @y: the y coordinate of the baseline of the text. + * @string: the string of characters to draw. + * + * Draws a string of characters in the given font or fontset. + * + * Deprecated: Use gdk_draw_layout() instead. + **/ void gdk_draw_string (GdkDrawable *drawable, GdkFont *font, @@ -447,6 +540,20 @@ gdk_draw_string (GdkDrawable *drawable, * * Interface changed: add "GdkFont *font" to specify font or fontset explicitely */ +/** + * gdk_draw_text: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @font: a #GdkFont. + * @gc: a #GdkGC. + * @x: the x coordinate of the left edge of the text. + * @y: the y coordinate of the baseline of the text. + * @text: the characters to draw. + * @text_length: the number of characters of @text to draw. + * + * Draws a number of characters in the given font or fontset. + * + * Deprecated: Use gdk_draw_layout() instead. + **/ void gdk_draw_text (GdkDrawable *drawable, GdkFont *font, @@ -464,6 +571,22 @@ gdk_draw_text (GdkDrawable *drawable, GDK_DRAWABLE_GET_CLASS (drawable)->draw_text (drawable, font, gc, x, y, text, text_length); } +/** + * gdk_draw_text_wc: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @font: a #GdkFont. + * @gc: a #GdkGC. + * @x: the x coordinate of the left edge of the text. + * @y: the y coordinate of the baseline of the text. + * @text: the wide characters to draw. + * @text_length: the number of characters to draw. + * + * Draws a number of wide characters using the given font of fontset. + * If the font is a 1-byte font, the string is converted into 1-byte + * characters (discarding the high bytes) before output. + * + * Deprecated: Use gdk_draw_layout() instead. + **/ void gdk_draw_text_wc (GdkDrawable *drawable, GdkFont *font, @@ -485,7 +608,7 @@ gdk_draw_text_wc (GdkDrawable *drawable, * gdk_draw_drawable: * @drawable: a #GdkDrawable * @gc: a #GdkGC sharing the drawable's visual and colormap - * @src: another #GdkDrawable + * @src: the source #GdkDrawable, which may be the same as @drawable * @xsrc: X position in @src of rectangle to draw * @ysrc: Y position in @src of rectangle to draw * @xdest: X position in @drawable where the rectangle should be drawn @@ -556,9 +679,26 @@ gdk_draw_drawable (GdkDrawable *drawable, xdest, ydest, width, height); - g_object_unref (G_OBJECT (composite)); + g_object_unref (composite); } +/** + * gdk_draw_image: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @image: the #GdkImage to draw. + * @xsrc: the left edge of the source rectangle within @image. + * @ysrc: the top of the source rectangle within @image. + * @xdest: the x coordinate of the destination within @drawable. + * @ydest: the y coordinate of the destination within @drawable. + * @width: the width of the area to be copied, or -1 to make the area + * extend to the right edge of @image. + * @height: the height of the area to be copied, or -1 to make the area + * extend to the bottom edge of @image. + * + * Draws a #GdkImage onto a drawable. + * The depth of the #GdkImage must match the depth of the #GdkDrawable. + **/ void gdk_draw_image (GdkDrawable *drawable, GdkGC *gc, @@ -584,7 +724,7 @@ gdk_draw_image (GdkDrawable *drawable, } /** - * _gdk_draw_pixbuf: + * gdk_draw_pixbuf: * @drawable: Destination drawable. * @gc: a #GdkGC, used for clipping, or %NULL * @pixbuf: a #GdkPixbuf @@ -594,20 +734,26 @@ gdk_draw_image (GdkDrawable *drawable, * @dest_y: Destination Y coordinate within drawable. * @width: Width of region to render, in pixels, or -1 to use pixbuf width. * @height: Height of region to render, in pixels, or -1 to use pixbuf height. - * @dither: Dithering mode for GdkRGB. + * @dither: Dithering mode for #GdkRGB. * @x_dither: X offset for dither. * @y_dither: Y offset for dither. * * Renders a rectangular portion of a pixbuf to a drawable. The destination * drawable must have a colormap. All windows have a colormap, however, pixmaps - * only have colormap by default if they were created with a non-NULL window argument. - * Otherwise a colormap must be set on them with gdk_drawable_set_colormap. + * only have colormap by default if they were created with a non-%NULL window + * argument. Otherwise a colormap must be set on them with + * gdk_drawable_set_colormap(). * - * On older X servers, rendering pixbufs with an alpha channel involves round trips - * to the X server, and may be somewhat slow. + * On older X servers, rendering pixbufs with an alpha channel involves round + * trips to the X server, and may be somewhat slow. + * + * The clip mask of @gc is ignored, but clip rectangles and clip regions work + * fine. + * + * Since: 2.2 **/ void -_gdk_draw_pixbuf (GdkDrawable *drawable, +gdk_draw_pixbuf (GdkDrawable *drawable, GdkGC *gc, GdkPixbuf *pixbuf, gint src_x, @@ -629,11 +775,21 @@ _gdk_draw_pixbuf (GdkDrawable *drawable, if (height == -1) height = gdk_pixbuf_get_height (pixbuf); - GDK_DRAWABLE_GET_CLASS (drawable)->_draw_pixbuf (drawable, gc, pixbuf, - src_x, src_y, dest_x, dest_y, width, height, - dither, x_dither, y_dither); + GDK_DRAWABLE_GET_CLASS (drawable)->draw_pixbuf (drawable, gc, pixbuf, + src_x, src_y, dest_x, dest_y, width, height, + dither, x_dither, y_dither); } +/** + * gdk_draw_points: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @points: an array of #GdkPoint structures. + * @npoints: the number of points to be drawn. + * + * Draws a number of points, using the foreground color and other + * attributes of the #GdkGC. + **/ void gdk_draw_points (GdkDrawable *drawable, GdkGC *gc, @@ -651,6 +807,17 @@ gdk_draw_points (GdkDrawable *drawable, GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc, points, npoints); } +/** + * gdk_draw_segments: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @segs: an array of #GdkSegment structures specifying the start and + * end points of the lines to be drawn. + * @nsegs: the number of line segments to draw, i.e. the size of the + * @segs array. + * + * Draws a number of unconnected lines. + **/ void gdk_draw_segments (GdkDrawable *drawable, GdkGC *gc, @@ -669,13 +836,24 @@ gdk_draw_segments (GdkDrawable *drawable, GDK_DRAWABLE_GET_CLASS (drawable)->draw_segments (drawable, gc, segs, nsegs); } +/** + * gdk_draw_lines: + * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). + * @gc: a #GdkGC. + * @points: an array of #GdkPoint structures specifying the endpoints of the + * @npoints: the size of the @points array. + * + * Draws a series of lines connecting the given points. + * The way in which joins between lines are draw is determined by the + * #GdkCapStyle value in the #GdkGC. This can be set with + * gdk_gc_set_line_attributes(). + **/ void gdk_draw_lines (GdkDrawable *drawable, GdkGC *gc, GdkPoint *points, gint npoints) { - g_return_if_fail (GDK_IS_DRAWABLE (drawable)); g_return_if_fail (points != NULL); g_return_if_fail (GDK_IS_GC (gc)); @@ -723,7 +901,7 @@ gdk_draw_glyphs (GdkDrawable *drawable, /** - * _gdk_drawable_copy_to_image: + * gdk_drawable_copy_to_image: * @drawable: a #GdkDrawable * @image: a #GdkDrawable, or %NULL if a new @image should be created. * @src_x: x coordinate on @drawable @@ -738,17 +916,19 @@ gdk_draw_glyphs (GdkDrawable *drawable, * and copies into that. See gdk_drawable_get_image() for further details. * * Return value: @image, or a new a #GdkImage containing the contents - of @drawable + * of @drawable + * + * Since: 2.4 **/ GdkImage* -_gdk_drawable_copy_to_image (GdkDrawable *drawable, - GdkImage *image, - gint src_x, - gint src_y, - gint dest_x, - gint dest_y, - gint width, - gint height) +gdk_drawable_copy_to_image (GdkDrawable *drawable, + GdkImage *image, + gint src_x, + gint src_y, + gint dest_x, + gint dest_y, + gint width, + gint height) { GdkDrawable *composite; gint composite_x_offset = 0; @@ -783,7 +963,7 @@ _gdk_drawable_copy_to_image (GdkDrawable *drawable, dest_x, dest_y, width, height); - g_object_unref (G_OBJECT (composite)); + g_object_unref (composite); if (!image && retval) { @@ -874,7 +1054,7 @@ gdk_drawable_get_image (GdkDrawable *drawable, y - composite_y_offset, width, height); - g_object_unref (G_OBJECT (composite)); + g_object_unref (composite); cmap = gdk_drawable_get_colormap (drawable); @@ -891,7 +1071,7 @@ gdk_drawable_real_get_image (GdkDrawable *drawable, gint width, gint height) { - return _gdk_drawable_copy_to_image (drawable, NULL, x, y, 0, 0, width, height); + return gdk_drawable_copy_to_image (drawable, NULL, x, y, 0, 0, width, height); } static GdkDrawable* @@ -908,7 +1088,7 @@ gdk_drawable_real_get_composite_drawable (GdkDrawable *drawable, *composite_x_offset = 0; *composite_y_offset = 0; - return GDK_DRAWABLE (g_object_ref (G_OBJECT (drawable))); + return g_object_ref (drawable); } /** @@ -1150,7 +1330,6 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable *drawable, gint x_dither, gint y_dither) { - gboolean free_gc = FALSE; GdkPixbuf *composited = NULL; gint dwidth, dheight; GdkRegion *clip; @@ -1226,12 +1405,8 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable *drawable, return; /* Actually draw */ - if (!gc) - { - gc = gdk_gc_new (drawable); - free_gc = TRUE; - } + gc = _gdk_drawable_get_scratch_gc (drawable, FALSE); if (pixbuf->has_alpha) { @@ -1283,10 +1458,10 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable *drawable, width1, height1, gdk_drawable_get_depth (drawable), &xs0, &ys0); - _gdk_drawable_copy_to_image (drawable, image, - dest_x + x0, dest_y + y0, - xs0, ys0, - width1, height1); + gdk_drawable_copy_to_image (drawable, image, + dest_x + x0, dest_y + y0, + xs0, ys0, + width1, height1); (*composite_func) (pixbuf->pixels + (src_y + y0) * pixbuf->rowstride + (src_x + x0) * 4, pixbuf->rowstride, (guchar*)image->mem + ys0 * image->bpl + xs0 * image->bpp, @@ -1355,8 +1530,64 @@ gdk_drawable_real_draw_pixbuf (GdkDrawable *drawable, out: if (composited) - g_object_unref (G_OBJECT (composited)); + g_object_unref (composited); +} + +/** + * _gdk_drawable_get_scratch_gc: + * @drawable: A #GdkDrawable + * @graphics_exposures: Whether the returned #GdkGC should generate graphics exposures + * + * Returns a #GdkGC suitable for drawing on @drawable. The #GdkGC has + * the standard values for @drawable, except for the graphics_exposures + * field which is determined by the @graphics_exposures parameter. + * + * The foreground color of the returned #GdkGC is undefined. The #GdkGC + * must not be altered in any way, except to change its foreground color. + * + * Return value: A #GdkGC suitable for drawing on @drawable + * + * Since: 2.4 + **/ +GdkGC * +_gdk_drawable_get_scratch_gc (GdkDrawable *drawable, + gboolean graphics_exposures) +{ + GdkScreen *screen; + gint depth; + + g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL); + + screen = gdk_drawable_get_screen (drawable); + + g_return_val_if_fail (!screen->closed, NULL); + + depth = gdk_drawable_get_depth (drawable) - 1; + + if (graphics_exposures) + { + if (!screen->exposure_gcs[depth]) + { + GdkGCValues values; + GdkGCValuesMask mask; - if (free_gc) - gdk_gc_unref (gc); + values.graphics_exposures = TRUE; + mask = GDK_GC_EXPOSURES; + + screen->exposure_gcs[depth] = + gdk_gc_new_with_values (drawable, &values, mask); + } + + return screen->exposure_gcs[depth]; + } + else + { + if (!screen->normal_gcs[depth]) + { + screen->normal_gcs[depth] = + gdk_gc_new (drawable); + } + + return screen->normal_gcs[depth]; + } }