## GogRenderer

GogRenderer — Multi-backend renderer

## Synopsis

                GogRenderer;
    void        gog_renderer_request_update     (GogRenderer *r);
    void        gog_renderer_push_style         (GogRenderer *rend,
                                                 GogStyle const *style);
    void        gog_renderer_push_selection_style
                                                (GogRenderer *renderer);
    void        gog_renderer_pop_style          (GogRenderer *rend);
    void        gog_renderer_push_clip          (GogRenderer *rend,
                                                 ArtVpath *clip_path);
    void        gog_renderer_pop_clip           (GogRenderer *rend);
    ArtVpath*   gog_renderer_get_rectangle_vpath
                                                (GogViewAllocation const *rect);
    ArtBpath*   gog_renderer_get_ring_wedge_bpath
                                                (double cx,
                                                 double cy,
                                                 double rx_out,
                                                 double ry_out,
                                                 double rx_in,
                                                 double ry_in,
                                                 double th0,
                                                 double th1);
    void        gog_renderer_draw_sharp_path    (GogRenderer *rend,
                                                 ArtVpath *path);
    void        gog_renderer_draw_sharp_polygon (GogRenderer *rend,
                                                 ArtVpath *path,
                                                 gboolean narrow);
    void        gog_renderer_draw_sharp_rectangle
                                                (GogRenderer *r,
                                                 GogViewAllocation const *rect);
    void        gog_renderer_draw_ring_wedge    (GogRenderer *rend,
                                                 double cx,
                                                 double cy,
                                                 double rx_out,
                                                 double ry_out,
                                                 double rx_in,
                                                 double ry_in,
                                                 double th0,
                                                 double th1,
                                                 gboolean narrow);
    void        gog_renderer_draw_path          (GogRenderer *rend,
                                                 ArtVpath const *path);
    void        gog_renderer_draw_polygon       (GogRenderer *rend,
                                                 ArtVpath const *path,
                                                 gboolean narrow);
    void        gog_renderer_draw_rectangle     (GogRenderer *rend,
                                                 GogViewAllocation const *rect);
    void        gog_renderer_draw_bezier_path   (GogRenderer *rend,
                                                 ArtBpath const *path);
    void        gog_renderer_draw_text          (GogRenderer *rend,
                                                 char const *text,
                                                 GogViewAllocation const *pos,
                                                 GtkAnchorType anchor,
                                                 GogViewAllocation *result);
    void        gog_renderer_draw_marker        (GogRenderer *rend,
                                                 double x,
                                                 double y);
    void        gog_renderer_draw_grip          (GogRenderer *renderer,
                                                 double x,
                                                 double y);
    #define     gog_renderer_in_grip            (x,y,grip_x,grip_y)
    void        gog_renderer_get_text_OBR       (GogRenderer *rend,
                                                 char const *text,
                                                 GOGeometryOBR *obr);
    void        gog_renderer_get_text_AABR      (GogRenderer *rend,
                                                 char const *text,
                                                 GOGeometryAABR *aabr);
    #define     gog_renderer_draw_arc           (r,cx,cy,rx,ry,th0,th1)
    #define     gog_renderer_draw_pie_wedge     (r,cx,cy,rx,ry,th0,th1,narrow)
    double      gog_renderer_line_size          (GogRenderer const *r,
                                                 double width);
    double      gog_renderer_pt2r_x             (GogRenderer const *r,
                                                 double d);
    double      gog_renderer_pt2r_y             (GogRenderer const *r,
                                                 double d);
    double      gog_renderer_pt2r               (GogRenderer const *r,
                                                 double d);
    GogRenderer* gog_renderer_new_for_pixbuf    (GogGraph *graph);
    gboolean    gog_renderer_update             (GogRenderer *renderer,
                                                 double w,
                                                 double h,
                                                 double zoom);
    GdkPixbuf*  gog_renderer_get_pixbuf         (GogRenderer *renderer);

    void        gog_graph_print_to_gnome_print  (GogGraph *graph,
                                                 GnomePrintContext *gp_context,
                                                 double width,
                                                 double height);

## Object Hierarchy

      GObject
       +----GogRenderer

## Properties

      "model"                GogGraph              : Read / Write
      "view"                 GogView               : Read
      "zoom"                 gdouble               : Read / Write

## Signals

    "request-update"
                void        user_function      (GogRenderer *gogrenderer,
                                                gpointer     user_data)        : Run last

## Description

## Details

### GogRenderer

    typedef struct _GogRenderer GogRenderer;

### gog_renderer_request_update ()

    void        gog_renderer_request_update     (GogRenderer *r);

`r` : |

### gog_renderer_push_style ()

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

`rend` : |
`style` : |

### gog_renderer_push_selection_style ()

    void        gog_renderer_push_selection_style
                                                (GogRenderer *renderer);

Push a style used for selection and grip rendering.

`renderer` : | GogRenderer

### gog_renderer_pop_style ()

    void        gog_renderer_pop_style          (GogRenderer *rend);

`rend` : |

### gog_renderer_push_clip ()

    void        gog_renderer_push_clip          (GogRenderer *rend,
                                                 ArtVpath *clip_path);

Defines the current clipping region.

`rend` : | GogRenderer
`clip_path` : | ArtVpath array

### gog_renderer_pop_clip ()

    void        gog_renderer_pop_clip           (GogRenderer *rend);

End the current clipping.

`rend` : | GogRenderer

### gog_renderer_get_rectangle_vpath ()

    ArtVpath*   gog_renderer_get_rectangle_vpath
                                                (GogViewAllocation const *rect);

a utility routine to build a rectangle path.

`rect` : |
Returns : |

### gog_renderer_get_ring_wedge_bpath ()

    ArtBpath*   gog_renderer_get_ring_wedge_bpath
                                                (double cx,
                                                 double cy,
                                                 double rx_out,
                                                 double ry_out,
                                                 double rx_in,
                                                 double ry_in,
                                                 double th0,
                                                 double th1);

`cx` : |
`cy` : |
`rx_out` : |
`ry_out` : |
`rx_in` : |
`ry_in` : |
`th0` : |
`th1` : |
Returns : |

### gog_renderer_draw_sharp_path ()

    void        gog_renderer_draw_sharp_path    (GogRenderer *rend,
                                                 ArtVpath *path);

Draws `path` using the outline elements of the current style, trying to make line with sharp edge.

`rend` : | GogRenderer
`path` : | ArtVpath

### gog_renderer_draw_sharp_polygon ()

    void        gog_renderer_draw_sharp_polygon (GogRenderer *rend,
                                                 ArtVpath *path,
                                                 gboolean narrow);

Draws `path` and fills it with the fill elements of the current style, trying to draw line with sharp edge. If `narrow` is false it alos outlines it using the outline elements.

`rend` : | GogRenderer
`path` : | ArtVpath
`narrow` : | if TRUE skip any outline the current style specifies.

### gog_renderer_draw_sharp_rectangle ()

    void        gog_renderer_draw_sharp_rectangle
                                                (GogRenderer *r,
                                                 GogViewAllocation const *rect);

`r` : |
`rect` : |

### gog_renderer_draw_ring_wedge ()

    void        gog_renderer_draw_ring_wedge    (GogRenderer *rend,
                                                 double cx,
                                                 double cy,
                                                 double rx_out,
                                                 double ry_out,
                                                 double rx_in,
                                                 double ry_in,
                                                 double th0,
                                                 double th1,
                                                 gboolean narrow);

a utility routine to draw an arc.

`rend` : | GogRenderer
`cx` : | center x coordinate
`cy` : | center y coordinate
`rx_out` : | x radius
`ry_out` : | y radius
`rx_in` : |
`ry_in` : |
`th0` : | start arc angle
`th1` : | stop arc angle
`narrow` : |

### gog_renderer_draw_path ()

    void        gog_renderer_draw_path          (GogRenderer *rend,
                                                 ArtVpath const *path);

Draws `path` using the outline elements of the current style.

`rend` : | GogRenderer
`path` : | ArtVpath

### gog_renderer_draw_polygon ()

    void        gog_renderer_draw_polygon       (GogRenderer *rend,
                                                 ArtVpath const *path,
                                                 gboolean narrow);

Draws `path` and fills it with the fill elements of the current style. If `narrow` is false it alos outlines it using the outline elements.

`rend` : | GogRenderer
`path` : | ArtVpath
`narrow` : | if TRUE skip any outline the current style specifies.

### 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_bezier_path ()

    void        gog_renderer_draw_bezier_path   (GogRenderer *rend,
                                                 ArtBpath const *path);

Draws `path` using the outline elements of the current style.

`rend` : | GogRenderer
`path` : | ArtBpath

### gog_renderer_draw_text ()

    void        gog_renderer_draw_text          (GogRenderer *rend,
                                                 char const *text,
                                                 GogViewAllocation const *pos,
                                                 GtkAnchorType anchor,
                                                 GogViewAllocation *result);

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. If `result` is supplied it will recieve the actual position of the result.

`rend` : | GogRenderer
`text` : | the string to draw
`pos` : | GogViewAllocation
`anchor` : | GtkAnchorType how to draw relative to `pos`
`result` : | an optionally NULL GogViewAllocation

### 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_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_in_grip()

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

`x` : |
`y` : |
`grip_x` : |
`grip_y` : |

### gog_renderer_get_text_OBR ()

    void        gog_renderer_get_text_OBR       (GogRenderer *rend,
                                                 char const *text,
                                                 GOGeometryOBR *obr);

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

### gog_renderer_get_text_AABR ()

    void        gog_renderer_get_text_AABR      (GogRenderer *rend,
                                                 char const *text,
                                                 GOGeometryAABR *aabr);

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

### gog_renderer_draw_arc()

    #define     gog_renderer_draw_arc(r,cx,cy,rx,ry,th0,th1)

`r` : |
`cx` : |
`cy` : |
`rx` : |
`ry` : |
`th0` : |
`th1` : |

### gog_renderer_draw_pie_wedge()

    #define     gog_renderer_draw_pie_wedge(r,cx,cy,rx,ry,th0,th1,narrow)

`r` : |
`cx` : |
`cy` : |
`rx` : |
`ry` : |
`th0` : |
`th1` : |
`narrow` : |

### gog_renderer_line_size ()

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

`r` : |
`width` : |
Returns : |

### gog_renderer_pt2r_x ()

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

`r` : |
`d` : |
Returns : |

### gog_renderer_pt2r_y ()

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

`r` : |
`d` : |
Returns : |

### gog_renderer_pt2r ()

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

`r` : |
`d` : |
Returns : |

### gog_renderer_new_for_pixbuf ()

    GogRenderer* gog_renderer_new_for_pixbuf    (GogGraph *graph);

Creates a new renderer which can render into a pixbuf, and sets `graph` as its model.

`graph` : | graph model
Returns : |

### gog_renderer_update ()

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

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

`renderer` : | a GogRenderer
`w` : | requested width
`h` : | requested height
`zoom` : | requested zoom
Returns : |

### 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.

### gog_graph_print_to_gnome_print ()

    void        gog_graph_print_to_gnome_print  (GogGraph *graph,
                                                 GnomePrintContext *gp_context,
                                                 double width,
                                                 double height);

`graph` : |
`gp_context` : |
`width` : |
`height` : |

## Property Details

### The "`model`" property

      "model"                GogGraph              : Read / Write

the GogGraph this renderer displays.

### The "`view`" property

      "view"                 GogView               : Read

the GogView this renderer is displaying.

### The "`zoom`" property

      "zoom"                 gdouble               : Read / Write

global scale factor.

Allowed values: >= 1

Default value: 1

## Signal Details

### The "request-update" signal

    void        user_function                  (GogRenderer *gogrenderer,
                                                gpointer     user_data)        : Run last

`gogrenderer` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.