gtk.gdk.Drawable
Prev | The gtk.gdk Class Reference | Next

## gtk.gdk.Drawable

gtk.gdk.Drawable — a base class for drawing methods

## Synopsis

    class gtk.gdk.Drawable(gobject.GObject):
        def get_size()
        def set_colormap(colormap)
        def get_colormap()
        def get_visual()
        def get_depth()
        def get_screen()
        def get_display()
        def draw_point(gc, x, y)
        def draw_line(gc, x1, y1, x2, y2)
        def draw_rectangle(gc, filled, x, y, width, height)
        def draw_arc(gc, filled, x, y, width, height, angle1, angle2)
        def draw_polygon(gc, filled, points)
        def draw_drawable(gc, src, xsrc, ysrc, xdest, ydest, width, height)
        def draw_image(gc, image, xsrc, ysrc, xdest, ydest, width, height)
        def draw_points(gc, points)
        def draw_segments(gc, segs)
        def draw_lines(gc, points)
        def draw_pixbuf(gc, pixbuf, src_x, src_y, dest_x, dest_y, width=-1, height=-1, dither=gtk.gdk.RGB_DITHER_NORMAL, x_dither=0, y_dither=0)
        def draw_glyphs(gc, font, x, y, glyphs)
        def draw_layout_line(gc, x, y, line, layout, foreground=None, background=None)
        def draw_layout(gc, x, y, layout, foreground=None, background=None)
        def get_image(x, y, width, height)
        def get_clip_region()
        def get_visible_region()
        def new_gc(foreground, background, font, function, fill, tile, stipple, clip_mask, subwindow_mode, ts_x_origin, ts_y_origin, clip_x_origin, clip_y_origin, graphics_exposures, line_width, line_style, cap_style, join_style>)
        def draw_rgb_image(gc, x, y, width, height, dith, rgb_buf, rowstride=-1, xdith=0, ydith=0)
        def draw_rgb_32_image(gc, x, y, width, height, dith, rgb_buf, rowstride=-1, xdith=0, ydith=0)
        def draw_gray_image(gc, x, y, width, height, dith, buf, rowstride=-1)
        def draw_indexed_image(gc, x, y, width, height, dith, buf, rowstride, cmap)
        def cairo_create()

## Ancestry

    +-- gobject.GObject
      +-- gtk.gdk.Drawable

## Attributes

"handle" | Read | The handle of the MS Windows window associated with the drawable. Not supported on X11.
"xid" | Read | The id of the X window available with the drawable. Not supported on MS Windows

## Description

A `gtk.gdk.Drawable` is a base class providing drawing primitives for its subclasses: `gtk.gdk.Pixmap` and `gtk.gdk.Window`.

These methods provide support for drawing points, lines, arcs and text onto what are called 'drawables'. Drawables, as the name suggests, are things which support drawing onto them, and are either `gtk.gdk.Window` or `gtk.gdk.Pixmap` objects.

Many of the drawing operations take a `gtk.gdk.GC` argument, which represents a graphics context. This `gtk.gdk.GC` contains a number of drawing attributes such as foreground color, background color and line width, and is used to reduce the number of arguments needed for each drawing operation. See the `Graphics Contexts` section for more information.

Some of the drawing operations take Pango objects like `pango.Context` or `pango.Layout` as arguments. Use the `gtk.Widget.create_pango_context`() or `gtk.Widget.create_pango_layout`() methods to obtain these objects.

## Methods

### gtk.gdk.Drawable.get_size

        def get_size()

Returns : | a tuple containing the drawable's width and height

The `get_size`() method returns a tuple containing the width and height of the drawable.

On the X11 platform, if the drawable is a `gtk.gdk.Window`, the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server.

### gtk.gdk.Drawable.set_colormap

        def set_colormap(colormap)

`colormap` : | a `gtk.gdk.Colormap`

The `set_colormap`() method sets the `gtk.gdk.Colormap` associated with the drawable to the value specified by `colormap`. Normally this will happen automatically when the drawable is created; you only need to use this function if the drawable-creating function did not have a way to determine the colormap, and you then use drawable operations that require a colormap. The colormap for all drawables and graphics contexts you intend to use together should match. i.e. when using a `gtk.gdk.GC` to draw to a drawable, or copying one drawable to another, the colormaps should match.

### gtk.gdk.Drawable.get_colormap

        def get_colormap()

Returns : | the colormap, or `None`

The `get_colormap`() method returns the `gtk.gdk.Colormap` for the drawable or `None` if no colormap is set.

### gtk.gdk.Drawable.get_visual

        def get_visual()

Returns : | a `gtk.gdk.Visual`

The `get_visual`() method returns the `gtk.gdk.Visual` describing the pixel format of the drawable.

### gtk.gdk.Drawable.get_depth

        def get_depth()

Returns : | the number of bits per pixel

The `get_depth`() method returns the bit depth of the drawable, that is, the number of bits that make up a pixel in the drawable's visual. Examples are 8 bits per pixel, 24 bits per pixel, etc.

### gtk.gdk.Drawable.get_screen

        def get_screen()

Returns : | the `gtk.gdk.Screen` associated with the drawable

### Note

This method is available in PyGTK 2.2 and above.

The `get_screen`() method returns the `gtk.gdk.Screen` associated with the drawable.

### gtk.gdk.Drawable.get_display

        def get_display()

Returns : | the `gtk.gdk.Display` associated with the drawable

### Note

This method is available in PyGTK 2.2 and above.

The `get_display`() method returns the `gtk.gdk.Display` associated with the drawable.

### gtk.gdk.Drawable.draw_point

        def draw_point(gc, x, y)

`gc` : | a graphics context
`x` : | the X coordinate of the point in drawable coordinates
`y` : | the Y coordinate of the point in drawable coordinates

The `draw_point`() method draws a point at the location specified by `x` and `y` in the drawable using the `gtk.gdk.GC` graphics context specified by `gc`.

### gtk.gdk.Drawable.draw_line

        def draw_line(gc, x1, y1, x2, y2)

`gc` : | a graphics context
`x1` : | the X coordinate of the first point
`y1` : | the Y coordinate of the first point
`x2` : | the X coordinate of the second point
`y2` : | the Y coordinate of the second point

The `draw_line`() method draws a line between the two points specified by (`x1`, `y1`) and (`x2`, `y2`) using the `gtk.gdk.GC` graphics context specified by `gc`.

### gtk.gdk.Drawable.draw_rectangle

        def draw_rectangle(gc, filled, x, y, width, height)

`gc` : | a graphics context
`filled` : | if `TRUE` the rectangle will be filled with the foreground color
`x` : | the X coordinate of the top left corner
`y` : | the Y coordinate of the top left corner
`width` : | the width of the rectangle
`height` : | the height of the rectangle

The `draw_rectangle`() method draws a rectangle of the specified `width` and `height` with its top left corner at the location specified by (`x`, `y`) using the `gtk.gdk.GC` graphics context specified by `gc`. If `filled` is `TRUE` the rectangle will be filled with the foreground color.

### Note

A rectangle drawn filled is 1 pixel smaller in both dimensions than a rectangle outlined. Calling:

      window.draw_rectangle(gc, TRUE, 0, 0, 20, 20)

results in a filled rectangle 20 pixels wide and 20 pixels high. Calling:

      window.draw_rectangle(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.

### gtk.gdk.Drawable.draw_arc

        def draw_arc(gc, filled, x, y, width, height, angle1, angle2)

`gc` : | a graphics context
`filled` : | if `TRUE` the arc will be filled with the foreground color creating 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, counter-clockwise, in 1/64ths of a degree.

The `draw_arc`() method draws an arc or a filled 'pie slice' if `filled` is `TRUE`. The arc is defined by the bounding rectangle of the entire ellipse (specified by `x`, `y`, `width` and `height`), and the start and end angles of the part of the ellipse to be drawn (specified by `angle1` and `angle2`). The `gtk.gdk.GC` graphics context specified by `gc` is used to determine the drawing attributes.

### gtk.gdk.Drawable.draw_polygon

        def draw_polygon(gc, filled, points)

`gc` : | a graphics context
`filled` : | if `TRUE` the polygon will be filled with the foreground color
`points` : | a sequence of 2-tuples

The `draw_polygon`() method draws an outlined or filled polygon using the points specified by `points`. `points` is a sequence of 2-tuples that each contain an x and y coordinate of a point. The points are connected in the order that they are specified and the last point is automatically connected to the first point. The `gtk.gdk.GC` graphics context specified by `gc` is used to determine the drawing attributes.

### gtk.gdk.Drawable.draw_drawable

        def draw_drawable(gc, src, xsrc, ysrc, xdest, ydest, width, height)

`gc` : | a `gtk.gdk.GC` sharing the drawable's visual and colormap
`src` : | another `gtk.gdk.Drawable`
`xsrc` : | the X position in `src` of rectangle to draw
`ysrc` : | the Y position in `src` of rectangle to draw
`xdest` : | the X position in the drawable where the rectangle should be drawn
`ydest` : | the Y position in the drawable where the rectangle should be drawn
`width` : | the width of rectangle to draw, or -1 for entire `src` width
`height` : | the height of rectangle to draw, or -1 for entire `src` height

The draw_drawable() method copies the specified `width` x `height` area of the drawable specified by `src` at the specified coordinates (`xsrc`, `ysrc`) to the specified coordinates (`xdest`, `ydest`) in the drawable. `width` and `height` may be given as -1, to copy the entire `src` drawable. Most fields in the `gtk.gdk.GC` specified by `gc` are not used for this operation, but the clip mask or clip region will be honored.

The source and destination drawables must have the same visual and colormap, or errors will result. (On X11, failure to match visual and colormap results in a `BadMatch` error from the X server.) A common cause of this problem is an attempt to draw a bitmap to a color drawable. The way to draw a bitmap is to set the bitmap as a clip mask on your `gtk.gdk.GC`, then use the `draw_rectangle`() method to draw a rectangle clipped to the bitmap.

### gtk.gdk.Drawable.draw_image

        def draw_image(gc, image, xsrc, ysrc, xdest, ydest, width, height)

`gc` : | a graphics context
`image` : | a `gtk.gdk.Image`
`xsrc` : | the left edge of the source rectangle within `image`.
`ysrc` : | the top edge of the source rectangle within `image`.
`xdest` : | the left edge of the destination within drawable.
`ydest` : | the top edge 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`.

The `draw_image`() method draws the portion of the `gtk.gdk.Image` specified by the rectangle (`xsrc`, `ysrc`, `width` and `height`) onto the drawable at the location specified by `xdest` and `ydest`. The depth of the `gtk.gdk.Image` must match the depth of the `gtk.gdk.Drawable`. The `gtk.gdk.GC` graphics context specified by `gc` is used to determine the drawing attributes.

### gtk.gdk.Drawable.draw_points

        def draw_points(gc, points)

`gc` : | a graphics context
`points` : | a sequence of 2-tuples

The `draw_points`() method draws the set of points specified by `points` on the drawable using the `gtk.gdk.GC` graphics context specified by `gc`. `points` is a sequence of 2-tuples each containing a pair of x and y coordinates of a point location in the drawable.

### gtk.gdk.Drawable.draw_segments

        def draw_segments(gc, segs)

`gc` : | a graphics context
`segs` : | a sequence of 4-tuples

The `draw_segments`() method draws a set of line segments specified by `segs` on the drawable using the `gtk.gdk.GC` graphics context specified by `gc` to specify the drawing attributes. `segs` is a sequence of 4-tuples each containing the coordinates of the start and end points of the line segment in the format (x1, y1, x2, y2).

### gtk.gdk.Drawable.draw_lines

        def draw_lines(gc, points)

`gc` : | a graphics context
`points` : | a sequence of 2-tuples

The `draw_lines`() method draws a series of lines connecting the points specified by `points`. `points` is a sequence of 2-tuples each containing the x and y coordinates of a point location. The `gtk.gdk.GC` graphics context specified by `gc` is used to determine the drawing attributes.The style of joins between lines is determined by the cap style attribute in the `gtk.gdk.GC`. This can be set with the `gtk.gdk.GC.set_line_attributes`() method.

### gtk.gdk.Drawable.draw_pixbuf

        def draw_pixbuf(gc, pixbuf, src_x, src_y, dest_x, dest_y, width=-1, height=-1, dither=gtk.gdk.RGB_DITHER_NORMAL, x_dither=0, y_dither=0)

`gc` : | a `gtk.gdk.GC`, used for clipping, or `None`
`pixbuf` : | a `gtk.gdk.Pixbuf`
`src_x` : | Source X coordinate within pixbuf.
`src_y` : | Source Y coordinate within pixbuf.
`dest_x` : | Destination X coordinate within drawable.
`dest_y` : | Destination Y coordinate within drawable.
`width` : | Width of region to render, in pixels, or -1 to use pixbuf width. Must be specified in PyGTK 2.2.
`height` : | Height of region to render, in pixels, or -1 to use pixbuf height. Must be specified in PyGTK 2.2
`dither` : | Dithering mode for `GdkRGB`.
`x_dither` : | X offset for dither.
`y_dither` : | Y offset for dither.

### Note

This method is available in PyGTK 2.2 and above.

The `draw_pixbuf`() method renders a rectangular portion of a `gtk.gdk.Pixbuf` specified by `pixbuf` to the drawable using the `gtk.gdk.GC` specified by `gc`. The portion of `pixbuf` that is rendered is specified by the origin point (`src_x` `src_y`) and the `width` and `height` arguments. `pixbuf` is rendered to the location in the drawable specified by (`dest_x` `dest_y`). `dither` specifies the dithering mode as one of:

`gtk.gdk.RGB_DITHER_NONE` | Never use dithering.
`gtk.gdk.RGB_DITHER_NORMAL` | Use dithering in 8 bits per pixel (and below) only.
`gtk.gdk.RGB_DITHER_MAX` | Use dithering in 16 bits per pixel and below.

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-`None` window argument. Otherwise a colormap must be set on them with the `gtk.gdk.Drawable.set_colormap()` method.

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.

### gtk.gdk.Drawable.draw_glyphs

        def draw_glyphs(gc, font, x, y, glyphs)

`gc` : | a `gtk.gdk.GC`
`font` : | the font to be used
`x` : | the X coordinate of baseline origin
`y` : | the Y coordinate of baseline origin
`glyphs` : | the glyphs to render

The `draw_glyphs`() method draws the sequence of glyphs (characters in a font) specified by `glyphs` at the location specified by `x` and `y` using the font specified by `font`. Instead of using this method 99% of text rendering should be done using the `draw_layout`() method.

### gtk.gdk.Drawable.draw_layout_line

        def draw_layout_line(gc, x, y, line, foreground=None, background=None)

`gc` : | base graphics to use
`x` : | the x position of start of string (in pixels)
`y` : | the y position of baseline (in pixels)
`line` : | a `pango.LayoutLine`
`foreground` : | a `gtk.gdk.Color` to override the foreground color or `None`
`background` : | a `gtk.gdk.Color` to override the background color or `None`

### Note

This method is available in PyGTK 2.10 and above.

The `draw_layout_line`() method renders the `pango.LayoutLine` specified by `line` onto the drawable at the position specified by (`x`, `y`). The `gtk.gdk.GC` specified by `gc` is used as the graphics context but the layout's normal colors may be overriden with the `gtk.gdk.Color`s specified by `foreground` and/or `background`. `foreground` and `background` are optional and default to `None`.

If the layout's `pango.Context` has a transformation matrix set, then `x` and `y` specify the position of the left edge of the baseline (left is in before-tranform user coordinates) in after-transform device coordinates.

### gtk.gdk.Drawable.draw_layout

        def draw_layout(gc, x, y, layout, foreground=None, background=None)

`gc` : | base graphics context to use
`x` : | the X position of the left of the layout (in pixels)
`y` : | the Y position of the top of the layout (in pixels)
`layout` : | a `pango.Layout`
`foreground` : | a `gtk.gdk.Color` to override the foreground color or `None`
`background` : | a `gtk.gdk.Color` to override the background color or `None`

The `draw_layout`() method renders the `pango.Layout` specified by `layout` onto the drawable at the location specified by `x` and `y`. If `foreground` or `background` has a value other than `None` it is used to override the corresponding attribute specified by `gc`.

### gtk.gdk.Drawable.get_image

        def get_image(x, y, width, height)

`x` : | the X coordinate on the drawable
`y` : | the Y coordinate on the drawable
`width` : | the width of region to get
`height` : | the height or region to get
Returns : | a `gtk.gdk.Image` containing the contents of the drawable

The `get_image`() method returns a `gtk.gdk.Image` object containing a copy of the region in the drawable specified by `x`, `y`, `width` and `height`. A `gtk.gdk.Image` stores client-side image data (pixels). In contrast, a `gtk.gdk.Pixmap` and `gtk.gdk.Window` are server-side objects. The `get_image`() method retrieves the pixels from a server-side drawable as a client-side `gtk.gdk.Image`. The format of a `gtk.gdk.Image` depends on the `gtk.gdk.Visual` of the current display, which makes manipulating `gtk.gdk.Image` extremely difficult; therefore, in most cases you should use the `gtk.gdk.Pixbuf.get_from_drawable`() method instead of this lower-level function. A `gtk.gdk.Pixbuf` contains image data in a canonicalized RGB format, rather than a display-dependent format. Of course, there's a convenience vs. speed tradeoff here, so you'll want to think about what makes sense for your application.

You would usually copy image data to the client side if you intend to examine the values of individual pixels, for example to darken an image or add a red tint. It would be prohibitively slow to make a round-trip request to the windowing system for each pixel, so instead you get all of them at once, modify them, then copy them all back at once. If the X server or other windowing system backend is on the local machine, this function may use shared memory to avoid copying the image data. If the source drawable is a `gtk.gdk.Window` and partially off screen or obscured, then the obscured portions of the returned image will contain undefined data.

### gtk.gdk.Drawable.get_clip_region

        def get_clip_region()

Returns : | a `gtk.gdk.Region`.

### Note

This method is available in PyGTK 2.10 and above.

The `get_clip_region`() method computes and returns the `gtk.gdk.Region` of the drawable that potentially can be written to by drawing primitives. This region will not take into account the clip region for the `gtk.gdk.GC`, and may also not take into account other factors such as if the window is obscured by other windows, but no area outside of this region will be affected by drawing primitives.

### gtk.gdk.Drawable.get_visible_region

        def get_visible_region()

Returns : | a `gtk.gdk.Region`. This must be freed with `gdk_region_destroy()` when you are done.

### Note

This method is available in PyGTK 2.10 and above.

The `get_visible_region`() method computes and returns the `gtk.gdk.Region` of the drawable that is potentially visible. This does not necessarily take into account if the window is obscured by other windows, but no area outside of this region is visible.

### gtk.gdk.Drawable.new_gc

        def new_gc(foreground, background, font, function, fill, tile, stipple, clip_mask, subwindow_mode, ts_x_origin, ts_y_origin, clip_x_origin, clip_y_origin, graphics_exposures, line_width, line_style, cap_style, join_style>)

`foreground` : | the foreground `gtk.gdk.Color`
`background` : | the background `gtk.gdk.Color`
`font` : | a font (deprecated and ignored)
`function` : | the bitwise operator used to combine the existing pixel value and a new pixel value - usually one of: `gtk.gdk.COPY`, `gtk.gdk.XOR` or `gtk.gdk.INVERT`.
`fill` : | the fill style - one of: `gtk.gdk.SOLID`, `gtk.gdk.TILED`, `gtk.gdk.STIPPLED`, `gtk.gdk.OPAQUE_STIPPLED`
`tile` : | a `gtk.gdk.Pixmap` used for tiling the background
`stipple` : | a `gtk.gdk.Pixmap` used for stippling the background
`clip_mask` : | a `gtk.gdk.Pixmap` of depth 1 used to mask pixels to be drawn
`subwindow_mode` : | the mode of drawing on subwindows in a `gtk.gdk.Window` - one of: `gtk.gdk.CLIP_BY_CHILDREN` or `gtk.gdk.INCLUDE_INFERIORS`
`ts_x_origin` : | the X coordinate of the origin of `tile` or `stipple`
`ts_y_origin` : | the Y coordinate of the origin of `tile` or `stipple`
`clip_x_origin` : | the X coordinate of the origin of `clip_mask`
`clip_y_origin` : | the Y coordinate of the origin of `clip_mask`
`graphics_exposures` : | if `TRUE` graphics exposures are enabled for calls to the `draw_drawable`() method.
`line_width` : | the line width in pixels
`line_style` : | the line style - one of: `gtk.gdk.LINE_SOLID`, `gtk.gdk.LINE_ON_OFF_DASH`, `gtk.gdk.LINE_DOUBLE_DASH`
`cap_style` : | the style of line ends - one of: `gtk.gdk.CAP_NOT_LAST`, `gtk.gdk.CAP_BUTT`, `gtk.gdk.CAP_ROUND`, `gtk.gdk.CAP_PROJECTING`
`join_style` : | the style of line joins - one of: `gtk.gdk.JOIN_MITER`, `gtk.gdk.JOIN_ROUND`, `gtk.gdk.JOIN_BEVEL`
Returns : | a graphics context

The `new_gc`() method creates a new `gtk.gdk.GC` object with the attributes as specified by the arguments. Since there are a large number of parameters it's probably best to specify the attributes using keywords. Any attributes not specified will use a default value.

### gtk.gdk.Drawable.draw_rgb_image

        def draw_rgb_image_dithalign(gc, x, y, width, height, dith, rgb_buf, rowstride=-1, xdith=0, ydith=0)

`gc` : | a graphics context
`x` : | the X coordinate of the top-left corner in the drawable.
`y` : | the Y coordinate of the top-left corner in the drawable.
`width` : | the width of the image to be drawn.
`height` : | the height of the image to be drawn.
`dith` : | a dither value - one of: `gtk.gdk.RGB_DITHER_NONE`, `gtk.gdk.RGB_DITHER_NORMAL`, `gtk.gdk.RGB_DITHER_MAX`
`rgb_buf` : | the pixel data, represented as packed 24-bit data.
`rowstride` : | the number of bytes from the start of one row in `rgb_buf` to the start of the next or -1 to calculate the number of bytes.
`xdith` : | an X offset for dither alignment.
`ydith` : | a Y offset for dither alignment.

The `draw_rgb_image`() method draws an RGB image in the drawable, with an adjustment for dither alignment. This method is useful when drawing dithered images into a window that may be scrolled. Pixel (x, y) will be drawn dithered as if its actual location is (x + xdith, y + ydith). Thus, if you draw an image into a window using zero dither alignment, then scroll up one pixel, subsequent draws to the window should have ydith = 1. Setting the dither alignment correctly allows updating of small parts of the screen while avoiding visible "seams" between the different dither textures.

### gtk.gdk.Drawable.draw_rgb_32_image

        def draw_rgb_32_image(gc, x, y, width, height, dith, rgb_buf, rowstride=-1, xdith=0, ydith=0)

`gc` : | a graphics context
`x` : | the X coordinate of the top-left corner in the drawable.
`y` : | the Y coordinate of the top-left corner in the drawable.
`width` : | the width of the image to be drawn.
`height` : | the height of the image to be drawn.
`dith` : | a dither value - one of: `gtk.gdk.RGB_DITHER_NONE`, `gtk.gdk.RGB_DITHER_NORMAL`, `gtk.gdk.RGB_DITHER_MAX`
`buf` : | the pixel data, represented as padded 32-bit data.
`rowstride` : | the number of bytes from the start of one row in `buf` to the start of the next or -1 to calculate the number of bytes.
`xdith` : | an X offset for dither alignment.
`ydith` : | a Y offset for dither alignment.

The `draw_rgb_32_image`() method draws a padded RGB image in the drawable. The image is stored as one pixel per 32-bit word. It is laid out as a red byte, a green byte, a blue byte, and a padding byte. Otherwise this method works the same as the `draw_rgb_image`() method.

### gtk.gdk.Drawable.draw_gray_image

        def draw_gray_image(gc, x, y, width, height, dith, buf, rowstride=-1)

`gc` : | a graphics context
`x` : | the X coordinate of the top-left corner in the drawable.
`y` : | the Y coordinate of the top-left corner in the drawable.
`width` : | the width of the image to be drawn.
`height` : | the height of the image to be drawn.
`dith` : | a dither value - one of: `gtk.gdk.RGB_DITHER_NONE`, `gtk.gdk.RGB_DITHER_NORMAL`, `gtk.gdk.RGB_DITHER_MAX`
`buf` : | the pixel data, represented as 8-bit gray values.
`rowstride` : | the number of bytes from the start of one row in `buf` to the start of the next or -1 to calculate the number of bytes.

The `draw_gray_image`() method draws a grayscale image on the drawable at the location specified by `x` and `y` with the image data in `buf`.

### gtk.gdk.Drawable.draw_indexed_image

        def draw_indexed_image(gc, x, y, width, height, dith, buf, rowstride, colors)

`gc` : | a graphics context
`x` : | The x coordinate of the top-left corner in the drawable.
`y` : | the y coordinate of the top-left corner in the drawable.
`width` : | the width of the rectangle to be drawn.
`height` : | the height of the rectangle to be drawn.
`dith` : | a GdkRgbDither value, selecting the desired dither mode.
`buf` : | the pixel data, represented as 8-bit color indices.
`rowstride` : | the number of bytes from the start of one row in `buf` to the start of the next.
`colors` : | a list of colors represented as 0xRRGGBB integer values.

### Note

This method is available in PyGTK 2.10 and above.

The `draw_indexed_image`() method draws an indexed image in the drawable, using the list of colors specified by `colors` to assign actual colors to the image's color indices.

### gtk.gdk.Drawable.cairo_create

        def cairo_create()

Returns : | a `gtk.gdk.CairoContext`

### Note

This method is available in PyGTK 2.8 and above.

The `cairo_create`() method returns a `gtk.gdk.CairoContext` object to be used for drawing on the drawable using Cairo drawing operations.

Prev | Up | Next
gtk.gdk.DragContext | Home | gtk.gdk.Event