gdk-GdkRGB               package:RGtk2               R Documentation

_G_d_k_R_G_B

_D_e_s_c_r_i_p_t_i_o_n:

     Renders RGB, grayscale, or indexed image data to a GdkDrawable

_M_e_t_h_o_d_s _a_n_d _F_u_n_c_t_i_o_n_s:

     'gdkDrawRgbImage(object, gc, x, y, width, height, dith, rgb.buf,
     rowstride)'
      'gdkDrawRgbImageDithalign(object, gc, x, y, width, height, dith,
     rgb.buf, xdith, ydith)'
      'gdkDrawIndexedImage(object, gc, x, y, width, height, dith, buf,
     cmap)'
      'gdkDrawGrayImage(object, gc, x, y, width, height, dith, buf)'
      'gdkDrawRgb32Image(object, gc, x, y, width, height, dith, buf)'
      'gdkDrawRgb32ImageDithalign(object, gc, x, y, width, height,
     dith, buf, xdith, ydith)'
      'gdkRgbCmapNew(colors)'
      'gdkRgbGcSetForeground(gc, rgb)'
      'gdkRgbGcSetBackground(gc, rgb)'
      'gdkRgbXpixelFromRgb(rgb)'
      'gdkRgbFindColor(colormap, color)'
      'gdkRgbSetInstall(install)'
      'gdkRgbSetMinColors(min.colors)'
      'gdkRgbGetVisual()'
      'gdkRgbGetColormap()'
      'gdkRgbDitherable()'
      'gdkRgbColormapDitherable(colormap)'
      'gdkRgbSetVerbose(verbose)'

_D_e_t_a_i_l_e_d _D_e_s_c_r_i_p_t_i_o_n:

     GdkRGB is a low-level module which renders RGB, grayscale, and
     indexed colormap images to a 'GdkDrawable'. It does this as
     efficiently as possible, handling issues such as colormaps,
     visuals, dithering, temporary buffers, and so on. Most code should
     use the higher-level 'GdkPixbuf' features in place of this module;
     for example, 'gdkPixbufRenderToDrawable' uses GdkRGB in its
     implementation.

     GdkRGB allocates a color cube to use when rendering images.  You
     can set the threshold for installing colormaps with
     'gdkRgbSetMinColors'. The default is 5x5x5 (125). If a colorcube
     of this size or larger can be allocated in the default colormap,
     then that's done. Otherwise, GdkRGB creates its own private
     colormap. Setting it to 0 means that it always tries to use the
     default colormap, and setting it to 216 means that it always
     creates a private one if it cannot allocate the 6x6x6 colormap in
     the default. If you always want a private colormap (to avoid
     consuming too many colormap entries for other apps, say), you can
     use  'gdk_rgb_set_install(TRUE)'. Setting the value greater than
     216 exercises a bug in older versions of GdkRGB. Note, however,
     that setting it to 0 doesn't let you get away with ignoring the
     colormap and visual - a colormap is always created in grayscale
     and direct color modes, and the visual is changed in cases where a
     "better" visual than the default is available.


     # Simple example of using GdkRGB with RGtk2

     IMAGE_WIDTH     <- 256
     IMAGE_HEIGHT <- 256


     rgb_example <- function()
     {
       window <- gtkWindow("toplevel", show = F)
       darea <- gtkDrawingArea()
       darea$setSizeRequest(IMAGE_WIDTH, IMAGE_HEIGHT)
       window$add(darea)

       # Set up the RGB buffer.
       x <- rep(0:(IMAGE_WIDTH-1), IMAGE_HEIGHT)
       y <- rep(0:(IMAGE_HEIGHT-1), IMAGE_WIDTH, each = T)
       red <- x - x 
       green <- (x / 32) * 4 + y - y 
       blue <- y - y 
       buf <- rbind(red, green, blue)

       # connect to expose event
       gSignalConnect(darea, "expose-event", on_darea_expose, buf)

       window$showAll()
     }


     on_darea_expose <- function(widget, event, buf)
     {
       gdkDrawRgbImage(widget[["window"]],
     widget[["style"]][["fgGc"]][[GtkStateType["normal"]+1]],
                           0, 0, IMAGE_WIDTH, IMAGE_HEIGHT,
                           "max", buf, IMAGE_WIDTH * 3)
     }


_S_t_r_u_c_t_u_r_e_s:

     '_G_d_k_R_g_b_C_m_a_p' A private data structure which maps color indices to
          actual RGB colors. This is used only for
          'gdkDrawIndexedImage'. *'GdkRgbCmap' is a transparent-type.*

_E_n_u_m_s _a_n_d _F_l_a_g_s:

     '_G_d_k_R_g_b_D_i_t_h_e_r' Selects whether or not GdkRGB applies dithering to
          the image on display. There are three values:

          Since GdkRGB currently only handles images with 8 bits per
          component, dithering on 24 bit per pixel displays is a moot
          point.

          '_n_o_n_e' _undocumented _

          '_n_o_r_m_a_l' _undocumented _

          '_m_a_x' _undocumented _

_A_u_t_h_o_r(_s):

     Derived by RGtkGen from GTK+ documentation

_R_e_f_e_r_e_n_c_e_s:

     <URL: http://developer.gnome.org/doc/API/2.0/gdk/gdk-GdkRGB.html>

