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, 'gdkDrawPixbuf' 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.

     If GDK is built with the Sun mediaLib library, the GdkRGB
     functions are accelerated using mediaLib, which provides hardware
     acceleration on Intel, AMD, and Sparc chipsets.  If desired,
     mediaLib support can be turned off by setting the
     GDK_DISABLE_MEDIALIB environment variable.

     _A simple example program using GdkRGB_


     # 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 %% 32
       green <- (x / 32) * 4 + y - y %% 32
       blue <- y - y %% 32
       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.*

          '_c_o_l_o_r_s' [numeric] The colors, represented as 0xRRGGBB
               integer values.

          '_n__c_o_l_o_r_s' [integer] The number of colors in the cmap.


_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. 

          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' Never use dithering.

          '_n_o_r_m_a_l' Use dithering in 8 bits per pixel (and below) only.

          '_m_a_x' Use dithering in 16 bits per pixel and below.


_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>

