GuppiCanvasItem

Name

GuppiCanvasItem -- 

Synopsis



void        (*GuppiCanvasItemFunc)          (GuppiCanvasItem*,
                                             gpointer);
gboolean    (*GuppiCanvasItemTest)          (GuppiCanvasItem*,
                                             gpointer);
#define     GUPPI_CANVAS_ITEM0              (obj)
#define     GUPPI_IS_CANVAS_ITEM0           (obj)
GuppiElementState* guppi_canvas_item_state  (GuppiCanvasItem *item);
GuppiElementView* guppi_canvas_item_view    (GuppiCanvasItem *item);
guppi_uniq_t guppi_canvas_item_unique_id    (GuppiCanvasItem *item);
double      guppi_canvas_item_scale         (GuppiCanvasItem *item);
GuppiGeometry* guppi_canvas_item_geometry   (GuppiCanvasItem *item);
gboolean    guppi_canvas_item_positioned    (GuppiCanvasItem *item);
void        guppi_canvas_item_set_view      (GuppiCanvasItem *item,
                                             GuppiElementView *view);
void        guppi_canvas_item_set_scale     (GuppiCanvasItem *item,
                                             double scale);
gboolean    guppi_canvas_item_ready         (GuppiCanvasItem *item);
void        guppi_canvas_item_set_ready     (GuppiCanvasItem *item);
void        guppi_canvas_item_set_position_handler
                                            (GuppiCanvasItem *item,
                                             GuppiCanvasItemFunc func,
                                             gpointer user_data);
void        guppi_canvas_item_set_bbox_c    (GuppiCanvasItem *item,
                                             gint cx0,
                                             gint cy0,
                                             gint cx1,
                                             gint cy1);
void        guppi_canvas_item_get_bbox_c    (GuppiCanvasItem *item,
                                             gint *cx0,
                                             gint *cy0,
                                             gint *cx1,
                                             gint *cy1);
void        guppi_canvas_item_get_bbox_vp   (GuppiCanvasItem *item,
                                             double *x0,
                                             double *y0,
                                             double *x1,
                                             double *y1);
void        guppi_canvas_item_get_bbox_pt   (GuppiCanvasItem *item,
                                             double *x0,
                                             double *y0,
                                             double *x1,
                                             double *y1);
void        guppi_canvas_item_conv          (GuppiCanvasItem *item,
                                             double c_x,
                                             double c_y,
                                             double *conv_x,
                                             double *conv_y);
void        guppi_canvas_item_unconv        (GuppiCanvasItem *item,
                                             double conv_x,
                                             double conv_y,
                                             double *c_x,
                                             double *c_y);
void        guppi_canvas_item_vp2c          (GuppiCanvasItem *item,
                                             double vp_x,
                                             double vp_y,
                                             gint *c_x,
                                             gint *c_y);
void        guppi_canvas_item_vp2c_d        (GuppiCanvasItem *item,
                                             double vp_x,
                                             double vp_y,
                                             double *c_x,
                                             double *c_y);
void        guppi_canvas_item_x_vp2c_d_bulk (GuppiCanvasItem *item,
                                             const double *vp_x,
                                             double *c_x,
                                             gsize N);
void        guppi_canvas_item_y_vp2c_d_bulk (GuppiCanvasItem *item,
                                             const double *vp_y,
                                             double *c_y,
                                             gsize N);
void        guppi_canvas_item_vp2c_d_bulk   (GuppiCanvasItem *item,
                                             const double *vp_x,
                                             const double *vp_y,
                                             double *c_x,
                                             double *c_y,
                                             gsize N);
void        guppi_canvas_item_c2vp          (GuppiCanvasItem *item,
                                             double c_x,
                                             double c_y,
                                             double *vp_x,
                                             double *vp_y);
void        guppi_canvas_item_pt2c          (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             gint *c_x,
                                             gint *c_y);
void        guppi_canvas_item_pt2c_d        (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             double *c_x,
                                             double *c_y);
void        guppi_canvas_item_c2pt          (GuppiCanvasItem *item,
                                             double c_x,
                                             double c_y,
                                             double *pt_x,
                                             double *pt_y);
void        guppi_canvas_item_vpath_vp2c    (GuppiCanvasItem *item,
                                             ArtVpath *path);
void        guppi_canvas_item_vpath_pt2c    (GuppiCanvasItem *item,
                                             ArtVpath *path);
void        guppi_canvas_item_request_redraw_c
                                            (GuppiCanvasItem *item,
                                             gint cx0,
                                             gint cy0,
                                             gint cx1,
                                             gint cy1);
void        guppi_canvas_item_request_redraw_vp
                                            (GuppiCanvasItem *item,
                                             double vx0,
                                             double vy0,
                                             double vx1,
                                             double vy1);
void        guppi_canvas_item_request_total_redraw
                                            (GuppiCanvasItem *item);
void        guppi_canvas_item_request_update
                                            (GuppiCanvasItem *item);
void        guppi_canvas_item_foreach       (GuppiCanvasItem *item,
                                             GuppiCanvasItemFunc func,
                                             gpointer user_data);
void        guppi_canvas_item_foreach_at    (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             GuppiCanvasItemFunc func,
                                             gpointer user_data);
GuppiCanvasItem* guppi_canvas_item_first_matching_at
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             GuppiCanvasItemTest test_func,
                                             gpointer user_data);
GuppiCanvasItem* guppi_canvas_item_data_drop_candidate
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y);
gboolean    guppi_canvas_item_data_drop     (GuppiCanvasItem *item,
                                             GuppiData *data);
gboolean    guppi_canvas_item_locate_button_tool
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             guint button,
                                             guint state,
                                             GuppiCanvasItem**,
                                             GuppiPlotTool**);
gboolean    guppi_canvas_item_locate_key_tool
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             guint key_code,
                                             guint state,
                                             GuppiCanvasItem**,
                                             GuppiPlotTool**);
gboolean    guppi_canvas_item_double_click  (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             guint button,
                                             guint state);
void        guppi_canvas_item_set_local_toolkit
                                            (GuppiCanvasItem *item,
                                             GuppiPlotToolkit *toolkit);
void        guppi_canvas_item_enable_local_toolkit
                                            (GuppiCanvasItem *item,
                                             gboolean flag);
void        guppi_canvas_item_enable_class_toolkit
                                            (GuppiCanvasItem *item,
                                             gboolean flag);
gboolean    guppi_canvas_item_nonlocal_tools_disabled
                                            (GuppiCanvasItem *item);
GuppiPlotTool* guppi_canvas_item_local_button_tool
                                            (GuppiCanvasItem *item,
                                             guint button,
                                             guint state);
GuppiPlotTool* guppi_canvas_item_local_key_tool
                                            (GuppiCanvasItem *item,
                                             guint key_code,
                                             guint state);
void        guppi_canvas_item_foreach_class_toolkit
                                            (GuppiCanvasItem *item,
                                             void (*callback) (GuppiPlotToolkit *,gpointer),
                                             gpointer user_data);
void        guppi_canvas_item_class_set_item_class_toolkit
                                            (GuppiCanvasItemClass *item,
                                             GuppiPlotToolkit *toolkit);

Object Hierarchy


  GtkObject
   +----GnomeCanvasItem
         +----GnomeCanvasGroup
               +----GuppiCanvasItem

Signal Prototypes


"changed-scale"
            void        user_function      (GuppiCanvasItem *guppicanvasitem,
                                            gpointer user_data);

Description

Details

GuppiCanvasItemFunc ()

void        (*GuppiCanvasItemFunc)          (GuppiCanvasItem*,
                                             gpointer);

Param1 : 
Param2 : 


GuppiCanvasItemTest ()

gboolean    (*GuppiCanvasItemTest)          (GuppiCanvasItem*,
                                             gpointer);

Param1 : 
Param2 : 
Returns : 


GUPPI_CANVAS_ITEM0()

#define GUPPI_CANVAS_ITEM0(obj) ((obj) ? (GUPPI_CANVAS_ITEM(obj)) : NULL)

obj : 


GUPPI_IS_CANVAS_ITEM0()

#define GUPPI_IS_CANVAS_ITEM0(obj) (((obj) == NULL) || (GUPPI_IS_CANVAS_ITEM(obj)))

obj : 


guppi_canvas_item_state ()

GuppiElementState* guppi_canvas_item_state  (GuppiCanvasItem *item);

item : the canvas item
Returns :the state object associated with this canvas item.


guppi_canvas_item_view ()

GuppiElementView* guppi_canvas_item_view    (GuppiCanvasItem *item);

item : the canvas item
Returns :the view object associated with this canvas item.


guppi_canvas_item_unique_id ()

guppi_uniq_t guppi_canvas_item_unique_id    (GuppiCanvasItem *item);

item : the canvas item
Returns :the canvas item's unique ID.


guppi_canvas_item_scale ()

double      guppi_canvas_item_scale         (GuppiCanvasItem *item);

item : the canvas item
Returns :the item's current scale factor.


guppi_canvas_item_geometry ()

GuppiGeometry* guppi_canvas_item_geometry   (GuppiCanvasItem *item);

item : the canvas item
Returns :the item's current geometry.


guppi_canvas_item_positioned ()

gboolean    guppi_canvas_item_positioned    (GuppiCanvasItem *item);

item : the canvas item
Returns :TRUE if the item's geometry has been specified yet, and FALSE otherwise.


guppi_canvas_item_set_view ()

void        guppi_canvas_item_set_view      (GuppiCanvasItem *item,
                                             GuppiElementView *view);

Binds a specific GuppiElementView to the canvas item. This function can only be called once per GuppiCanvasItem, and will fail (printing an warning to the console) if the item already has a different view bound to it.

item : the canvas item
view : a view


guppi_canvas_item_set_scale ()

void        guppi_canvas_item_set_scale     (GuppiCanvasItem *item,
                                             double scale);

Scales the canvas item by the desired scale factor. Items with non-positive scale factors are simply not rendered.

item : the canvas item
scale : the desired scale factor


guppi_canvas_item_ready ()

gboolean    guppi_canvas_item_ready         (GuppiCanvasItem *item);

item : the canvas item
Returns :TRUE if the item is ready to be displayed, and FALSE otherwise.


guppi_canvas_item_set_ready ()

void        guppi_canvas_item_set_ready     (GuppiCanvasItem *item);

Sets the item's ready flag, indicating that it is ready to be displayed. It is an error to call this function on any GuppiCanvasItem more than once.

item : the canvas item


guppi_canvas_item_set_position_handler ()

void        guppi_canvas_item_set_position_handler
                                            (GuppiCanvasItem *item,
                                             GuppiCanvasItemFunc func,
                                             gpointer user_data);

Attach a callback function to the item that is invoked every time the item is determined to have changed position.

item : the canvas item
func : a callback function
user_data : a pointer passed to the callback function


guppi_canvas_item_set_bbox_c ()

void        guppi_canvas_item_set_bbox_c    (GuppiCanvasItem *item,
                                             gint cx0,
                                             gint cy0,
                                             gint cx1,
                                             gint cy1);

Sets the bounding box of the canvas item, in canvas coordinates.

item : the canvas item
cx0 : the lesser x-coordinate of a bounding box
cy0 : the lesser y-coordinate of a bounding box
cx1 : the greater x-coordinate of a bounding box
cy1 : the greater y-coordinate of a bounding box


guppi_canvas_item_get_bbox_c ()

void        guppi_canvas_item_get_bbox_c    (GuppiCanvasItem *item,
                                             gint *cx0,
                                             gint *cy0,
                                             gint *cx1,
                                             gint *cy1);

Gives the bounding box of the canvas item, in canvas coordinates. If NULL is passed to any of the coordinate arguments, that coordinate is ignored.

item : the canvas item
cx0 : the lesser x-coordinate of a bounding box
cy0 : the lesser y-coordinate of a bounding box
cx1 : the greater x-coordinate of a bounding box
cy1 : the greater y-coordinate of a bounding box


guppi_canvas_item_get_bbox_vp ()

void        guppi_canvas_item_get_bbox_vp   (GuppiCanvasItem *item,
                                             double *x0,
                                             double *y0,
                                             double *x1,
                                             double *y1);

Gives the bounding box of the canvas item, in virtual coordinates. If NULL is passed to any of the coordinate arguments, that coordinate is ignored.

item : the canvas item
x0 : a pointer to the lesser x-coordinate of a bounding box
y0 : a pointer to the lesser y-coordinate of a bounding box
x1 : a pointer to the greater x-coordinate of a bounding box
y1 : a pointer to the greater y-coordinate of a bounding box


guppi_canvas_item_get_bbox_pt ()

void        guppi_canvas_item_get_bbox_pt   (GuppiCanvasItem *item,
                                             double *x0,
                                             double *y0,
                                             double *x1,
                                             double *y1);

Gives the bounding box of the canvas item, in ps-points. If NULL is passed to any of the coordinate arguments, that coordinate is ignored.

item : the canvas item
x0 : a pointer to the lesser x-coordinate of a bounding box
y0 : a pointer to the lesser y-coordinate of a bounding box
x1 : a pointer to the greater x-coordinate of a bounding box
y1 : a pointer to the greater y-coordinate of a bounding box


guppi_canvas_item_conv ()

void        guppi_canvas_item_conv          (GuppiCanvasItem *item,
                                             double c_x,
                                             double c_y,
                                             double *conv_x,
                                             double *conv_y);

Transform an (x,y)-pair from canvas to unit coordinates.

item : the canvas item
c_x : an x-value, in canvas coordinates
c_y : a y-value, in canvas coordinates
conv_x : a pointer to the converted x-value, in unit coordinates
conv_y : a pointer to the converted y-value, in unit coordinates


guppi_canvas_item_unconv ()

void        guppi_canvas_item_unconv        (GuppiCanvasItem *item,
                                             double conv_x,
                                             double conv_y,
                                             double *c_x,
                                             double *c_y);

Transform an (x,y)-pair from unit to canvas coordinates.

item : the canvas item
conv_x : an x-value, in unit coordinates
conv_y : a y-value, in unit coordinates
c_x : a pointer the converted x-value, in canvas coordinates
c_y : a pointer to the converted y-value, in canvas coordinates


guppi_canvas_item_vp2c ()

void        guppi_canvas_item_vp2c          (GuppiCanvasItem *item,
                                             double vp_x,
                                             double vp_y,
                                             gint *c_x,
                                             gint *c_y);

Transform an (x,y)-pair from virtual to canvas coordinates.

item : the canvas item
vp_x : an x-value, in virtual coordinates
vp_y : a y-value, in virtual coordinates
c_x : a pointer to the converted x-value, in canvas coordinates
c_y : a pointer to the converted y-value, in canvas coordinates


guppi_canvas_item_vp2c_d ()

void        guppi_canvas_item_vp2c_d        (GuppiCanvasItem *item,
                                             double vp_x,
                                             double vp_y,
                                             double *c_x,
                                             double *c_y);

Transform an (x,y)-pair from virtual to canvas coordinates, but don't round off the canvas coordinates after converting.

item : the canvas item
vp_x : an x-value, in virtual coordinates
vp_y : a y-value, in virtual coordinates
c_x : a pointer to the converted x-value, in fractional canvas coordinates
c_y : a pointer to the converted y-value, in fractional canvas coordinates


guppi_canvas_item_x_vp2c_d_bulk ()

void        guppi_canvas_item_x_vp2c_d_bulk (GuppiCanvasItem *item,
                                             const double *vp_x,
                                             double *c_x,
                                             gsize N);

Convert N x-values from virtual coordinates to fractional canvas coordinates.

item : the canvas item
vp_x : an array of x-values, in virtual coordinates
c_x : an array to hold the converted fractional canvas x-coordinates
N : the size of the arrays


guppi_canvas_item_y_vp2c_d_bulk ()

void        guppi_canvas_item_y_vp2c_d_bulk (GuppiCanvasItem *item,
                                             const double *vp_y,
                                             double *c_y,
                                             gsize N);

Convert N y-values from virtual coordinates to fractional canvas coordinates.

item : the canvas item
vp_y : an array of y-values, in virtual coordinates
c_y : an array to hold the converted fractional canvas y-coordinates
N : the size of the arrays


guppi_canvas_item_vp2c_d_bulk ()

void        guppi_canvas_item_vp2c_d_bulk   (GuppiCanvasItem *item,
                                             const double *vp_x,
                                             const double *vp_y,
                                             double *c_x,
                                             double *c_y,
                                             gsize N);

Convert N (x,y)-pairs from virtual coordinates to fractional canvas coordinates.

item : the canvas item
vp_x : an array of x-values, in virtual coordinates
vp_y : an array of y-values, in virtual coordinates
c_x : an array to hold the converted fractional canvas x-coordinates
c_y : an array to hold the converted fractional canvas y-coordinates
N : the size of the arrays


guppi_canvas_item_c2vp ()

void        guppi_canvas_item_c2vp          (GuppiCanvasItem *item,
                                             double c_x,
                                             double c_y,
                                             double *vp_x,
                                             double *vp_y);

Transform an (x,y)-pair from canvas to virtual coordinates.

item : the canvas item
c_x : an x-value, in canvas coordinates
c_y : a y-value, in canvas coordinates
vp_x : a pointer to the converted x-value, in virtual coordinates
vp_y : a pointer to the converted y-value, in virtual coordinates


guppi_canvas_item_pt2c ()

void        guppi_canvas_item_pt2c          (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             gint *c_x,
                                             gint *c_y);

Transform an (x,y)-pair from virtual to canvas coordinates.

item : the canvas item
pt_x : an x-value, in ps-point coordinates
pt_y : a y-value, in ps-point coordinates
c_x : a pointer to the converted x-value, in canvas coordinates
c_y : a pointer to the converted y-value, in canvas coordinates


guppi_canvas_item_pt2c_d ()

void        guppi_canvas_item_pt2c_d        (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             double *c_x,
                                             double *c_y);

Transform an (x,y)-pair from ps-point to canvas coordinates, but don't round off the canvas coordinates after converting.

item : the canvas item
pt_x : an x-value, in ps-point coordinates
pt_y : a y-value, in ps-point coordinates
c_x : a pointer to the converted x-value, in fractional canvas coordinates
c_y : a pointer to the converted y-value, in fractional canvas coordinates


guppi_canvas_item_c2pt ()

void        guppi_canvas_item_c2pt          (GuppiCanvasItem *item,
                                             double c_x,
                                             double c_y,
                                             double *pt_x,
                                             double *pt_y);

Transform an (x,y)-pair from canvas to ps-point coordinates.

item : the canvas item
c_x : an x-value, in canvas coordinates
c_y : a y-value, in canvas coordinates
pt_x : a pointer to the converted x-value, in ps-point coordinates
pt_y : a pointer to the converted y-value, in ps-point coordinates


guppi_canvas_item_vpath_vp2c ()

void        guppi_canvas_item_vpath_vp2c    (GuppiCanvasItem *item,
                                             ArtVpath *path);

Transform the vertices of path from virtual to canvas coordinates.

item : the canvas item
path : a path


guppi_canvas_item_vpath_pt2c ()

void        guppi_canvas_item_vpath_pt2c    (GuppiCanvasItem *item,
                                             ArtVpath *path);

Transform the vertices of path from ps-point to canvas coordinates.

item : the canvas item
path : a path


guppi_canvas_item_request_redraw_c ()

void        guppi_canvas_item_request_redraw_c
                                            (GuppiCanvasItem *item,
                                             gint cx0,
                                             gint cy0,
                                             gint cx1,
                                             gint cy1);

Request that the piece of the canvas item intersecting the specified box is redrawn. The box is taken to be in canvas coordinates.

item : the canvas item
cx0 : the lesser x-coordinate of a box
cy0 : the lesser y-coordinate of a box
cx1 : the greater x-coordinate of a box
cy1 : the greater y-coordinate of a box


guppi_canvas_item_request_redraw_vp ()

void        guppi_canvas_item_request_redraw_vp
                                            (GuppiCanvasItem *item,
                                             double vx0,
                                             double vy0,
                                             double vx1,
                                             double vy1);

Request that the piece of the canvas item intersecting the specified box is redrawn. The box is taken to be in virtual coordinates.

item : the canvas item
vx0 : the lesser x-coordinate of a box
vy0 : the lesser y-coordinate of a box
vx1 : the greater x-coordinate of a box
vy1 : the greater y-coordinate of a box


guppi_canvas_item_request_total_redraw ()

void        guppi_canvas_item_request_total_redraw
                                            (GuppiCanvasItem *item);

Request that the entire canvas item be redrawn.

item : the canvas item


guppi_canvas_item_request_update ()

void        guppi_canvas_item_request_update
                                            (GuppiCanvasItem *item);

Request a canvas update for the specified item.

item : the canvas item


guppi_canvas_item_foreach ()

void        guppi_canvas_item_foreach       (GuppiCanvasItem *item,
                                             GuppiCanvasItemFunc func,
                                             gpointer user_data);

Call the function func on item and each subitem of item. If item is not some sort of canvas group, this is just equivalent to calling the function func with item and user_data as arguments.

item : the canvas item
func : a callback function
user_data : a pointer passed to the callback function


guppi_canvas_item_foreach_at ()

void        guppi_canvas_item_foreach_at    (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             GuppiCanvasItemFunc func,
                                             gpointer user_data);

Call the function func on the item, and each subitem whose bounding box contains the point (pt_x, py_y). Again, if item isn't a group object, this just causes func to be called with item and user_data as arguments.

item : the canvas item
pt_x : an x-coordinate, in ps-points
pt_y : a y-coordinate, in ps-points
func : a callback function
user_data : a pointer passed to the callback function


guppi_canvas_item_first_matching_at ()

GuppiCanvasItem* guppi_canvas_item_first_matching_at
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             GuppiCanvasItemTest test_func,
                                             gpointer user_data);

item : the canvas item
pt_x : an x-coordinate, in ps-points
pt_y : a y-coordinate, in ps-points
test_func : a callback function
user_data : a points passed to the callback
Returns :the first GuppiCanvasItem which is a subitem of item and for which test_func returns TRUE. If all of the item's subitems return FALSE from test_func, NULL is returned.


guppi_canvas_item_data_drop_candidate ()

GuppiCanvasItem* guppi_canvas_item_data_drop_candidate
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y);

item : 
pt_x : 
pt_y : 
Returns : 


guppi_canvas_item_data_drop ()

gboolean    guppi_canvas_item_data_drop     (GuppiCanvasItem *item,
                                             GuppiData *data);

item : 
data : 
Returns : 


guppi_canvas_item_locate_button_tool ()

gboolean    guppi_canvas_item_locate_button_tool
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             guint button,
                                             guint state,
                                             GuppiCanvasItem**,
                                             GuppiPlotTool**);

item : 
pt_x : 
pt_y : 
button : 
state : 
Param6 : 
Param7 : 
Returns : 


guppi_canvas_item_locate_key_tool ()

gboolean    guppi_canvas_item_locate_key_tool
                                            (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             guint key_code,
                                             guint state,
                                             GuppiCanvasItem**,
                                             GuppiPlotTool**);

item : 
pt_x : 
pt_y : 
key_code : 
state : 
Param6 : 
Param7 : 
Returns : 


guppi_canvas_item_double_click ()

gboolean    guppi_canvas_item_double_click  (GuppiCanvasItem *item,
                                             double pt_x,
                                             double pt_y,
                                             guint button,
                                             guint state);

item : 
pt_x : 
pt_y : 
button : 
state : 
Returns : 


guppi_canvas_item_set_local_toolkit ()

void        guppi_canvas_item_set_local_toolkit
                                            (GuppiCanvasItem *item,
                                             GuppiPlotToolkit *toolkit);

item : 
toolkit : 


guppi_canvas_item_enable_local_toolkit ()

void        guppi_canvas_item_enable_local_toolkit
                                            (GuppiCanvasItem *item,
                                             gboolean flag);

item : 
flag : 


guppi_canvas_item_enable_class_toolkit ()

void        guppi_canvas_item_enable_class_toolkit
                                            (GuppiCanvasItem *item,
                                             gboolean flag);

item : 
flag : 


guppi_canvas_item_nonlocal_tools_disabled ()

gboolean    guppi_canvas_item_nonlocal_tools_disabled
                                            (GuppiCanvasItem *item);

item : 
Returns : 


guppi_canvas_item_local_button_tool ()

GuppiPlotTool* guppi_canvas_item_local_button_tool
                                            (GuppiCanvasItem *item,
                                             guint button,
                                             guint state);

item : 
button : 
state : 
Returns : 


guppi_canvas_item_local_key_tool ()

GuppiPlotTool* guppi_canvas_item_local_key_tool
                                            (GuppiCanvasItem *item,
                                             guint key_code,
                                             guint state);

item : 
key_code : 
state : 
Returns : 


guppi_canvas_item_foreach_class_toolkit ()

void        guppi_canvas_item_foreach_class_toolkit
                                            (GuppiCanvasItem *item,
                                             void (*callback) (GuppiPlotToolkit *,gpointer),
                                             gpointer user_data);

item : 
callback : 
user_data : 


guppi_canvas_item_class_set_item_class_toolkit ()

void        guppi_canvas_item_class_set_item_class_toolkit
                                            (GuppiCanvasItemClass *item,
                                             GuppiPlotToolkit *toolkit);

item : 
toolkit : 

Signals

The "changed-scale" signal

void        user_function                  (GuppiCanvasItem *guppicanvasitem,
                                            gpointer user_data);

guppicanvasitem :the object which received the signal.
user_data :user data set when the signal handler was connected.