gtk.gdk.Drawable.get_size

    def get_size()

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)

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()

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()

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

gtk.gdk.Drawable.get_depth

    def get_depth()

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()

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

gtk.gdk.Drawable.get_display

    def get_display()

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

gtk.gdk.Drawable.draw_point

    def draw_point(gc, x, y)

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)

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)

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.

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

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

gtk.gdk.Drawable.draw_arc

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

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)

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)

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)

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)

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)

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)

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)

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:

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)

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)

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.Colors 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)

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)

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()

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()

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>)

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)

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)

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)

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)

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()

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