GdkPangoRenderer

typedef struct _GdkPangoRenderer GdkPangoRenderer;

GdkPangoRenderer is a subclass of PangoRenderer used for rendering Pango objects into GDK drawables. The default renderer for a particular screen is obtained with gdk_pango_renderer_get_default(); Pango functions like pango_renderer_draw_layout() and pango_renderer_draw_layout_line() are then used to draw objects with the renderer.

In most simple cases, applications can just use gdk_draw_layout(), and don't need to directly use GdkPangoRenderer at all. Using the GdkPangoRenderer directly is most useful when working with a transformation such as a rotation, because the Pango drawing functions take user space coordinates (coordinates before the transformation) instead of device coordinates.

In certain cases it can be useful to subclass GdkPangoRenderer. Examples of reasons to do this are to add handling of custom attributes by overriding 'prepare_run' or to do custom drawing of embedded objects by overriding 'draw_shape'.

Since 2.6

GdkPangoRendererClass

typedef struct {
} GdkPangoRendererClass;

GdkPangoRenderer is the class structure for GdkPangoRenderer.

Since 2.6

gdk_pango_renderer_new ()

PangoRenderer*      gdk_pango_renderer_new              (GdkScreen *screen);

Creates a new PangoRenderer for screen. Normally you can use the results of gdk_pango_renderer_get_default() rather than creating a new renderer.

Since 2.6

gdk_pango_renderer_get_default ()

PangoRenderer*      gdk_pango_renderer_get_default      (GdkScreen *screen);

Gets the default PangoRenderer for a screen. This default renderer is shared by all users of the display, so properties such as the color or transformation matrix set for the renderer may be overwritten by functions such as gdk_draw_layout().

Before using the renderer, you need to call gdk_pango_renderer_set_drawable() and gdk_pango_renderer_set_gc() to set the drawable and graphics context to use for drawing.

Since 2.6

gdk_pango_renderer_set_drawable ()

void                gdk_pango_renderer_set_drawable     (GdkPangoRenderer *gdk_renderer,
                                                         GdkDrawable *drawable);

Sets the drawable the renderer draws to.

Since 2.6

gdk_pango_renderer_set_gc ()

void                gdk_pango_renderer_set_gc           (GdkPangoRenderer *gdk_renderer,
                                                         GdkGC *gc);

Sets the GC the renderer draws with. Note that the GC must not be modified until it is unset by calling the function again with NULL for the gc parameter, since GDK may make internal copies of the GC which won't be updated to follow changes to the original GC.

Since 2.6

gdk_pango_renderer_set_stipple ()

void                gdk_pango_renderer_set_stipple      (GdkPangoRenderer *gdk_renderer,
                                                         PangoRenderPart part,
                                                         GdkBitmap *stipple);

Sets the stipple for one render part (foreground, background, underline, etc.) Note that this is overwritten when iterating through the individual styled runs of a PangoLayout or PangoLayoutLine. This function is thus only useful when you call low level functions like pango_renderer_draw_glyphs() directly, or in the 'prepare_run' virtual function of a subclass of GdkPangoRenderer.

Since 2.6

gdk_pango_renderer_set_override_color ()

void                gdk_pango_renderer_set_override_color
                                                        (GdkPangoRenderer *gdk_renderer,
                                                         PangoRenderPart part,
                                                         const GdkColor *color);

Sets the color for a particular render part (foreground, background, underline, etc.), overriding any attributes on the layouts renderered with this renderer.

Since 2.6

gdk_pango_context_get ()

PangoContext*       gdk_pango_context_get               (void);

Creates a PangoContext for the default GDK screen.

The context must be freed when you're finished with it.

When using GTK+, normally you should use gtk_widget_get_pango_context() instead of this function, to get the appropriate context for the widget you intend to render text onto.

The newly created context will have the default font options (see cairo_font_options_t) for the default screen; if these options change it will not be updated. Using gtk_widget_get_pango_context() is more convenient if you want to keep a context around and track changes to the screen's font rendering settings.

gdk_pango_context_get_for_screen ()

PangoContext*       gdk_pango_context_get_for_screen    (GdkScreen *screen);

Creates a PangoContext for screen.

The context must be freed when you're finished with it.

When using GTK+, normally you should use gtk_widget_get_pango_context() instead of this function, to get the appropriate context for the widget you intend to render text onto.

The newly created context will have the default font options (see cairo_font_options_t) for the screen; if these options change it will not be updated. Using gtk_widget_get_pango_context() is more convenient if you want to keep a context around and track changes to the screen's font rendering settings.

Since 2.2

gdk_pango_context_set_colormap ()

void                gdk_pango_context_set_colormap      (PangoContext *context,
                                                         GdkColormap *colormap);

This function used to set the colormap to be used for drawing with context. The colormap is now always derived from the graphics context used for drawing, so calling this function is no longer necessary.

GdkPangoAttrEmbossed

typedef struct {
  PangoAttribute attr;
  gboolean embossed;
} GdkPangoAttrEmbossed;

A Pango text attribute containing a embossed bitmap to be used when rendering the text.

GdkPangoAttrEmbossColor

typedef struct {
  PangoAttribute attr;
  PangoColor color;
} GdkPangoAttrEmbossColor;

A Pango text attribute specifying the color to emboss text with.

GdkPangoAttrStipple

typedef struct {
  PangoAttribute attr;
  GdkBitmap *stipple;
} GdkPangoAttrStipple;

A Pango text attribute containing a stipple bitmap to be used when rendering the text.

gdk_pango_attr_emboss_color_new ()

PangoAttribute*     gdk_pango_attr_emboss_color_new     (const GdkColor *color);

Creates a new attribute specifying the color to emboss text with.

Since 2.12

gdk_pango_attr_embossed_new ()

PangoAttribute*     gdk_pango_attr_embossed_new         (gboolean embossed);

Creates a new attribute flagging a region as embossed or not.

gdk_pango_attr_stipple_new ()

PangoAttribute*     gdk_pango_attr_stipple_new          (GdkBitmap *stipple);

Creates a new attribute containing a stipple bitmap to be used when rendering the text.

gdk_pango_layout_get_clip_region ()

GdkRegion*          gdk_pango_layout_get_clip_region    (PangoLayout *layout,
                                                         gint x_origin,
                                                         gint y_origin,
                                                         const gint *index_ranges,
                                                         gint n_ranges);

Obtains a clip region which contains the areas where the given ranges of text would be drawn. x_origin and y_origin are the same position you would pass to gdk_draw_layout_line(). index_ranges should contain ranges of bytes in the layout's text.

Note that the regions returned correspond to logical extents of the text ranges, not ink extents. So the drawn layout may in fact touch areas out of the clip region. The clip region is mainly useful for highlightling parts of text, such as when text is selected.

gdk_pango_layout_line_get_clip_region ()

GdkRegion*          gdk_pango_layout_line_get_clip_region
                                                        (PangoLayoutLine *line,
                                                         gint x_origin,
                                                         gint y_origin,
                                                         const gint *index_ranges,
                                                         gint n_ranges);

Obtains a clip region which contains the areas where the given ranges of text would be drawn. x_origin and y_origin are the same position you would pass to gdk_draw_layout_line(). index_ranges should contain ranges of bytes in the layout's text. The clip region will include space to the left or right of the line (to the layout bounding box) if you have indexes above or below the indexes contained inside the line. This is to draw the selection all the way to the side of the layout. However, the clip region is in line coordinates, not layout coordinates.

Note that the regions returned correspond to logical extents of the text ranges, not ink extents. So the drawn line may in fact touch areas out of the clip region. The clip region is mainly useful for highlightling parts of text, such as when text is selected.

The "screen" property

  "screen"                   GdkScreen*            : Read / Write / Construct Only

the GdkScreen for the renderer.