diff --git a/bindings/python/meson.build b/bindings/python/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..a1b1c07d39d22c8cc45434231dac124a81c4be41 --- /dev/null +++ b/bindings/python/meson.build @@ -0,0 +1,4 @@ +install_data( + 'GooCanvas.py', + install_dir: py_installation.get_path('purelib') / 'gi/overrides', +) diff --git a/demo/meson.build b/demo/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..d37990169eba129789055835dd3922aecd68c8de --- /dev/null +++ b/demo/meson.build @@ -0,0 +1,67 @@ +tests = [ + ['generic-position-demo', {'sources': files('generic-position-demo.c')}], + ['mv-generic-position-demo', {'sources': files('mv-generic-position-demo.c')}], + ['mv-radii-demo', {'sources': files('mv-radii-demo.c')}], + ['mv-rotate-skew-demo', {'sources': files('mv-rotate-skew-demo.c')}], + ['mv-scalability-demo', {'sources': files('mv-scalability-demo.c')}], + ['mv-simple-demo', {'sources': files('mv-simple-demo.c')}], + ['mv-table-demo', {'sources': files('mv-table-demo.c')}], + ['radii-demo', {'sources': files('radii-demo.c')}], + ['scalability-demo', {'sources': files('scalability-demo.c')}], + ['simple-demo', {'sources': files('simple-demo.c')}], + ['table-demo', {'sources': files('table-demo.c')}], + ['units-demo', {'sources': files('units-demo.c')}], + ['widgets-demo', {'sources': files('widgets-demo.c')}], +] + +sources = files( + 'demo-animation.c', + 'demo-arrowhead.c', + 'demo.c', + 'demo-clipping.c', + 'demo-events.c', + 'demo-features.c', + 'demo-fifteen.c', + 'demo-focus.c', + 'demo-grabs.c', + 'demo-item.c', + 'demo-large-items.c', + 'demo-large-line.c', + 'demo-large-rect.c', + 'demo-paths.c', + 'demo-scalability.c', + 'demo-table.c', +) + +tests += [['demo', {'sources': sources}]] + +sources = files( + 'mv-demo-animation.c', + 'mv-demo-arrowhead.c', + 'mv-demo.c', + 'mv-demo-clipping.c', + 'mv-demo-events.c', + 'mv-demo-features.c', + 'mv-demo-fifteen.c', + 'mv-demo-focus.c', + 'mv-demo-grabs.c', + 'mv-demo-paths.c', + 'mv-demo-scalability.c', + 'mv-demo-table.c', +) + +tests += [['mv-demo', {'sources': sources}]] + +deps = [ + libgoocanvas_dep, + m_dep, +] + +foreach test: tests + executable( + test[0], + include_directories: top_inc, + dependencies: deps, + kwargs: test[1], + ) +endforeach diff --git a/docs/meson.build b/docs/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..ffbbf8048f5b510a77aa3a4f97f838ff1e83d572 --- /dev/null +++ b/docs/meson.build @@ -0,0 +1,38 @@ +subdir('xml') + +# FIXME: the file name has not been updated +doc_module_basename = meson.project_name() + (goocanvas_major_version - 1).to_string() + +doc_module_dir = gnome.gtkdoc_html_dir(goocanvas_api_name) + +private_headers = [ + 'goocanvasmarshal.h', + 'goocanvasprivate.h', +] + +expand_content_files = [ + 'architecture.xml', + 'coordinates.xml', + 'creating-items.xml', + 'model-view-canvas.xml', + 'overview.xml', + 'simple-canvas.xml', + 'wysiwyg.xml', +] + +gnome.gtkdoc( + goocanvas_api_name, + main_xml: doc_module_basename + '-docs.sgml', + module_version: goocanvas_major_version.to_string(), + src_dir: src_inc, + ignore_headers: private_headers, + include_directories: top_inc, + dependencies: libgoocanvas_dep, + gobject_typesfile: files(doc_module_basename + '.types'), + fixxref_args: '--html-dir=' + (goocanvas_prefix / doc_module_dir), + scan_args: '--rebuild-types', + scanobjs_args: '--query-child-properties=goo_canvas_query_child_properties', + expand_content_files: expand_content_files, + install: true, + install_dir: doc_module_dir, +) diff --git a/docs/xml/gtkdocentities.ent.in b/docs/xml/gtkdocentities.ent.in new file mode 100644 index 0000000000000000000000000000000000000000..fd86c1654dad7d4a45a1f16b4b5de51a32b8ce7b --- /dev/null +++ b/docs/xml/gtkdocentities.ent.in @@ -0,0 +1,7 @@ + + + + + + + diff --git a/docs/xml/meson.build b/docs/xml/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..973e7219b93b374323785d57fbe25e77ede0ef5f --- /dev/null +++ b/docs/xml/meson.build @@ -0,0 +1,15 @@ +ent_conf = { + 'PACKAGE': goocanvas_name, + 'PACKAGE_BUGREPORT': '', + 'PACKAGE_NAME': goocanvas_name, + 'PACKAGE_STRING': '@0@ @1@'.format(goocanvas_name, goocanvas_version), + 'PACKAGE_TARNAME': goocanvas_name, + 'PACKAGE_URL': '', + 'PACKAGE_VERSION': goocanvas_version, +} + +configure_file( + input: 'gtkdocentities.ent.in', + output: '@BASENAME@', + configuration: ent_conf, +) diff --git a/meson.build b/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..a727a16a3398390f0e94cc8415bb1bc289ff07e5 --- /dev/null +++ b/meson.build @@ -0,0 +1,90 @@ +project( + 'goocanvas', 'c', + version: '3.0.0', + license: 'LGPL', + default_options: 'buildtype=debugoptimized', + meson_version: '>= 0.49.0', +) + +goocanvas_name = meson.project_name() + +goocanvas_version = meson.project_version() +version_array = goocanvas_version.split('.') +goocanvas_major_version = version_array[0].to_int() +goocanvas_minor_version = version_array[1].to_int() +goocanvas_micro_version = version_array[2].to_int() + +# If the source code has changed at all, increment goocanvasui_revision +# If any interfaces have been added, removed, or changed, increment goocanvasui_current, and set goocanvasui_revision to 0. +# If any interfaces have been added since the last public release, then increment goocanvasui_age. +# If any interfaces have been removed since the last public release, then set goocanvasui_age to 0. +# Reference: http://www.gnu.org/software/libtool/manual/libtool.html#Versioning + +goocanvas_revision = 2 +goocanvas_current = 12 +goocanvas_age = 3 +goocanvas_current_minus_age = goocanvas_current - goocanvas_age +goocanvas_libversion = '@0@.@1@.@2@'.format(goocanvas_current_minus_age, goocanvas_age, goocanvas_revision) + +goocanvas_api_name = meson.project_name() + goocanvas_major_version.to_string() +goocanvas_api_version = '@0@.@1@'.format(goocanvas_major_version, goocanvas_minor_version) +goocanvas_api_prefix = 'Goo' + +goocanvas_api_ns = 'GooCanvas' + +goocanvas_prefix = get_option('prefix') +goocanvas_includedir = get_option('includedir') +goocanvas_libdir = get_option('libdir') + +gnome = import('gnome') +i18n = import('i18n') +pkg = import('pkgconfig') +pymod = import('python') + +source_root = meson.current_source_dir() +build_root = meson.current_build_dir() + +its_dir = source_root / 'data/gettext' +po_dir = source_root / 'po' + +top_inc = include_directories('.') + +cc = meson.get_compiler('c') + +config_h = configuration_data() +config_h.set_quoted('GETTEXT_PACKAGE', goocanvas_api_name) + +cairo_dep = dependency('cairo', version: '>= 1.10.0') +glib_dep = dependency('glib-2.0', version: '>= 2.28.0') +gtk_dep = dependency('gtk+-3.0', version: '>= 3.0.0') + +m_dep = cc.find_library('m', required: false) + +if cc.get_argument_syntax() == 'msvc' + add_project_arguments(cc.get_supported_arguments([ + '-utf-8', # Use UTF-8 mode + '-FImsvc_recommended_pragmas.h', + '-D_USE_MATH_DEFINES', + ]), language: ['c']) +endif + +enable_introspection = dependency('gobject-introspection-1.0', version: '>= 0.6.7', required: get_option('introspection')).found() + +subdir('po') +subdir('src') +subdir('demo') + +py_installation = pymod.find_installation('python3', required: get_option('python')) +if py_installation.found() + subdir('bindings/python') +endif + +enable_gtk_doc = get_option('gtk_doc') +if enable_gtk_doc + subdir('docs') +endif + +configure_file( + output: 'config.h', + configuration: config_h, +) diff --git a/meson_options.txt b/meson_options.txt new file mode 100644 index 0000000000000000000000000000000000000000..d274c64fc4005f19582b2f597d41571e8e22887c --- /dev/null +++ b/meson_options.txt @@ -0,0 +1,4 @@ +option('python', type: 'feature', value: 'auto', description: 'build python support') +option('introspection', type: 'feature', value: 'auto', description: 'build introspection support') + +option('gtk_doc', type: 'boolean', value: false, description: 'build GTK Doc reference') diff --git a/po/meson.build b/po/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..df18f14cbb9d4388097f41dbdf2f5bb7750a8562 --- /dev/null +++ b/po/meson.build @@ -0,0 +1 @@ +i18n.gettext(goocanvas_api_name, preset: 'glib') diff --git a/src/Makefile.am b/src/Makefile.am index 2f7d4f354477c2005ead50fcc94124e5231ca82c..9226e5145c139d5351b72fc562094d049f22672f 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -29,6 +29,7 @@ libgoocanvasincludedir = $(includedir)/goocanvas-3.0 libgoocanvas_public_headers = \ goocanvasellipse.h \ + goocanvasexports.h \ goocanvasgrid.h \ goocanvasgroup.h \ goocanvasimage.h \ @@ -117,9 +118,9 @@ goocanvasenumtypes.h: stamp-goocanvasenumtypes.h @true stamp-goocanvasenumtypes.h: @REBUILD@ $(goo_canvas_public_headers) Makefile (cd $(srcdir) && $(GLIB_MKENUMS) \ - --fhead "#ifndef __GOO_CANVAS_ENUM_TYPES_H__\n#define __GOO_CANVAS_ENUM_TYPES_H__\n\n#include \n\nG_BEGIN_DECLS\n" \ + --fhead "#ifndef __GOO_CANVAS_ENUM_TYPES_H__\n#define __GOO_CANVAS_ENUM_TYPES_H__\n\n#include \n#include \"goocanvasexports.h\"\n\nG_BEGIN_DECLS\n" \ --fprod "/* Enumerations from \"@filename@\" */\n" \ - --vhead "GType @enum_name@_get_type (void);\n#define GOO_TYPE_@ENUMSHORT@ (@enum_name@_get_type())\n\n\n" \ + --vhead "GOOCANVAS_API\nGType @enum_name@_get_type (void);\n#define GOO_TYPE_@ENUMSHORT@ (@enum_name@_get_type())\n\n\n" \ --ftail "G_END_DECLS\n\n#endif /* __GOO_CANVAS_ENUM_TYPES_H__ */" \ $(libgoocanvas_public_headers)) >> xgen-gtbh \ && (cmp -s xgen-gtbh goocanvasenumtypes.h || cp xgen-gtbh goocanvasenumtypes.h ) \ diff --git a/src/goocanvas.h b/src/goocanvas.h index d7f96951f5332a923280d637d32b42756ea16a53..5d8a2c0c9d7e24bf50b14a6dd0a1b742438a7c1f 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.c b/src/goocanvasatk.c index 565f1bc63cd53e4adcfe56bbdf24745c2ce0d124..abdbe413247c33b47cb11e0f48ce182c167f9a5d 100644 --- a/src/goocanvasatk.c +++ b/src/goocanvasatk.c @@ -11,6 +11,7 @@ #include #include #include "goocanvas.h" +#include "goocanvasatk.h" /* diff --git a/src/goocanvasatk.h b/src/goocanvasatk.h index 92aa4e5d77c89d77fff7e8cc6043ae612f737f10..ee83ebb4f59930ad704913998a1fce83b86deb1b 100644 --- a/src/goocanvasatk.h +++ b/src/goocanvasatk.h @@ -8,12 +8,15 @@ #define __GOO_CANVAS_ATK_H__ #include - +#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 0e62acdf230612eb20306273826d5d692356f355..5210c666c14c1009aa19ab6aedcb4fb1a47e9041 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/goocanvasenumtypes.c.template b/src/goocanvasenumtypes.c.template new file mode 100644 index 0000000000000000000000000000000000000000..e3feb03ff60da87f934b7300da7d53434e886cba --- /dev/null +++ b/src/goocanvasenumtypes.c.template @@ -0,0 +1,41 @@ +/*** BEGIN file-header ***/ +#include "goocanvas.h" +#include + +/*** END file-header ***/ + +/*** BEGIN file-production ***/ +/* enumerations from "@basename@" */ + +/*** END file-production ***/ + +/*** BEGIN value-header ***/ +GType +@enum_name@_get_type (void) +{ + static volatile gsize g_define_type_id__volatile = 0; + + if (g_once_init_enter (&g_define_type_id__volatile)) { + static const G@Type@Value values[] = { +/*** END value-header ***/ + +/*** BEGIN value-production ***/ + { @VALUENAME@, "@VALUENAME@", "@valuenick@" }, +/*** END value-production ***/ + +/*** BEGIN value-tail ***/ + { 0, NULL, NULL } + }; + GType g_define_type_id = \ + g_@type@_register_static (g_intern_static_string ("@EnumName@"), values); + + g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); + } + + return g_define_type_id__volatile; +} + +/*** END value-tail ***/ + +/*** BEGIN file-tail ***/ +/*** END file-tail ***/ diff --git a/src/goocanvasenumtypes.h.template b/src/goocanvasenumtypes.h.template new file mode 100644 index 0000000000000000000000000000000000000000..095c8805a06d4e7c0eee48d342674ecdd9482627 --- /dev/null +++ b/src/goocanvasenumtypes.h.template @@ -0,0 +1,26 @@ +/*** BEGIN file-header ***/ +#pragma once + +#include +#include "goocanvasexports.h" + +G_BEGIN_DECLS + +/*** END file-header ***/ + +/*** BEGIN file-production ***/ +/* enumerations from "@basename@" */ + +/*** END file-production ***/ + +/*** BEGIN value-header ***/ +#define GOO_TYPE_@ENUMSHORT@ (@enum_name@_get_type ()) +GOOCANVAS_API +GType @enum_name@_get_type (void) G_GNUC_CONST; + +/*** END value-header ***/ + +/*** BEGIN file-tail ***/ +G_END_DECLS + +/*** END file-tail ***/ diff --git a/src/goocanvasexports.h b/src/goocanvasexports.h new file mode 100644 index 0000000000000000000000000000000000000000..96ecd581ce8e05ea64a09ecc3abc44879e499eea --- /dev/null +++ b/src/goocanvasexports.h @@ -0,0 +1,25 @@ +/* + * GooCanvas. Copyright (C) 2005-6 Damon Chaplin. + * Released under the GNU LGPL license. See COPYING for details. + * + * goocanvasexports.h - API export/import macros + */ +#ifndef __GOO_CANVAS_EXPORTS_H__ +#define __GOO_CANVAS_EXPORTS_H__ + +#include + +#if defined (G_OS_WIN32) && defined (_MSC_VER) && !defined (GOOCANVAS_BUILD_STATIC) +# ifdef BUILDING_GOOCANVAS +# define GOOCANVAS_EXTERNAL_V __declspec(dllexport) extern +# define GOOCANVAS_API __declspec(dllexport) +# else +# define GOOCANVAS_EXTERNAL_V __declspec(dllimport) extern +# define GOOCANVAS_API __declspec(dllimport) +# endif +#else +# define GOOCANVAS_EXTERNAL_V extern +# define GOOCANVAS_API +#endif + +#endif /* __GOO_CANVAS_EXPORTS_H__ */ diff --git a/src/goocanvasgrid.h b/src/goocanvasgrid.h index 7d233bc08bf04c4e1dc00cd7f7f9d5167a2bc3e1..9fcfdebdb3aa4bd55f888c8b8cec89eeb4b5454e 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 9c5b50c3af893f298f959a50bb4d858e24b66c1b..7d38415d45a4e19a1b395cc0ab969328674adcbb 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 aa588c5ed669ee830929c7d51a855334a23c0f01..3f4f3a540e1d67b653fb0496ea7e2697aaabbbf7 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 bf8b336e22370193998022fd7796807b7b1159aa..638c0bdd0615496c2d43c1f8692026eb08f77609 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 42d90e39e86cad892710d1ea493e1081fea7c8ff..525f2028c5511e0007b927bd16327a0d4ae0dea2 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 15f7eea79288b5209cd364caba9412c20e89cbb4..b6d146babca85a58d4c925d3f708967048107d60 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 3ccd8d4375ada6056d37c48834e2b9105dceff42..6bbde2b27523ce9d7aee4b0bf4c3495ac0f66a87 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 ea689033c58de9f38c882bd8641cf9613763e186..bdbfc4ab0a8a8102a10a0fd1b1df3719852043bc 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 ed102cfa7459441f937bc0637987b276c0a19972..f4d150457438bdb48716e78ea3db6c5736b1b5b1 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 697f2798c5df2c4a3f402345b05c8739f1bc856b..280dd944182fa44e6351f7b6c925a93b6108da62 100644 --- a/src/goocanvasstyle.h +++ b/src/goocanvasstyle.h @@ -8,23 +8,24 @@ #define __GOO_CANVAS_STYLE_H__ #include +#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 b5848556f5e406708ef7b2be0b0eeea487834e41..5291d6a2a06db57f4bd2a9cafd949beeb2361231 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 183120bc0194ff0b1223a7b5ad2c7bdb5ec51cba..c6965eed79d0f3232a1da047e796a47f97779791 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 331e60b9e2a6f8b4021e72ae2b8c3cffee10b311..ead0892bd28670e05e6182fd9682d8e5c707f8fb 100644 --- a/src/goocanvasutils.h +++ b/src/goocanvasutils.h @@ -8,6 +8,7 @@ #define __GOO_CANVAS_UTILS_H__ #include +#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 9ef48bb1258b4e76077a896a9ddd561a20a0a600..019f22647db8466c3e76ead10b7887c59a3d5882 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, diff --git a/src/meson.build b/src/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..72fe0b6ae89685b605f2e7f6f2972aed549cb366 --- /dev/null +++ b/src/meson.build @@ -0,0 +1,122 @@ +src_inc = include_directories('.') + +libname = '@0@-@1@'.format(goocanvas_name, goocanvas_api_version) + +headers = files( + 'goocanvasellipse.h', + 'goocanvasexports.h', + 'goocanvasgrid.h', + 'goocanvasgroup.h', + 'goocanvas.h', + 'goocanvasimage.h', + 'goocanvasitem.h', + 'goocanvasitemmodel.h', + 'goocanvasitemsimple.h', + 'goocanvaspath.h', + 'goocanvaspolyline.h', + 'goocanvasrect.h', + 'goocanvasstyle.h', + 'goocanvastable.h', + 'goocanvastext.h', + 'goocanvasutils.h', + 'goocanvaswidget.h', +) + +install_headers( + headers, + install_dir: goocanvas_includedir / libname, +) + +sources = files( + 'goocanvasatk.c', + 'goocanvas.c', + 'goocanvasellipse.c', + 'goocanvasgrid.c', + 'goocanvasgroup.c', + 'goocanvasimage.c', + 'goocanvasitem.c', + 'goocanvasitemmodel.c', + 'goocanvasitemsimple.c', + 'goocanvaspath.c', + 'goocanvaspolyline.c', + 'goocanvasrect.c', + 'goocanvasstyle.c', + 'goocanvastable.c', + 'goocanvastext.c', + 'goocanvasutils.c', + 'goocanvaswidget.c', +) + + +marshal = 'goocanvasmarshal' + +sources += gnome.genmarshal( + marshal, + sources: marshal + '.list', + prefix: 'goo_canvas_marshal', + install_header: true, + install_dir: goocanvas_includedir / libname, +) + +enum_types = 'goocanvasenumtypes' + +enum_sources = gnome.mkenums( + enum_types, + sources: headers, + h_template: enum_types + '.h.template', + c_template: enum_types + '.c.template', + install_header: true, + install_dir: goocanvas_includedir / libname, +) + +private_deps = [ + glib_dep, + m_dep, +] + +deps = [ + cairo_dep, + gtk_dep, +] + +libgoocanvas = shared_library( + libname, + version: goocanvas_libversion, + sources: sources + enum_sources, + include_directories: top_inc, + dependencies: deps + private_deps, + c_args: [ '-DG_LOG_DOMAIN="GooCanvas"', '-DBUILDING_GOOCANVAS'], + install: true, + install_rpath: goocanvas_libdir, +) + +libgoocanvas_dep = declare_dependency( + sources: enum_sources[1], + include_directories: src_inc, + dependencies: gtk_dep, + link_with: libgoocanvas, +) + +pkg.generate( + libraries: libgoocanvas, + name: goocanvas_api_ns, + description: 'A GTK+ canvas widget using cairo', + filebase: libname, + subdirs: libname, + requires: deps, + variables: 'exec_prefix=${prefix}', +) + +if enable_introspection + libgoocanvas_gir = gnome.generate_gir( + libgoocanvas, + sources: sources + enum_sources + headers, + includes: 'Gtk-3.0', + nsversion: goocanvas_api_version, + namespace: goocanvas_api_ns, + identifier_prefix: goocanvas_api_prefix, + symbol_prefix: goocanvas_api_prefix.to_lower(), + export_packages: '@0@-@1@'.format(goocanvas_api_ns, goocanvas_api_version), + install: true, + ) +endif