From 3753ca583f3ba9661dfe70ea4a4edd0d2098b2ac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?I=C3=B1igo=20Mart=C3=ADnez?= Date: Mon, 18 Jan 2021 11:41:53 +0100 Subject: [PATCH 1/8] build: Port to meson build system meson is a build system focused on speed an ease of use, which helps speeding up the software development. --- bindings/python/meson.build | 4 + demo/meson.build | 67 +++++++++++++++++ docs/meson.build | 38 ++++++++++ docs/xml/gtkdocentities.ent.in | 7 ++ docs/xml/meson.build | 15 ++++ meson.build | 82 ++++++++++++++++++++ meson_options.txt | 4 + po/meson.build | 1 + src/goocanvasenumtypes.c.template | 41 ++++++++++ src/goocanvasenumtypes.h.template | 24 ++++++ src/meson.build | 121 ++++++++++++++++++++++++++++++ 11 files changed, 404 insertions(+) create mode 100644 bindings/python/meson.build create mode 100644 demo/meson.build create mode 100644 docs/meson.build create mode 100644 docs/xml/gtkdocentities.ent.in create mode 100644 docs/xml/meson.build create mode 100644 meson.build create mode 100644 meson_options.txt create mode 100644 po/meson.build create mode 100644 src/goocanvasenumtypes.c.template create mode 100644 src/goocanvasenumtypes.h.template create mode 100644 src/meson.build diff --git a/bindings/python/meson.build b/bindings/python/meson.build new file mode 100644 index 0000000..a1b1c07 --- /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 0000000..d379901 --- /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 0000000..ffbbf80 --- /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 0000000..fd86c16 --- /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 0000000..973e721 --- /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 0000000..83777f2 --- /dev/null +++ b/meson.build @@ -0,0 +1,82 @@ +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') + +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 0000000..d274c64 --- /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 0000000..df18f14 --- /dev/null +++ b/po/meson.build @@ -0,0 +1 @@ +i18n.gettext(goocanvas_api_name, preset: 'glib') diff --git a/src/goocanvasenumtypes.c.template b/src/goocanvasenumtypes.c.template new file mode 100644 index 0000000..e3feb03 --- /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 0000000..13d9bde --- /dev/null +++ b/src/goocanvasenumtypes.h.template @@ -0,0 +1,24 @@ +/*** BEGIN file-header ***/ +#pragma once + +#include + +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 ()) +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/meson.build b/src/meson.build new file mode 100644 index 0000000..061e75b --- /dev/null +++ b/src/meson.build @@ -0,0 +1,121 @@ +src_inc = include_directories('.') + +libname = '@0@-@1@'.format(goocanvas_name, goocanvas_api_version) + +headers = files( + 'goocanvasellipse.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"', + 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 -- GitLab From a20962113d848cdd571cda9fb06afe6de51d121c Mon Sep 17 00:00:00 2001 From: Chun-wei Fan Date: Sat, 12 Jun 2021 12:10:03 +0800 Subject: [PATCH 2/8] src/: Add goocanvasexports.h This adds a public header that can be used to export and import public API and variables so that goocanvas can be buildable and usable on Visual Studio builds as well --- src/Makefile.am | 1 + src/goocanvasexports.h | 25 +++++++++++++++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 src/goocanvasexports.h diff --git a/src/Makefile.am b/src/Makefile.am index 2f7d4f3..e893c24 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 \ diff --git a/src/goocanvasexports.h b/src/goocanvasexports.h new file mode 100644 index 0000000..96ecd58 --- /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__ */ -- GitLab From a91584ca9dc0dcf81bad60644b82b4bbb43897c4 Mon Sep 17 00:00:00 2001 From: Chun-wei Fan Date: Sat, 12 Jun 2021 12:13:42 +0800 Subject: [PATCH 3/8] 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 - +#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 +#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 +#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, -- GitLab From a05eae5eea0b3735f14f5aa1b0a57388abf015ae Mon Sep 17 00:00:00 2001 From: Chun-wei Fan Date: Sat, 12 Jun 2021 12:16:53 +0800 Subject: [PATCH 4/8] src/goocanvasatk.c: Include goocanvasatk.h This way, the compiler can pick up the __declspec(dllexport) directives during the build on Visual Studio. The symbols here are needed for building the introspection files. --- src/goocanvasatk.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/goocanvasatk.c b/src/goocanvasatk.c index 565f1bc..abdbe41 100644 --- a/src/goocanvasatk.c +++ b/src/goocanvasatk.c @@ -11,6 +11,7 @@ #include #include #include "goocanvas.h" +#include "goocanvasatk.h" /* -- GitLab From 6ec49d084fb43f5129f34a535a24737508367e0b Mon Sep 17 00:00:00 2001 From: Chun-wei Fan Date: Sat, 12 Jun 2021 12:19:21 +0800 Subject: [PATCH 5/8] src/Makefile.am: Update generating goocanvasenumtypes.h Make sure that we include goocanvasexports.h in the generated header, and the prototypes are also marked for export --- src/Makefile.am | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Makefile.am b/src/Makefile.am index e893c24..9226e51 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -118,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 ) \ -- GitLab From 4f2bbd2ce727dbc9c865586cb0779a444e24b661 Mon Sep 17 00:00:00 2001 From: Chun-wei Fan Date: Sat, 12 Jun 2021 15:52:26 +0800 Subject: [PATCH 6/8] goocanvasenumtypes.h.template: Mark symbols for export This way, for Visual Studio-style builds, we can export the symbols in the generated enumeration headers --- src/goocanvasenumtypes.h.template | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/goocanvasenumtypes.h.template b/src/goocanvasenumtypes.h.template index 13d9bde..095c880 100644 --- a/src/goocanvasenumtypes.h.template +++ b/src/goocanvasenumtypes.h.template @@ -2,6 +2,7 @@ #pragma once #include +#include "goocanvasexports.h" G_BEGIN_DECLS @@ -14,6 +15,7 @@ G_BEGIN_DECLS /*** 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 ***/ -- GitLab From d76419d1038ff897f19a464cb7b498f7e0f912ec Mon Sep 17 00:00:00 2001 From: Chun-wei Fan Date: Sat, 12 Jun 2021 15:53:54 +0800 Subject: [PATCH 7/8] meson.build: Fix building on Visual Studio The Meson build files are almost ready to support building with Visual Studio, so update them a bit to fix that: * Don't mandate looking for -lm. Windows compilers ship math functions in its CRT import library and/or inline in the CRT headers. * Define some compiler flags that are useful for Visual Studio-style builds * Define BUILDING_GOOCANVAS when building the goocanvas library, so that we can export the symbols there using compiler directives --- meson.build | 10 +++++++++- src/meson.build | 2 +- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/meson.build b/meson.build index 83777f2..a727a16 100644 --- a/meson.build +++ b/meson.build @@ -58,7 +58,15 @@ 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') +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() diff --git a/src/meson.build b/src/meson.build index 061e75b..1c52689 100644 --- a/src/meson.build +++ b/src/meson.build @@ -84,7 +84,7 @@ libgoocanvas = shared_library( sources: sources + enum_sources, include_directories: top_inc, dependencies: deps + private_deps, - c_args: '-DG_LOG_DOMAIN="GooCanvas"', + c_args: [ '-DG_LOG_DOMAIN="GooCanvas"', '-DBUILDING_GOOCANVAS'], install: true, install_rpath: goocanvas_libdir, ) -- GitLab From d78fccd7db61337d0a9c1ab5a43abcbebc5e12fa Mon Sep 17 00:00:00 2001 From: Chun-wei Fan Date: Sat, 12 Jun 2021 16:05:07 +0800 Subject: [PATCH 8/8] src/meson.build: "Install" goocanvasexports.h It is part of the public headers.... --- src/meson.build | 1 + 1 file changed, 1 insertion(+) diff --git a/src/meson.build b/src/meson.build index 1c52689..72fe0b6 100644 --- a/src/meson.build +++ b/src/meson.build @@ -4,6 +4,7 @@ libname = '@0@-@1@'.format(goocanvas_name, goocanvas_api_version) headers = files( 'goocanvasellipse.h', + 'goocanvasexports.h', 'goocanvasgrid.h', 'goocanvasgroup.h', 'goocanvas.h', -- GitLab