## GogView GogView |

## Synopsis

                        GogView;
                        GogViewClass;
                        GogViewAllocation;
                        GogViewPadding;
                        GogViewRequisition;
    GogView *           gog_view_find_child_view            (GogView const *container,
                                                             GogObject const *target_model);
    GogObject *         gog_view_get_model                  (GogView const *view);
    void                gog_view_get_natural_size           (GogView *view,
                                                             GogViewRequisition *requisition);
    char *              gog_view_get_tip_at_point           (GogView *view,
                                                             double x,
                                                             double y);
    GogTool *           gog_view_get_tool_at_point          (GogView *view,
                                                             double x,
                                                             double y,
                                                             GogObject **gobj);
    GSList const	*      gog_view_get_toolkit                (GogView *view);
    GogView *           gog_view_get_view_at_point          (GogView *view,
                                                             double x,
                                                             double y,
                                                             GogObject **obj,
                                                             GogTool **tool);
    void                gog_view_padding_request            (GogView *view,
                                                             GogViewAllocation const *bbox,
                                                             GogViewPadding *padding);
    void                gog_view_queue_redraw               (GogView *view);
    void                gog_view_queue_resize               (GogView *view);
    void                gog_view_render                     (GogView *view,
                                                             GogViewAllocation const *bbox);
    void                gog_view_render_toolkit             (GogView *view);
    void                gog_view_size_allocate              (GogView *view,
                                                             GogViewAllocation const *allocation);
    void                gog_view_size_child_request         (GogView *view,
                                                             GogViewRequisition const *available,
                                                             GogViewRequisition *req,
                                                             GogViewRequisition *min_req);
    void                gog_view_size_request               (GogView *view,
                                                             GogViewRequisition const *available,
                                                             GogViewRequisition *requisition);
    gboolean            gog_view_update_sizes               (GogView *view);

## Object Hierarchy

      GObject
       +----GogView
             +----GogAxisBaseView
             +----GogOutlinedView
             +----GogPlotView

      GBoxed
       +----GogViewAllocation

## Properties

      "model"                    GogObject*            : Write
      "parent"                   GogView*              : Write

## Description

## Details

### GogView

    typedef struct _GogView GogView;

### GogViewClass

    typedef struct {
    	GObjectClass base;

    	unsigned clip; 	/* Automaticaly clip to object bounding box */

    	/* Virtuals */
    	void	 (*state_init)    (GogView *view);
    	void	 (*padding_request) 		(GogView *view, GogViewAllocation const *bbox,
    						 GogViewPadding *padding);
    	void	 (*size_request)    		(GogView *view, GogViewRequisition const *available,
    						 GogViewRequisition *requisition);
    	void	 (*size_allocate)   		(GogView *view, GogViewAllocation const *allocation);

    	void	 (*render)        		(GogView *view, GogViewAllocation const *bbox);

    	void	 (*build_toolkit)		(GogView *view);
    	char    *(*get_tip_at_point)		(GogView *view, double x, double y);
    	void	 (*natural_size)    		(GogView *view, GogViewRequisition *req);
    } GogViewClass;

the GogViewClass::clip firled should be set to `TRUE` to clip drawings to the vew allocation.

GObjectClass `base`; | base class.
`state_init` () | state intialization.
`padding_request` () | padding request.
`size_request` () | size request.
`size_allocate` () | size allocate.
`render` () | render to cairo.
`build_toolkit` () | builds the associated toolkit.
`get_tip_at_point` () | gets tip at pointer position.
`natural_size` () | gets natural size.

### GogViewAllocation

    typedef struct {
    	double w, h;
    	double x, y;
    } GogViewAllocation;

double `w`; | width.
double `h`; | height.
double `x`; | horizontal position.
double `y`; | vertical position.

### GogViewPadding

    typedef struct {
    	double wr, hb;
    	double wl, ht;
    } GogViewPadding;

double `wr`; | right padding.
double `hb`; | bottom padding.
double `wl`; | left pdding.
double `ht`; | top padding.

### GogViewRequisition

    typedef struct {
    	double w, h;
    } GogViewRequisition;

double `w`; | width.
double `h`; | height.

### gog_view_find_child_view ()

    GogView *           gog_view_find_child_view            (GogView const *container,
                                                             GogObject const *target_model);

Find the GogView contained in `container` that corresponds to `model`.

`container` : | GogView
`target_model` : | GogObject
Returns : | NULL on error or if `target_model` has no view. [transfer none]

### gog_view_get_model ()

    GogObject *         gog_view_get_model                  (GogView const *view);

`view` : | GogView
Returns : | the GogObject owning the view. [transfer none]

### gog_view_get_natural_size ()

    void                gog_view_get_natural_size           (GogView *view,
                                                             GogViewRequisition *requisition);

### gog_view_get_tip_at_point ()

    char *              gog_view_get_tip_at_point           (GogView *view,
                                                             double x,
                                                             double y);

Gets a tip string related to the position as defined by (`x`,`y`) in `view`.

`view` : | GogView
`x` : | x position
`y` : | y position
Returns : | the newly allocated tip string if the view class supports that or NULL.

### gog_view_get_tool_at_point ()

    GogTool *           gog_view_get_tool_at_point          (GogView *view,
                                                             double x,
                                                             double y,
                                                             GogObject **gobj);

`view` : | GogView
`x` : | in coords
`y` : | in coords
`gobj` : | pointed object or NULL
Returns : | tool under cursor for a given view, or `NULL`. [transfer none]

### gog_view_get_toolkit ()

    GSList const	*      gog_view_get_toolkit                (GogView *view);

`view` : | GogView
Returns : | toolkit associated with given view. [element-type GogTool][transfer none]

### gog_view_get_view_at_point ()

    GogView *           gog_view_get_view_at_point          (GogView *view,
                                                             double x,
                                                             double y,
                                                             GogObject **obj,
                                                             GogTool **tool);

Gets view under cursor, searching recursively from `view`. Corresponding object is stored in `obj`. This object may or may not be `view->model` of pointed view. This function also stores tool under cursor, for the pointed view.

`view` : | GogView
`x` : | cursor x position
`y` : | cursor y position
`obj` : | pointed object or NULL
`tool` : | pointed tool or NULL
Returns : | the GogView at x,y position. [transfer none]

### gog_view_padding_request ()

    void                gog_view_padding_request            (GogView *view,
                                                             GogViewAllocation const *bbox,
                                                             GogViewPadding *padding);

### gog_view_queue_redraw ()

    void                gog_view_queue_redraw               (GogView *view);

Requests a redraw for the entire graph.

`view` : | a GogView

### gog_view_queue_resize ()

    void                gog_view_queue_resize               (GogView *view);

Flags a view to have its size renegotiated; should be called when a model for some reason has a new size request. For example, when you change the size of a legend.

`view` : | a GogView

### gog_view_render ()

    void                gog_view_render                     (GogView *view,
                                                             GogViewAllocation const *bbox);

### gog_view_render_toolkit ()

    void                gog_view_render_toolkit             (GogView *view);

Render toolkit elements.

`view` : | GogView

### gog_view_size_allocate ()

    void                gog_view_size_allocate              (GogView *view,
                                                             GogViewAllocation const *allocation);

Assign a size and position to a GogView. Primarilly used by containers.

`view` : | a GogView
`allocation` : | position and size to be allocated to `view`

### gog_view_size_child_request ()

    void                gog_view_size_child_request         (GogView *view,
                                                             GogViewRequisition const *available,
                                                             GogViewRequisition *req,
                                                             GogViewRequisition *min_req);

Computes additional requision in `req` which must be added to parent requisition, and minimum requisition in `min_req` which is minimum space for displaying all children.

`view` : | a GogView
`available` : | the amount of space available in total
`req` : | additionnal requisition
`min_req` : | minimum size for displaying all children

### gog_view_size_request ()

    void                gog_view_size_request               (GogView *view,
                                                             GogViewRequisition const *available,
                                                             GogViewRequisition *requisition);

Determines the desired size of a view.

Note, that the virtual method deviates slightly from this function. This function will zero `requisition` before calling the virtual method.

Remember that the size request is not necessarily the size a view will actually be allocated.

`view` : | a GogView
`available` : | available space.
`requisition` : | a GogViewRequisition.

### gog_view_update_sizes ()

    gboolean            gog_view_update_sizes               (GogView *view);

`view` : | GogView
Returns : | `TRUE` if a redraw is necessary.

## Property Details

### The `"model"` property

      "model"                    GogObject*            : Write

The GogObject this view displays.

### The `"parent"` property

      "parent"                   GogView*              : Write

the GogView parent.