[goocanvas/prep-msvc-3.0: 2/4] src/*.h: Mark public API/symbols for export/import




commit 7dbe24b23fce90647d7c12c714c3da9aea3c9aea
Author: Chun-wei Fan <fanchunwei src gnome org>
Date:   Sat Jun 12 12:13:42 2021 +0800

    src/*.h: Mark public API/symbols for export/import
    
    Decorate the APIs in the public headers, as well as goocanvasatk.h, with macros
    that were added in goocanvasexports.h, so that we can properly export (and
    import them in the case of public variables) when building or using with Visual
    Studio.

 src/goocanvas.h           | 42 ++++++++++++++++++++++++++++++++++++
 src/goocanvasatk.h        |  5 ++++-
 src/goocanvasellipse.h    |  4 ++++
 src/goocanvasgrid.h       |  4 ++++
 src/goocanvasgroup.h      |  4 ++++
 src/goocanvasimage.h      |  4 ++++
 src/goocanvasitem.h       | 54 +++++++++++++++++++++++++++++++++++++++++++++++
 src/goocanvasitemmodel.h  | 35 ++++++++++++++++++++++++++++++
 src/goocanvasitemsimple.h | 11 ++++++++++
 src/goocanvaspath.h       |  4 ++++
 src/goocanvaspolyline.h   | 12 +++++++++++
 src/goocanvasrect.h       |  4 ++++
 src/goocanvasstyle.h      | 34 ++++++++++++++++++-----------
 src/goocanvastable.h      |  4 ++++
 src/goocanvastext.h       |  5 +++++
 src/goocanvasutils.h      | 19 +++++++++++++++++
 src/goocanvaswidget.h     |  2 ++
 17 files changed, 234 insertions(+), 13 deletions(-)
---
diff --git a/src/goocanvas.h b/src/goocanvas.h
index d7f9695..5d8a2c0 100644
--- a/src/goocanvas.h
+++ b/src/goocanvas.h
@@ -200,63 +200,84 @@ struct _GooCanvasClass
 };
 
 
+GOOCANVAS_API
 GType           goo_canvas_get_type        (void) G_GNUC_CONST;
+GOOCANVAS_API
 GtkWidget*      goo_canvas_new             (void);
 
+GOOCANVAS_API
 GooCanvasItem*  goo_canvas_get_root_item    (GooCanvas         *canvas);
+GOOCANVAS_API
 void            goo_canvas_set_root_item    (GooCanvas         *canvas,
                                             GooCanvasItem      *item);
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_get_root_item_model (GooCanvas         *canvas);
+GOOCANVAS_API
 void                goo_canvas_set_root_item_model (GooCanvas         *canvas,
                                                    GooCanvasItemModel *model);
 
+GOOCANVAS_API
 GooCanvasItem*  goo_canvas_get_static_root_item    (GooCanvas          *canvas);
+GOOCANVAS_API
 void            goo_canvas_set_static_root_item    (GooCanvas          *canvas,
                                                    GooCanvasItem      *item);
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_get_static_root_item_model (GooCanvas          *canvas);
+GOOCANVAS_API
 void                goo_canvas_set_static_root_item_model (GooCanvas          *canvas,
                                                           GooCanvasItemModel *model);
 
+GOOCANVAS_API
 GooCanvasItem*  goo_canvas_get_item        (GooCanvas          *canvas,
                                             GooCanvasItemModel *model);
+GOOCANVAS_API
 GooCanvasItem*  goo_canvas_get_item_at     (GooCanvas          *canvas,
                                             gdouble             x,
                                             gdouble             y,
                                             gboolean            is_pointer_event);
+GOOCANVAS_API
 GList*         goo_canvas_get_items_at     (GooCanvas          *canvas,
                                             gdouble             x,
                                             gdouble             y,
                                             gboolean            is_pointer_event);
+GOOCANVAS_API
 GList*         goo_canvas_get_items_in_area(GooCanvas          *canvas,
                                             const GooCanvasBounds *area,
                                             gboolean            inside_area,
                                             gboolean            allow_overlaps,
                                             gboolean            include_containers);
 
+GOOCANVAS_API
 gdouble         goo_canvas_get_scale       (GooCanvas          *canvas);
+GOOCANVAS_API
 void            goo_canvas_set_scale       (GooCanvas          *canvas,
                                             gdouble             scale);
 
+GOOCANVAS_API
 void            goo_canvas_get_bounds      (GooCanvas          *canvas,
                                             gdouble            *left,
                                             gdouble            *top,
                                             gdouble            *right,
                                             gdouble            *bottom);
+GOOCANVAS_API
 void            goo_canvas_set_bounds      (GooCanvas          *canvas,
                                             gdouble             left,
                                             gdouble             top,
                                             gdouble             right,
                                             gdouble             bottom);
 
+GOOCANVAS_API
 void            goo_canvas_scroll_to       (GooCanvas          *canvas,
                                             gdouble             left,
                                             gdouble             top);
 
+GOOCANVAS_API
 void            goo_canvas_grab_focus      (GooCanvas          *canvas,
                                             GooCanvasItem      *item);
 
+GOOCANVAS_API
 void            goo_canvas_render          (GooCanvas             *canvas,
                                             cairo_t               *cr,
                                             const GooCanvasBounds *bounds,
@@ -265,28 +286,35 @@ void            goo_canvas_render     (GooCanvas             *canvas,
 /*
  * Coordinate conversion.
  */
+GOOCANVAS_API
 void           goo_canvas_convert_to_pixels       (GooCanvas       *canvas,
                                                    gdouble         *x,
                                                    gdouble         *y);
+GOOCANVAS_API
 void           goo_canvas_convert_from_pixels     (GooCanvas       *canvas,
                                                    gdouble         *x,
                                                    gdouble         *y);
                                                    
+GOOCANVAS_API
 void goo_canvas_convert_units_to_pixels (GooCanvas *canvas,
                                                    gdouble         *x,
                                                    gdouble         *y);
+GOOCANVAS_API
 void goo_canvas_convert_units_from_pixels (GooCanvas *canvas,
                                                    gdouble         *x,
                                                    gdouble         *y);
 
+GOOCANVAS_API
 void           goo_canvas_convert_to_item_space   (GooCanvas       *canvas,
                                                    GooCanvasItem   *item,
                                                    gdouble         *x,
                                                    gdouble         *y);
+GOOCANVAS_API
 void           goo_canvas_convert_from_item_space (GooCanvas       *canvas,
                                                    GooCanvasItem   *item,
                                                    gdouble         *x,
                                                    gdouble         *y);
+GOOCANVAS_API
 void           goo_canvas_convert_bounds_to_item_space (GooCanvas           *canvas,
                                                         GooCanvasItem       *item,
                                                         GooCanvasBounds     *bounds);
@@ -295,18 +323,22 @@ void              goo_canvas_convert_bounds_to_item_space (GooCanvas           *canvas,
 /*
  * Pointer/keyboard grabbing & ungrabbing.
  */
+GOOCANVAS_API
 GdkGrabStatus  goo_canvas_pointer_grab     (GooCanvas          *canvas,
                                             GooCanvasItem      *item,
                                             GdkEventMask        event_mask,
                                             GdkCursor          *cursor,
                                             guint32             time);
+GOOCANVAS_API
 void           goo_canvas_pointer_ungrab   (GooCanvas          *canvas,
                                             GooCanvasItem      *item,
                                             guint32             time);
+GOOCANVAS_API
 GdkGrabStatus  goo_canvas_keyboard_grab    (GooCanvas          *canvas,
                                             GooCanvasItem      *item,
                                             gboolean            owner_events,
                                             guint32             time);
+GOOCANVAS_API
 void           goo_canvas_keyboard_ungrab  (GooCanvas          *canvas,
                                             GooCanvasItem      *item,
                                             guint32             time);
@@ -315,23 +347,33 @@ void              goo_canvas_keyboard_ungrab  (GooCanvas          *canvas,
 /*
  * Internal functions, mainly for canvas subclasses and item implementations.
  */
+GOOCANVAS_API
 cairo_t*       goo_canvas_create_cairo_context (GooCanvas *canvas);
+GOOCANVAS_API
 GooCanvasItem* goo_canvas_create_item      (GooCanvas          *canvas,
                                             GooCanvasItemModel *model);
+GOOCANVAS_API
 void           goo_canvas_unregister_item  (GooCanvas          *canvas,
                                             GooCanvasItemModel *model);
+GOOCANVAS_API
 void           goo_canvas_update           (GooCanvas          *canvas);
+GOOCANVAS_API
 void           goo_canvas_request_update   (GooCanvas          *canvas);
+GOOCANVAS_API
 void           goo_canvas_request_redraw   (GooCanvas          *canvas,
                                             const GooCanvasBounds *bounds);
+GOOCANVAS_API
 void           goo_canvas_request_item_redraw   (GooCanvas             *canvas,
                                                  const GooCanvasBounds *bounds,
                                                  gboolean               is_static);
+GOOCANVAS_API
 gdouble         goo_canvas_get_default_line_width (GooCanvas    *canvas);
 
 
+GOOCANVAS_API
 void            goo_canvas_register_widget_item   (GooCanvas          *canvas,
                                                   GooCanvasWidget    *witem);
+GOOCANVAS_API
 void            goo_canvas_unregister_widget_item (GooCanvas          *canvas,
                                                   GooCanvasWidget    *witem);
 
diff --git a/src/goocanvasatk.h b/src/goocanvasatk.h
index 92aa4e5..ee83ebb 100644
--- a/src/goocanvasatk.h
+++ b/src/goocanvasatk.h
@@ -8,12 +8,15 @@
 #define __GOO_CANVAS_ATK_H__
 
 #include <gtk/gtk.h>
-
+#include "goocanvasexports.h"
 
 G_BEGIN_DECLS
 
+GOOCANVAS_API
 GType    goo_canvas_accessible_factory_get_type  (void) G_GNUC_CONST;
+GOOCANVAS_API
 GType    goo_canvas_item_accessible_factory_get_type  (void) G_GNUC_CONST;
+GOOCANVAS_API
 GType    goo_canvas_widget_accessible_factory_get_type  (void) G_GNUC_CONST;
 
 
diff --git a/src/goocanvasellipse.h b/src/goocanvasellipse.h
index 0e62acd..5210c66 100644
--- a/src/goocanvasellipse.h
+++ b/src/goocanvasellipse.h
@@ -58,8 +58,10 @@ struct _GooCanvasEllipseClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_ellipse_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItem*      goo_canvas_ellipse_new      (GooCanvasItem      *parent,
                                                  gdouble             center_x,
                                                  gdouble             center_y,
@@ -106,8 +108,10 @@ struct _GooCanvasEllipseModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_ellipse_model_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_ellipse_model_new (GooCanvasItemModel *parent,
                                                  gdouble             center_x,
                                                  gdouble             center_y,
diff --git a/src/goocanvasgrid.h b/src/goocanvasgrid.h
index 7d233bc..9fcfdeb 100644
--- a/src/goocanvasgrid.h
+++ b/src/goocanvasgrid.h
@@ -84,7 +84,9 @@ struct _GooCanvasGridClass
 };
 
 
+GOOCANVAS_API
 GType          goo_canvas_grid_get_type      (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasItem* goo_canvas_grid_new           (GooCanvasItem      *parent,
                                              gdouble             x,
                                              gdouble             y,
@@ -135,7 +137,9 @@ struct _GooCanvasGridModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_grid_model_get_type (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_grid_model_new      (GooCanvasItemModel *parent,
                                                    gdouble             x,
                                                    gdouble             y,
diff --git a/src/goocanvasgroup.h b/src/goocanvasgroup.h
index 9c5b50c..7d38415 100644
--- a/src/goocanvasgroup.h
+++ b/src/goocanvasgroup.h
@@ -56,7 +56,9 @@ struct _GooCanvasGroupClass
 };
 
 
+GOOCANVAS_API
 GType          goo_canvas_group_get_type    (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasItem* goo_canvas_group_new         (GooCanvasItem  *parent,
                                             ...);
 
@@ -99,7 +101,9 @@ struct _GooCanvasGroupModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_group_model_get_type (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_group_model_new      (GooCanvasItemModel  *parent,
                                                     ...);
 
diff --git a/src/goocanvasimage.h b/src/goocanvasimage.h
index aa588c5..3f4f3a5 100644
--- a/src/goocanvasimage.h
+++ b/src/goocanvasimage.h
@@ -60,8 +60,10 @@ struct _GooCanvasImageClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_image_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItem*      goo_canvas_image_new       (GooCanvasItem      *parent,
                                                GdkPixbuf          *pixbuf,
                                                gdouble             x,
@@ -107,8 +109,10 @@ struct _GooCanvasImageModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_image_model_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_image_model_new (GooCanvasItemModel *parent,
                                                GdkPixbuf          *pixbuf,
                                                gdouble             x,
diff --git a/src/goocanvasitem.h b/src/goocanvasitem.h
index bf8b336..638c0bd 100644
--- a/src/goocanvasitem.h
+++ b/src/goocanvasitem.h
@@ -49,6 +49,7 @@ struct _GooCanvasBounds
   gdouble x1, y1, x2, y2;
 };
 
+GOOCANVAS_API
 GType goo_canvas_bounds_get_type (void) G_GNUC_CONST;
 #define GOO_TYPE_CANVAS_BOUNDS (goo_canvas_bounds_get_type ())
 
@@ -311,47 +312,61 @@ struct _GooCanvasItemIface
 };
 
 
+GOOCANVAS_API
 GType              goo_canvas_item_get_type       (void) G_GNUC_CONST;
 
 
 /*
  * Group functions - these should only be called on container items.
  */
+GOOCANVAS_API
 gint               goo_canvas_item_get_n_children (GooCanvasItem   *item);
+GOOCANVAS_API
 GooCanvasItem*     goo_canvas_item_get_child      (GooCanvasItem   *item,
                                                   gint             child_num);
+GOOCANVAS_API
 gint               goo_canvas_item_find_child     (GooCanvasItem   *item,
                                                   GooCanvasItem   *child);
+GOOCANVAS_API
 void               goo_canvas_item_add_child      (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   gint             position);
+GOOCANVAS_API
 void               goo_canvas_item_move_child     (GooCanvasItem   *item,
                                                   gint             old_position,
                                                   gint             new_position);
+GOOCANVAS_API
 void               goo_canvas_item_remove_child   (GooCanvasItem   *item,
                                                   gint             child_num);
 
+GOOCANVAS_API
 void  goo_canvas_item_get_child_property         (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   const gchar     *property_name,
                                                   GValue          *value);
+GOOCANVAS_API
 void  goo_canvas_item_set_child_property         (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   const gchar     *property_name,
                                                   const GValue    *value);
+GOOCANVAS_API
 void  goo_canvas_item_get_child_properties        (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   ...) G_GNUC_NULL_TERMINATED;
+GOOCANVAS_API
 void  goo_canvas_item_set_child_properties        (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   ...) G_GNUC_NULL_TERMINATED;
+GOOCANVAS_API
 void  goo_canvas_item_get_child_properties_valist (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   va_list          var_args);
+GOOCANVAS_API
 void  goo_canvas_item_set_child_properties_valist (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   va_list          var_args);
 
+GOOCANVAS_API
 gboolean goo_canvas_item_get_transform_for_child  (GooCanvasItem   *item,
                                                   GooCanvasItem   *child,
                                                   cairo_matrix_t  *transform);
@@ -360,58 +375,78 @@ gboolean goo_canvas_item_get_transform_for_child  (GooCanvasItem   *item,
 /*
  * Item functions - these are safe to call on all items.
  */
+GOOCANVAS_API
 GooCanvas*         goo_canvas_item_get_canvas     (GooCanvasItem   *item);
+GOOCANVAS_API
 void               goo_canvas_item_set_canvas     (GooCanvasItem   *item,
                                                   GooCanvas       *canvas);
+GOOCANVAS_API
 GooCanvasItem*     goo_canvas_item_get_parent     (GooCanvasItem   *item);
+GOOCANVAS_API
 void               goo_canvas_item_set_parent    (GooCanvasItem   *item,
                                                   GooCanvasItem   *parent);
+GOOCANVAS_API
 void               goo_canvas_item_remove         (GooCanvasItem   *item);
+GOOCANVAS_API
 gboolean           goo_canvas_item_is_container   (GooCanvasItem   *item);
 
+GOOCANVAS_API
 void               goo_canvas_item_raise          (GooCanvasItem   *item,
                                                   GooCanvasItem   *above);
+GOOCANVAS_API
 void               goo_canvas_item_lower          (GooCanvasItem   *item,
                                                   GooCanvasItem   *below);
 
+GOOCANVAS_API
 gboolean           goo_canvas_item_get_transform  (GooCanvasItem   *item,
                                                   cairo_matrix_t  *transform);
+GOOCANVAS_API
 void               goo_canvas_item_set_transform  (GooCanvasItem         *item,
                                                   const cairo_matrix_t  *transform);
+GOOCANVAS_API
 gboolean          goo_canvas_item_get_simple_transform (GooCanvasItem   *item,
                                                         gdouble         *x,
                                                         gdouble         *y,
                                                         gdouble         *scale,
                                                         gdouble         *rotation);
+GOOCANVAS_API
 void               goo_canvas_item_set_simple_transform (GooCanvasItem   *item,
                                                         gdouble          x,
                                                         gdouble          y,
                                                         gdouble          scale,
                                                         gdouble          rotation);
 
+GOOCANVAS_API
 void               goo_canvas_item_translate      (GooCanvasItem   *item,
                                                   gdouble          tx,
                                                   gdouble          ty);
+GOOCANVAS_API
 void               goo_canvas_item_scale          (GooCanvasItem   *item,
                                                   gdouble          sx,
                                                   gdouble          sy);
+GOOCANVAS_API
 void               goo_canvas_item_rotate         (GooCanvasItem   *item,
                                                   gdouble          degrees,
                                                   gdouble          cx,
                                                   gdouble          cy);
+GOOCANVAS_API
 void               goo_canvas_item_skew_x         (GooCanvasItem   *item,
                                                   gdouble          degrees,
                                                   gdouble          cx,
                                                   gdouble          cy);
+GOOCANVAS_API
 void               goo_canvas_item_skew_y         (GooCanvasItem   *item,
                                                   gdouble          degrees,
                                                   gdouble          cx,
                                                   gdouble          cy);
 
+GOOCANVAS_API
 GooCanvasStyle*    goo_canvas_item_get_style      (GooCanvasItem   *item);
+GOOCANVAS_API
 void               goo_canvas_item_set_style      (GooCanvasItem   *item,
                                                   GooCanvasStyle  *style);
 
+GOOCANVAS_API
 void               goo_canvas_item_animate        (GooCanvasItem   *item,
                                                   gdouble           x,
                                                   gdouble           y,
@@ -421,12 +456,15 @@ void               goo_canvas_item_animate        (GooCanvasItem   *item,
                                                   gint             duration,
                                                   gint             step_time,
                                                   GooCanvasAnimateType type);
+GOOCANVAS_API
 void               goo_canvas_item_stop_animation (GooCanvasItem   *item);
 
 
 
+GOOCANVAS_API
 void               goo_canvas_item_get_bounds    (GooCanvasItem   *item,
                                                   GooCanvasBounds *bounds);
+GOOCANVAS_API
 GList*            goo_canvas_item_get_items_at   (GooCanvasItem   *item,
                                                   gdouble          x,
                                                   gdouble          y,
@@ -434,33 +472,44 @@ GList*               goo_canvas_item_get_items_at   (GooCanvasItem   *item,
                                                   gboolean         is_pointer_event,
                                                   gboolean         parent_is_visible,
                                                   GList           *found_items);
+GOOCANVAS_API
 gboolean           goo_canvas_item_is_visible     (GooCanvasItem   *item);
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_item_get_model    (GooCanvasItem      *item);
+GOOCANVAS_API
 void                goo_canvas_item_set_model    (GooCanvasItem      *item,
                                                   GooCanvasItemModel *model);
 
+GOOCANVAS_API
 void               goo_canvas_item_request_update (GooCanvasItem   *item);
+GOOCANVAS_API
 void              goo_canvas_item_ensure_updated (GooCanvasItem   *item);
+GOOCANVAS_API
 void               goo_canvas_item_update         (GooCanvasItem   *item,
                                                   gboolean         entire_tree,
                                                   cairo_t         *cr,
                                                   GooCanvasBounds *bounds);
+GOOCANVAS_API
 void               goo_canvas_item_paint          (GooCanvasItem         *item,
                                                   cairo_t               *cr,
                                                   const GooCanvasBounds *bounds,
                                                   gdouble                scale);
 
+GOOCANVAS_API
 gboolean          goo_canvas_item_get_requested_area (GooCanvasItem    *item,
                                                       cairo_t          *cr,
                                                       GooCanvasBounds  *requested_area);
+GOOCANVAS_API
 gboolean          goo_canvas_item_get_requested_area_for_width (GooCanvasItem  *item,
                                                                 cairo_t          *cr,
                                                                 gdouble           width,
                                                                 GooCanvasBounds  *requested_area);
+GOOCANVAS_API
 gdouble            goo_canvas_item_get_requested_height (GooCanvasItem  *item,
                                                         cairo_t        *cr,
                                                         gdouble         width);
+GOOCANVAS_API
 void              goo_canvas_item_allocate_area      (GooCanvasItem         *item,
                                                       cairo_t               *cr,
                                                       const GooCanvasBounds *requested_area,
@@ -468,7 +517,9 @@ void                   goo_canvas_item_allocate_area      (GooCanvasItem         *item,
                                                       gdouble                x_offset,
                                                       gdouble                y_offset);
 
+GOOCANVAS_API
 gboolean          goo_canvas_item_get_is_static        (GooCanvasItem          *item);
+GOOCANVAS_API
 void              goo_canvas_item_set_is_static        (GooCanvasItem          *item,
                                                         gboolean                is_static);
 
@@ -476,11 +527,14 @@ void                 goo_canvas_item_set_is_static        (GooCanvasItem          *item,
 /*
  * Functions to support child properties when implementing new canvas items.
  */
+GOOCANVAS_API
 void         goo_canvas_item_class_install_child_property (GObjectClass *iclass,
                                                           guint         property_id,
                                                           GParamSpec   *pspec);
+GOOCANVAS_API
 GParamSpec*  goo_canvas_item_class_find_child_property   (GObjectClass *iclass,
                                                           const gchar  *property_name);
+GOOCANVAS_API
 GParamSpec** goo_canvas_item_class_list_child_properties  (GObjectClass        *iclass,
                                                           guint        *n_properties);
 
diff --git a/src/goocanvasitemmodel.h b/src/goocanvasitemmodel.h
index 42d90e3..525f202 100644
--- a/src/goocanvasitemmodel.h
+++ b/src/goocanvasitemmodel.h
@@ -151,43 +151,56 @@ struct _GooCanvasItemModelIface
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_item_model_get_type       (void) G_GNUC_CONST;
 
 
 /*
  * Group functions - these should only be called on container models.
  */
+GOOCANVAS_API
 gint                goo_canvas_item_model_get_n_children (GooCanvasItemModel *model);
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_item_model_get_child      (GooCanvasItemModel *model,
                                                          gint                child_num);
+GOOCANVAS_API
 void                goo_canvas_item_model_add_child      (GooCanvasItemModel *model,
                                                          GooCanvasItemModel *child,
                                                          gint                position);
+GOOCANVAS_API
 void                goo_canvas_item_model_move_child     (GooCanvasItemModel *model,
                                                          gint                old_position,
                                                          gint                new_position);
+GOOCANVAS_API
 void                goo_canvas_item_model_remove_child   (GooCanvasItemModel *model,
                                                          gint                child_num);
+GOOCANVAS_API
 gint                goo_canvas_item_model_find_child     (GooCanvasItemModel *model,
                                                          GooCanvasItemModel *child);
 
+GOOCANVAS_API
 void     goo_canvas_item_model_get_child_property       (GooCanvasItemModel   *model,
                                                          GooCanvasItemModel   *child,
                                                          const gchar          *property_name,
                                                          GValue               *value);
+GOOCANVAS_API
 void     goo_canvas_item_model_set_child_property       (GooCanvasItemModel   *model,
                                                          GooCanvasItemModel   *child,
                                                          const gchar          *property_name,
                                                          const GValue         *value);
+GOOCANVAS_API
 void     goo_canvas_item_model_get_child_properties     (GooCanvasItemModel   *model,
                                                          GooCanvasItemModel   *child,
                                                          ...) G_GNUC_NULL_TERMINATED;
+GOOCANVAS_API
 void     goo_canvas_item_model_set_child_properties     (GooCanvasItemModel   *model,
                                                          GooCanvasItemModel   *child,
                                                          ...) G_GNUC_NULL_TERMINATED;
+GOOCANVAS_API
 void     goo_canvas_item_model_get_child_properties_valist (GooCanvasItemModel   *model,
                                                            GooCanvasItemModel   *child,
                                                            va_list              var_args);
+GOOCANVAS_API
 void     goo_canvas_item_model_set_child_properties_valist (GooCanvasItemModel   *model,
                                                            GooCanvasItemModel   *child,
                                                            va_list              var_args);
@@ -196,55 +209,73 @@ void     goo_canvas_item_model_set_child_properties_valist (GooCanvasItemModel
 /*
  * Model functions - these are safe to call on all models.
  */
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_item_model_get_parent     (GooCanvasItemModel *model);
+GOOCANVAS_API
 void                goo_canvas_item_model_set_parent    (GooCanvasItemModel *model,
                                                          GooCanvasItemModel *parent);
+GOOCANVAS_API
 void                goo_canvas_item_model_remove         (GooCanvasItemModel *model);
+GOOCANVAS_API
 gboolean            goo_canvas_item_model_is_container   (GooCanvasItemModel *model);
 
+GOOCANVAS_API
 void                goo_canvas_item_model_raise          (GooCanvasItemModel *model,
                                                          GooCanvasItemModel *above);
+GOOCANVAS_API
 void                goo_canvas_item_model_lower          (GooCanvasItemModel *model,
                                                          GooCanvasItemModel *below);
 
+GOOCANVAS_API
 gboolean            goo_canvas_item_model_get_transform  (GooCanvasItemModel *model,
                                                          cairo_matrix_t     *transform);
+GOOCANVAS_API
 void                goo_canvas_item_model_set_transform  (GooCanvasItemModel   *model,
                                                          const cairo_matrix_t *transform);
+GOOCANVAS_API
 gboolean           goo_canvas_item_model_get_simple_transform (GooCanvasItemModel *model,
                                                                gdouble            *x,
                                                                gdouble            *y,
                                                                gdouble            *scale,
                                                                gdouble            *rotation);
+GOOCANVAS_API
 void                goo_canvas_item_model_set_simple_transform (GooCanvasItemModel *model,
                                                                gdouble             x,
                                                                gdouble             y,
                                                                gdouble             scale,
                                                                gdouble             rotation);
 
+GOOCANVAS_API
 void                goo_canvas_item_model_translate      (GooCanvasItemModel *model,
                                                          gdouble             tx,
                                                          gdouble             ty);
+GOOCANVAS_API
 void                goo_canvas_item_model_scale          (GooCanvasItemModel *model,
                                                          gdouble             sx,
                                                          gdouble             sy);
+GOOCANVAS_API
 void                goo_canvas_item_model_rotate         (GooCanvasItemModel *model,
                                                          gdouble             degrees,
                                                          gdouble             cx,
                                                          gdouble             cy);
+GOOCANVAS_API
 void                goo_canvas_item_model_skew_x         (GooCanvasItemModel *model,
                                                          gdouble             degrees,
                                                          gdouble             cx,
                                                          gdouble             cy);
+GOOCANVAS_API
 void                goo_canvas_item_model_skew_y         (GooCanvasItemModel *model,
                                                          gdouble             degrees,
                                                          gdouble             cx,
                                                          gdouble             cy);
 
+GOOCANVAS_API
 GooCanvasStyle*     goo_canvas_item_model_get_style      (GooCanvasItemModel *model);
+GOOCANVAS_API
 void                goo_canvas_item_model_set_style      (GooCanvasItemModel *model,
                                                          GooCanvasStyle  *style);
 
+GOOCANVAS_API
 void                goo_canvas_item_model_animate        (GooCanvasItemModel *model,
                                                          gdouble             x,
                                                          gdouble             y,
@@ -254,17 +285,21 @@ void                goo_canvas_item_model_animate        (GooCanvasItemModel *mo
                                                          gint                duration,
                                                          gint                step_time,
                                                          GooCanvasAnimateType type);
+GOOCANVAS_API
 void                goo_canvas_item_model_stop_animation (GooCanvasItemModel *model);
 
 
 /*
  * Functions to support child properties when implementing new canvas items.
  */
+GOOCANVAS_API
 void         goo_canvas_item_model_class_install_child_property (GObjectClass *mclass,
                                                                 guint   property_id,
                                                                 GParamSpec     *pspec);
+GOOCANVAS_API
 GParamSpec*  goo_canvas_item_model_class_find_child_property   (GObjectClass   *mclass,
                                                                 const gchar    *property_name);
+GOOCANVAS_API
 GParamSpec** goo_canvas_item_model_class_list_child_properties  (GObjectClass  *mclass,
                                                                 guint  *n_properties);
 
diff --git a/src/goocanvasitemsimple.h b/src/goocanvasitemsimple.h
index 15f7eea..b6d146b 100644
--- a/src/goocanvasitemsimple.h
+++ b/src/goocanvasitemsimple.h
@@ -160,30 +160,40 @@ struct _GooCanvasItemSimpleClass
 };
 
 
+GOOCANVAS_API
 GType    goo_canvas_item_simple_get_type               (void) G_GNUC_CONST;
 
 
+GOOCANVAS_API
 void     goo_canvas_item_simple_get_path_bounds                (GooCanvasItemSimple    *item,
                                                         cairo_t                *cr,
                                                         GooCanvasBounds        *bounds);
+GOOCANVAS_API
 void     goo_canvas_item_simple_user_bounds_to_device  (GooCanvasItemSimple    *item,
                                                         cairo_t                *cr,
                                                         GooCanvasBounds        *bounds);
+GOOCANVAS_API
 void     goo_canvas_item_simple_user_bounds_to_parent  (GooCanvasItemSimple    *item,
                                                         cairo_t                *cr,
                                                         GooCanvasBounds        *bounds);
+GOOCANVAS_API
 gboolean goo_canvas_item_simple_check_in_path          (GooCanvasItemSimple    *item,
                                                         gdouble                 x,
                                                         gdouble                 y,
                                                         cairo_t                *cr,
                                                         GooCanvasPointerEvents  pointer_events);
+GOOCANVAS_API
 void     goo_canvas_item_simple_paint_path             (GooCanvasItemSimple    *item,
                                                         cairo_t                *cr);
 
+GOOCANVAS_API
 void     goo_canvas_item_simple_changed                        (GooCanvasItemSimple    *item,
                                                         gboolean                recompute_bounds);
+GOOCANVAS_API
 void     goo_canvas_item_simple_check_style            (GooCanvasItemSimple    *item);
+GOOCANVAS_API
 gdouble  goo_canvas_item_simple_get_line_width         (GooCanvasItemSimple   *item);
+GOOCANVAS_API
 void    goo_canvas_item_simple_set_model               (GooCanvasItemSimple    *item,
                                                         GooCanvasItemModel     *model);
 
@@ -239,6 +249,7 @@ struct _GooCanvasItemModelSimpleClass
 };
 
 
+GOOCANVAS_API
 GType    goo_canvas_item_model_simple_get_type  (void) G_GNUC_CONST;
 
 
diff --git a/src/goocanvaspath.h b/src/goocanvaspath.h
index 3ccd8d4..6bbde2b 100644
--- a/src/goocanvaspath.h
+++ b/src/goocanvaspath.h
@@ -59,8 +59,10 @@ struct _GooCanvasPathClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_path_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItem*      goo_canvas_path_new       (GooCanvasItem      *parent,
                                               const gchar        *path_data,
                                               ...);
@@ -104,8 +106,10 @@ struct _GooCanvasPathModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_path_model_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_path_model_new (GooCanvasItemModel *parent,
                                               const gchar        *path_data,
                                               ...);
diff --git a/src/goocanvaspolyline.h b/src/goocanvaspolyline.h
index ea68903..bdbfc4a 100644
--- a/src/goocanvaspolyline.h
+++ b/src/goocanvaspolyline.h
@@ -31,11 +31,17 @@ struct _GooCanvasPoints
 };
 
 #define GOO_TYPE_CANVAS_POINTS goo_canvas_points_get_type()
+GOOCANVAS_API
 GType            goo_canvas_points_get_type (void);
+GOOCANVAS_API
 GooCanvasPoints* goo_canvas_points_new      (int              num_points);
+GOOCANVAS_API
 GooCanvasPoints* goo_canvas_points_ref      (GooCanvasPoints *points);
+GOOCANVAS_API
 void             goo_canvas_points_unref    (GooCanvasPoints *points);
+GOOCANVAS_API
 void             goo_canvas_points_set_point(GooCanvasPoints *points, int idx, double x, double y);
+GOOCANVAS_API
 void             goo_canvas_points_get_point(GooCanvasPoints *points, int idx, double *x, double *y);
 
 #define GOO_CANVAS_POLYLINE_NUM_ARROW_POINTS     5             /* number of points in an arrowhead */
@@ -106,13 +112,16 @@ struct _GooCanvasPolylineClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_polyline_get_type       (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItem*      goo_canvas_polyline_new            (GooCanvasItem      *parent,
                                                        gboolean            close_path,
                                                        gint                num_points,
                                                        ...);
 
+GOOCANVAS_API
 GooCanvasItem*      goo_canvas_polyline_new_line       (GooCanvasItem      *parent,
                                                        gdouble             x1,
                                                        gdouble             y1,
@@ -159,13 +168,16 @@ struct _GooCanvasPolylineModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_polyline_model_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_polyline_model_new      (GooCanvasItemModel *parent,
                                                        gboolean            close_path,
                                                        gint                num_points,
                                                        ...);
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_polyline_model_new_line (GooCanvasItemModel *parent,
                                                        gdouble             x1,
                                                        gdouble             y1,
diff --git a/src/goocanvasrect.h b/src/goocanvasrect.h
index ed102cf..f4d1504 100644
--- a/src/goocanvasrect.h
+++ b/src/goocanvasrect.h
@@ -60,8 +60,10 @@ struct _GooCanvasRectClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_rect_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItem*      goo_canvas_rect_new       (GooCanvasItem      *parent,
                                               gdouble             x,
                                               gdouble             y,
@@ -108,8 +110,10 @@ struct _GooCanvasRectModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_rect_model_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_rect_model_new (GooCanvasItemModel *parent,
                                               gdouble             x,
                                               gdouble             y,
diff --git a/src/goocanvasstyle.h b/src/goocanvasstyle.h
index 697f279..280dd94 100644
--- a/src/goocanvasstyle.h
+++ b/src/goocanvasstyle.h
@@ -8,23 +8,24 @@
 #define __GOO_CANVAS_STYLE_H__
 
 #include <gtk/gtk.h>
+#include "goocanvasexports.h"
 
 G_BEGIN_DECLS
 
 
 /* GQuarks for the basic properties. */
-extern GQuark goo_canvas_style_stroke_pattern_id;
-extern GQuark goo_canvas_style_fill_pattern_id;
-extern GQuark goo_canvas_style_fill_rule_id;
-extern GQuark goo_canvas_style_operator_id;
-extern GQuark goo_canvas_style_antialias_id;
-extern GQuark goo_canvas_style_line_width_id;
-extern GQuark goo_canvas_style_line_cap_id;
-extern GQuark goo_canvas_style_line_join_id;
-extern GQuark goo_canvas_style_line_join_miter_limit_id;
-extern GQuark goo_canvas_style_line_dash_id;
-extern GQuark goo_canvas_style_font_desc_id;
-extern GQuark goo_canvas_style_hint_metrics_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_stroke_pattern_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_fill_pattern_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_fill_rule_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_operator_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_antialias_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_line_width_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_line_cap_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_line_join_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_line_join_miter_limit_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_line_dash_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_font_desc_id;
+GOOCANVAS_EXTERNAL_V GQuark goo_canvas_style_hint_metrics_id;
 
 
 /**
@@ -85,23 +86,32 @@ struct _GooCanvasStyleClass
 };
 
 
+GOOCANVAS_API
 GType           goo_canvas_style_get_type           (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasStyle* goo_canvas_style_new                (void);
+GOOCANVAS_API
 GooCanvasStyle* goo_canvas_style_copy               (GooCanvasStyle *style);
 
+GOOCANVAS_API
 GooCanvasStyle* goo_canvas_style_get_parent         (GooCanvasStyle *style);
+GOOCANVAS_API
 void            goo_canvas_style_set_parent         (GooCanvasStyle *style,
                                                     GooCanvasStyle *parent);
 
+GOOCANVAS_API
 GValue*         goo_canvas_style_get_property       (GooCanvasStyle *style,
                                                     GQuark          property_id);
+GOOCANVAS_API
 void            goo_canvas_style_set_property      (GooCanvasStyle *style,
                                                     GQuark          property_id,
                                                     const GValue   *value);
 
 /* Convenience functions to set the standard cairo stroke and fill options. */
+GOOCANVAS_API
 gboolean        goo_canvas_style_set_stroke_options (GooCanvasStyle *style,
                                                     cairo_t        *cr);
+GOOCANVAS_API
 gboolean        goo_canvas_style_set_fill_options   (GooCanvasStyle *style,
                                                     cairo_t        *cr);
 
diff --git a/src/goocanvastable.h b/src/goocanvastable.h
index b584855..5291d6a 100644
--- a/src/goocanvastable.h
+++ b/src/goocanvastable.h
@@ -85,7 +85,9 @@ struct _GooCanvasTableClass
 };
 
 
+GOOCANVAS_API
 GType          goo_canvas_table_get_type    (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasItem* goo_canvas_table_new         (GooCanvasItem  *parent,
                                             ...);
 
@@ -129,7 +131,9 @@ struct _GooCanvasTableModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_table_model_get_type (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_table_model_new      (GooCanvasItemModel *parent,
                                                     ...);
 
diff --git a/src/goocanvastext.h b/src/goocanvastext.h
index 183120b..c6965ee 100644
--- a/src/goocanvastext.h
+++ b/src/goocanvastext.h
@@ -65,8 +65,10 @@ struct _GooCanvasTextClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_text_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItem*      goo_canvas_text_new       (GooCanvasItem      *parent,
                                               const char         *string,
                                               gdouble             x,
@@ -75,6 +77,7 @@ GooCanvasItem*      goo_canvas_text_new       (GooCanvasItem      *parent,
                                               GooCanvasAnchorType       anchor,
                                               ...);
 
+GOOCANVAS_API
 void   goo_canvas_text_get_natural_extents   (GooCanvasText  *text,
                                               PangoRectangle *ink_rect,
                                               PangoRectangle *logical_rect);
@@ -117,8 +120,10 @@ struct _GooCanvasTextModelClass
 };
 
 
+GOOCANVAS_API
 GType               goo_canvas_text_model_get_type  (void) G_GNUC_CONST;
 
+GOOCANVAS_API
 GooCanvasItemModel* goo_canvas_text_model_new (GooCanvasItemModel *parent,
                                               const char         *string,
                                               gdouble             x,
diff --git a/src/goocanvasutils.h b/src/goocanvasutils.h
index 331e60b..ead0892 100644
--- a/src/goocanvasutils.h
+++ b/src/goocanvasutils.h
@@ -8,6 +8,7 @@
 #define __GOO_CANVAS_UTILS_H__
 
 #include <gtk/gtk.h>
+#include "goocanvasexports.h"
 
 G_BEGIN_DECLS
 
@@ -224,7 +225,9 @@ union _GooCanvasPathCommand
 };
 
 
+GOOCANVAS_API
 GArray*        goo_canvas_parse_path_data      (const gchar       *path_data);
+GOOCANVAS_API
 void   goo_canvas_create_path          (GArray            *commands,
                                         cairo_t           *cr);
 
@@ -339,40 +342,56 @@ typedef cairo_pattern_t           GooCairoPattern;
 
 
 #define GOO_TYPE_CANVAS_LINE_DASH  (goo_canvas_line_dash_get_type ())
+GOOCANVAS_API
 GType              goo_canvas_line_dash_get_type (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasLineDash* goo_canvas_line_dash_new   (gint               num_dashes,
                                               ...);
+GOOCANVAS_API
 GooCanvasLineDash* goo_canvas_line_dash_newv  (gint               num_dashes,
                                                double            *dashes);
+GOOCANVAS_API
 GooCanvasLineDash* goo_canvas_line_dash_ref   (GooCanvasLineDash *dash);
+GOOCANVAS_API
 void               goo_canvas_line_dash_unref (GooCanvasLineDash *dash);
+GOOCANVAS_API
 void              goo_canvas_line_dash_set_offset (GooCanvasLineDash *dash,
                                                    double             dash_offset);
 
 #define GOO_TYPE_CAIRO_MATRIX     (goo_cairo_matrix_get_type())
+GOOCANVAS_API
 GType              goo_cairo_matrix_get_type  (void) G_GNUC_CONST;
+GOOCANVAS_API
 cairo_matrix_t*    goo_cairo_matrix_copy      (const cairo_matrix_t *matrix);
+GOOCANVAS_API
 void               goo_cairo_matrix_free      (cairo_matrix_t       *matrix);
 
 #define GOO_TYPE_CAIRO_PATTERN    (goo_cairo_pattern_get_type ())
+GOOCANVAS_API
 GType              goo_cairo_pattern_get_type (void) G_GNUC_CONST;
 
 #define GOO_TYPE_CAIRO_FILL_RULE   (goo_cairo_fill_rule_get_type ())
+GOOCANVAS_API
 GType             goo_cairo_fill_rule_get_type (void) G_GNUC_CONST;
 
 #define GOO_TYPE_CAIRO_OPERATOR    (goo_cairo_operator_get_type())
+GOOCANVAS_API
 GType             goo_cairo_operator_get_type  (void) G_GNUC_CONST;
 
 #define GOO_TYPE_CAIRO_ANTIALIAS   (goo_cairo_antialias_get_type())
+GOOCANVAS_API
 GType             goo_cairo_antialias_get_type (void) G_GNUC_CONST;
 
 #define GOO_TYPE_CAIRO_LINE_CAP    (goo_cairo_line_cap_get_type ())
+GOOCANVAS_API
 GType             goo_cairo_line_cap_get_type  (void) G_GNUC_CONST;
 
 #define GOO_TYPE_CAIRO_LINE_JOIN   (goo_cairo_line_join_get_type ())
+GOOCANVAS_API
 GType             goo_cairo_line_join_get_type (void) G_GNUC_CONST;
 
 #define GOO_TYPE_CAIRO_HINT_METRICS (goo_cairo_hint_metrics_get_type ())
+GOOCANVAS_API
 GType             goo_cairo_hint_metrics_get_type (void) G_GNUC_CONST;
 
 
diff --git a/src/goocanvaswidget.h b/src/goocanvaswidget.h
index 9ef48bb..019f226 100644
--- a/src/goocanvaswidget.h
+++ b/src/goocanvaswidget.h
@@ -52,7 +52,9 @@ struct _GooCanvasWidgetClass
 };
 
 
+GOOCANVAS_API
 GType          goo_canvas_widget_get_type          (void) G_GNUC_CONST;
+GOOCANVAS_API
 GooCanvasItem* goo_canvas_widget_new               (GooCanvasItem    *parent,
                                                    GtkWidget        *widget,
                                                    gdouble           x,


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]