graphics-gdkrgb.html

linux下gnome编程

BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>Void gdk_draw_rgb_image(GdkDrawable *drawable,
    GdkGC *gc, gint x, gint y, gint width, gint height,
    GdkRgbDither dith, guchar *rgb_buf, gint rowstride);
        </PRE
></TD
></TR
></TABLE
><P
>          The dith parameter can be GDK_RGB_DITHER_NONE for no
          dithering (remember our discussion about banding),
          GDK_RGB_DITHER_NORMAL to tell GdkRGB to dither only when
          rendering to 8-bit color visuals, or GDK_RGB_DITHER_MAX to
          dither on both 8-bit and 16-bit visuals. Usually the
          reduction in performance that accompanies dithering on a
          16-bit color drawable isn't worth the slight improvement
          in appearance, so your best bet is
          GDK_RGB_DITHER_NORMAL. The gc parameter points to a GdkGC
          structure, which should hold any contextual information for
          the drawing operation (see Section 2.2.4).
        </P
><P
>          GdkRGB has four additional specializations of the basic
          gdk_draw_rgb_image( ) function. The first two constrain the
          rendering to a specific style of
          visual. gdk_draw_gray_image( ) uses only shades of gray to
          render to the drawable, regardless of the target visual. You
          can use gdk_draw_indexed_image( ) to force GdkRGB to render
          according to a color map you specify. Rather than using the
          native GDK API for creating and populating your color map,
          GdkRGB provides an easy-to-use convenience function,
          gdk_rgb_cmap_new( ). This color map is allocated
          dynamically, so you must free it when you're done, using
          gdk_rgb_cmap_free( ):
        </P
><TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>void gdk_draw_gray_image(GdkDrawable *drawable,
    GdkGC *gc, gint x, gint y, gint width, gint height,
    GdkRgbDither dith, guchar *buf, gint rowstride);
void gdk_draw_indexed_image (GdkDrawable *drawable,
    GdkGC *gc, gint x, gint y, gint width, gint height,
    GdkRgbDither dith, guchar *buf, gint rowstride,
    GdkRgbCmap *cmap);
GdkRgbCmap* gdk_rgb_cmap_new (guint32 *colors, gint n_colors);
void gdk_rgb_cmap_free (GdkRgbCmap *cmap);
        </PRE
></TD
></TR
></TABLE
><P
>          The other two drawing functions have a less visible effect
          on the image.  The gdk_draw_rgb_image_dithalign( ) function
          is good for rendering parts of a dithered image,
          particularly to a scrollable drawing surface. In order for
          the dithering algorithms to match up seamlessly, without
          leaving noticeable transition lines, you must supply two
          extra parameters-xdith and ydith-the offset of the
          scrolled image from its base, unscrolled position. Supplying
          consistent values of xdith and ydith ensures that multiple
          passes of the dithering algorithm will generate the same
          pattern, even when the rendering region shifts.
        </P
><P
>          The final drawing function, gdk_draw_rgb_32_image( ), is
          more of a friendly curiosity than a critical supplement. It
          attempts to align every 3-byte color value in the RGB buffer
          along a 4-byte boundary to improve memory access
          time. Rather than just aligning the final pixel of a row, it
          aligns every pixel in the image. In practice, however, the
          added speed is not enough to justify the significant
          increase in memory consumption.
        </P
><TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>void gdk_draw_rgb_image_dithalign(GdkDrawable *drawable,
    GdkGC *gc, gint x, gint y, gint width, gint height,
    GdkRgbDither dith, guchar *rgb_buf, gint rowstride,
    gint xdith, gint ydith);
void gdk_draw_rgb_32_image(GdkDrawable *drawable,
    GdkGC *gc, gint x, gint y, gint width, gint height,
    GdkRgbDither dith, guchar *buf, gint rowstride);
        </PRE
></TD
></TR
></TABLE
></DIV
><DIV
CLASS="SECT2"
><H2
CLASS="SECT2"
><A
NAME="AEN796"
>Color Management</A
></H2
><P
>          As we learned in Section 10.1, color management can be a
          tricky process at the lower levels. One of the most tedious
          tasks is setting up the visual and the color map for a given
          display. A simple mistake inside the complex color man-
          agement code can cause your application to crash and bail
          out when it becomes impossible to render to a visual in a
          sane way, leading to X's nebulous "Bad Match" errors.
        </P
><P
>          Another helpful abstraction service that GdkRGB provides is
          the automatic generation of a rational visual and color map
          for whichever display the application runs on. If one user
          runs the application on an 8-bit pseudocolor display,
          GdkRGB detects that and creates an appropriate indexed color
          map. If another user runs the same application on a 24-bit
          color display, GdkRGB creates a TrueColor color map and
          its corresponding visual instead. You can access this
          customized color map and visual at any time after
          gdk_rgb_init( ) has run, by calling these two functions:
        </P
><TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>GdkColormap* gdk_rgb_get_cmap(  );
GdkVisual* gdk_rgb_get_visual(  );
        </PRE
></TD
></TR
></TABLE
><P
>          You can force a widget to use GdkRGB's color map and visual
          by pushing it onto a pair of global stacks (really a pair of
          singly linked lists used to simulate the stacks) in GTK+
          and then popping it back off when you're done. You need to
          push it only for the time it takes to create the
          widget. Once created, the widget will continue to use that
          color map and visual for the rest of its life span; all of
          the widget's children will inherit them too. The common
          practice is to push them, create the top-level widget, and
          then pop them immediately afterward:
        </P
><TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>gtk_widget_push_visual(gdk_rgb_get_visual(  ));
gtk_widget_push_colormap(gdk_rgb_get_cmap(  ));
widget = gtk_widget_new(...);
gtk_widget_pop_visual(  );
gtk_widget_pop_colormap(  );
        </PRE
></TD
></TR
></TABLE
><P
>          GdkRGB also supplies a convenience function for looking up
          values in this GdkColormap. If you feed it a 24-bit RGB
          color value, it will return that color's corresponding value
          in the color map. You can then use the returned color in the
          various raw GDK functions. Two other functions allow you to
          set the default foreground and background colors of the
          graphics context with RGB colors, rather than having to
          perform the lookup first, as you would normally have to do
          with the gdk_gc_set_fore/background( ) functions.
        </P
><TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>gulong gdk_rgb_xpixel_from_rgb(guint32 rgb);
void gdk_rgb_gc_set_foreground(GdkGC *gc, guint32 rgb);
void gdk_rgb_gc_set_background(GdkGC *gc, guint32 rgb);
        </PRE
></TD
></TR
></TABLE
><P
>          Finally, you can use gdk_rgb_ditherable( ) to find out
          whether or not GdkRGB's visual is ditherable, and act
          accordingly. You might use this function to decide whether
          to call gdk_draw_rgb_image( ) or
          gdk_draw_rgb_image_ditherable( ):
        </P
><TABLE
BORDER="0"
BGCOLOR="#E0E0E0"
WIDTH="100%"
><TR
><TD
><PRE
CLASS="PROGRAMLISTING"
>gboolean gdk_rgb_ditherable(  );
        </PRE
></TD
></TR
></TABLE
></DIV
></DIV
><DIV
CLASS="NAVFOOTER"
><HR
ALIGN="LEFT"
WIDTH="100%"><TABLE
WIDTH="100%"
BORDER="0"
CELLPADDING="0"
CELLSPACING="0"
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
><A
HREF="graphics-gdk.html"
>Prev</A
></TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="index.html"
>Home</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
><A
HREF="graphics-libart.html"
>Next</A
></TD
></TR
><TR
><TD
WIDTH="33%"
ALIGN="left"
VALIGN="top"
>The GDK Wrapper</TD
><TD
WIDTH="34%"
ALIGN="center"
VALIGN="top"
><A
HREF="graphics.html"
>Up</A
></TD
><TD
WIDTH="33%"
ALIGN="right"
VALIGN="top"
>Libart</TD
></TR
></TABLE
></DIV
></BODY
></HTML
>