Gdk::Drawable is the base class for all of the objects that accept drawing commands. The available drawables include pixmaps, windows, and bitmaps. Drawable is abstract as there is no such type on the server side.
To use a drawable, create a concrete Drawable of the type you wish to use and a Gdk::GC (graphics context) for that Drawable. With the GC you can draw lines, text, arcs and such.
Copies the width x height region of src at coordinates ( xsrc , ysrc ) to coordinates ( xdest , ydest ) in drawable .
width and/or height may be given as -1, in which case the entire src drawable will be copied.
Most fields in gc are not used for this operation, but notably 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/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 Gdk::GC, then use gdk_draw_rectangle() to draw a rectangle clipped to the bitmap.
A Gdk::GC sharing the drawable's visual and colormap.
X position in src of rectangle to draw.
Y position in src of rectangle to draw.
X position in drawable where the rectangle should be drawn.
Y position in drawable where the rectangle should be drawn.
Width of rectangle to draw, or -1 for entire src width.
Height of rectangle to draw, or -1 for entire src height.
This is a low-level function; 99% of text rendering should be done using gdk_draw_layout() instead.
A glyph is a character in a font. This function draws a sequence of glyphs. To obtain a sequence of glyphs you have to understand a lot about internationalized text handling, which you don't want to understand; thus, use gdk_draw_layout() instead of this function, gdk_draw_layout() handles the details.
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-0 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.
Draws a rectangular outline or filled rectangle, using the foreground color and other attributes of the Gdk::GC.
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.
Computes the region of a drawable that potentially can be written to by drawing primitives.
This region will not take into account the clip region for the 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.
A Gdk::Region. This must be freed with gdk_region_destroy() when you are done.
A Gdk::Image stores client-side image data (pixels).
In contrast, Gdk::Pixmap and Gdk::Window are server-side objects. get_image() obtains the pixels from a server-side drawable as a client-side Gdk::Image. The format of a Gdk::Image depends on the Gdk::Visual of the current display, which makes manipulating Gdk::Image extremely difficult; therefore, in most cases you should use Gdk::Pixbuf::get_from_drawable() instead of this lower-level function. A 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.
x , y , width , and height define the region of drawable to obtain as an image.
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 Gdk::Window and partially offscreen or obscured, then the obscured portions of the returned image will contain undefined data.
X coordinate on drawable .
Y coordinate on drawable .
Width of region to get.
Height or region to get.
A Gdk::Image containing the contents of drawable .
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 Gdk::GC to draw to a drawable, or copying one drawable to another, the colormaps should match.