GogRenderer

## GogRenderer GogRenderer — Rendering |

## Synopsis

    enum                GoJustification;
    #define             GOG_RENDERER_GRIP_SIZE
    #define             GOG_RENDERER_HAIRLINE_WIDTH_PTS
    void                gog_renderer_draw_circle            (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double r);
    void                gog_renderer_draw_color_map         (GogRenderer *rend,
                                                             GogAxisColorMap const *map,
                                                             int discrete,
                                                             gboolean horizontal,
                                                             GogViewAllocation const *rect);
    void                gog_renderer_draw_data_label        (GogRenderer *rend,
                                                             GogSeriesLabelElt const *elt,
                                                             GogViewAllocation const *pos,
                                                             GOAnchorType anchor,
                                                             GOStyle *legend_style);
    void                gog_renderer_draw_gostring          (GogRenderer *rend,
                                                             GOString *str,
                                                             GogViewAllocation const *pos,
                                                             GOAnchorType anchor,
                                                             GoJustification justification,
                                                             double width);
    void                gog_renderer_draw_grip              (GogRenderer *renderer,
                                                             double x,
                                                             double y);
    void                gog_renderer_draw_marker            (GogRenderer *rend,
                                                             double x,
                                                             double y);
    void                gog_renderer_draw_rectangle         (GogRenderer *rend,
                                                             GogViewAllocation const *rect);
    void                gog_renderer_draw_rotated_rectangle (GogRenderer *rend,
                                                             GogViewAllocation const *rect,
                                                             gboolean rotate_bg);
    void                gog_renderer_draw_selection_rectangle
                                                            (GogRenderer *renderer,
                                                             GogViewAllocation const *rectangle);
    void                gog_renderer_draw_shape             (GogRenderer *renderer,
                                                             GOPath const *path);
    void                gog_renderer_draw_text              (GogRenderer *rend,
                                                             char const *text,
                                                             GogViewAllocation const *pos,
                                                             GOAnchorType anchor,
                                                             gboolean use_markup,
                                                             GoJustification justification,
                                                             double width);
    gboolean            gog_renderer_export_image           (GogRenderer *renderer,
                                                             GOImageFormat format,
                                                             GsfOutput *output,
                                                             double x_dpi,
                                                             double y_dpi);
    void                gog_renderer_fill_circle            (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double r);
    void                gog_renderer_fill_rectangle         (GogRenderer *rend,
                                                             GogViewAllocation const *rect);
    void                gog_renderer_fill_serie             (GogRenderer *renderer,
                                                             GOPath const *path,
                                                             GOPath const *close_path);
    void                gog_renderer_fill_shape             (GogRenderer *renderer,
                                                             GOPath const *path);
    cairo_surface_t *   gog_renderer_get_cairo_surface      (GogRenderer *renderer);
    void                gog_renderer_get_gostring_AABR      (GogRenderer *rend,
                                                             GOString *str,
                                                             GOGeometryAABR *aabr,
                                                             double max_width);
    void                gog_renderer_get_gostring_OBR       (GogRenderer *rend,
                                                             GOString *str,
                                                             GOGeometryOBR *obr,
                                                             double max_width);
    double              gog_renderer_get_hairline_width_pts (GogRenderer const *rend);
    GdkPixbuf *         gog_renderer_get_pixbuf             (GogRenderer *renderer);
    double              gog_renderer_get_scale              (GogRenderer *renderer);
    void                gog_renderer_get_text_AABR          (GogRenderer *rend,
                                                             char const *text,
                                                             gboolean use_markup,
                                                             GOGeometryAABR *aabr,
                                                             double max_width);
    void                gog_renderer_get_text_OBR           (GogRenderer *rend,
                                                             char const *text,
                                                             gboolean use_markup,
                                                             GOGeometryOBR *obr,
                                                             double max_width);
    #define             gog_renderer_in_grip                (x,
                                                             y,
                                                             grip_x,
                                                             grip_y)
    double              gog_renderer_line_size              (GogRenderer const *r,
                                                             double width);
    GogRenderer *       gog_renderer_new                    (GogGraph *graph);
    void                gog_renderer_pop_clip               (GogRenderer *rend);
    void                gog_renderer_pop_style              (GogRenderer *rend);
    double              gog_renderer_pt2r                   (GogRenderer const *r,
                                                             double d);
    double              gog_renderer_pt2r_x                 (GogRenderer const *r,
                                                             double d);
    double              gog_renderer_pt2r_y                 (GogRenderer const *r,
                                                             double d);
    void                gog_renderer_push_clip              (GogRenderer *rend,
                                                             GOPath const *path);
    void                gog_renderer_push_clip_rectangle    (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double w,
                                                             double h);
    void                gog_renderer_push_style             (GogRenderer *rend,
                                                             GOStyle const *style);
    gboolean            gog_renderer_render_to_cairo        (GogRenderer *renderer,
                                                             cairo_t *cairo,
                                                             double width,
                                                             double height);
    void                gog_renderer_request_update         (GogRenderer *renderer);
    void                gog_renderer_stroke_circle          (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double r);
    void                gog_renderer_stroke_rectangle       (GogRenderer *rend,
                                                             GogViewAllocation const *rect);
    void                gog_renderer_stroke_serie           (GogRenderer *renderer,
                                                             GOPath const *path);
    void                gog_renderer_stroke_shape           (GogRenderer *renderer,
                                                             GOPath const *path);
    gboolean            gog_renderer_update                 (GogRenderer *renderer,
                                                             double w,
                                                             double h);

## Description

Note that GogGraph has a functions for export/rendering, so you do not always need to use a GogRenderer directly.

## Details

### enum GoJustification

    typedef enum {
      GO_JUSTIFY_LEFT,
      GO_JUSTIFY_RIGHT,
      GO_JUSTIFY_CENTER,
      GO_JUSTIFY_FILL
    } GoJustification;

Used for justifying the text inside multiline label.

`GO_JUSTIFY_LEFT` | The text is placed at the left edge of the label.
`GO_JUSTIFY_RIGHT` | The text is placed at the right edge of the label.
`GO_JUSTIFY_CENTER` | The text is placed in the center of the label.
`GO_JUSTIFY_FILL` | The text is placed is distributed across the label.

### GOG_RENDERER_GRIP_SIZE

    #define GOG_RENDERER_GRIP_SIZE 4

### GOG_RENDERER_HAIRLINE_WIDTH_PTS

    #define GOG_RENDERER_HAIRLINE_WIDTH_PTS 0.5

### gog_renderer_draw_circle ()

    void                gog_renderer_draw_circle            (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double r);

### gog_renderer_draw_color_map ()

    void                gog_renderer_draw_color_map         (GogRenderer *rend,
                                                             GogAxisColorMap const *map,
                                                             int discrete,
                                                             gboolean horizontal,
                                                             GogViewAllocation const *rect);

### gog_renderer_draw_data_label ()

    void                gog_renderer_draw_data_label        (GogRenderer *rend,
                                                             GogSeriesLabelElt const *elt,
                                                             GogViewAllocation const *pos,
                                                             GOAnchorType anchor,
                                                             GOStyle *legend_style);

### gog_renderer_draw_gostring ()

    void                gog_renderer_draw_gostring          (GogRenderer *rend,
                                                             GOString *str,
                                                             GogViewAllocation const *pos,
                                                             GOAnchorType anchor,
                                                             GoJustification justification,
                                                             double width);

Have `rend` draw `layout` in the at `pos`.{x,y} anchored by the `anchor` corner. If `pos.w` or `pos.h` are >= 0 then clip the results to less than that size.

`rend` : | GogRenderer
`str` : | the GOString to draw
`pos` : | GogViewAllocation
`anchor` : | GOAnchorType how to draw relative to `pos`
`justification` : | GoJustification for multiline string.
`width` : | if positive, the maximum width to get a multiline string if needed.

### gog_renderer_draw_grip ()

    void                gog_renderer_draw_grip              (GogRenderer *renderer,
                                                             double x,
                                                             double y);

Draw a grip, used for moving/resizing of objects.

`renderer` : | GogRenderer
`x` : | x position of grip
`y` : | y position of grip

### gog_renderer_draw_marker ()

    void                gog_renderer_draw_marker            (GogRenderer *rend,
                                                             double x,
                                                             double y);

`rend` : | GogRenderer
`x` : | X-coordinate
`y` : | Y-coordinate

### gog_renderer_draw_rectangle ()

    void                gog_renderer_draw_rectangle         (GogRenderer *rend,
                                                             GogViewAllocation const *rect);

A utility routine to build a closed rectangle vpath.

`rend` : | a GogRenderer
`rect` : | position and extent of rectangle

### gog_renderer_draw_rotated_rectangle ()

    void                gog_renderer_draw_rotated_rectangle (GogRenderer *rend,
                                                             GogViewAllocation const *rect,
                                                             gboolean rotate_bg);

### gog_renderer_draw_selection_rectangle ()

    void                gog_renderer_draw_selection_rectangle
                                                            (GogRenderer *renderer,
                                                             GogViewAllocation const *rectangle);

### gog_renderer_draw_shape ()

    void                gog_renderer_draw_shape             (GogRenderer *renderer,
                                                             GOPath const *path);

### gog_renderer_draw_text ()

    void                gog_renderer_draw_text              (GogRenderer *rend,
                                                             char const *text,
                                                             GogViewAllocation const *pos,
                                                             GOAnchorType anchor,
                                                             gboolean use_markup,
                                                             GoJustification justification,
                                                             double width);

Have `rend` draw `text` in the at `pos`.{x,y} anchored by the `anchor` corner. If `pos.w` or `pos.h` are >= 0 then clip the results to less than that size.

`rend` : | GogRenderer
`text` : | the string to draw
`pos` : | GogViewAllocation
`anchor` : | GOAnchorType how to draw relative to `pos`
`use_markup` : | wether to use pango markup
`justification` : | GoJustification for multiline text.
`width` : | if positive, the maximum width to get a multiline text if needed.

### gog_renderer_export_image ()

    gboolean            gog_renderer_export_image           (GogRenderer *renderer,
                                                             GOImageFormat format,
                                                             GsfOutput *output,
                                                             double x_dpi,
                                                             double y_dpi);

Exports an image of `graph` in given `format`, writing results in a GsfOutput stream. If export format type is a bitmap one, it computes image size with x_dpi, y_dpi and `graph` size (see `gog_graph_get_size()`).

`renderer` : | a GogRenderer
`format` : | image format for export
`output` : | a GsfOutput stream
`x_dpi` : | x resolution of exported graph
`y_dpi` : | y resolution of exported graph
Returns : | `TRUE` if export succeed.

### gog_renderer_fill_circle ()

    void                gog_renderer_fill_circle            (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double r);

### gog_renderer_fill_rectangle ()

    void                gog_renderer_fill_rectangle         (GogRenderer *rend,
                                                             GogViewAllocation const *rect);

### gog_renderer_fill_serie ()

    void                gog_renderer_fill_serie             (GogRenderer *renderer,
                                                             GOPath const *path,
                                                             GOPath const *close_path);

### gog_renderer_fill_shape ()

    void                gog_renderer_fill_shape             (GogRenderer *renderer,
                                                             GOPath const *path);

### gog_renderer_get_cairo_surface ()

    cairo_surface_t *   gog_renderer_get_cairo_surface      (GogRenderer *renderer);

### gog_renderer_get_gostring_AABR ()

    void                gog_renderer_get_gostring_AABR      (GogRenderer *rend,
                                                             GOString *str,
                                                             GOGeometryAABR *aabr,
                                                             double max_width);

`rend` : | GogRenderer
`str` : | the string to draw
`aabr` : | GOGeometryAABR to store the Axis Aligned Bounding Rectangle of `text`.

### gog_renderer_get_gostring_OBR ()

    void                gog_renderer_get_gostring_OBR       (GogRenderer *rend,
                                                             GOString *str,
                                                             GOGeometryOBR *obr,
                                                             double max_width);

`rend` : | GogRenderer
`str` : | the string to draw
`obr` : | GOGeometryOBR to store the Object Bounding Rectangle of `text`.

### gog_renderer_get_hairline_width_pts ()

    double              gog_renderer_get_hairline_width_pts (GogRenderer const *rend);

`rend` : | a GogRenderer
Returns : | the hairline width in pts.

### gog_renderer_get_pixbuf ()

    GdkPixbuf *         gog_renderer_get_pixbuf             (GogRenderer *renderer);

`renderer` : | GogRenderer
Returns : | current pixbuf buffer from a renderer that can render into a pixbuf. or `NULL` on error. [transfer none]

### gog_renderer_get_scale ()

    double              gog_renderer_get_scale              (GogRenderer *renderer);

### gog_renderer_get_text_AABR ()

    void                gog_renderer_get_text_AABR          (GogRenderer *rend,
                                                             char const *text,
                                                             gboolean use_markup,
                                                             GOGeometryAABR *aabr,
                                                             double max_width);

`rend` : | GogRenderer
`text` : | the string to draw
`use_markup` : | whether to use pango markup
`aabr` : | GOGeometryAABR to store the Axis Aligned Bounding Rectangle of `text`.

### gog_renderer_get_text_OBR ()

    void                gog_renderer_get_text_OBR           (GogRenderer *rend,
                                                             char const *text,
                                                             gboolean use_markup,
                                                             GOGeometryOBR *obr,
                                                             double max_width);

`rend` : | GogRenderer
`text` : | the string to draw
`use_markup` : | wether to use pango markup
`obr` : | GOGeometryOBR to store the Object Bounding Rectangle of `text`.

### gog_renderer_in_grip()

    #define             gog_renderer_in_grip(x,y,grip_x,grip_y)

### gog_renderer_line_size ()

    double              gog_renderer_line_size              (GogRenderer const *r,
                                                             double width);

### gog_renderer_new ()

    GogRenderer *       gog_renderer_new                    (GogGraph *graph);

`graph` : | graph model
Returns : | a new GogRenderer which can render into a pixbuf, and sets `graph` as its model.

### gog_renderer_pop_clip ()

    void                gog_renderer_pop_clip               (GogRenderer *rend);

End the current clipping.

`rend` : | GogRenderer

### gog_renderer_pop_style ()

    void                gog_renderer_pop_style              (GogRenderer *rend);

### gog_renderer_pt2r ()

    double              gog_renderer_pt2r                   (GogRenderer const *r,
                                                             double d);

### gog_renderer_pt2r_x ()

    double              gog_renderer_pt2r_x                 (GogRenderer const *r,
                                                             double d);

### gog_renderer_pt2r_y ()

    double              gog_renderer_pt2r_y                 (GogRenderer const *r,
                                                             double d);

### gog_renderer_push_clip ()

    void                gog_renderer_push_clip              (GogRenderer *rend,
                                                             GOPath const *path);

Defines the current clipping region.

`rend` : | GogRenderer
`path` : | a GOPath

### gog_renderer_push_clip_rectangle ()

    void                gog_renderer_push_clip_rectangle    (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double w,
                                                             double h);

Defines a rectangular clipping region. For efficient screen rendering, this function takes care to round the coordinates.

`rend` : | GogRenderer
`x` : | left coordinate
`y` : | top coordinate
`w` : | width of clipping rectangle
`h` : | height of clipping rectangle

### gog_renderer_push_style ()

    void                gog_renderer_push_style             (GogRenderer *rend,
                                                             GOStyle const *style);

### gog_renderer_render_to_cairo ()

    gboolean            gog_renderer_render_to_cairo        (GogRenderer *renderer,
                                                             cairo_t *cairo,
                                                             double width,
                                                             double height);

### gog_renderer_request_update ()

    void                gog_renderer_request_update         (GogRenderer *renderer);

### gog_renderer_stroke_circle ()

    void                gog_renderer_stroke_circle          (GogRenderer *rend,
                                                             double x,
                                                             double y,
                                                             double r);

### gog_renderer_stroke_rectangle ()

    void                gog_renderer_stroke_rectangle       (GogRenderer *rend,
                                                             GogViewAllocation const *rect);

### gog_renderer_stroke_serie ()

    void                gog_renderer_stroke_serie           (GogRenderer *renderer,
                                                             GOPath const *path);

### gog_renderer_stroke_shape ()

    void                gog_renderer_stroke_shape           (GogRenderer *renderer,
                                                             GOPath const *path);

### gog_renderer_update ()

    gboolean            gog_renderer_update                 (GogRenderer *renderer,
                                                             double w,
                                                             double h);

Requests a renderer update, only useful for pixbuf based renderer.

`renderer` : | a GogRenderer
`w` : | requested width
`h` : | requested height
Returns : | `TRUE` if a redraw is necessary.