diff options
Diffstat (limited to 'app/vectors')
30 files changed, 10421 insertions, 0 deletions
diff --git a/app/vectors/Makefile.am b/app/vectors/Makefile.am new file mode 100644 index 0000000..aa6e10d --- /dev/null +++ b/app/vectors/Makefile.am @@ -0,0 +1,44 @@ +## Process this file with automake to produce Makefile.in + +AM_CPPFLAGS = \ + -DG_LOG_DOMAIN=\"Gimp-Vectors\" \ + -I$(top_builddir) \ + -I$(top_srcdir) \ + -I$(top_builddir)/app \ + -I$(top_srcdir)/app \ + $(CAIRO_CFLAGS) \ + $(GEGL_CFLAGS) \ + $(GDK_PIXBUF_CFLAGS) \ + -I$(includedir) + +noinst_LIBRARIES = libappvectors.a + +libappvectors_a_SOURCES = \ + vectors-enums.h \ + vectors-types.h \ + gimpanchor.c \ + gimpanchor.h \ + gimpbezierstroke.h \ + gimpbezierstroke.c \ + gimpstroke.h \ + gimpstroke.c \ + gimpstroke-new.h \ + gimpstroke-new.c \ + gimpvectors.c \ + gimpvectors.h \ + gimpvectors-compat.c \ + gimpvectors-compat.h \ + gimpvectors-export.c \ + gimpvectors-export.h \ + gimpvectors-import.c \ + gimpvectors-import.h \ + gimpvectors-preview.c \ + gimpvectors-preview.h \ + gimpvectors-warp.c \ + gimpvectors-warp.h \ + gimpvectorsmodundo.c \ + gimpvectorsmodundo.h \ + gimpvectorspropundo.c \ + gimpvectorspropundo.h \ + gimpvectorsundo.c \ + gimpvectorsundo.h diff --git a/app/vectors/Makefile.in b/app/vectors/Makefile.in new file mode 100644 index 0000000..5a08c69 --- /dev/null +++ b/app/vectors/Makefile.in @@ -0,0 +1,992 @@ +# Makefile.in generated by automake 1.16.3 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2020 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = { \ + if test -z '$(MAKELEVEL)'; then \ + false; \ + elif test -n '$(MAKE_HOST)'; then \ + true; \ + elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ + true; \ + else \ + false; \ + fi; \ +} +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = app/vectors +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/acinclude.m4 \ + $(top_srcdir)/m4macros/alsa.m4 \ + $(top_srcdir)/m4macros/ax_compare_version.m4 \ + $(top_srcdir)/m4macros/ax_cxx_compile_stdcxx.m4 \ + $(top_srcdir)/m4macros/ax_gcc_func_attribute.m4 \ + $(top_srcdir)/m4macros/ax_prog_cc_for_build.m4 \ + $(top_srcdir)/m4macros/ax_prog_perl_version.m4 \ + $(top_srcdir)/m4macros/detectcflags.m4 \ + $(top_srcdir)/m4macros/pythondev.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +LIBRARIES = $(noinst_LIBRARIES) +ARFLAGS = cru +AM_V_AR = $(am__v_AR_@AM_V@) +am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@) +am__v_AR_0 = @echo " AR " $@; +am__v_AR_1 = +libappvectors_a_AR = $(AR) $(ARFLAGS) +libappvectors_a_LIBADD = +am_libappvectors_a_OBJECTS = gimpanchor.$(OBJEXT) \ + gimpbezierstroke.$(OBJEXT) gimpstroke.$(OBJEXT) \ + gimpstroke-new.$(OBJEXT) gimpvectors.$(OBJEXT) \ + gimpvectors-compat.$(OBJEXT) gimpvectors-export.$(OBJEXT) \ + gimpvectors-import.$(OBJEXT) gimpvectors-preview.$(OBJEXT) \ + gimpvectors-warp.$(OBJEXT) gimpvectorsmodundo.$(OBJEXT) \ + gimpvectorspropundo.$(OBJEXT) gimpvectorsundo.$(OBJEXT) +libappvectors_a_OBJECTS = $(am_libappvectors_a_OBJECTS) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__maybe_remake_depfiles = depfiles +am__depfiles_remade = ./$(DEPDIR)/gimpanchor.Po \ + ./$(DEPDIR)/gimpbezierstroke.Po ./$(DEPDIR)/gimpstroke-new.Po \ + ./$(DEPDIR)/gimpstroke.Po ./$(DEPDIR)/gimpvectors-compat.Po \ + ./$(DEPDIR)/gimpvectors-export.Po \ + ./$(DEPDIR)/gimpvectors-import.Po \ + ./$(DEPDIR)/gimpvectors-preview.Po \ + ./$(DEPDIR)/gimpvectors-warp.Po ./$(DEPDIR)/gimpvectors.Po \ + ./$(DEPDIR)/gimpvectorsmodundo.Po \ + ./$(DEPDIR)/gimpvectorspropundo.Po \ + ./$(DEPDIR)/gimpvectorsundo.Po +am__mv = mv -f +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) +AM_V_CC = $(am__v_CC_@AM_V@) +am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) +am__v_CC_0 = @echo " CC " $@; +am__v_CC_1 = +CCLD = $(CC) +LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CCLD = $(am__v_CCLD_@AM_V@) +am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) +am__v_CCLD_0 = @echo " CCLD " $@; +am__v_CCLD_1 = +SOURCES = $(libappvectors_a_SOURCES) +DIST_SOURCES = $(libappvectors_a_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +AA_LIBS = @AA_LIBS@ +ACLOCAL = @ACLOCAL@ +ALLOCA = @ALLOCA@ +ALL_LINGUAS = @ALL_LINGUAS@ +ALSA_CFLAGS = @ALSA_CFLAGS@ +ALSA_LIBS = @ALSA_LIBS@ +ALTIVEC_EXTRA_CFLAGS = @ALTIVEC_EXTRA_CFLAGS@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +APPSTREAM_UTIL = @APPSTREAM_UTIL@ +AR = @AR@ +AS = @AS@ +ATK_CFLAGS = @ATK_CFLAGS@ +ATK_LIBS = @ATK_LIBS@ +ATK_REQUIRED_VERSION = @ATK_REQUIRED_VERSION@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +BABL_CFLAGS = @BABL_CFLAGS@ +BABL_LIBS = @BABL_LIBS@ +BABL_REQUIRED_VERSION = @BABL_REQUIRED_VERSION@ +BUG_REPORT_URL = @BUG_REPORT_URL@ +BUILD_EXEEXT = @BUILD_EXEEXT@ +BUILD_OBJEXT = @BUILD_OBJEXT@ +BZIP2_LIBS = @BZIP2_LIBS@ +CAIRO_CFLAGS = @CAIRO_CFLAGS@ +CAIRO_LIBS = @CAIRO_LIBS@ +CAIRO_PDF_CFLAGS = @CAIRO_PDF_CFLAGS@ +CAIRO_PDF_LIBS = @CAIRO_PDF_LIBS@ +CAIRO_PDF_REQUIRED_VERSION = @CAIRO_PDF_REQUIRED_VERSION@ +CAIRO_REQUIRED_VERSION = @CAIRO_REQUIRED_VERSION@ +CATALOGS = @CATALOGS@ +CATOBJEXT = @CATOBJEXT@ +CC = @CC@ +CCAS = @CCAS@ +CCASDEPMODE = @CCASDEPMODE@ +CCASFLAGS = @CCASFLAGS@ +CCDEPMODE = @CCDEPMODE@ +CC_FOR_BUILD = @CC_FOR_BUILD@ +CC_VERSION = @CC_VERSION@ +CFLAGS = @CFLAGS@ +CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CPPFLAGS_FOR_BUILD = @CPPFLAGS_FOR_BUILD@ +CPP_FOR_BUILD = @CPP_FOR_BUILD@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DATADIRNAME = @DATADIRNAME@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DESKTOP_DATADIR = @DESKTOP_DATADIR@ +DESKTOP_FILE_VALIDATE = @DESKTOP_FILE_VALIDATE@ +DLLTOOL = @DLLTOOL@ +DOC_SHOOTER = @DOC_SHOOTER@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +FILE_AA = @FILE_AA@ +FILE_EXR = @FILE_EXR@ +FILE_HEIF = @FILE_HEIF@ +FILE_JP2_LOAD = @FILE_JP2_LOAD@ +FILE_JPEGXL = @FILE_JPEGXL@ +FILE_MNG = @FILE_MNG@ +FILE_PDF_SAVE = @FILE_PDF_SAVE@ +FILE_PS = @FILE_PS@ +FILE_WMF = @FILE_WMF@ +FILE_XMC = @FILE_XMC@ +FILE_XPM = @FILE_XPM@ +FONTCONFIG_CFLAGS = @FONTCONFIG_CFLAGS@ +FONTCONFIG_LIBS = @FONTCONFIG_LIBS@ +FONTCONFIG_REQUIRED_VERSION = @FONTCONFIG_REQUIRED_VERSION@ +FREETYPE2_REQUIRED_VERSION = @FREETYPE2_REQUIRED_VERSION@ +FREETYPE_CFLAGS = @FREETYPE_CFLAGS@ +FREETYPE_LIBS = @FREETYPE_LIBS@ +GDBUS_CODEGEN = @GDBUS_CODEGEN@ +GDK_PIXBUF_CFLAGS = @GDK_PIXBUF_CFLAGS@ +GDK_PIXBUF_CSOURCE = @GDK_PIXBUF_CSOURCE@ +GDK_PIXBUF_LIBS = @GDK_PIXBUF_LIBS@ +GDK_PIXBUF_REQUIRED_VERSION = @GDK_PIXBUF_REQUIRED_VERSION@ +GEGL = @GEGL@ +GEGL_CFLAGS = @GEGL_CFLAGS@ +GEGL_LIBS = @GEGL_LIBS@ +GEGL_MAJOR_MINOR_VERSION = @GEGL_MAJOR_MINOR_VERSION@ +GEGL_REQUIRED_VERSION = @GEGL_REQUIRED_VERSION@ +GETTEXT_PACKAGE = @GETTEXT_PACKAGE@ +GEXIV2_CFLAGS = @GEXIV2_CFLAGS@ +GEXIV2_LIBS = @GEXIV2_LIBS@ +GEXIV2_REQUIRED_VERSION = @GEXIV2_REQUIRED_VERSION@ +GIMP_API_VERSION = @GIMP_API_VERSION@ +GIMP_APP_VERSION = @GIMP_APP_VERSION@ +GIMP_BINARY_AGE = @GIMP_BINARY_AGE@ +GIMP_COMMAND = @GIMP_COMMAND@ +GIMP_DATA_VERSION = @GIMP_DATA_VERSION@ +GIMP_FULL_NAME = @GIMP_FULL_NAME@ +GIMP_INTERFACE_AGE = @GIMP_INTERFACE_AGE@ +GIMP_MAJOR_VERSION = @GIMP_MAJOR_VERSION@ +GIMP_MICRO_VERSION = @GIMP_MICRO_VERSION@ +GIMP_MINOR_VERSION = @GIMP_MINOR_VERSION@ +GIMP_MKENUMS = @GIMP_MKENUMS@ +GIMP_MODULES = @GIMP_MODULES@ +GIMP_PACKAGE_REVISION = @GIMP_PACKAGE_REVISION@ +GIMP_PKGCONFIG_VERSION = @GIMP_PKGCONFIG_VERSION@ +GIMP_PLUGINS = @GIMP_PLUGINS@ +GIMP_PLUGIN_VERSION = @GIMP_PLUGIN_VERSION@ +GIMP_REAL_VERSION = @GIMP_REAL_VERSION@ +GIMP_RELEASE = @GIMP_RELEASE@ +GIMP_SYSCONF_VERSION = @GIMP_SYSCONF_VERSION@ +GIMP_TOOL_VERSION = @GIMP_TOOL_VERSION@ +GIMP_UNSTABLE = @GIMP_UNSTABLE@ +GIMP_USER_VERSION = @GIMP_USER_VERSION@ +GIMP_VERSION = @GIMP_VERSION@ +GIO_CFLAGS = @GIO_CFLAGS@ +GIO_LIBS = @GIO_LIBS@ +GIO_UNIX_CFLAGS = @GIO_UNIX_CFLAGS@ +GIO_UNIX_LIBS = @GIO_UNIX_LIBS@ +GIO_WINDOWS_CFLAGS = @GIO_WINDOWS_CFLAGS@ +GIO_WINDOWS_LIBS = @GIO_WINDOWS_LIBS@ +GLIB_CFLAGS = @GLIB_CFLAGS@ +GLIB_COMPILE_RESOURCES = @GLIB_COMPILE_RESOURCES@ +GLIB_GENMARSHAL = @GLIB_GENMARSHAL@ +GLIB_LIBS = @GLIB_LIBS@ +GLIB_MKENUMS = @GLIB_MKENUMS@ +GLIB_REQUIRED_VERSION = @GLIB_REQUIRED_VERSION@ +GMODULE_NO_EXPORT_CFLAGS = @GMODULE_NO_EXPORT_CFLAGS@ +GMODULE_NO_EXPORT_LIBS = @GMODULE_NO_EXPORT_LIBS@ +GMOFILES = @GMOFILES@ +GMSGFMT = @GMSGFMT@ +GOBJECT_QUERY = @GOBJECT_QUERY@ +GREP = @GREP@ +GS_LIBS = @GS_LIBS@ +GTKDOC_CHECK = @GTKDOC_CHECK@ +GTKDOC_CHECK_PATH = @GTKDOC_CHECK_PATH@ +GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@ +GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@ +GTKDOC_MKPDF = @GTKDOC_MKPDF@ +GTKDOC_REBASE = @GTKDOC_REBASE@ +GTK_CFLAGS = @GTK_CFLAGS@ +GTK_LIBS = @GTK_LIBS@ +GTK_MAC_INTEGRATION_CFLAGS = @GTK_MAC_INTEGRATION_CFLAGS@ +GTK_MAC_INTEGRATION_LIBS = @GTK_MAC_INTEGRATION_LIBS@ +GTK_REQUIRED_VERSION = @GTK_REQUIRED_VERSION@ +GTK_UPDATE_ICON_CACHE = @GTK_UPDATE_ICON_CACHE@ +GUDEV_CFLAGS = @GUDEV_CFLAGS@ +GUDEV_LIBS = @GUDEV_LIBS@ +HARFBUZZ_CFLAGS = @HARFBUZZ_CFLAGS@ +HARFBUZZ_LIBS = @HARFBUZZ_LIBS@ +HARFBUZZ_REQUIRED_VERSION = @HARFBUZZ_REQUIRED_VERSION@ +HAVE_CXX14 = @HAVE_CXX14@ +HAVE_FINITE = @HAVE_FINITE@ +HAVE_ISFINITE = @HAVE_ISFINITE@ +HAVE_VFORK = @HAVE_VFORK@ +HOST_GLIB_COMPILE_RESOURCES = @HOST_GLIB_COMPILE_RESOURCES@ +HTML_DIR = @HTML_DIR@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +INSTOBJEXT = @INSTOBJEXT@ +INTLLIBS = @INTLLIBS@ +INTLTOOL_EXTRACT = @INTLTOOL_EXTRACT@ +INTLTOOL_MERGE = @INTLTOOL_MERGE@ +INTLTOOL_PERL = @INTLTOOL_PERL@ +INTLTOOL_REQUIRED_VERSION = @INTLTOOL_REQUIRED_VERSION@ +INTLTOOL_UPDATE = @INTLTOOL_UPDATE@ +INTLTOOL_V_MERGE = @INTLTOOL_V_MERGE@ +INTLTOOL_V_MERGE_OPTIONS = @INTLTOOL_V_MERGE_OPTIONS@ +INTLTOOL__v_MERGE_ = @INTLTOOL__v_MERGE_@ +INTLTOOL__v_MERGE_0 = @INTLTOOL__v_MERGE_0@ +INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@ +ISO_CODES_LOCALEDIR = @ISO_CODES_LOCALEDIR@ +ISO_CODES_LOCATION = @ISO_CODES_LOCATION@ +JPEG_LIBS = @JPEG_LIBS@ +JSON_GLIB_CFLAGS = @JSON_GLIB_CFLAGS@ +JSON_GLIB_LIBS = @JSON_GLIB_LIBS@ +JXL_CFLAGS = @JXL_CFLAGS@ +JXL_LIBS = @JXL_LIBS@ +JXL_THREADS_CFLAGS = @JXL_THREADS_CFLAGS@ +JXL_THREADS_LIBS = @JXL_THREADS_LIBS@ +LCMS_CFLAGS = @LCMS_CFLAGS@ +LCMS_LIBS = @LCMS_LIBS@ +LCMS_REQUIRED_VERSION = @LCMS_REQUIRED_VERSION@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@ +LIBBACKTRACE_LIBS = @LIBBACKTRACE_LIBS@ +LIBHEIF_CFLAGS = @LIBHEIF_CFLAGS@ +LIBHEIF_LIBS = @LIBHEIF_LIBS@ +LIBHEIF_REQUIRED_VERSION = @LIBHEIF_REQUIRED_VERSION@ +LIBJXL_REQUIRED_VERSION = @LIBJXL_REQUIRED_VERSION@ +LIBLZMA_REQUIRED_VERSION = @LIBLZMA_REQUIRED_VERSION@ +LIBMYPAINT_CFLAGS = @LIBMYPAINT_CFLAGS@ +LIBMYPAINT_LIBS = @LIBMYPAINT_LIBS@ +LIBMYPAINT_REQUIRED_VERSION = @LIBMYPAINT_REQUIRED_VERSION@ +LIBOBJS = @LIBOBJS@ +LIBPNG_REQUIRED_VERSION = @LIBPNG_REQUIRED_VERSION@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIBUNWIND_CFLAGS = @LIBUNWIND_CFLAGS@ +LIBUNWIND_LIBS = @LIBUNWIND_LIBS@ +LIBUNWIND_REQUIRED_VERSION = @LIBUNWIND_REQUIRED_VERSION@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +LT_CURRENT_MINUS_AGE = @LT_CURRENT_MINUS_AGE@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ +LT_VERSION_INFO = @LT_VERSION_INFO@ +LZMA_CFLAGS = @LZMA_CFLAGS@ +LZMA_LIBS = @LZMA_LIBS@ +MAIL = @MAIL@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MIME_INFO_CFLAGS = @MIME_INFO_CFLAGS@ +MIME_INFO_LIBS = @MIME_INFO_LIBS@ +MIME_TYPES = @MIME_TYPES@ +MKDIR_P = @MKDIR_P@ +MKINSTALLDIRS = @MKINSTALLDIRS@ +MMX_EXTRA_CFLAGS = @MMX_EXTRA_CFLAGS@ +MNG_CFLAGS = @MNG_CFLAGS@ +MNG_LIBS = @MNG_LIBS@ +MSGFMT = @MSGFMT@ +MSGFMT_OPTS = @MSGFMT_OPTS@ +MSGMERGE = @MSGMERGE@ +MYPAINT_BRUSHES_CFLAGS = @MYPAINT_BRUSHES_CFLAGS@ +MYPAINT_BRUSHES_LIBS = @MYPAINT_BRUSHES_LIBS@ +NATIVE_GLIB_CFLAGS = @NATIVE_GLIB_CFLAGS@ +NATIVE_GLIB_LIBS = @NATIVE_GLIB_LIBS@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OPENEXR_CFLAGS = @OPENEXR_CFLAGS@ +OPENEXR_LIBS = @OPENEXR_LIBS@ +OPENEXR_REQUIRED_VERSION = @OPENEXR_REQUIRED_VERSION@ +OPENJPEG_CFLAGS = @OPENJPEG_CFLAGS@ +OPENJPEG_LIBS = @OPENJPEG_LIBS@ +OPENJPEG_REQUIRED_VERSION = @OPENJPEG_REQUIRED_VERSION@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PANGOCAIRO_CFLAGS = @PANGOCAIRO_CFLAGS@ +PANGOCAIRO_LIBS = @PANGOCAIRO_LIBS@ +PANGOCAIRO_REQUIRED_VERSION = @PANGOCAIRO_REQUIRED_VERSION@ +PATHSEP = @PATHSEP@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PERL = @PERL@ +PERL_REQUIRED_VERSION = @PERL_REQUIRED_VERSION@ +PERL_VERSION = @PERL_VERSION@ +PKG_CONFIG = @PKG_CONFIG@ +PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ +PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ +PNG_CFLAGS = @PNG_CFLAGS@ +PNG_LIBS = @PNG_LIBS@ +POFILES = @POFILES@ +POPPLER_CFLAGS = @POPPLER_CFLAGS@ +POPPLER_DATA_CFLAGS = @POPPLER_DATA_CFLAGS@ +POPPLER_DATA_LIBS = @POPPLER_DATA_LIBS@ +POPPLER_DATA_REQUIRED_VERSION = @POPPLER_DATA_REQUIRED_VERSION@ +POPPLER_LIBS = @POPPLER_LIBS@ +POPPLER_REQUIRED_VERSION = @POPPLER_REQUIRED_VERSION@ +POSUB = @POSUB@ +PO_IN_DATADIR_FALSE = @PO_IN_DATADIR_FALSE@ +PO_IN_DATADIR_TRUE = @PO_IN_DATADIR_TRUE@ +PYBIN_PATH = @PYBIN_PATH@ +PYCAIRO_CFLAGS = @PYCAIRO_CFLAGS@ +PYCAIRO_LIBS = @PYCAIRO_LIBS@ +PYGIMP_EXTRA_CFLAGS = @PYGIMP_EXTRA_CFLAGS@ +PYGTK_CFLAGS = @PYGTK_CFLAGS@ +PYGTK_CODEGEN = @PYGTK_CODEGEN@ +PYGTK_DEFSDIR = @PYGTK_DEFSDIR@ +PYGTK_LIBS = @PYGTK_LIBS@ +PYLINK_LIBS = @PYLINK_LIBS@ +PYTHON = @PYTHON@ +PYTHON2_REQUIRED_VERSION = @PYTHON2_REQUIRED_VERSION@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_INCLUDES = @PYTHON_INCLUDES@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +RSVG_REQUIRED_VERSION = @RSVG_REQUIRED_VERSION@ +RT_LIBS = @RT_LIBS@ +SCREENSHOT_LIBS = @SCREENSHOT_LIBS@ +SED = @SED@ +SENDMAIL = @SENDMAIL@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +SOCKET_LIBS = @SOCKET_LIBS@ +SSE2_EXTRA_CFLAGS = @SSE2_EXTRA_CFLAGS@ +SSE4_1_EXTRA_CFLAGS = @SSE4_1_EXTRA_CFLAGS@ +SSE_EXTRA_CFLAGS = @SSE_EXTRA_CFLAGS@ +STRIP = @STRIP@ +SVG_CFLAGS = @SVG_CFLAGS@ +SVG_LIBS = @SVG_LIBS@ +SYMPREFIX = @SYMPREFIX@ +TIFF_LIBS = @TIFF_LIBS@ +USE_NLS = @USE_NLS@ +VERSION = @VERSION@ +WEBKIT_CFLAGS = @WEBKIT_CFLAGS@ +WEBKIT_LIBS = @WEBKIT_LIBS@ +WEBKIT_REQUIRED_VERSION = @WEBKIT_REQUIRED_VERSION@ +WEBPDEMUX_CFLAGS = @WEBPDEMUX_CFLAGS@ +WEBPDEMUX_LIBS = @WEBPDEMUX_LIBS@ +WEBPMUX_CFLAGS = @WEBPMUX_CFLAGS@ +WEBPMUX_LIBS = @WEBPMUX_LIBS@ +WEBP_CFLAGS = @WEBP_CFLAGS@ +WEBP_LIBS = @WEBP_LIBS@ +WEBP_REQUIRED_VERSION = @WEBP_REQUIRED_VERSION@ +WEB_PAGE = @WEB_PAGE@ +WIN32_LARGE_ADDRESS_AWARE = @WIN32_LARGE_ADDRESS_AWARE@ +WINDRES = @WINDRES@ +WMF_CFLAGS = @WMF_CFLAGS@ +WMF_CONFIG = @WMF_CONFIG@ +WMF_LIBS = @WMF_LIBS@ +WMF_REQUIRED_VERSION = @WMF_REQUIRED_VERSION@ +XDG_EMAIL = @XDG_EMAIL@ +XFIXES_CFLAGS = @XFIXES_CFLAGS@ +XFIXES_LIBS = @XFIXES_LIBS@ +XGETTEXT = @XGETTEXT@ +XGETTEXT_REQUIRED_VERSION = @XGETTEXT_REQUIRED_VERSION@ +XMC_CFLAGS = @XMC_CFLAGS@ +XMC_LIBS = @XMC_LIBS@ +XMKMF = @XMKMF@ +XMLLINT = @XMLLINT@ +XMU_LIBS = @XMU_LIBS@ +XPM_LIBS = @XPM_LIBS@ +XSLTPROC = @XSLTPROC@ +XVFB_RUN = @XVFB_RUN@ +X_CFLAGS = @X_CFLAGS@ +X_EXTRA_LIBS = @X_EXTRA_LIBS@ +X_LIBS = @X_LIBS@ +X_PRE_LIBS = @X_PRE_LIBS@ +Z_LIBS = @Z_LIBS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CC_FOR_BUILD = @ac_ct_CC_FOR_BUILD@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +gimpdatadir = @gimpdatadir@ +gimpdir = @gimpdir@ +gimplocaledir = @gimplocaledir@ +gimpplugindir = @gimpplugindir@ +gimpsysconfdir = @gimpsysconfdir@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +intltool__v_merge_options_ = @intltool__v_merge_options_@ +intltool__v_merge_options_0 = @intltool__v_merge_options_0@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +manpage_gimpdir = @manpage_gimpdir@ +mkdir_p = @mkdir_p@ +ms_librarian = @ms_librarian@ +mypaint_brushes_dir = @mypaint_brushes_dir@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +runstatedir = @runstatedir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +AM_CPPFLAGS = \ + -DG_LOG_DOMAIN=\"Gimp-Vectors\" \ + -I$(top_builddir) \ + -I$(top_srcdir) \ + -I$(top_builddir)/app \ + -I$(top_srcdir)/app \ + $(CAIRO_CFLAGS) \ + $(GEGL_CFLAGS) \ + $(GDK_PIXBUF_CFLAGS) \ + -I$(includedir) + +noinst_LIBRARIES = libappvectors.a +libappvectors_a_SOURCES = \ + vectors-enums.h \ + vectors-types.h \ + gimpanchor.c \ + gimpanchor.h \ + gimpbezierstroke.h \ + gimpbezierstroke.c \ + gimpstroke.h \ + gimpstroke.c \ + gimpstroke-new.h \ + gimpstroke-new.c \ + gimpvectors.c \ + gimpvectors.h \ + gimpvectors-compat.c \ + gimpvectors-compat.h \ + gimpvectors-export.c \ + gimpvectors-export.h \ + gimpvectors-import.c \ + gimpvectors-import.h \ + gimpvectors-preview.c \ + gimpvectors-preview.h \ + gimpvectors-warp.c \ + gimpvectors-warp.h \ + gimpvectorsmodundo.c \ + gimpvectorsmodundo.h \ + gimpvectorspropundo.c \ + gimpvectorspropundo.h \ + gimpvectorsundo.c \ + gimpvectorsundo.h + +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .lo .o .obj +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu app/vectors/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu app/vectors/Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +clean-noinstLIBRARIES: + -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES) + +libappvectors.a: $(libappvectors_a_OBJECTS) $(libappvectors_a_DEPENDENCIES) $(EXTRA_libappvectors_a_DEPENDENCIES) + $(AM_V_at)-rm -f libappvectors.a + $(AM_V_AR)$(libappvectors_a_AR) libappvectors.a $(libappvectors_a_OBJECTS) $(libappvectors_a_LIBADD) + $(AM_V_at)$(RANLIB) libappvectors.a + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpanchor.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpbezierstroke.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpstroke-new.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpstroke.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectors-compat.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectors-export.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectors-import.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectors-preview.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectors-warp.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectors.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectorsmodundo.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectorspropundo.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gimpvectorsundo.Po@am__quote@ # am--include-marker + +$(am__depfiles_remade): + @$(MKDIR_P) $(@D) + @echo '# dummy' >$@-t && $(am__mv) $@-t $@ + +am--depfiles: $(am__depfiles_remade) + +.c.o: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< + +.c.obj: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.c.lo: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) distdir-am + +distdir-am: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LIBRARIES) +installdirs: +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool clean-noinstLIBRARIES \ + mostlyclean-am + +distclean: distclean-am + -rm -f ./$(DEPDIR)/gimpanchor.Po + -rm -f ./$(DEPDIR)/gimpbezierstroke.Po + -rm -f ./$(DEPDIR)/gimpstroke-new.Po + -rm -f ./$(DEPDIR)/gimpstroke.Po + -rm -f ./$(DEPDIR)/gimpvectors-compat.Po + -rm -f ./$(DEPDIR)/gimpvectors-export.Po + -rm -f ./$(DEPDIR)/gimpvectors-import.Po + -rm -f ./$(DEPDIR)/gimpvectors-preview.Po + -rm -f ./$(DEPDIR)/gimpvectors-warp.Po + -rm -f ./$(DEPDIR)/gimpvectors.Po + -rm -f ./$(DEPDIR)/gimpvectorsmodundo.Po + -rm -f ./$(DEPDIR)/gimpvectorspropundo.Po + -rm -f ./$(DEPDIR)/gimpvectorsundo.Po + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f ./$(DEPDIR)/gimpanchor.Po + -rm -f ./$(DEPDIR)/gimpbezierstroke.Po + -rm -f ./$(DEPDIR)/gimpstroke-new.Po + -rm -f ./$(DEPDIR)/gimpstroke.Po + -rm -f ./$(DEPDIR)/gimpvectors-compat.Po + -rm -f ./$(DEPDIR)/gimpvectors-export.Po + -rm -f ./$(DEPDIR)/gimpvectors-import.Po + -rm -f ./$(DEPDIR)/gimpvectors-preview.Po + -rm -f ./$(DEPDIR)/gimpvectors-warp.Po + -rm -f ./$(DEPDIR)/gimpvectors.Po + -rm -f ./$(DEPDIR)/gimpvectorsmodundo.Po + -rm -f ./$(DEPDIR)/gimpvectorspropundo.Po + -rm -f ./$(DEPDIR)/gimpvectorsundo.Po + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \ + clean-generic clean-libtool clean-noinstLIBRARIES \ + cscopelist-am ctags ctags-am distclean distclean-compile \ + distclean-generic distclean-libtool distclean-tags distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-am uninstall uninstall-am + +.PRECIOUS: Makefile + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/app/vectors/gimpanchor.c b/app/vectors/gimpanchor.c new file mode 100644 index 0000000..f5085cd --- /dev/null +++ b/app/vectors/gimpanchor.c @@ -0,0 +1,71 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpanchor.c + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <glib-object.h> + +#include "vectors-types.h" + +#include "gimpanchor.h" + + +GType +gimp_anchor_get_type (void) +{ + static GType anchor_type = 0; + + if (!anchor_type) + anchor_type = g_boxed_type_register_static ("GimpAnchor", + (GBoxedCopyFunc) gimp_anchor_copy, + (GBoxedFreeFunc) gimp_anchor_free); + + return anchor_type; +} + +GimpAnchor * +gimp_anchor_new (GimpAnchorType type, + const GimpCoords *position) +{ + GimpAnchor *anchor = g_slice_new0 (GimpAnchor); + + anchor->type = type; + + if (position) + anchor->position = *position; + + return anchor; +} + +GimpAnchor * +gimp_anchor_copy (const GimpAnchor *anchor) +{ + g_return_val_if_fail (anchor != NULL, NULL); + + return g_slice_dup (GimpAnchor, anchor); +} + +void +gimp_anchor_free (GimpAnchor *anchor) +{ + g_return_if_fail (anchor != NULL); + + g_slice_free (GimpAnchor, anchor); +} diff --git a/app/vectors/gimpanchor.h b/app/vectors/gimpanchor.h new file mode 100644 index 0000000..75203a4 --- /dev/null +++ b/app/vectors/gimpanchor.h @@ -0,0 +1,48 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpanchor.h + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_ANCHOR_H__ +#define __GIMP_ANCHOR_H__ + +#define GIMP_ANCHOR(anchor) ((GimpAnchor *) (anchor)) + +#define GIMP_TYPE_ANCHOR (gimp_anchor_get_type ()) +#define GIMP_VALUE_HOLDS_ANCHOR(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_ANCHOR)) + +GType gimp_anchor_get_type (void) G_GNUC_CONST; + + +struct _GimpAnchor +{ + GimpCoords position; + + GimpAnchorType type; /* Interpretation dependent on GimpStroke type */ + gboolean selected; +}; + + +GimpAnchor * gimp_anchor_new (GimpAnchorType type, + const GimpCoords *position); + +GimpAnchor * gimp_anchor_copy (const GimpAnchor *anchor); +void gimp_anchor_free (GimpAnchor *anchor); + + +#endif /* __GIMP_ANCHOR_H__ */ diff --git a/app/vectors/gimpbezierstroke.c b/app/vectors/gimpbezierstroke.c new file mode 100644 index 0000000..3cfe735 --- /dev/null +++ b/app/vectors/gimpbezierstroke.c @@ -0,0 +1,2309 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpbezierstroke.c + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <glib-object.h> +#include <cairo.h> + +#include "libgimpmath/gimpmath.h" + +#include "vectors-types.h" + +#include "core/gimp-transform-utils.h" +#include "core/gimpbezierdesc.h" +#include "core/gimpcoords.h" +#include "core/gimpcoords-interpolate.h" + +#include "gimpanchor.h" +#include "gimpbezierstroke.h" + + +/* local prototypes */ + +static gdouble + gimp_bezier_stroke_nearest_point_get (GimpStroke *stroke, + const GimpCoords *coord, + gdouble precision, + GimpCoords *ret_point, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); +static gdouble + gimp_bezier_stroke_segment_nearest_point_get + (const GimpCoords *beziercoords, + const GimpCoords *coord, + gdouble precision, + GimpCoords *ret_point, + gdouble *ret_pos, + gint depth); +static gdouble + gimp_bezier_stroke_nearest_tangent_get (GimpStroke *stroke, + const GimpCoords *coord1, + const GimpCoords *coord2, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); +static gdouble + gimp_bezier_stroke_segment_nearest_tangent_get + (const GimpCoords *beziercoords, + const GimpCoords *coord1, + const GimpCoords *coord2, + gdouble precision, + GimpCoords *ret_point, + gdouble *ret_pos); +static void + gimp_bezier_stroke_anchor_move_relative + (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature); +static void + gimp_bezier_stroke_anchor_move_absolute + (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *coord, + GimpAnchorFeatureType feature); +static void + gimp_bezier_stroke_anchor_convert (GimpStroke *stroke, + GimpAnchor *anchor, + GimpAnchorFeatureType feature); +static void + gimp_bezier_stroke_anchor_delete (GimpStroke *stroke, + GimpAnchor *anchor); +static gboolean + gimp_bezier_stroke_point_is_movable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); +static void + gimp_bezier_stroke_point_move_relative (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature); +static void + gimp_bezier_stroke_point_move_absolute (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *coord, + GimpAnchorFeatureType feature); + +static void gimp_bezier_stroke_close (GimpStroke *stroke); + +static GimpStroke * + gimp_bezier_stroke_open (GimpStroke *stroke, + GimpAnchor *end_anchor); +static gboolean + gimp_bezier_stroke_anchor_is_insertable + (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); +static GimpAnchor * + gimp_bezier_stroke_anchor_insert (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); +static gboolean + gimp_bezier_stroke_is_extendable (GimpStroke *stroke, + GimpAnchor *neighbor); +static gboolean + gimp_bezier_stroke_connect_stroke (GimpStroke *stroke, + GimpAnchor *anchor, + GimpStroke *extension, + GimpAnchor *neighbor); +static GArray * + gimp_bezier_stroke_interpolate (GimpStroke *stroke, + gdouble precision, + gboolean *closed); +static GimpBezierDesc * + gimp_bezier_stroke_make_bezier (GimpStroke *stroke); +static void gimp_bezier_stroke_transform (GimpStroke *stroke, + const GimpMatrix3 *matrix, + GQueue *ret_strokes); + +static void gimp_bezier_stroke_finalize (GObject *object); + + +static GList * gimp_bezier_stroke_get_anchor_listitem + (GList *list); + + +G_DEFINE_TYPE (GimpBezierStroke, gimp_bezier_stroke, GIMP_TYPE_STROKE) + +#define parent_class gimp_bezier_stroke_parent_class + + +static void +gimp_bezier_stroke_class_init (GimpBezierStrokeClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpStrokeClass *stroke_class = GIMP_STROKE_CLASS (klass); + + object_class->finalize = gimp_bezier_stroke_finalize; + + stroke_class->nearest_point_get = gimp_bezier_stroke_nearest_point_get; + stroke_class->nearest_tangent_get = gimp_bezier_stroke_nearest_tangent_get; + stroke_class->nearest_intersection_get = NULL; + stroke_class->anchor_move_relative = gimp_bezier_stroke_anchor_move_relative; + stroke_class->anchor_move_absolute = gimp_bezier_stroke_anchor_move_absolute; + stroke_class->anchor_convert = gimp_bezier_stroke_anchor_convert; + stroke_class->anchor_delete = gimp_bezier_stroke_anchor_delete; + stroke_class->point_is_movable = gimp_bezier_stroke_point_is_movable; + stroke_class->point_move_relative = gimp_bezier_stroke_point_move_relative; + stroke_class->point_move_absolute = gimp_bezier_stroke_point_move_absolute; + stroke_class->close = gimp_bezier_stroke_close; + stroke_class->open = gimp_bezier_stroke_open; + stroke_class->anchor_is_insertable = gimp_bezier_stroke_anchor_is_insertable; + stroke_class->anchor_insert = gimp_bezier_stroke_anchor_insert; + stroke_class->is_extendable = gimp_bezier_stroke_is_extendable; + stroke_class->extend = gimp_bezier_stroke_extend; + stroke_class->connect_stroke = gimp_bezier_stroke_connect_stroke; + stroke_class->interpolate = gimp_bezier_stroke_interpolate; + stroke_class->make_bezier = gimp_bezier_stroke_make_bezier; + stroke_class->transform = gimp_bezier_stroke_transform; +} + +static void +gimp_bezier_stroke_init (GimpBezierStroke *stroke) +{ +} + +static void +gimp_bezier_stroke_finalize (GObject *object) +{ + G_OBJECT_CLASS (parent_class)->finalize (object); +} + + +/* Bezier specific functions */ + +GimpStroke * +gimp_bezier_stroke_new (void) +{ + return g_object_new (GIMP_TYPE_BEZIER_STROKE, NULL); +} + + +GimpStroke * +gimp_bezier_stroke_new_from_coords (const GimpCoords *coords, + gint n_coords, + gboolean closed) +{ + GimpStroke *stroke; + GimpAnchor *last_anchor; + gint count; + + g_return_val_if_fail (coords != NULL, NULL); + g_return_val_if_fail (n_coords >= 3, NULL); + g_return_val_if_fail ((n_coords % 3) == 0, NULL); + + stroke = gimp_bezier_stroke_new (); + + last_anchor = NULL; + + for (count = 0; count < n_coords; count++) + last_anchor = gimp_bezier_stroke_extend (stroke, + &coords[count], + last_anchor, + EXTEND_SIMPLE); + + if (closed) + gimp_stroke_close (stroke); + + return stroke; +} + +static void +gimp_bezier_stroke_anchor_delete (GimpStroke *stroke, + GimpAnchor *anchor) +{ + GList *list; + GList *list2; + gint i; + + /* Anchors always are surrounded by two handles that have to + * be deleted too + */ + + list2 = g_queue_find (stroke->anchors, anchor); + list = g_list_previous (list2); + + for (i = 0; i < 3; i++) + { + g_return_if_fail (list != NULL); + + list2 = g_list_next (list); + gimp_anchor_free (list->data); + g_queue_delete_link (stroke->anchors, list); + list = list2; + } +} + +static GimpStroke * +gimp_bezier_stroke_open (GimpStroke *stroke, + GimpAnchor *end_anchor) +{ + GList *list; + GList *list2; + GimpStroke *new_stroke = NULL; + + list = g_queue_find (stroke->anchors, end_anchor); + + g_return_val_if_fail (list != NULL && list->next != NULL, NULL); + + list = g_list_next (list); /* protect the handle... */ + + list2 = list->next; + list->next = NULL; + + if (list2 != NULL) + { + GList *tail = stroke->anchors->tail; + + stroke->anchors->tail = list; + stroke->anchors->length -= g_list_length (list2); + + list2->prev = NULL; + + if (stroke->closed) + { + GList *l; + + for (l = tail; l; l = g_list_previous (l)) + g_queue_push_head (stroke->anchors, l->data); + + g_list_free (list2); + } + else + { + new_stroke = gimp_bezier_stroke_new (); + new_stroke->anchors->head = list2; + new_stroke->anchors->tail = g_list_last (list2); + new_stroke->anchors->length = g_list_length (list2); + } + } + + stroke->closed = FALSE; + g_object_notify (G_OBJECT (stroke), "closed"); + + return new_stroke; +} + +static gboolean +gimp_bezier_stroke_anchor_is_insertable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + return (g_queue_find (stroke->anchors, predec) != NULL); +} + + +static GimpAnchor * +gimp_bezier_stroke_anchor_insert (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + GList *segment_start; + GList *list; + GList *list2; + GimpCoords subdivided[8]; + GimpCoords beziercoords[4]; + gint i; + + segment_start = g_queue_find (stroke->anchors, predec); + + if (! segment_start) + return NULL; + + list = segment_start; + + for (i = 0; i <= 3; i++) + { + beziercoords[i] = GIMP_ANCHOR (list->data)->position; + list = g_list_next (list); + if (! list) + list = stroke->anchors->head; + } + + subdivided[0] = beziercoords[0]; + subdivided[6] = beziercoords[3]; + + gimp_coords_mix (1-position, &(beziercoords[0]), + position, &(beziercoords[1]), + &(subdivided[1])); + + gimp_coords_mix (1-position, &(beziercoords[1]), + position, &(beziercoords[2]), + &(subdivided[7])); + + gimp_coords_mix (1-position, &(beziercoords[2]), + position, &(beziercoords[3]), + &(subdivided[5])); + + gimp_coords_mix (1-position, &(subdivided[1]), + position, &(subdivided[7]), + &(subdivided[2])); + + gimp_coords_mix (1-position, &(subdivided[7]), + position, &(subdivided[5]), + &(subdivided[4])); + + gimp_coords_mix (1-position, &(subdivided[2]), + position, &(subdivided[4]), + &(subdivided[3])); + + /* subdivided 0-6 contains the bezier segment subdivided at <position> */ + + list = segment_start; + + for (i = 0; i <= 6; i++) + { + if (i >= 2 && i <= 4) + { + list2 = g_list_append (NULL, + gimp_anchor_new ((i == 3 ? + GIMP_ANCHOR_ANCHOR: + GIMP_ANCHOR_CONTROL), + &(subdivided[i]))); + /* insert it *before* list manually. */ + list2->next = list; + list2->prev = list->prev; + if (list->prev) + list->prev->next = list2; + list->prev = list2; + + list = list2; + + if (i == 3) + segment_start = list; + } + else + { + GIMP_ANCHOR (list->data)->position = subdivided[i]; + } + + list = g_list_next (list); + if (! list) + list = stroke->anchors->head; + } + + stroke->anchors->head = g_list_first (list); + stroke->anchors->tail = g_list_last (list); + stroke->anchors->length += 3; + + return GIMP_ANCHOR (segment_start->data); +} + + +static gboolean +gimp_bezier_stroke_point_is_movable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + return (g_queue_find (stroke->anchors, predec) != NULL); +} + + +static void +gimp_bezier_stroke_point_move_relative (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature) +{ + GimpCoords offsetcoords[2]; + GList *segment_start; + GList *list; + gint i; + gdouble feel_good; + + segment_start = g_queue_find (stroke->anchors, predec); + + g_return_if_fail (segment_start != NULL); + + /* dragging close to endpoints just moves the handle related to + * the endpoint. Just make sure that feel_good is in the range from + * 0 to 1. The 1.0 / 6.0 and 5.0 / 6.0 are duplicated in + * tools/gimpvectortool.c. + */ + if (position <= 1.0 / 6.0) + feel_good = 0; + else if (position <= 0.5) + feel_good = (pow((6 * position - 1) / 2.0, 3)) / 2; + else if (position <= 5.0 / 6.0) + feel_good = (1 - pow((6 * (1-position) - 1) / 2.0, 3)) / 2 + 0.5; + else + feel_good = 1; + + gimp_coords_scale ((1-feel_good)/(3*position* + (1-position)*(1-position)), + deltacoord, + &(offsetcoords[0])); + gimp_coords_scale (feel_good/(3*position*position*(1-position)), + deltacoord, + &(offsetcoords[1])); + + list = segment_start; + list = g_list_next (list); + if (! list) + list = stroke->anchors->head; + + for (i = 0; i <= 1; i++) + { + gimp_stroke_anchor_move_relative (stroke, GIMP_ANCHOR (list->data), + &(offsetcoords[i]), feature); + list = g_list_next (list); + if (! list) + list = stroke->anchors->head; + } +} + + +static void +gimp_bezier_stroke_point_move_absolute (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *coord, + GimpAnchorFeatureType feature) +{ + GimpCoords deltacoord; + GimpCoords tmp1, tmp2, abs_pos; + GimpCoords beziercoords[4]; + GList *segment_start; + GList *list; + gint i; + + segment_start = g_queue_find (stroke->anchors, predec); + + g_return_if_fail (segment_start != NULL); + + list = segment_start; + + for (i = 0; i <= 3; i++) + { + beziercoords[i] = GIMP_ANCHOR (list->data)->position; + list = g_list_next (list); + if (! list) + list = stroke->anchors->head; + } + + gimp_coords_mix ((1-position)*(1-position)*(1-position), &(beziercoords[0]), + 3*(1-position)*(1-position)*position, &(beziercoords[1]), + &tmp1); + gimp_coords_mix (3*(1-position)*position*position, &(beziercoords[2]), + position*position*position, &(beziercoords[3]), + &tmp2); + gimp_coords_add (&tmp1, &tmp2, &abs_pos); + + gimp_coords_difference (coord, &abs_pos, &deltacoord); + + gimp_bezier_stroke_point_move_relative (stroke, predec, position, + &deltacoord, feature); +} + +static void +gimp_bezier_stroke_close (GimpStroke *stroke) +{ + GList *start; + GList *end; + GimpAnchor *anchor; + + start = stroke->anchors->head; + end = stroke->anchors->tail; + + g_return_if_fail (start->next != NULL && end->prev != NULL); + + if (start->next != end->prev) + { + if (gimp_coords_equal (&(GIMP_ANCHOR (start->next->data)->position), + &(GIMP_ANCHOR (start->data)->position)) && + gimp_coords_equal (&(GIMP_ANCHOR (start->data)->position), + &(GIMP_ANCHOR (end->data)->position)) && + gimp_coords_equal (&(GIMP_ANCHOR (end->data)->position), + &(GIMP_ANCHOR (end->prev->data)->position))) + { + /* redundant segment */ + + gimp_anchor_free (stroke->anchors->tail->data); + g_queue_delete_link (stroke->anchors, stroke->anchors->tail); + + gimp_anchor_free (stroke->anchors->tail->data); + g_queue_delete_link (stroke->anchors, stroke->anchors->tail); + + anchor = stroke->anchors->tail->data; + g_queue_delete_link (stroke->anchors, stroke->anchors->tail); + + gimp_anchor_free (stroke->anchors->head->data); + stroke->anchors->head->data = anchor; + } + } + + GIMP_STROKE_CLASS (parent_class)->close (stroke); +} + +static gdouble +gimp_bezier_stroke_nearest_point_get (GimpStroke *stroke, + const GimpCoords *coord, + gdouble precision, + GimpCoords *ret_point, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos) +{ + gdouble min_dist, dist, pos; + GimpCoords point = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; + GimpCoords segmentcoords[4]; + GList *anchorlist; + GimpAnchor *segment_start; + GimpAnchor *segment_end = NULL; + GimpAnchor *anchor; + gint count; + + if (g_queue_is_empty (stroke->anchors)) + return -1.0; + + count = 0; + min_dist = -1; + pos = 0; + + for (anchorlist = stroke->anchors->head; + GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR; + anchorlist = g_list_next (anchorlist)); + + segment_start = anchorlist->data; + + for ( ; anchorlist; anchorlist = g_list_next (anchorlist)) + { + anchor = anchorlist->data; + + segmentcoords[count] = anchor->position; + count++; + + if (count == 4) + { + segment_end = anchorlist->data; + dist = gimp_bezier_stroke_segment_nearest_point_get (segmentcoords, + coord, precision, + &point, &pos, + 10); + + if (dist < min_dist || min_dist < 0) + { + min_dist = dist; + + if (ret_pos) + *ret_pos = pos; + if (ret_point) + *ret_point = point; + if (ret_segment_start) + *ret_segment_start = segment_start; + if (ret_segment_end) + *ret_segment_end = segment_end; + } + + segment_start = anchorlist->data; + segmentcoords[0] = segmentcoords[3]; + count = 1; + } + } + + if (stroke->closed && stroke->anchors->head) + { + anchorlist = stroke->anchors->head; + + while (count < 3) + { + segmentcoords[count] = GIMP_ANCHOR (anchorlist->data)->position; + count++; + } + + anchorlist = g_list_next (anchorlist); + + if (anchorlist) + { + segment_end = GIMP_ANCHOR (anchorlist->data); + segmentcoords[3] = segment_end->position; + } + + dist = gimp_bezier_stroke_segment_nearest_point_get (segmentcoords, + coord, precision, + &point, &pos, + 10); + + if (dist < min_dist || min_dist < 0) + { + min_dist = dist; + + if (ret_pos) + *ret_pos = pos; + if (ret_point) + *ret_point = point; + if (ret_segment_start) + *ret_segment_start = segment_start; + if (ret_segment_end) + *ret_segment_end = segment_end; + } + } + + return min_dist; +} + + +static gdouble +gimp_bezier_stroke_segment_nearest_point_get (const GimpCoords *beziercoords, + const GimpCoords *coord, + gdouble precision, + GimpCoords *ret_point, + gdouble *ret_pos, + gint depth) +{ + /* + * beziercoords has to contain four GimpCoords with the four control points + * of the bezier segment. We subdivide it at the parameter 0.5. + */ + + GimpCoords subdivided[8]; + gdouble dist1, dist2; + GimpCoords point1, point2; + gdouble pos1, pos2; + + gimp_coords_difference (&beziercoords[1], &beziercoords[0], &point1); + gimp_coords_difference (&beziercoords[3], &beziercoords[2], &point2); + + if (! depth || (gimp_coords_bezier_is_straight (beziercoords, precision) && + gimp_coords_length_squared (&point1) < precision && + gimp_coords_length_squared (&point2) < precision)) + { + GimpCoords line, dcoord; + gdouble length2, scalar; + gint i; + + gimp_coords_difference (&(beziercoords[3]), + &(beziercoords[0]), + &line); + + gimp_coords_difference (coord, + &(beziercoords[0]), + &dcoord); + + length2 = gimp_coords_scalarprod (&line, &line); + scalar = gimp_coords_scalarprod (&line, &dcoord) / length2; + + scalar = CLAMP (scalar, 0.0, 1.0); + + /* lines look the same as bezier curves where the handles + * sit on the anchors, however, they are parametrized + * differently. Hence we have to do some weird approximation. */ + + pos1 = pos2 = 0.5; + + for (i = 0; i <= 15; i++) + { + pos2 *= 0.5; + + if (3 * pos1 * pos1 * (1-pos1) + pos1 * pos1 * pos1 < scalar) + pos1 += pos2; + else + pos1 -= pos2; + } + + *ret_pos = pos1; + + gimp_coords_mix (1.0, &(beziercoords[0]), + scalar, &line, + ret_point); + + gimp_coords_difference (coord, ret_point, &dcoord); + + return gimp_coords_length (&dcoord); + } + + /* ok, we have to subdivide */ + + subdivided[0] = beziercoords[0]; + subdivided[6] = beziercoords[3]; + + /* if (!depth) g_printerr ("Hit recursion depth limit!\n"); */ + + gimp_coords_average (&(beziercoords[0]), &(beziercoords[1]), + &(subdivided[1])); + + gimp_coords_average (&(beziercoords[1]), &(beziercoords[2]), + &(subdivided[7])); + + gimp_coords_average (&(beziercoords[2]), &(beziercoords[3]), + &(subdivided[5])); + + gimp_coords_average (&(subdivided[1]), &(subdivided[7]), + &(subdivided[2])); + + gimp_coords_average (&(subdivided[7]), &(subdivided[5]), + &(subdivided[4])); + + gimp_coords_average (&(subdivided[2]), &(subdivided[4]), + &(subdivided[3])); + + /* + * We now have the coordinates of the two bezier segments in + * subdivided [0-3] and subdivided [3-6] + */ + + dist1 = gimp_bezier_stroke_segment_nearest_point_get (&(subdivided[0]), + coord, precision, + &point1, &pos1, + depth - 1); + + dist2 = gimp_bezier_stroke_segment_nearest_point_get (&(subdivided[3]), + coord, precision, + &point2, &pos2, + depth - 1); + + if (dist1 <= dist2) + { + *ret_point = point1; + *ret_pos = 0.5 * pos1; + return dist1; + } + else + { + *ret_point = point2; + *ret_pos = 0.5 + 0.5 * pos2; + return dist2; + } +} + + +static gdouble +gimp_bezier_stroke_nearest_tangent_get (GimpStroke *stroke, + const GimpCoords *coord1, + const GimpCoords *coord2, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos) +{ + gdouble min_dist, dist, pos; + GimpCoords point; + GimpCoords segmentcoords[4]; + GList *anchorlist; + GimpAnchor *segment_start; + GimpAnchor *segment_end = NULL; + GimpAnchor *anchor; + gint count; + + if (g_queue_is_empty (stroke->anchors)) + return -1.0; + + count = 0; + min_dist = -1; + + for (anchorlist = stroke->anchors->head; + GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR; + anchorlist = g_list_next (anchorlist)); + + segment_start = anchorlist->data; + + for ( ; anchorlist; anchorlist = g_list_next (anchorlist)) + { + anchor = anchorlist->data; + + segmentcoords[count] = anchor->position; + count++; + + if (count == 4) + { + segment_end = anchorlist->data; + dist = gimp_bezier_stroke_segment_nearest_tangent_get (segmentcoords, + coord1, coord2, + precision, + &point, &pos); + + if (dist >= 0 && (dist < min_dist || min_dist < 0)) + { + min_dist = dist; + + if (ret_pos) + *ret_pos = pos; + if (nearest) + *nearest = point; + if (ret_segment_start) + *ret_segment_start = segment_start; + if (ret_segment_end) + *ret_segment_end = segment_end; + } + + segment_start = anchorlist->data; + segmentcoords[0] = segmentcoords[3]; + count = 1; + } + } + + if (stroke->closed && ! g_queue_is_empty (stroke->anchors)) + { + anchorlist = stroke->anchors->head; + + while (count < 3) + { + segmentcoords[count] = GIMP_ANCHOR (anchorlist->data)->position; + count++; + } + + anchorlist = g_list_next (anchorlist); + + if (anchorlist) + { + segment_end = GIMP_ANCHOR (anchorlist->data); + segmentcoords[3] = segment_end->position; + } + + dist = gimp_bezier_stroke_segment_nearest_tangent_get (segmentcoords, + coord1, coord2, + precision, + &point, &pos); + + if (dist >= 0 && (dist < min_dist || min_dist < 0)) + { + min_dist = dist; + + if (ret_pos) + *ret_pos = pos; + if (nearest) + *nearest = point; + if (ret_segment_start) + *ret_segment_start = segment_start; + if (ret_segment_end) + *ret_segment_end = segment_end; + } + } + + return min_dist; +} + +static gdouble +gimp_bezier_stroke_segment_nearest_tangent_get (const GimpCoords *beziercoords, + const GimpCoords *coord1, + const GimpCoords *coord2, + gdouble precision, + GimpCoords *ret_point, + gdouble *ret_pos) +{ + GArray *ret_coords; + GArray *ret_params; + GimpCoords dir, line, dcoord, min_point; + gdouble min_dist = -1; + gdouble dist, length2, scalar, ori, ori2; + gint i; + + gimp_coords_difference (coord2, coord1, &line); + + ret_coords = g_array_new (FALSE, FALSE, sizeof (GimpCoords)); + ret_params = g_array_new (FALSE, FALSE, sizeof (gdouble)); + + g_printerr ("(%.2f, %.2f)-(%.2f,%.2f): ", coord1->x, coord1->y, + coord2->x, coord2->y); + + gimp_coords_interpolate_bezier (beziercoords, precision, + ret_coords, ret_params); + + g_return_val_if_fail (ret_coords->len == ret_params->len, -1.0); + + if (ret_coords->len < 2) + return -1; + + gimp_coords_difference (&g_array_index (ret_coords, GimpCoords, 1), + &g_array_index (ret_coords, GimpCoords, 0), + &dir); + ori = dir.x * line.y - dir.y * line.x; + + for (i = 2; i < ret_coords->len; i++) + { + gimp_coords_difference (&g_array_index (ret_coords, GimpCoords, i), + &g_array_index (ret_coords, GimpCoords, i-1), + &dir); + ori2 = dir.x * line.y - dir.y * line.x; + + if (ori * ori2 <= 0) + { + gimp_coords_difference (&g_array_index (ret_coords, GimpCoords, i), + coord1, + &dcoord); + + length2 = gimp_coords_scalarprod (&line, &line); + scalar = gimp_coords_scalarprod (&line, &dcoord) / length2; + + if (scalar >= 0 && scalar <= 1) + { + gimp_coords_mix (1.0, coord1, + scalar, &line, + &min_point); + gimp_coords_difference (&min_point, + &g_array_index (ret_coords, GimpCoords, i), + &dcoord); + dist = gimp_coords_length (&dcoord); + + if (dist < min_dist || min_dist < 0) + { + min_dist = dist; + *ret_point = g_array_index (ret_coords, GimpCoords, i); + *ret_pos = g_array_index (ret_params, gdouble, i); + } + } + } + ori = ori2; + } + + if (min_dist < 0) + g_printerr ("-\n"); + else + g_printerr ("%f: (%.2f, %.2f) /%.3f/\n", min_dist, + (*ret_point).x, (*ret_point).y, *ret_pos); + + g_array_free (ret_coords, TRUE); + g_array_free (ret_params, TRUE); + + return min_dist; +} + +static gboolean +gimp_bezier_stroke_is_extendable (GimpStroke *stroke, + GimpAnchor *neighbor) +{ + GList *listneighbor; + gint loose_end; + + if (stroke->closed) + return FALSE; + + if (g_queue_is_empty (stroke->anchors)) + return TRUE; + + /* assure that there is a neighbor specified */ + g_return_val_if_fail (neighbor != NULL, FALSE); + + loose_end = 0; + listneighbor = stroke->anchors->tail; + + /* Check if the neighbor is at an end of the control points */ + if (listneighbor->data == neighbor) + { + loose_end = 1; + } + else + { + listneighbor = g_list_first (stroke->anchors->head); + + if (listneighbor->data == neighbor) + { + loose_end = -1; + } + else + { + /* + * It isn't. If we are on a handle go to the nearest + * anchor and see if we can find an end from it. + * Yes, this is tedious. + */ + + listneighbor = g_queue_find (stroke->anchors, neighbor); + + if (listneighbor && neighbor->type == GIMP_ANCHOR_CONTROL) + { + if (listneighbor->prev && + GIMP_ANCHOR (listneighbor->prev->data)->type == GIMP_ANCHOR_ANCHOR) + { + listneighbor = listneighbor->prev; + } + else if (listneighbor->next && + GIMP_ANCHOR (listneighbor->next->data)->type == GIMP_ANCHOR_ANCHOR) + { + listneighbor = listneighbor->next; + } + else + { + loose_end = 0; + listneighbor = NULL; + } + } + + if (listneighbor) + /* we found a suitable ANCHOR_ANCHOR now, lets + * search for its loose end. + */ + { + if (listneighbor->prev && + listneighbor->prev->prev == NULL) + { + loose_end = -1; + } + else if (listneighbor->next && + listneighbor->next->next == NULL) + { + loose_end = 1; + } + } + } + } + + return (loose_end != 0); +} + +GimpAnchor * +gimp_bezier_stroke_extend (GimpStroke *stroke, + const GimpCoords *coords, + GimpAnchor *neighbor, + GimpVectorExtendMode extend_mode) +{ + GimpAnchor *anchor = NULL; + GList *listneighbor; + gint loose_end, control_count; + + if (g_queue_is_empty (stroke->anchors)) + { + /* assure that there is no neighbor specified */ + g_return_val_if_fail (neighbor == NULL, NULL); + + anchor = gimp_anchor_new (GIMP_ANCHOR_CONTROL, coords); + + g_queue_push_tail (stroke->anchors, anchor); + + switch (extend_mode) + { + case EXTEND_SIMPLE: + break; + + case EXTEND_EDITABLE: + anchor = gimp_bezier_stroke_extend (stroke, + coords, anchor, + EXTEND_SIMPLE); + + /* we return the GIMP_ANCHOR_ANCHOR */ + gimp_bezier_stroke_extend (stroke, + coords, anchor, + EXTEND_SIMPLE); + + break; + + default: + anchor = NULL; + } + + return anchor; + } + else + { + /* assure that there is a neighbor specified */ + g_return_val_if_fail (neighbor != NULL, NULL); + + loose_end = 0; + listneighbor = stroke->anchors->tail; + + /* Check if the neighbor is at an end of the control points */ + if (listneighbor->data == neighbor) + { + loose_end = 1; + } + else + { + listneighbor = stroke->anchors->head; + + if (listneighbor->data == neighbor) + { + loose_end = -1; + } + else + { + /* + * It isn't. If we are on a handle go to the nearest + * anchor and see if we can find an end from it. + * Yes, this is tedious. + */ + + listneighbor = g_queue_find (stroke->anchors, neighbor); + + if (listneighbor && neighbor->type == GIMP_ANCHOR_CONTROL) + { + if (listneighbor->prev && + GIMP_ANCHOR (listneighbor->prev->data)->type == GIMP_ANCHOR_ANCHOR) + { + listneighbor = listneighbor->prev; + } + else if (listneighbor->next && + GIMP_ANCHOR (listneighbor->next->data)->type == GIMP_ANCHOR_ANCHOR) + { + listneighbor = listneighbor->next; + } + else + { + loose_end = 0; + listneighbor = NULL; + } + } + + if (listneighbor) + /* we found a suitable ANCHOR_ANCHOR now, lets + * search for its loose end. + */ + { + if (listneighbor->next && + listneighbor->next->next == NULL) + { + loose_end = 1; + listneighbor = listneighbor->next; + } + else if (listneighbor->prev && + listneighbor->prev->prev == NULL) + { + loose_end = -1; + listneighbor = listneighbor->prev; + } + } + } + } + + if (loose_end) + { + GimpAnchorType type; + + /* We have to detect the type of the point to add... */ + + control_count = 0; + + if (loose_end == 1) + { + while (listneighbor && + GIMP_ANCHOR (listneighbor->data)->type == GIMP_ANCHOR_CONTROL) + { + control_count++; + listneighbor = listneighbor->prev; + } + } + else + { + while (listneighbor && + GIMP_ANCHOR (listneighbor->data)->type == GIMP_ANCHOR_CONTROL) + { + control_count++; + listneighbor = listneighbor->next; + } + } + + switch (extend_mode) + { + case EXTEND_SIMPLE: + switch (control_count) + { + case 0: + type = GIMP_ANCHOR_CONTROL; + break; + case 1: + if (listneighbor) /* only one handle in the path? */ + type = GIMP_ANCHOR_CONTROL; + else + type = GIMP_ANCHOR_ANCHOR; + break; + case 2: + type = GIMP_ANCHOR_ANCHOR; + break; + default: + g_warning ("inconsistent bezier curve: " + "%d successive control handles", control_count); + type = GIMP_ANCHOR_ANCHOR; + } + + anchor = gimp_anchor_new (type, coords); + + if (loose_end == 1) + g_queue_push_tail (stroke->anchors, anchor); + + if (loose_end == -1) + g_queue_push_head (stroke->anchors, anchor); + break; + + case EXTEND_EDITABLE: + switch (control_count) + { + case 0: + neighbor = gimp_bezier_stroke_extend (stroke, + &(neighbor->position), + neighbor, + EXTEND_SIMPLE); + case 1: + neighbor = gimp_bezier_stroke_extend (stroke, + coords, + neighbor, + EXTEND_SIMPLE); + case 2: + anchor = gimp_bezier_stroke_extend (stroke, + coords, + neighbor, + EXTEND_SIMPLE); + + neighbor = gimp_bezier_stroke_extend (stroke, + coords, + anchor, + EXTEND_SIMPLE); + break; + default: + g_warning ("inconsistent bezier curve: " + "%d successive control handles", control_count); + } + } + + return anchor; + } + + return NULL; + } +} + +static gboolean +gimp_bezier_stroke_connect_stroke (GimpStroke *stroke, + GimpAnchor *anchor, + GimpStroke *extension, + GimpAnchor *neighbor) +{ + GList *list1; + GList *list2; + + list1 = g_queue_find (stroke->anchors, anchor); + list1 = gimp_bezier_stroke_get_anchor_listitem (list1); + list2 = g_queue_find (extension->anchors, neighbor); + list2 = gimp_bezier_stroke_get_anchor_listitem (list2); + + g_return_val_if_fail (list1 != NULL && list2 != NULL, FALSE); + + if (stroke == extension) + { + g_return_val_if_fail ((list1->prev && list1->prev->prev == NULL && + list2->next && list2->next->next == NULL) || + (list1->next && list1->next->next == NULL && + list2->prev && list2->prev->prev == NULL), FALSE); + gimp_stroke_close (stroke); + return TRUE; + } + + if (list1->prev && list1->prev->prev == NULL) + { + g_queue_reverse (stroke->anchors); + } + + g_return_val_if_fail (list1->next && list1->next->next == NULL, FALSE); + + if (list2->next && list2->next->next == NULL) + { + g_queue_reverse (extension->anchors); + } + + g_return_val_if_fail (list2->prev && list2->prev->prev == NULL, FALSE); + + for (list1 = extension->anchors->head; list1; list1 = g_list_next (list1)) + g_queue_push_tail (stroke->anchors, list1->data); + + g_queue_clear (extension->anchors); + + return TRUE; +} + + +static void +gimp_bezier_stroke_anchor_move_relative (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature) +{ + GimpCoords delta, coord1, coord2; + GList *anchor_list; + + delta = *deltacoord; + delta.pressure = 0; + delta.xtilt = 0; + delta.ytilt = 0; + delta.wheel = 0; + + gimp_coords_add (&(anchor->position), &delta, &coord1); + anchor->position = coord1; + + anchor_list = g_queue_find (stroke->anchors, anchor); + g_return_if_fail (anchor_list != NULL); + + if (anchor->type == GIMP_ANCHOR_ANCHOR) + { + if (g_list_previous (anchor_list)) + { + coord2 = GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position; + gimp_coords_add (&coord2, &delta, &coord1); + GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position = coord1; + } + + if (g_list_next (anchor_list)) + { + coord2 = GIMP_ANCHOR (g_list_next (anchor_list)->data)->position; + gimp_coords_add (&coord2, &delta, &coord1); + GIMP_ANCHOR (g_list_next (anchor_list)->data)->position = coord1; + } + } + else + { + if (feature == GIMP_ANCHOR_FEATURE_SYMMETRIC) + { + GList *neighbour = NULL, *opposite = NULL; + + /* search for opposite control point. Sigh. */ + neighbour = g_list_previous (anchor_list); + if (neighbour && + GIMP_ANCHOR (neighbour->data)->type == GIMP_ANCHOR_ANCHOR) + { + opposite = g_list_previous (neighbour); + } + else + { + neighbour = g_list_next (anchor_list); + if (neighbour && + GIMP_ANCHOR (neighbour->data)->type == GIMP_ANCHOR_ANCHOR) + { + opposite = g_list_next (neighbour); + } + } + if (opposite && + GIMP_ANCHOR (opposite->data)->type == GIMP_ANCHOR_CONTROL) + { + gimp_coords_difference (&(GIMP_ANCHOR (neighbour->data)->position), + &(anchor->position), &delta); + gimp_coords_add (&(GIMP_ANCHOR (neighbour->data)->position), + &delta, &coord1); + GIMP_ANCHOR (opposite->data)->position = coord1; + } + } + } +} + + +static void +gimp_bezier_stroke_anchor_move_absolute (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *coord, + GimpAnchorFeatureType feature) +{ + GimpCoords deltacoord; + + gimp_coords_difference (coord, &anchor->position, &deltacoord); + gimp_bezier_stroke_anchor_move_relative (stroke, anchor, + &deltacoord, feature); +} + +static void +gimp_bezier_stroke_anchor_convert (GimpStroke *stroke, + GimpAnchor *anchor, + GimpAnchorFeatureType feature) +{ + GList *anchor_list; + + anchor_list = g_queue_find (stroke->anchors, anchor); + + g_return_if_fail (anchor_list != NULL); + + switch (feature) + { + case GIMP_ANCHOR_FEATURE_EDGE: + if (anchor->type == GIMP_ANCHOR_ANCHOR) + { + if (g_list_previous (anchor_list)) + GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position = + anchor->position; + + if (g_list_next (anchor_list)) + GIMP_ANCHOR (g_list_next (anchor_list)->data)->position = + anchor->position; + } + else + { + if (g_list_previous (anchor_list) && + GIMP_ANCHOR (g_list_previous (anchor_list)->data)->type == GIMP_ANCHOR_ANCHOR) + anchor->position = GIMP_ANCHOR (g_list_previous (anchor_list)->data)->position; + if (g_list_next (anchor_list) && + GIMP_ANCHOR (g_list_next (anchor_list)->data)->type == GIMP_ANCHOR_ANCHOR) + anchor->position = GIMP_ANCHOR (g_list_next (anchor_list)->data)->position; + } + + break; + + default: + g_warning ("gimp_bezier_stroke_anchor_convert: " + "unimplemented anchor conversion %d\n", feature); + } +} + + +static GimpBezierDesc * +gimp_bezier_stroke_make_bezier (GimpStroke *stroke) +{ + GArray *points; + GArray *cmd_array; + GimpBezierDesc *bezdesc; + cairo_path_data_t pathdata; + gint num_cmds, i; + + points = gimp_stroke_control_points_get (stroke, NULL); + + g_return_val_if_fail (points && points->len % 3 == 0, NULL); + if (points->len < 3) + return NULL; + + /* Moveto + (n-1) * curveto + (if closed) curveto + closepath */ + num_cmds = 2 + (points->len / 3 - 1) * 4; + if (stroke->closed) + num_cmds += 1 + 4; + + cmd_array = g_array_sized_new (FALSE, FALSE, + sizeof (cairo_path_data_t), + num_cmds); + + pathdata.header.type = CAIRO_PATH_MOVE_TO; + pathdata.header.length = 2; + g_array_append_val (cmd_array, pathdata); + pathdata.point.x = g_array_index (points, GimpAnchor, 1).position.x; + pathdata.point.y = g_array_index (points, GimpAnchor, 1).position.y; + g_array_append_val (cmd_array, pathdata); + + for (i = 2; i+2 < points->len; i += 3) + { + pathdata.header.type = CAIRO_PATH_CURVE_TO; + pathdata.header.length = 4; + g_array_append_val (cmd_array, pathdata); + + pathdata.point.x = g_array_index (points, GimpAnchor, i).position.x; + pathdata.point.y = g_array_index (points, GimpAnchor, i).position.y; + g_array_append_val (cmd_array, pathdata); + + pathdata.point.x = g_array_index (points, GimpAnchor, i+1).position.x; + pathdata.point.y = g_array_index (points, GimpAnchor, i+1).position.y; + g_array_append_val (cmd_array, pathdata); + + pathdata.point.x = g_array_index (points, GimpAnchor, i+2).position.x; + pathdata.point.y = g_array_index (points, GimpAnchor, i+2).position.y; + g_array_append_val (cmd_array, pathdata); + } + + if (stroke->closed) + { + pathdata.header.type = CAIRO_PATH_CURVE_TO; + pathdata.header.length = 4; + g_array_append_val (cmd_array, pathdata); + + pathdata.point.x = g_array_index (points, GimpAnchor, i).position.x; + pathdata.point.y = g_array_index (points, GimpAnchor, i).position.y; + g_array_append_val (cmd_array, pathdata); + + pathdata.point.x = g_array_index (points, GimpAnchor, 0).position.x; + pathdata.point.y = g_array_index (points, GimpAnchor, 0).position.y; + g_array_append_val (cmd_array, pathdata); + + pathdata.point.x = g_array_index (points, GimpAnchor, 1).position.x; + pathdata.point.y = g_array_index (points, GimpAnchor, 1).position.y; + g_array_append_val (cmd_array, pathdata); + + pathdata.header.type = CAIRO_PATH_CLOSE_PATH; + pathdata.header.length = 1; + g_array_append_val (cmd_array, pathdata); + } + + if (cmd_array->len != num_cmds) + g_printerr ("miscalculated path cmd length! (%d vs. %d)\n", + cmd_array->len, num_cmds); + + bezdesc = gimp_bezier_desc_new ((cairo_path_data_t *) cmd_array->data, + cmd_array->len); + g_array_free (points, TRUE); + g_array_free (cmd_array, FALSE); + + return bezdesc; +} + + +static GArray * +gimp_bezier_stroke_interpolate (GimpStroke *stroke, + gdouble precision, + gboolean *ret_closed) +{ + GArray *ret_coords; + GimpAnchor *anchor; + GList *anchorlist; + GimpCoords segmentcoords[4]; + gint count; + gboolean need_endpoint = FALSE; + + if (g_queue_is_empty (stroke->anchors)) + { + if (ret_closed) + *ret_closed = FALSE; + return NULL; + } + + ret_coords = g_array_new (FALSE, FALSE, sizeof (GimpCoords)); + + count = 0; + + for (anchorlist = stroke->anchors->head; + anchorlist && GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR; + anchorlist = g_list_next (anchorlist)); + + for ( ; anchorlist; anchorlist = g_list_next (anchorlist)) + { + anchor = anchorlist->data; + + segmentcoords[count] = anchor->position; + count++; + + if (count == 4) + { + gimp_coords_interpolate_bezier (segmentcoords, precision, + ret_coords, NULL); + segmentcoords[0] = segmentcoords[3]; + count = 1; + need_endpoint = TRUE; + } + } + + if (stroke->closed && ! g_queue_is_empty (stroke->anchors)) + { + anchorlist = stroke->anchors->head; + + while (count < 3) + { + segmentcoords[count] = GIMP_ANCHOR (anchorlist->data)->position; + count++; + } + anchorlist = g_list_next (anchorlist); + if (anchorlist) + segmentcoords[3] = GIMP_ANCHOR (anchorlist->data)->position; + + gimp_coords_interpolate_bezier (segmentcoords, precision, + ret_coords, NULL); + need_endpoint = TRUE; + + } + + if (need_endpoint) + ret_coords = g_array_append_val (ret_coords, segmentcoords[3]); + + if (ret_closed) + *ret_closed = stroke->closed; + + if (ret_coords->len == 0) + { + g_array_free (ret_coords, TRUE); + ret_coords = NULL; + } + + return ret_coords; +} + + +static void +gimp_bezier_stroke_transform (GimpStroke *stroke, + const GimpMatrix3 *matrix, + GQueue *ret_strokes) +{ + GimpStroke *first_stroke = NULL; + GimpStroke *last_stroke = NULL; + GList *anchorlist; + GimpAnchor *anchor; + GimpCoords segmentcoords[4]; + GQueue *transformed[2]; + gint n_transformed; + gint count; + gboolean first; + gboolean last; + + /* if there's no need for clipping, use the default implementation */ + if (! ret_strokes || + gimp_matrix3_is_affine (matrix) || + g_queue_is_empty (stroke->anchors)) + { + GIMP_STROKE_CLASS (parent_class)->transform (stroke, matrix, ret_strokes); + + return; + } + + /* transform the individual segments */ + count = 0; + first = TRUE; + last = FALSE; + + /* find the first non-control anchor */ + for (anchorlist = stroke->anchors->head; + anchorlist && GIMP_ANCHOR (anchorlist->data)->type != GIMP_ANCHOR_ANCHOR; + anchorlist = g_list_next (anchorlist)); + + for ( ; anchorlist || stroke->closed; anchorlist = g_list_next (anchorlist)) + { + /* wrap around if 'stroke' is closed, so that we transform the final + * segment + */ + if (! anchorlist) + { + anchorlist = stroke->anchors->head; + last = TRUE; + } + + anchor = anchorlist->data; + + segmentcoords[count] = anchor->position; + count++; + + if (count == 4) + { + gboolean start_in; + gboolean end_in; + gint i; + + gimp_transform_bezier_coords (matrix, segmentcoords, + transformed, &n_transformed, + &start_in, &end_in); + + for (i = 0; i < n_transformed; i++) + { + GimpStroke *s = NULL; + GList *list; + gint j; + + if (i == 0 && start_in) + { + /* current stroke is connected to last stroke */ + s = last_stroke; + } + else if (last_stroke) + { + /* current stroke is not connected to last stroke. finalize + * last stroke. + */ + anchor = g_queue_peek_tail (last_stroke->anchors); + + g_queue_push_tail (last_stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + &anchor->position)); + } + + for (list = transformed[i]->head; list; list = g_list_next (list)) + { + GimpCoords *transformedcoords = list->data; + + if (! s) + { + /* start a new stroke */ + s = gimp_bezier_stroke_new (); + + g_queue_push_tail (s->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + &transformedcoords[0])); + + g_queue_push_tail (ret_strokes, s); + + j = 0; + } + else + { + /* continue an existing stroke, skipping the first anchor, + * which is the same as the last anchor of the last stroke + */ + j = 1; + } + + for (; j < 4; j++) + { + GimpAnchorType type; + + if (j == 0 || j == 3) + type = GIMP_ANCHOR_ANCHOR; + else + type = GIMP_ANCHOR_CONTROL; + + g_queue_push_tail (s->anchors, + gimp_anchor_new (type, + &transformedcoords[j])); + } + + g_free (transformedcoords); + } + + g_queue_free (transformed[i]); + + /* if the current stroke is an initial segment of 'stroke', + * remember it, so that we can possibly connect it to the last + * stroke later. + */ + if (i == 0 && start_in && first) + first_stroke = s; + + last_stroke = s; + first = FALSE; + } + + if (! end_in && last_stroke) + { + /* the next stroke is not connected to the last stroke. finalize + * the last stroke. + */ + anchor = g_queue_peek_tail (last_stroke->anchors); + + g_queue_push_tail (last_stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + &anchor->position)); + + last_stroke = NULL; + } + + if (last) + break; + + segmentcoords[0] = segmentcoords[3]; + count = 1; + } + } + + /* if the last stroke is a final segment of 'stroke'... */ + if (last_stroke) + { + /* ... and the first stroke is an initial segment of 'stroke', and + * 'stroke' is closed ... + */ + if (first_stroke && stroke->closed) + { + /* connect the first and last strokes */ + + /* remove the first anchor, which is a synthetic control point */ + gimp_anchor_free (g_queue_pop_head (first_stroke->anchors)); + /* remove the last anchor, which is the same anchor point as the + * first anchor + */ + gimp_anchor_free (g_queue_pop_tail (last_stroke->anchors)); + + if (first_stroke == last_stroke) + { + /* the result is a single stroke. move the last anchor, which is + * an orphan control point, to the front, to fill in the removed + * control point of the first anchor, and close the stroke. + */ + g_queue_push_head (first_stroke->anchors, + g_queue_pop_tail (first_stroke->anchors)); + + first_stroke->closed = TRUE; + } + else + { + /* the result is multiple strokes. prepend the last stroke to + * the first stroke, and discard it. + */ + while ((anchor = g_queue_pop_tail (last_stroke->anchors))) + g_queue_push_head (first_stroke->anchors, anchor); + + g_object_unref (g_queue_pop_tail (ret_strokes)); + } + } + else + { + /* otherwise, the first and last strokes are not connected. finalize + * the last stroke. + */ + anchor = g_queue_peek_tail (last_stroke->anchors); + + g_queue_push_tail (last_stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + &anchor->position)); + } + } +} + + +GimpStroke * +gimp_bezier_stroke_new_moveto (const GimpCoords *start) +{ + GimpStroke *stroke = gimp_bezier_stroke_new (); + + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + start)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_ANCHOR, + start)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + start)); + return stroke; +} + +void +gimp_bezier_stroke_lineto (GimpStroke *stroke, + const GimpCoords *end) +{ + g_return_if_fail (GIMP_IS_BEZIER_STROKE (stroke)); + g_return_if_fail (stroke->closed == FALSE); + g_return_if_fail (g_queue_is_empty (stroke->anchors) == FALSE); + + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + end)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_ANCHOR, + end)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + end)); +} + +void +gimp_bezier_stroke_conicto (GimpStroke *stroke, + const GimpCoords *control, + const GimpCoords *end) +{ + GimpCoords start, coords; + + g_return_if_fail (GIMP_IS_BEZIER_STROKE (stroke)); + g_return_if_fail (stroke->closed == FALSE); + g_return_if_fail (g_queue_get_length (stroke->anchors) > 1); + + start = GIMP_ANCHOR (stroke->anchors->tail->prev->data)->position; + + gimp_coords_mix (2.0 / 3.0, control, 1.0 / 3.0, &start, &coords); + + GIMP_ANCHOR (stroke->anchors->tail->data)->position = coords; + + gimp_coords_mix (2.0 / 3.0, control, 1.0 / 3.0, end, &coords); + + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + &coords)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_ANCHOR, + end)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + end)); +} + +void +gimp_bezier_stroke_cubicto (GimpStroke *stroke, + const GimpCoords *control1, + const GimpCoords *control2, + const GimpCoords *end) +{ + g_return_if_fail (GIMP_IS_BEZIER_STROKE (stroke)); + g_return_if_fail (stroke->closed == FALSE); + g_return_if_fail (g_queue_is_empty (stroke->anchors) == FALSE); + + GIMP_ANCHOR (stroke->anchors->tail->data)->position = *control1; + + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + control2)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_ANCHOR, + end)); + g_queue_push_tail (stroke->anchors, + gimp_anchor_new (GIMP_ANCHOR_CONTROL, + end)); +} + +static gdouble +arcto_circleparam (gdouble h, + gdouble *y) +{ + gdouble t0 = 0.5; + gdouble dt = 0.25; + gdouble pt0; + gdouble y01, y12, y23, y012, y123, y0123; /* subdividing y[] */ + + while (dt >= 0.00001) + { + pt0 = ( y[0] * (1-t0) * (1-t0) * (1-t0) + + 3 * y[1] * (1-t0) * (1-t0) * t0 + + 3 * y[2] * (1-t0) * t0 * t0 + + y[3] * t0 * t0 * t0 ); + + if (pt0 > h) + t0 = t0 - dt; + else if (pt0 < h) + t0 = t0 + dt; + else + break; + dt = dt/2; + } + + y01 = y[0] * (1-t0) + y[1] * t0; + y12 = y[1] * (1-t0) + y[2] * t0; + y23 = y[2] * (1-t0) + y[3] * t0; + y012 = y01 * (1-t0) + y12 * t0; + y123 = y12 * (1-t0) + y23 * t0; + y0123 = y012 * (1-t0) + y123 * t0; + + y[0] = y0123; y[1] = y123; y[2] = y23; /* y[3] unchanged */ + + return t0; +} + +static void +arcto_subdivide (gdouble t, + gint part, + GimpCoords *p) +{ + GimpCoords p01, p12, p23, p012, p123, p0123; + + gimp_coords_mix (1-t, &(p[0]), t, &(p[1]), &p01 ); + gimp_coords_mix (1-t, &(p[1]), t, &(p[2]), &p12 ); + gimp_coords_mix (1-t, &(p[2]), t, &(p[3]), &p23 ); + gimp_coords_mix (1-t, &p01 , t, &p12 , &p012 ); + gimp_coords_mix (1-t, &p12 , t, &p23 , &p123 ); + gimp_coords_mix (1-t, &p012 , t, &p123 , &p0123); + + if (part == 0) + { + /* p[0] unchanged */ + p[1] = p01; + p[2] = p012; + p[3] = p0123; + } + else + { + p[0] = p0123; + p[1] = p123; + p[2] = p23; + /* p[3] unchanged */ + } +} + +static void +arcto_ellipsesegment (gdouble radius_x, + gdouble radius_y, + gdouble phi0, + gdouble phi1, + GimpCoords *ellips) +{ + const GimpCoords template = GIMP_COORDS_DEFAULT_VALUES; + const gdouble circlemagic = 4.0 * (G_SQRT2 - 1.0) / 3.0; + + gdouble phi_s, phi_e; + gdouble y[4]; + gdouble h0, h1; + gdouble t0, t1; + + g_return_if_fail (ellips != NULL); + + y[0] = 0.0; + y[1] = circlemagic; + y[2] = 1.0; + y[3] = 1.0; + + ellips[0] = template; + ellips[1] = template; + ellips[2] = template; + ellips[3] = template; + + if (phi0 < phi1) + { + phi_s = floor (phi0 / G_PI_2) * G_PI_2; + while (phi_s < 0) phi_s += 2 * G_PI; + phi_e = phi_s + G_PI_2; + } + else + { + phi_e = floor (phi1 / G_PI_2) * G_PI_2; + while (phi_e < 0) phi_e += 2 * G_PI; + phi_s = phi_e + G_PI_2; + } + + h0 = sin (fabs (phi0-phi_s)); + h1 = sin (fabs (phi1-phi_s)); + + ellips[0].x = cos (phi_s); ellips[0].y = sin (phi_s); + ellips[3].x = cos (phi_e); ellips[3].y = sin (phi_e); + + gimp_coords_mix (1, &(ellips[0]), circlemagic, &(ellips[3]), &(ellips[1])); + gimp_coords_mix (circlemagic, &(ellips[0]), 1, &(ellips[3]), &(ellips[2])); + + if (h0 > y[0]) + { + t0 = arcto_circleparam (h0, y); /* also subdivides y[] at t0 */ + arcto_subdivide (t0, 1, ellips); + } + + if (h1 < y[3]) + { + t1 = arcto_circleparam (h1, y); + arcto_subdivide (t1, 0, ellips); + } + + ellips[0].x *= radius_x ; ellips[0].y *= radius_y; + ellips[1].x *= radius_x ; ellips[1].y *= radius_y; + ellips[2].x *= radius_x ; ellips[2].y *= radius_y; + ellips[3].x *= radius_x ; ellips[3].y *= radius_y; +} + +void +gimp_bezier_stroke_arcto (GimpStroke *bez_stroke, + gdouble radius_x, + gdouble radius_y, + gdouble angle_rad, + gboolean large_arc, + gboolean sweep, + const GimpCoords *end) +{ + GimpCoords start; + GimpCoords middle; /* between start and end */ + GimpCoords trans_delta; + GimpCoords trans_center; + GimpCoords tmp_center; + GimpCoords center; + GimpCoords ellips[4]; /* control points of untransformed ellipse segment */ + GimpCoords ctrl[4]; /* control points of next bezier segment */ + + GimpMatrix3 anglerot; + + gdouble lambda; + gdouble phi0, phi1, phi2; + gdouble tmpx, tmpy; + + g_return_if_fail (GIMP_IS_BEZIER_STROKE (bez_stroke)); + g_return_if_fail (bez_stroke->closed == FALSE); + g_return_if_fail (g_queue_get_length (bez_stroke->anchors) > 1); + + if (radius_x == 0 || radius_y == 0) + { + gimp_bezier_stroke_lineto (bez_stroke, end); + return; + } + + start = GIMP_ANCHOR (bez_stroke->anchors->tail->prev->data)->position; + + gimp_matrix3_identity (&anglerot); + gimp_matrix3_rotate (&anglerot, -angle_rad); + + gimp_coords_mix (0.5, &start, -0.5, end, &trans_delta); + gimp_matrix3_transform_point (&anglerot, + trans_delta.x, trans_delta.y, + &tmpx, &tmpy); + trans_delta.x = tmpx; + trans_delta.y = tmpy; + + lambda = (SQR (trans_delta.x) / SQR (radius_x) + + SQR (trans_delta.y) / SQR (radius_y)); + + if (lambda < 0.00001) + { + /* don't bother with it - endpoint is too close to startpoint */ + return; + } + + trans_center = trans_delta; + + if (lambda > 1.0) + { + /* The radii are too small for a matching ellipse. We expand them + * so that they fit exactly (center of the ellipse between the + * start- and endpoint + */ + radius_x *= sqrt (lambda); + radius_y *= sqrt (lambda); + trans_center.x = 0.0; + trans_center.y = 0.0; + } + else + { + gdouble factor = sqrt ((1.0 - lambda) / lambda); + + trans_center.x = trans_delta.y * radius_x / radius_y * factor; + trans_center.y = - trans_delta.x * radius_y / radius_x * factor; + } + + if ((large_arc && sweep) || (!large_arc && !sweep)) + { + trans_center.x *= -1; + trans_center.y *= -1; + } + + gimp_matrix3_identity (&anglerot); + gimp_matrix3_rotate (&anglerot, angle_rad); + + tmp_center = trans_center; + gimp_matrix3_transform_point (&anglerot, + tmp_center.x, tmp_center.y, + &tmpx, &tmpy); + tmp_center.x = tmpx; + tmp_center.y = tmpy; + + gimp_coords_mix (0.5, &start, 0.5, end, &middle); + gimp_coords_add (&tmp_center, &middle, ¢er); + + phi1 = atan2 ((trans_delta.y - trans_center.y) / radius_y, + (trans_delta.x - trans_center.x) / radius_x); + + phi2 = atan2 ((- trans_delta.y - trans_center.y) / radius_y, + (- trans_delta.x - trans_center.x) / radius_x); + + if (phi1 < 0) + phi1 += 2 * G_PI; + + if (phi2 < 0) + phi2 += 2 * G_PI; + + if (sweep) + { + while (phi2 < phi1) + phi2 += 2 * G_PI; + + phi0 = floor (phi1 / G_PI_2) * G_PI_2; + + while (phi0 < phi2) + { + arcto_ellipsesegment (radius_x, radius_y, + MAX (phi0, phi1), MIN (phi0 + G_PI_2, phi2), + ellips); + + gimp_matrix3_transform_point (&anglerot, ellips[0].x, ellips[0].y, + &tmpx, &tmpy); + ellips[0].x = tmpx; ellips[0].y = tmpy; + gimp_matrix3_transform_point (&anglerot, ellips[1].x, ellips[1].y, + &tmpx, &tmpy); + ellips[1].x = tmpx; ellips[1].y = tmpy; + gimp_matrix3_transform_point (&anglerot, ellips[2].x, ellips[2].y, + &tmpx, &tmpy); + ellips[2].x = tmpx; ellips[2].y = tmpy; + gimp_matrix3_transform_point (&anglerot, ellips[3].x, ellips[3].y, + &tmpx, &tmpy); + ellips[3].x = tmpx; ellips[3].y = tmpy; + + gimp_coords_add (¢er, &(ellips[1]), &(ctrl[1])); + gimp_coords_add (¢er, &(ellips[2]), &(ctrl[2])); + gimp_coords_add (¢er, &(ellips[3]), &(ctrl[3])); + + gimp_bezier_stroke_cubicto (bez_stroke, + &(ctrl[1]), &(ctrl[2]), &(ctrl[3])); + phi0 += G_PI_2; + } + } + else + { + while (phi1 < phi2) + phi1 += 2 * G_PI; + + phi0 = ceil (phi1 / G_PI_2) * G_PI_2; + + while (phi0 > phi2) + { + arcto_ellipsesegment (radius_x, radius_y, + MIN (phi0, phi1), MAX (phi0 - G_PI_2, phi2), + ellips); + + gimp_matrix3_transform_point (&anglerot, ellips[0].x, ellips[0].y, + &tmpx, &tmpy); + ellips[0].x = tmpx; ellips[0].y = tmpy; + gimp_matrix3_transform_point (&anglerot, ellips[1].x, ellips[1].y, + &tmpx, &tmpy); + ellips[1].x = tmpx; ellips[1].y = tmpy; + gimp_matrix3_transform_point (&anglerot, ellips[2].x, ellips[2].y, + &tmpx, &tmpy); + ellips[2].x = tmpx; ellips[2].y = tmpy; + gimp_matrix3_transform_point (&anglerot, ellips[3].x, ellips[3].y, + &tmpx, &tmpy); + ellips[3].x = tmpx; ellips[3].y = tmpy; + + gimp_coords_add (¢er, &(ellips[1]), &(ctrl[1])); + gimp_coords_add (¢er, &(ellips[2]), &(ctrl[2])); + gimp_coords_add (¢er, &(ellips[3]), &(ctrl[3])); + + gimp_bezier_stroke_cubicto (bez_stroke, + &(ctrl[1]), &(ctrl[2]), &(ctrl[3])); + phi0 -= G_PI_2; + } + } +} + +GimpStroke * +gimp_bezier_stroke_new_ellipse (const GimpCoords *center, + gdouble radius_x, + gdouble radius_y, + gdouble angle) +{ + GimpStroke *stroke; + GimpCoords p1 = *center; + GimpCoords p2 = *center; + GimpCoords p3 = *center; + GimpCoords dx = { 0, }; + GimpCoords dy = { 0, }; + const gdouble circlemagic = 4.0 * (G_SQRT2 - 1.0) / 3.0; + GimpAnchor *handle; + + dx.x = radius_x * cos (angle); + dx.y = - radius_x * sin (angle); + dy.x = radius_y * sin (angle); + dy.y = radius_y * cos (angle); + + gimp_coords_mix (1.0, center, 1.0, &dx, &p1); + stroke = gimp_bezier_stroke_new_moveto (&p1); + + handle = g_queue_peek_head (stroke->anchors); + gimp_coords_mix (1.0, &p1, -circlemagic, &dy, &handle->position); + + gimp_coords_mix (1.0, &p1, circlemagic, &dy, &p1); + gimp_coords_mix (1.0, center, 1.0, &dy, &p3); + gimp_coords_mix (1.0, &p3, circlemagic, &dx, &p2); + gimp_bezier_stroke_cubicto (stroke, &p1, &p2, &p3); + + gimp_coords_mix (1.0, &p3, -circlemagic, &dx, &p1); + gimp_coords_mix (1.0, center, -1.0, &dx, &p3); + gimp_coords_mix (1.0, &p3, circlemagic, &dy, &p2); + gimp_bezier_stroke_cubicto (stroke, &p1, &p2, &p3); + + gimp_coords_mix (1.0, &p3, -circlemagic, &dy, &p1); + gimp_coords_mix (1.0, center, -1.0, &dy, &p3); + gimp_coords_mix (1.0, &p3, -circlemagic, &dx, &p2); + gimp_bezier_stroke_cubicto (stroke, &p1, &p2, &p3); + + handle = g_queue_peek_tail (stroke->anchors); + gimp_coords_mix (1.0, &p3, circlemagic, &dx, &handle->position); + + gimp_stroke_close (stroke); + + return stroke; +} + + +/* helper function to get the associated anchor of a listitem */ + +static GList * +gimp_bezier_stroke_get_anchor_listitem (GList *list) +{ + if (!list) + return NULL; + + if (GIMP_ANCHOR (list->data)->type == GIMP_ANCHOR_ANCHOR) + return list; + + if (list->prev && GIMP_ANCHOR (list->prev->data)->type == GIMP_ANCHOR_ANCHOR) + return list->prev; + + if (list->next && GIMP_ANCHOR (list->next->data)->type == GIMP_ANCHOR_ANCHOR) + return list->next; + + g_return_val_if_fail (/* bezier stroke inconsistent! */ FALSE, NULL); + + return NULL; +} diff --git a/app/vectors/gimpbezierstroke.h b/app/vectors/gimpbezierstroke.h new file mode 100644 index 0000000..2fe6b98 --- /dev/null +++ b/app/vectors/gimpbezierstroke.h @@ -0,0 +1,84 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpbezierstroke.h + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_BEZIER_STROKE_H__ +#define __GIMP_BEZIER_STROKE_H__ + +#include "gimpstroke.h" + + +#define GIMP_TYPE_BEZIER_STROKE (gimp_bezier_stroke_get_type ()) +#define GIMP_BEZIER_STROKE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_BEZIER_STROKE, GimpBezierStroke)) +#define GIMP_BEZIER_STROKE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BEZIER_STROKE, GimpBezierStrokeClass)) +#define GIMP_IS_BEZIER_STROKE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_BEZIER_STROKE)) +#define GIMP_IS_BEZIER_STROKE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_BEZIER_STROKE)) +#define GIMP_BEZIER_STROKE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_BEZIER_STROKE, GimpBezierStrokeClass)) + + +typedef struct _GimpBezierStrokeClass GimpBezierStrokeClass; + +struct _GimpBezierStroke +{ + GimpStroke parent_instance; +}; + +struct _GimpBezierStrokeClass +{ + GimpStrokeClass parent_class; +}; + + +GType gimp_bezier_stroke_get_type (void) G_GNUC_CONST; + +GimpStroke * gimp_bezier_stroke_new (void); +GimpStroke * gimp_bezier_stroke_new_from_coords (const GimpCoords *coords, + gint n_coords, + gboolean closed); + +GimpStroke * gimp_bezier_stroke_new_moveto (const GimpCoords *start); +void gimp_bezier_stroke_lineto (GimpStroke *bez_stroke, + const GimpCoords *end); +void gimp_bezier_stroke_conicto (GimpStroke *bez_stroke, + const GimpCoords *control, + const GimpCoords *end); +void gimp_bezier_stroke_cubicto (GimpStroke *bez_stroke, + const GimpCoords *control1, + const GimpCoords *control2, + const GimpCoords *end); +void gimp_bezier_stroke_arcto (GimpStroke *bez_stroke, + gdouble radius_x, + gdouble radius_y, + gdouble angle_rad, + gboolean large_arc, + gboolean sweep, + const GimpCoords *end); +GimpStroke * gimp_bezier_stroke_new_ellipse (const GimpCoords *center, + gdouble radius_x, + gdouble radius_y, + gdouble angle); + + +GimpAnchor * gimp_bezier_stroke_extend (GimpStroke *stroke, + const GimpCoords *coords, + GimpAnchor *neighbor, + GimpVectorExtendMode extend_mode); + + +#endif /* __GIMP_BEZIER_STROKE_H__ */ diff --git a/app/vectors/gimpstroke-new.c b/app/vectors/gimpstroke-new.c new file mode 100644 index 0000000..daba683 --- /dev/null +++ b/app/vectors/gimpstroke-new.c @@ -0,0 +1,47 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpstroke-new.c + * Copyright (C) 2006 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <glib-object.h> + +#include "vectors-types.h" + +#include "gimpstroke-new.h" +#include "gimpbezierstroke.h" + + +GimpStroke * +gimp_stroke_new_from_coords (GimpVectorsStrokeType type, + const GimpCoords *coords, + gint n_coords, + gboolean closed) +{ + switch (type) + { + case GIMP_VECTORS_STROKE_TYPE_BEZIER: + return gimp_bezier_stroke_new_from_coords (coords, n_coords, closed); + break; + default: + g_warning ("unknown type in gimp_stroke_new_from_coords(): %d", type); + return NULL; + } +} + diff --git a/app/vectors/gimpstroke-new.h b/app/vectors/gimpstroke-new.h new file mode 100644 index 0000000..5365cc5 --- /dev/null +++ b/app/vectors/gimpstroke-new.h @@ -0,0 +1,31 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpstroke-new.c + * Copyright (C) 2006 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_NEW_H__ +#define __GIMP_VECTORS_NEW_H__ + + +GimpStroke * gimp_stroke_new_from_coords (GimpVectorsStrokeType type, + const GimpCoords *coords, + gint n_coords, + gboolean closed); + + +#endif /* __GIMP_VECTORS_NEW_H__ */ diff --git a/app/vectors/gimpstroke.c b/app/vectors/gimpstroke.c new file mode 100644 index 0000000..3a3ab90 --- /dev/null +++ b/app/vectors/gimpstroke.c @@ -0,0 +1,1431 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpstroke.c + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <cairo.h> +#include <gegl.h> +#include <gdk-pixbuf/gdk-pixbuf.h> + +#include "libgimpbase/gimpbase.h" +#include "libgimpmath/gimpmath.h" + +#include "vectors-types.h" + +#include "core/gimp-memsize.h" +#include "core/gimpcoords.h" +#include "core/gimpparamspecs.h" +#include "core/gimp-transform-utils.h" + +#include "gimpanchor.h" +#include "gimpstroke.h" + +enum +{ + PROP_0, + PROP_CONTROL_POINTS, + PROP_CLOSED +}; + +/* Prototypes */ + +static void gimp_stroke_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_stroke_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); +static void gimp_stroke_finalize (GObject *object); + +static gint64 gimp_stroke_get_memsize (GimpObject *object, + gint64 *gui_size); + +static GimpAnchor * gimp_stroke_real_anchor_get (GimpStroke *stroke, + const GimpCoords *coord); +static GimpAnchor * gimp_stroke_real_anchor_get_next (GimpStroke *stroke, + const GimpAnchor *prev); +static void gimp_stroke_real_anchor_select (GimpStroke *stroke, + GimpAnchor *anchor, + gboolean selected, + gboolean exclusive); +static void gimp_stroke_real_anchor_move_relative (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *delta, + GimpAnchorFeatureType feature); +static void gimp_stroke_real_anchor_move_absolute (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *delta, + GimpAnchorFeatureType feature); +static void gimp_stroke_real_anchor_convert (GimpStroke *stroke, + GimpAnchor *anchor, + GimpAnchorFeatureType feature); +static void gimp_stroke_real_anchor_delete (GimpStroke *stroke, + GimpAnchor *anchor); +static gboolean gimp_stroke_real_point_is_movable + (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); +static void gimp_stroke_real_point_move_relative + (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature); +static void gimp_stroke_real_point_move_absolute + (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *coord, + GimpAnchorFeatureType feature); + +static void gimp_stroke_real_close (GimpStroke *stroke); +static GimpStroke * gimp_stroke_real_open (GimpStroke *stroke, + GimpAnchor *end_anchor); +static gboolean gimp_stroke_real_anchor_is_insertable + (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); +static GimpAnchor * gimp_stroke_real_anchor_insert (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); + +static gboolean gimp_stroke_real_is_extendable (GimpStroke *stroke, + GimpAnchor *neighbor); + +static GimpAnchor * gimp_stroke_real_extend (GimpStroke *stroke, + const GimpCoords *coords, + GimpAnchor *neighbor, + GimpVectorExtendMode extend_mode); + +gboolean gimp_stroke_real_connect_stroke (GimpStroke *stroke, + GimpAnchor *anchor, + GimpStroke *extension, + GimpAnchor *neighbor); + + +static gboolean gimp_stroke_real_is_empty (GimpStroke *stroke); + +static gdouble gimp_stroke_real_get_length (GimpStroke *stroke, + gdouble precision); +static gdouble gimp_stroke_real_get_distance (GimpStroke *stroke, + const GimpCoords *coord); +static GArray * gimp_stroke_real_interpolate (GimpStroke *stroke, + gdouble precision, + gboolean *closed); +static GimpStroke * gimp_stroke_real_duplicate (GimpStroke *stroke); +static GimpBezierDesc * gimp_stroke_real_make_bezier (GimpStroke *stroke); + +static void gimp_stroke_real_translate (GimpStroke *stroke, + gdouble offset_x, + gdouble offset_y); +static void gimp_stroke_real_scale (GimpStroke *stroke, + gdouble scale_x, + gdouble scale_y); +static void gimp_stroke_real_rotate (GimpStroke *stroke, + gdouble center_x, + gdouble center_y, + gdouble angle); +static void gimp_stroke_real_flip (GimpStroke *stroke, + GimpOrientationType flip_type, + gdouble axis); +static void gimp_stroke_real_flip_free (GimpStroke *stroke, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); +static void gimp_stroke_real_transform (GimpStroke *stroke, + const GimpMatrix3 *matrix, + GQueue *ret_strokes); + +static GList * gimp_stroke_real_get_draw_anchors (GimpStroke *stroke); +static GList * gimp_stroke_real_get_draw_controls (GimpStroke *stroke); +static GArray * gimp_stroke_real_get_draw_lines (GimpStroke *stroke); +static GArray * gimp_stroke_real_control_points_get (GimpStroke *stroke, + gboolean *ret_closed); +static gboolean gimp_stroke_real_get_point_at_dist (GimpStroke *stroke, + gdouble dist, + gdouble precision, + GimpCoords *position, + gdouble *slope); + + +G_DEFINE_TYPE (GimpStroke, gimp_stroke, GIMP_TYPE_OBJECT) + +#define parent_class gimp_stroke_parent_class + + +static void +gimp_stroke_class_init (GimpStrokeClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass); + GParamSpec *param_spec; + + object_class->finalize = gimp_stroke_finalize; + object_class->get_property = gimp_stroke_get_property; + object_class->set_property = gimp_stroke_set_property; + + gimp_object_class->get_memsize = gimp_stroke_get_memsize; + + klass->changed = NULL; + klass->removed = NULL; + + klass->anchor_get = gimp_stroke_real_anchor_get; + klass->anchor_get_next = gimp_stroke_real_anchor_get_next; + klass->anchor_select = gimp_stroke_real_anchor_select; + klass->anchor_move_relative = gimp_stroke_real_anchor_move_relative; + klass->anchor_move_absolute = gimp_stroke_real_anchor_move_absolute; + klass->anchor_convert = gimp_stroke_real_anchor_convert; + klass->anchor_delete = gimp_stroke_real_anchor_delete; + + klass->point_is_movable = gimp_stroke_real_point_is_movable; + klass->point_move_relative = gimp_stroke_real_point_move_relative; + klass->point_move_absolute = gimp_stroke_real_point_move_absolute; + + klass->nearest_point_get = NULL; + klass->nearest_tangent_get = NULL; + klass->nearest_intersection_get = NULL; + klass->close = gimp_stroke_real_close; + klass->open = gimp_stroke_real_open; + klass->anchor_is_insertable = gimp_stroke_real_anchor_is_insertable; + klass->anchor_insert = gimp_stroke_real_anchor_insert; + klass->is_extendable = gimp_stroke_real_is_extendable; + klass->extend = gimp_stroke_real_extend; + klass->connect_stroke = gimp_stroke_real_connect_stroke; + + klass->is_empty = gimp_stroke_real_is_empty; + klass->get_length = gimp_stroke_real_get_length; + klass->get_distance = gimp_stroke_real_get_distance; + klass->get_point_at_dist = gimp_stroke_real_get_point_at_dist; + klass->interpolate = gimp_stroke_real_interpolate; + + klass->duplicate = gimp_stroke_real_duplicate; + klass->make_bezier = gimp_stroke_real_make_bezier; + + klass->translate = gimp_stroke_real_translate; + klass->scale = gimp_stroke_real_scale; + klass->rotate = gimp_stroke_real_rotate; + klass->flip = gimp_stroke_real_flip; + klass->flip_free = gimp_stroke_real_flip_free; + klass->transform = gimp_stroke_real_transform; + + + klass->get_draw_anchors = gimp_stroke_real_get_draw_anchors; + klass->get_draw_controls = gimp_stroke_real_get_draw_controls; + klass->get_draw_lines = gimp_stroke_real_get_draw_lines; + klass->control_points_get = gimp_stroke_real_control_points_get; + + param_spec = g_param_spec_boxed ("gimp-anchor", + "Gimp Anchor", + "The control points of a Stroke", + GIMP_TYPE_ANCHOR, + GIMP_PARAM_WRITABLE | + G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (object_class, PROP_CONTROL_POINTS, + gimp_param_spec_value_array ("control-points", + "Control Points", + "This is an ValueArray " + "with the initial " + "control points of " + "the new Stroke", + param_spec, + GIMP_PARAM_WRITABLE | + G_PARAM_CONSTRUCT_ONLY)); + + g_object_class_install_property (object_class, PROP_CLOSED, + g_param_spec_boolean ("closed", + "Close Flag", + "this flag indicates " + "whether the stroke " + "is closed or not", + FALSE, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); +} + +static void +gimp_stroke_init (GimpStroke *stroke) +{ + stroke->anchors = g_queue_new (); +} + +static void +gimp_stroke_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpStroke *stroke = GIMP_STROKE (object); + GimpValueArray *val_array; + gint length; + gint i; + + switch (property_id) + { + case PROP_CLOSED: + stroke->closed = g_value_get_boolean (value); + break; + + case PROP_CONTROL_POINTS: + g_return_if_fail (g_queue_is_empty (stroke->anchors)); + g_return_if_fail (value != NULL); + + val_array = g_value_get_boxed (value); + + if (val_array == NULL) + return; + + length = gimp_value_array_length (val_array); + + for (i = 0; i < length; i++) + { + GValue *item = gimp_value_array_index (val_array, i); + + g_return_if_fail (G_VALUE_HOLDS (item, GIMP_TYPE_ANCHOR)); + g_queue_push_tail (stroke->anchors, g_value_dup_boxed (item)); + } + + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_stroke_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpStroke *stroke = GIMP_STROKE (object); + + switch (property_id) + { + case PROP_CLOSED: + g_value_set_boolean (value, stroke->closed); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_stroke_finalize (GObject *object) +{ + GimpStroke *stroke = GIMP_STROKE (object); + + g_queue_free_full (stroke->anchors, (GDestroyNotify) gimp_anchor_free); + stroke->anchors = NULL; + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static gint64 +gimp_stroke_get_memsize (GimpObject *object, + gint64 *gui_size) +{ + GimpStroke *stroke = GIMP_STROKE (object); + gint64 memsize = 0; + + memsize += gimp_g_queue_get_memsize (stroke->anchors, sizeof (GimpAnchor)); + + return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object, + gui_size); +} + +void +gimp_stroke_set_ID (GimpStroke *stroke, + gint id) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + g_return_if_fail (stroke->ID == 0 /* we don't want changing IDs... */); + + stroke->ID = id; +} + +gint +gimp_stroke_get_ID (GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), -1); + + return stroke->ID; +} + + +GimpAnchor * +gimp_stroke_anchor_get (GimpStroke *stroke, + const GimpCoords *coord) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->anchor_get (stroke, coord); +} + + +gdouble +gimp_stroke_nearest_point_get (GimpStroke *stroke, + const GimpCoords *coord, + const gdouble precision, + GimpCoords *ret_point, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + g_return_val_if_fail (coord != NULL, FALSE); + + if (GIMP_STROKE_GET_CLASS (stroke)->nearest_point_get) + return GIMP_STROKE_GET_CLASS (stroke)->nearest_point_get (stroke, + coord, + precision, + ret_point, + ret_segment_start, + ret_segment_end, + ret_pos); + return -1; +} + +gdouble +gimp_stroke_nearest_tangent_get (GimpStroke *stroke, + const GimpCoords *coords1, + const GimpCoords *coords2, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + g_return_val_if_fail (coords1 != NULL, FALSE); + g_return_val_if_fail (coords2 != NULL, FALSE); + + if (GIMP_STROKE_GET_CLASS (stroke)->nearest_tangent_get) + return GIMP_STROKE_GET_CLASS (stroke)->nearest_tangent_get (stroke, + coords1, + coords2, + precision, + nearest, + ret_segment_start, + ret_segment_end, + ret_pos); + return -1; +} + +gdouble +gimp_stroke_nearest_intersection_get (GimpStroke *stroke, + const GimpCoords *coords1, + const GimpCoords *direction, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + g_return_val_if_fail (coords1 != NULL, FALSE); + g_return_val_if_fail (direction != NULL, FALSE); + + if (GIMP_STROKE_GET_CLASS (stroke)->nearest_intersection_get) + return GIMP_STROKE_GET_CLASS (stroke)->nearest_intersection_get (stroke, + coords1, + direction, + precision, + nearest, + ret_segment_start, + ret_segment_end, + ret_pos); + return -1; +} + +static GimpAnchor * +gimp_stroke_real_anchor_get (GimpStroke *stroke, + const GimpCoords *coord) +{ + gdouble dx, dy; + gdouble mindist = -1; + GList *anchors; + GList *list; + GimpAnchor *anchor = NULL; + + anchors = gimp_stroke_get_draw_controls (stroke); + + for (list = anchors; list; list = g_list_next (list)) + { + dx = coord->x - GIMP_ANCHOR (list->data)->position.x; + dy = coord->y - GIMP_ANCHOR (list->data)->position.y; + + if (mindist < 0 || mindist > dx * dx + dy * dy) + { + mindist = dx * dx + dy * dy; + anchor = GIMP_ANCHOR (list->data); + } + } + + g_list_free (anchors); + + anchors = gimp_stroke_get_draw_anchors (stroke); + + for (list = anchors; list; list = g_list_next (list)) + { + dx = coord->x - GIMP_ANCHOR (list->data)->position.x; + dy = coord->y - GIMP_ANCHOR (list->data)->position.y; + + if (mindist < 0 || mindist > dx * dx + dy * dy) + { + mindist = dx * dx + dy * dy; + anchor = GIMP_ANCHOR (list->data); + } + } + + g_list_free (anchors); + + return anchor; +} + + +GimpAnchor * +gimp_stroke_anchor_get_next (GimpStroke *stroke, + const GimpAnchor *prev) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->anchor_get_next (stroke, prev); +} + +static GimpAnchor * +gimp_stroke_real_anchor_get_next (GimpStroke *stroke, + const GimpAnchor *prev) +{ + GList *list; + + if (prev) + { + list = g_queue_find (stroke->anchors, prev); + if (list) + list = g_list_next (list); + } + else + { + list = stroke->anchors->head; + } + + if (list) + return GIMP_ANCHOR (list->data); + + return NULL; +} + + +void +gimp_stroke_anchor_select (GimpStroke *stroke, + GimpAnchor *anchor, + gboolean selected, + gboolean exclusive) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->anchor_select (stroke, anchor, + selected, exclusive); +} + +static void +gimp_stroke_real_anchor_select (GimpStroke *stroke, + GimpAnchor *anchor, + gboolean selected, + gboolean exclusive) +{ + GList *list = stroke->anchors->head; + + if (exclusive) + { + while (list) + { + GIMP_ANCHOR (list->data)->selected = FALSE; + list = g_list_next (list); + } + } + + list = g_queue_find (stroke->anchors, anchor); + + if (list) + GIMP_ANCHOR (list->data)->selected = selected; +} + + +void +gimp_stroke_anchor_move_relative (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *delta, + GimpAnchorFeatureType feature) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + g_return_if_fail (anchor != NULL); + g_return_if_fail (g_queue_find (stroke->anchors, anchor)); + + GIMP_STROKE_GET_CLASS (stroke)->anchor_move_relative (stroke, anchor, + delta, feature); +} + +static void +gimp_stroke_real_anchor_move_relative (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *delta, + GimpAnchorFeatureType feature) +{ + anchor->position.x += delta->x; + anchor->position.y += delta->y; +} + + +void +gimp_stroke_anchor_move_absolute (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *coord, + GimpAnchorFeatureType feature) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + g_return_if_fail (anchor != NULL); + g_return_if_fail (g_queue_find (stroke->anchors, anchor)); + + GIMP_STROKE_GET_CLASS (stroke)->anchor_move_absolute (stroke, anchor, + coord, feature); +} + +static void +gimp_stroke_real_anchor_move_absolute (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *coord, + GimpAnchorFeatureType feature) +{ + anchor->position.x = coord->x; + anchor->position.y = coord->y; +} + +gboolean +gimp_stroke_point_is_movable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + + return GIMP_STROKE_GET_CLASS (stroke)->point_is_movable (stroke, predec, + position); +} + + +static gboolean +gimp_stroke_real_point_is_movable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + return FALSE; +} + + +void +gimp_stroke_point_move_relative (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->point_move_relative (stroke, predec, + position, deltacoord, + feature); +} + + +static void +gimp_stroke_real_point_move_relative (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature) +{ + g_printerr ("gimp_stroke_point_move_relative: default implementation\n"); +} + + +void +gimp_stroke_point_move_absolute (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *coord, + GimpAnchorFeatureType feature) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->point_move_absolute (stroke, predec, + position, coord, + feature); +} + +static void +gimp_stroke_real_point_move_absolute (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *coord, + GimpAnchorFeatureType feature) +{ + g_printerr ("gimp_stroke_point_move_absolute: default implementation\n"); +} + + +void +gimp_stroke_close (GimpStroke *stroke) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + g_return_if_fail (g_queue_is_empty (stroke->anchors) == FALSE); + + GIMP_STROKE_GET_CLASS (stroke)->close (stroke); +} + +static void +gimp_stroke_real_close (GimpStroke *stroke) +{ + stroke->closed = TRUE; + g_object_notify (G_OBJECT (stroke), "closed"); +} + + +void +gimp_stroke_anchor_convert (GimpStroke *stroke, + GimpAnchor *anchor, + GimpAnchorFeatureType feature) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->anchor_convert (stroke, anchor, feature); +} + +static void +gimp_stroke_real_anchor_convert (GimpStroke *stroke, + GimpAnchor *anchor, + GimpAnchorFeatureType feature) +{ + g_printerr ("gimp_stroke_anchor_convert: default implementation\n"); +} + + +void +gimp_stroke_anchor_delete (GimpStroke *stroke, + GimpAnchor *anchor) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + g_return_if_fail (anchor && anchor->type == GIMP_ANCHOR_ANCHOR); + + GIMP_STROKE_GET_CLASS (stroke)->anchor_delete (stroke, anchor); +} + +static void +gimp_stroke_real_anchor_delete (GimpStroke *stroke, + GimpAnchor *anchor) +{ + g_printerr ("gimp_stroke_anchor_delete: default implementation\n"); +} + +GimpStroke * +gimp_stroke_open (GimpStroke *stroke, + GimpAnchor *end_anchor) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + g_return_val_if_fail (end_anchor && + end_anchor->type == GIMP_ANCHOR_ANCHOR, NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->open (stroke, end_anchor); +} + +static GimpStroke * +gimp_stroke_real_open (GimpStroke *stroke, + GimpAnchor *end_anchor) +{ + g_printerr ("gimp_stroke_open: default implementation\n"); + return NULL; +} + +gboolean +gimp_stroke_anchor_is_insertable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + + return GIMP_STROKE_GET_CLASS (stroke)->anchor_is_insertable (stroke, + predec, + position); +} + +static gboolean +gimp_stroke_real_anchor_is_insertable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + + return FALSE; +} + +GimpAnchor * +gimp_stroke_anchor_insert (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + g_return_val_if_fail (predec->type == GIMP_ANCHOR_ANCHOR, NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->anchor_insert (stroke, + predec, position); +} + +static GimpAnchor * +gimp_stroke_real_anchor_insert (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return NULL; +} + + +gboolean +gimp_stroke_is_extendable (GimpStroke *stroke, + GimpAnchor *neighbor) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + + return GIMP_STROKE_GET_CLASS (stroke)->is_extendable (stroke, neighbor); +} + +static gboolean +gimp_stroke_real_is_extendable (GimpStroke *stroke, + GimpAnchor *neighbor) +{ + return FALSE; +} + + +GimpAnchor * +gimp_stroke_extend (GimpStroke *stroke, + const GimpCoords *coords, + GimpAnchor *neighbor, + GimpVectorExtendMode extend_mode) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + g_return_val_if_fail (!stroke->closed, NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->extend (stroke, coords, + neighbor, extend_mode); +} + +static GimpAnchor * +gimp_stroke_real_extend (GimpStroke *stroke, + const GimpCoords *coords, + GimpAnchor *neighbor, + GimpVectorExtendMode extend_mode) +{ + g_printerr ("gimp_stroke_extend: default implementation\n"); + return NULL; +} + +gboolean +gimp_stroke_connect_stroke (GimpStroke *stroke, + GimpAnchor *anchor, + GimpStroke *extension, + GimpAnchor *neighbor) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + g_return_val_if_fail (GIMP_IS_STROKE (extension), FALSE); + g_return_val_if_fail (stroke->closed == FALSE && + extension->closed == FALSE, FALSE); + + return GIMP_STROKE_GET_CLASS (stroke)->connect_stroke (stroke, anchor, + extension, neighbor); +} + +gboolean +gimp_stroke_real_connect_stroke (GimpStroke *stroke, + GimpAnchor *anchor, + GimpStroke *extension, + GimpAnchor *neighbor) +{ + g_printerr ("gimp_stroke_connect_stroke: default implementation\n"); + return FALSE; +} + +gboolean +gimp_stroke_is_empty (GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + + return GIMP_STROKE_GET_CLASS (stroke)->is_empty (stroke); +} + +static gboolean +gimp_stroke_real_is_empty (GimpStroke *stroke) +{ + return g_queue_is_empty (stroke->anchors); +} + + +gdouble +gimp_stroke_get_length (GimpStroke *stroke, + gdouble precision) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0); + + return GIMP_STROKE_GET_CLASS (stroke)->get_length (stroke, precision); +} + +static gdouble +gimp_stroke_real_get_length (GimpStroke *stroke, + gdouble precision) +{ + GArray *points; + gint i; + gdouble length; + GimpCoords difference; + + if (g_queue_is_empty (stroke->anchors)) + return -1; + + points = gimp_stroke_interpolate (stroke, precision, NULL); + if (points == NULL) + return -1; + + length = 0; + + for (i = 0; i < points->len - 1; i++ ) + { + gimp_coords_difference (&(g_array_index (points, GimpCoords, i)), + &(g_array_index (points, GimpCoords, i+1)), + &difference); + length += gimp_coords_length (&difference); + } + + g_array_free(points, TRUE); + + return length; +} + + +gdouble +gimp_stroke_get_distance (GimpStroke *stroke, + const GimpCoords *coord) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0); + + return GIMP_STROKE_GET_CLASS (stroke)->get_distance (stroke, coord); +} + +static gdouble +gimp_stroke_real_get_distance (GimpStroke *stroke, + const GimpCoords *coord) +{ + g_printerr ("gimp_stroke_get_distance: default implementation\n"); + + return 0.0; +} + + +GArray * +gimp_stroke_interpolate (GimpStroke *stroke, + gdouble precision, + gboolean *ret_closed) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->interpolate (stroke, precision, + ret_closed); +} + +static GArray * +gimp_stroke_real_interpolate (GimpStroke *stroke, + gdouble precision, + gboolean *ret_closed) +{ + g_printerr ("gimp_stroke_interpolate: default implementation\n"); + + return NULL; +} + +GimpStroke * +gimp_stroke_duplicate (GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->duplicate (stroke); +} + +static GimpStroke * +gimp_stroke_real_duplicate (GimpStroke *stroke) +{ + GimpStroke *new_stroke; + GList *list; + + new_stroke = g_object_new (G_TYPE_FROM_INSTANCE (stroke), + "name", gimp_object_get_name (stroke), + NULL); + + g_queue_free_full (new_stroke->anchors, (GDestroyNotify) gimp_anchor_free); + new_stroke->anchors = g_queue_copy (stroke->anchors); + + for (list = new_stroke->anchors->head; list; list = g_list_next (list)) + { + list->data = gimp_anchor_copy (GIMP_ANCHOR (list->data)); + } + + new_stroke->closed = stroke->closed; + /* we do *not* copy the ID! */ + + return new_stroke; +} + + +GimpBezierDesc * +gimp_stroke_make_bezier (GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->make_bezier (stroke); +} + +static GimpBezierDesc * +gimp_stroke_real_make_bezier (GimpStroke *stroke) +{ + g_printerr ("gimp_stroke_make_bezier: default implementation\n"); + + return NULL; +} + + +void +gimp_stroke_translate (GimpStroke *stroke, + gdouble offset_x, + gdouble offset_y) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->translate (stroke, offset_x, offset_y); +} + +static void +gimp_stroke_real_translate (GimpStroke *stroke, + gdouble offset_x, + gdouble offset_y) +{ + GList *list; + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + GimpAnchor *anchor = list->data; + + anchor->position.x += offset_x; + anchor->position.y += offset_y; + } +} + + +void +gimp_stroke_scale (GimpStroke *stroke, + gdouble scale_x, + gdouble scale_y) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->scale (stroke, scale_x, scale_y); +} + +static void +gimp_stroke_real_scale (GimpStroke *stroke, + gdouble scale_x, + gdouble scale_y) +{ + GList *list; + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + GimpAnchor *anchor = list->data; + + anchor->position.x *= scale_x; + anchor->position.y *= scale_y; + } +} + +void +gimp_stroke_rotate (GimpStroke *stroke, + gdouble center_x, + gdouble center_y, + gdouble angle) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->rotate (stroke, center_x, center_y, angle); +} + +static void +gimp_stroke_real_rotate (GimpStroke *stroke, + gdouble center_x, + gdouble center_y, + gdouble angle) +{ + GimpMatrix3 matrix; + + angle = angle / 180.0 * G_PI; + gimp_matrix3_identity (&matrix); + gimp_transform_matrix_rotate_center (&matrix, center_x, center_y, angle); + + gimp_stroke_transform (stroke, &matrix, NULL); +} + +void +gimp_stroke_flip (GimpStroke *stroke, + GimpOrientationType flip_type, + gdouble axis) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->flip (stroke, flip_type, axis); +} + +static void +gimp_stroke_real_flip (GimpStroke *stroke, + GimpOrientationType flip_type, + gdouble axis) +{ + GimpMatrix3 matrix; + + gimp_matrix3_identity (&matrix); + gimp_transform_matrix_flip (&matrix, flip_type, axis); + gimp_stroke_transform (stroke, &matrix, NULL); +} + +void +gimp_stroke_flip_free (GimpStroke *stroke, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->flip_free (stroke, x1, y1, x2, y2); +} + +static void +gimp_stroke_real_flip_free (GimpStroke *stroke, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2) +{ + /* x, y, width and height parameter in gimp_transform_matrix_flip_free are unused */ + GimpMatrix3 matrix; + + gimp_matrix3_identity (&matrix); + gimp_transform_matrix_flip_free (&matrix, x1, y1, x2, y2); + + gimp_stroke_transform (stroke, &matrix, NULL); +} + +/* transforms 'stroke' by 'matrix'. due to clipping, the transformation may + * result in multiple strokes. + * + * if 'ret_strokes' is not NULL, the transformed strokes are appended to the + * queue, and 'stroke' is left in an unspecified state. one of the resulting + * strokes may alias 'stroke'. + * + * if 'ret_strokes' is NULL, the transformation is performed in-place. if the + * transformation results in multiple strokes (which, atm, can only happen for + * non-affine transformation), the result is undefined. + */ +void +gimp_stroke_transform (GimpStroke *stroke, + const GimpMatrix3 *matrix, + GQueue *ret_strokes) +{ + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + GIMP_STROKE_GET_CLASS (stroke)->transform (stroke, matrix, ret_strokes); +} + +static void +gimp_stroke_real_transform (GimpStroke *stroke, + const GimpMatrix3 *matrix, + GQueue *ret_strokes) +{ + GList *list; + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + GimpAnchor *anchor = list->data; + + gimp_matrix3_transform_point (matrix, + anchor->position.x, + anchor->position.y, + &anchor->position.x, + &anchor->position.y); + } + + if (ret_strokes) + { + stroke->ID = 0; + + g_queue_push_tail (ret_strokes, g_object_ref (stroke)); + } +} + + +GList * +gimp_stroke_get_draw_anchors (GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->get_draw_anchors (stroke); +} + +static GList * +gimp_stroke_real_get_draw_anchors (GimpStroke *stroke) +{ + GList *list; + GList *ret_list = NULL; + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + if (GIMP_ANCHOR (list->data)->type == GIMP_ANCHOR_ANCHOR) + ret_list = g_list_prepend (ret_list, list->data); + } + + return g_list_reverse (ret_list); +} + + +GList * +gimp_stroke_get_draw_controls (GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->get_draw_controls (stroke); +} + +static GList * +gimp_stroke_real_get_draw_controls (GimpStroke *stroke) +{ + GList *list; + GList *ret_list = NULL; + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + GimpAnchor *anchor = list->data; + + if (anchor->type == GIMP_ANCHOR_CONTROL) + { + GimpAnchor *next = list->next ? list->next->data : NULL; + GimpAnchor *prev = list->prev ? list->prev->data : NULL; + + if (next && next->type == GIMP_ANCHOR_ANCHOR && next->selected) + { + /* Ok, this is a hack. + * The idea is to give control points at the end of a + * stroke a higher priority for the interactive tool. + */ + if (prev) + ret_list = g_list_prepend (ret_list, anchor); + else + ret_list = g_list_append (ret_list, anchor); + } + else if (prev && prev->type == GIMP_ANCHOR_ANCHOR && prev->selected) + { + /* same here... */ + if (next) + ret_list = g_list_prepend (ret_list, anchor); + else + ret_list = g_list_append (ret_list, anchor); + } + } + } + + return g_list_reverse (ret_list); +} + + +GArray * +gimp_stroke_get_draw_lines (GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->get_draw_lines (stroke); +} + +static GArray * +gimp_stroke_real_get_draw_lines (GimpStroke *stroke) +{ + GList *list; + GArray *ret_lines = NULL; + gint count = 0; + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + GimpAnchor *anchor = list->data; + + if (anchor->type == GIMP_ANCHOR_ANCHOR && anchor->selected) + { + if (list->next) + { + GimpAnchor *next = list->next->data; + + if (count == 0) + ret_lines = g_array_new (FALSE, FALSE, sizeof (GimpCoords)); + + ret_lines = g_array_append_val (ret_lines, anchor->position); + ret_lines = g_array_append_val (ret_lines, next->position); + count += 1; + } + + if (list->prev) + { + GimpAnchor *prev = list->prev->data; + + if (count == 0) + ret_lines = g_array_new (FALSE, FALSE, sizeof (GimpCoords)); + + ret_lines = g_array_append_val (ret_lines, anchor->position); + ret_lines = g_array_append_val (ret_lines, prev->position); + count += 1; + } + } + } + + return ret_lines; +} + +GArray * +gimp_stroke_control_points_get (GimpStroke *stroke, + gboolean *ret_closed) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), NULL); + + return GIMP_STROKE_GET_CLASS (stroke)->control_points_get (stroke, + ret_closed); +} + +static GArray * +gimp_stroke_real_control_points_get (GimpStroke *stroke, + gboolean *ret_closed) +{ + guint num_anchors; + GArray *ret_array; + GList *list; + + num_anchors = g_queue_get_length (stroke->anchors); + ret_array = g_array_sized_new (FALSE, FALSE, + sizeof (GimpAnchor), num_anchors); + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + g_array_append_vals (ret_array, list->data, 1); + } + + if (ret_closed) + *ret_closed = stroke->closed; + + return ret_array; +} + +gboolean +gimp_stroke_get_point_at_dist (GimpStroke *stroke, + gdouble dist, + gdouble precision, + GimpCoords *position, + gdouble *slope) +{ + g_return_val_if_fail (GIMP_IS_STROKE (stroke), FALSE); + + return GIMP_STROKE_GET_CLASS (stroke)->get_point_at_dist (stroke, + dist, + precision, + position, + slope); +} + + +static gboolean +gimp_stroke_real_get_point_at_dist (GimpStroke *stroke, + gdouble dist, + gdouble precision, + GimpCoords *position, + gdouble *slope) +{ + GArray *points; + gint i; + gdouble length; + gdouble segment_length; + gboolean ret = FALSE; + GimpCoords difference; + + points = gimp_stroke_interpolate (stroke, precision, NULL); + if (points == NULL) + return ret; + + length = 0; + for (i=0; i < points->len - 1; i++) + { + gimp_coords_difference (&(g_array_index (points, GimpCoords , i)), + &(g_array_index (points, GimpCoords , i+1)), + &difference); + segment_length = gimp_coords_length (&difference); + + if (segment_length == 0 || length + segment_length < dist ) + { + length += segment_length; + } + else + { + /* x = x1 + (x2 - x1 ) u */ + /* x = x1 (1-u) + u x2 */ + + gdouble u = (dist - length) / segment_length; + + gimp_coords_mix (1 - u, &(g_array_index (points, GimpCoords , i)), + u, &(g_array_index (points, GimpCoords , i+1)), + position); + + if (difference.x == 0) + *slope = G_MAXDOUBLE; + else + *slope = difference.y / difference.x; + + ret = TRUE; + break; + } + } + + g_array_free (points, TRUE); + + return ret; +} diff --git a/app/vectors/gimpstroke.h b/app/vectors/gimpstroke.h new file mode 100644 index 0000000..f44b9ab --- /dev/null +++ b/app/vectors/gimpstroke.h @@ -0,0 +1,343 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpstroke.h + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_STROKE_H__ +#define __GIMP_STROKE_H__ + +#include "core/gimpobject.h" + + +#define GIMP_TYPE_STROKE (gimp_stroke_get_type ()) +#define GIMP_STROKE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_STROKE, GimpStroke)) +#define GIMP_STROKE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_STROKE, GimpStrokeClass)) +#define GIMP_IS_STROKE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_STROKE)) +#define GIMP_IS_STROKE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_STROKE)) +#define GIMP_STROKE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_STROKE, GimpStrokeClass)) + + +typedef struct _GimpStrokeClass GimpStrokeClass; + +struct _GimpStroke +{ + GimpObject parent_instance; + gint ID; + + GQueue *anchors; + + gboolean closed; +}; + +struct _GimpStrokeClass +{ + GimpObjectClass parent_class; + + void (* changed) (GimpStroke *stroke); + void (* removed) (GimpStroke *stroke); + + GimpAnchor * (* anchor_get) (GimpStroke *stroke, + const GimpCoords *coord); + gdouble (* nearest_point_get) (GimpStroke *stroke, + const GimpCoords *coord, + gdouble precision, + GimpCoords *ret_point, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); + gdouble (* nearest_tangent_get) (GimpStroke *stroke, + const GimpCoords *coord1, + const GimpCoords *coord2, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); + gdouble (* nearest_intersection_get) + (GimpStroke *stroke, + const GimpCoords *coord1, + const GimpCoords *direction, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); + GimpAnchor * (* anchor_get_next) (GimpStroke *stroke, + const GimpAnchor *prev); + void (* anchor_select) (GimpStroke *stroke, + GimpAnchor *anchor, + gboolean selected, + gboolean exclusive); + void (* anchor_move_relative) (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature); + void (* anchor_move_absolute) (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *coord, + GimpAnchorFeatureType feature); + void (* anchor_convert) (GimpStroke *stroke, + GimpAnchor *anchor, + GimpAnchorFeatureType feature); + void (* anchor_delete) (GimpStroke *stroke, + GimpAnchor *anchor); + + gboolean (* point_is_movable) (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); + void (* point_move_relative) (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature); + void (* point_move_absolute) (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *coord, + GimpAnchorFeatureType feature); + + void (* close) (GimpStroke *stroke); + GimpStroke * (* open) (GimpStroke *stroke, + GimpAnchor *end_anchor); + gboolean (* anchor_is_insertable) (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); + GimpAnchor * (* anchor_insert) (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); + gboolean (* is_extendable) (GimpStroke *stroke, + GimpAnchor *neighbor); + GimpAnchor * (* extend) (GimpStroke *stroke, + const GimpCoords *coords, + GimpAnchor *neighbor, + GimpVectorExtendMode extend_mode); + gboolean (* connect_stroke) (GimpStroke *stroke, + GimpAnchor *anchor, + GimpStroke *extension, + GimpAnchor *neighbor); + + gboolean (* is_empty) (GimpStroke *stroke); + gdouble (* get_length) (GimpStroke *stroke, + gdouble precision); + gdouble (* get_distance) (GimpStroke *stroke, + const GimpCoords *coord); + gboolean (* get_point_at_dist) (GimpStroke *stroke, + gdouble dist, + gdouble precision, + GimpCoords *position, + gdouble *slope); + + GArray * (* interpolate) (GimpStroke *stroke, + gdouble precision, + gboolean *ret_closed); + + GimpStroke * (* duplicate) (GimpStroke *stroke); + + GimpBezierDesc * (* make_bezier) (GimpStroke *stroke); + + void (* translate) (GimpStroke *stroke, + gdouble offset_x, + gdouble offset_y); + void (* scale) (GimpStroke *stroke, + gdouble scale_x, + gdouble scale_y); + void (* rotate) (GimpStroke *stroke, + gdouble center_x, + gdouble center_y, + gdouble angle); + void (* flip) (GimpStroke *stroke, + GimpOrientationType flip_type, + gdouble axis); + void (* flip_free) (GimpStroke *stroke, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); + void (* transform) (GimpStroke *stroke, + const GimpMatrix3 *matrix, + GQueue *ret_strokes); + + GList * (* get_draw_anchors) (GimpStroke *stroke); + GList * (* get_draw_controls) (GimpStroke *stroke); + GArray * (* get_draw_lines) (GimpStroke *stroke); + GArray * (* control_points_get) (GimpStroke *stroke, + gboolean *ret_closed); +}; + + +GType gimp_stroke_get_type (void) G_GNUC_CONST; + +void gimp_stroke_set_ID (GimpStroke *stroke, + gint id); +gint gimp_stroke_get_ID (GimpStroke *stroke); + + +/* accessing / modifying the anchors */ + +GArray * gimp_stroke_control_points_get (GimpStroke *stroke, + gboolean *closed); + +GimpAnchor * gimp_stroke_anchor_get (GimpStroke *stroke, + const GimpCoords *coord); + +gdouble gimp_stroke_nearest_point_get (GimpStroke *stroke, + const GimpCoords *coord, + gdouble precision, + GimpCoords *ret_point, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); +gdouble gimp_stroke_nearest_tangent_get (GimpStroke *stroke, + const GimpCoords *coords1, + const GimpCoords *coords2, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); +gdouble gimp_stroke_nearest_intersection_get (GimpStroke *stroke, + const GimpCoords *coords1, + const GimpCoords *direction, + gdouble precision, + GimpCoords *nearest, + GimpAnchor **ret_segment_start, + GimpAnchor **ret_segment_end, + gdouble *ret_pos); + + +/* prev == NULL: "first" anchor */ +GimpAnchor * gimp_stroke_anchor_get_next (GimpStroke *stroke, + const GimpAnchor *prev); + +void gimp_stroke_anchor_select (GimpStroke *stroke, + GimpAnchor *anchor, + gboolean selected, + gboolean exclusive); + +/* type will be an xorable enum: + * VECTORS_NONE, VECTORS_FIX_ANGLE, VECTORS_FIX_RATIO, VECTORS_RESTRICT_ANGLE + * or so. + */ +void gimp_stroke_anchor_move_relative (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *delta, + GimpAnchorFeatureType feature); +void gimp_stroke_anchor_move_absolute (GimpStroke *stroke, + GimpAnchor *anchor, + const GimpCoords *coord, + GimpAnchorFeatureType feature); + +gboolean gimp_stroke_point_is_movable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); +void gimp_stroke_point_move_relative (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *deltacoord, + GimpAnchorFeatureType feature); +void gimp_stroke_point_move_absolute (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position, + const GimpCoords *coord, + GimpAnchorFeatureType feature); + +void gimp_stroke_close (GimpStroke *stroke); + +void gimp_stroke_anchor_convert (GimpStroke *stroke, + GimpAnchor *anchor, + GimpAnchorFeatureType feature); + +void gimp_stroke_anchor_delete (GimpStroke *stroke, + GimpAnchor *anchor); + +GimpStroke * gimp_stroke_open (GimpStroke *stroke, + GimpAnchor *end_anchor); +gboolean gimp_stroke_anchor_is_insertable (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); +GimpAnchor * gimp_stroke_anchor_insert (GimpStroke *stroke, + GimpAnchor *predec, + gdouble position); + +gboolean gimp_stroke_is_extendable (GimpStroke *stroke, + GimpAnchor *neighbor); + +GimpAnchor * gimp_stroke_extend (GimpStroke *stroke, + const GimpCoords *coords, + GimpAnchor *neighbor, + GimpVectorExtendMode extend_mode); + +gboolean gimp_stroke_connect_stroke (GimpStroke *stroke, + GimpAnchor *anchor, + GimpStroke *extension, + GimpAnchor *neighbor); + +gboolean gimp_stroke_is_empty (GimpStroke *stroke); + +/* accessing the shape of the curve */ + +gdouble gimp_stroke_get_length (GimpStroke *stroke, + gdouble precision); +gdouble gimp_stroke_get_distance (GimpStroke *stroke, + const GimpCoords *coord); + +gboolean gimp_stroke_get_point_at_dist (GimpStroke *stroke, + gdouble dist, + gdouble precision, + GimpCoords *position, + gdouble *slope); + +/* returns an array of valid coordinates */ +GArray * gimp_stroke_interpolate (GimpStroke *stroke, + const gdouble precision, + gboolean *closed); + +GimpStroke * gimp_stroke_duplicate (GimpStroke *stroke); + +/* creates a bezier approximation. */ +GimpBezierDesc * gimp_stroke_make_bezier (GimpStroke *stroke); + +void gimp_stroke_translate (GimpStroke *stroke, + gdouble offset_x, + gdouble offset_y); +void gimp_stroke_scale (GimpStroke *stroke, + gdouble scale_x, + gdouble scale_y); +void gimp_stroke_rotate (GimpStroke *stroke, + gdouble center_x, + gdouble center_y, + gdouble angle); +void gimp_stroke_flip (GimpStroke *stroke, + GimpOrientationType flip_type, + gdouble axis); +void gimp_stroke_flip_free (GimpStroke *stroke, + gdouble x1, + gdouble y1, + gdouble x2, + gdouble y2); +void gimp_stroke_transform (GimpStroke *stroke, + const GimpMatrix3 *matrix, + GQueue *ret_strokes); + + +GList * gimp_stroke_get_draw_anchors (GimpStroke *stroke); +GList * gimp_stroke_get_draw_controls (GimpStroke *stroke); +GArray * gimp_stroke_get_draw_lines (GimpStroke *stroke); + +#endif /* __GIMP_STROKE_H__ */ + diff --git a/app/vectors/gimpvectors-compat.c b/app/vectors/gimpvectors-compat.c new file mode 100644 index 0000000..5416d00 --- /dev/null +++ b/app/vectors/gimpvectors-compat.c @@ -0,0 +1,285 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpvectors-compat.c + * Copyright (C) 2003 Michael Natterer <mitch@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "vectors-types.h" + +#include "core/gimpimage.h" + +#include "gimpanchor.h" +#include "gimpbezierstroke.h" +#include "gimpvectors.h" +#include "gimpvectors-compat.h" + + +enum +{ + GIMP_VECTORS_COMPAT_ANCHOR = 1, + GIMP_VECTORS_COMPAT_CONTROL = 2, + GIMP_VECTORS_COMPAT_NEW_STROKE = 3 +}; + + +static const GimpCoords default_coords = GIMP_COORDS_DEFAULT_VALUES; + + +GimpVectors * +gimp_vectors_compat_new (GimpImage *image, + const gchar *name, + GimpVectorsCompatPoint *points, + gint n_points, + gboolean closed) +{ + GimpVectors *vectors; + GimpStroke *stroke; + GimpCoords *coords; + GimpCoords *curr_stroke; + GimpCoords *curr_coord; + gint i; + + g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); + g_return_val_if_fail (name != NULL, NULL); + g_return_val_if_fail (points != NULL || n_points == 0, NULL); + g_return_val_if_fail (n_points >= 0, NULL); + + vectors = gimp_vectors_new (image, name); + + coords = g_new0 (GimpCoords, n_points + 1); + + curr_stroke = curr_coord = coords; + + /* skip the first control point, will set it later */ + curr_coord++; + + for (i = 0; i < n_points; i++) + { + *curr_coord = default_coords; + + curr_coord->x = points[i].x; + curr_coord->y = points[i].y; + + /* copy the first anchor to be the first control point */ + if (curr_coord == curr_stroke + 1) + *curr_stroke = *curr_coord; + + /* found new stroke start */ + if (points[i].type == GIMP_VECTORS_COMPAT_NEW_STROKE) + { + /* copy the last control point to the beginning of the stroke */ + *curr_stroke = *(curr_coord - 1); + + stroke = + gimp_bezier_stroke_new_from_coords (curr_stroke, + curr_coord - curr_stroke - 1, + TRUE); + gimp_vectors_stroke_add (vectors, stroke); + g_object_unref (stroke); + + /* start a new stroke */ + curr_stroke = curr_coord - 1; + + /* copy the first anchor to be the first control point */ + *curr_stroke = *curr_coord; + } + + curr_coord++; + } + + if (closed) + { + /* copy the last control point to the beginning of the stroke */ + curr_coord--; + *curr_stroke = *curr_coord; + } + + stroke = gimp_bezier_stroke_new_from_coords (curr_stroke, + curr_coord - curr_stroke, + closed); + gimp_vectors_stroke_add (vectors, stroke); + g_object_unref (stroke); + + g_free (coords); + + return vectors; +} + +gboolean +gimp_vectors_compat_is_compatible (GimpImage *image) +{ + GList *list; + + g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); + + for (list = gimp_image_get_vectors_iter (image); + list; + list = g_list_next (list)) + { + GimpVectors *vectors = GIMP_VECTORS (list->data); + GList *strokes; + gint open_count = 0; + + if (gimp_item_get_visible (GIMP_ITEM (vectors))) + return FALSE; + + for (strokes = vectors->strokes->head; + strokes; + strokes = g_list_next (strokes)) + { + GimpStroke *stroke = GIMP_STROKE (strokes->data); + + if (! GIMP_IS_BEZIER_STROKE (stroke)) + return FALSE; + + if (!stroke->closed) + open_count++; + } + + if (open_count >= 2) + return FALSE; + } + + return TRUE; +} + +GimpVectorsCompatPoint * +gimp_vectors_compat_get_points (GimpVectors *vectors, + gint32 *n_points, + gint32 *closed) +{ + GimpVectorsCompatPoint *points; + GList *strokes; + gint i; + GList *postponed = NULL; /* for the one open stroke... */ + gint open_count; + gboolean first_stroke = TRUE; + + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + g_return_val_if_fail (n_points != NULL, NULL); + g_return_val_if_fail (closed != NULL, NULL); + + *n_points = 0; + *closed = TRUE; + + open_count = 0; + + for (strokes = vectors->strokes->head; + strokes; + strokes = g_list_next (strokes)) + { + GimpStroke *stroke = strokes->data; + gint n_anchors; + + if (! stroke->closed) + { + open_count++; + postponed = strokes; + *closed = FALSE; + + if (open_count >= 2) + { + g_warning ("gimp_vectors_compat_get_points(): convert failed"); + *n_points = 0; + return NULL; + } + } + + n_anchors = g_queue_get_length (stroke->anchors); + + if (! stroke->closed) + n_anchors--; + + *n_points += n_anchors; + } + + points = g_new0 (GimpVectorsCompatPoint, *n_points); + + i = 0; + + for (strokes = vectors->strokes->head; + strokes || postponed; + strokes = g_list_next (strokes)) + { + GimpStroke *stroke; + GList *anchors; + + if (strokes) + { + if (postponed && strokes == postponed) + /* we need to visit the open stroke last... */ + continue; + else + stroke = GIMP_STROKE (strokes->data); + } + else + { + stroke = GIMP_STROKE (postponed->data); + postponed = NULL; + } + + for (anchors = stroke->anchors->head; + anchors; + anchors = g_list_next (anchors)) + { + GimpAnchor *anchor = anchors->data; + + /* skip the first anchor, will add it at the end if needed */ + if (! anchors->prev) + continue; + + switch (anchor->type) + { + case GIMP_ANCHOR_ANCHOR: + if (anchors->prev == stroke->anchors->head && ! first_stroke) + points[i].type = GIMP_VECTORS_COMPAT_NEW_STROKE; + else + points[i].type = GIMP_VECTORS_COMPAT_ANCHOR; + break; + + case GIMP_ANCHOR_CONTROL: + points[i].type = GIMP_VECTORS_COMPAT_CONTROL; + break; + } + + points[i].x = anchor->position.x; + points[i].y = anchor->position.y; + + i++; + + /* write the skipped control point */ + if (! anchors->next && stroke->closed) + { + anchor = g_queue_peek_head (stroke->anchors); + + points[i].type = GIMP_VECTORS_COMPAT_CONTROL; + points[i].x = anchor->position.x; + points[i].y = anchor->position.y; + + i++; + } + } + first_stroke = FALSE; + } + + return points; +} diff --git a/app/vectors/gimpvectors-compat.h b/app/vectors/gimpvectors-compat.h new file mode 100644 index 0000000..561043a --- /dev/null +++ b/app/vectors/gimpvectors-compat.h @@ -0,0 +1,48 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpvectors-compat.h + * Copyright (C) 2003 Michael Natterer <mitch@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_COMPAT_H__ +#define __GIMP_VECTORS_COMPAT_H__ + + +typedef struct _GimpVectorsCompatPoint GimpVectorsCompatPoint; + +struct _GimpVectorsCompatPoint +{ + guint32 type; + gdouble x; + gdouble y; +}; + + +GimpVectors * gimp_vectors_compat_new (GimpImage *image, + const gchar *name, + GimpVectorsCompatPoint *points, + gint n_points, + gboolean closed); + +gboolean gimp_vectors_compat_is_compatible (GimpImage *image); + +GimpVectorsCompatPoint * gimp_vectors_compat_get_points (GimpVectors *vectors, + gint32 *n_points, + gint32 *closed); + + +#endif /* __GIMP_VECTORS_COMPAT_H__ */ diff --git a/app/vectors/gimpvectors-export.c b/app/vectors/gimpvectors-export.c new file mode 100644 index 0000000..f8a33e8 --- /dev/null +++ b/app/vectors/gimpvectors-export.c @@ -0,0 +1,333 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "libgimpbase/gimpbase.h" + +#include "vectors-types.h" + +#include "core/gimpimage.h" +#include "core/gimpitem.h" + +#include "gimpanchor.h" +#include "gimpstroke.h" +#include "gimpbezierstroke.h" +#include "gimpvectors.h" +#include "gimpvectors-export.h" + +#include "gimp-intl.h" + + +static GString * gimp_vectors_export (GimpImage *image, + GimpVectors *vectors); +static void gimp_vectors_export_image_size (GimpImage *image, + GString *str); +static void gimp_vectors_export_path (GimpVectors *vectors, + GString *str); +static gchar * gimp_vectors_export_path_data (GimpVectors *vectors); + + +/** + * gimp_vectors_export_file: + * @image: the #GimpImage from which to export vectors + * @vectors: a #GimpVectors object or %NULL to export all vectors in @image + * @file: the file to write + * @error: return location for errors + * + * Exports one or more vectors to a SVG file. + * + * Return value: %TRUE on success, + * %FALSE if there was an error writing the file + **/ +gboolean +gimp_vectors_export_file (GimpImage *image, + GimpVectors *vectors, + GFile *file, + GError **error) +{ + GOutputStream *output; + GString *string; + GError *my_error = NULL; + + g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); + g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + + output = G_OUTPUT_STREAM (g_file_replace (file, + NULL, FALSE, G_FILE_CREATE_NONE, + NULL, error)); + if (! output) + return FALSE; + + string = gimp_vectors_export (image, vectors); + + if (! g_output_stream_write_all (output, string->str, string->len, + NULL, NULL, &my_error)) + { + GCancellable *cancellable = g_cancellable_new (); + + g_set_error (error, my_error->domain, my_error->code, + _("Writing SVG file '%s' failed: %s"), + gimp_file_get_utf8_name (file), my_error->message); + g_clear_error (&my_error); + g_string_free (string, TRUE); + + /* Cancel the overwrite initiated by g_file_replace(). */ + g_cancellable_cancel (cancellable); + g_output_stream_close (output, cancellable, NULL); + g_object_unref (cancellable); + g_object_unref (output); + + return FALSE; + } + + g_string_free (string, TRUE); + g_object_unref (output); + + return TRUE; +} + +/** + * gimp_vectors_export_string: + * @image: the #GimpImage from which to export vectors + * @vectors: a #GimpVectors object or %NULL to export all vectors in @image + * + * Exports one or more vectors to a SVG string. + * + * Return value: a %NUL-terminated string that holds a complete XML document + **/ +gchar * +gimp_vectors_export_string (GimpImage *image, + GimpVectors *vectors) +{ + g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); + g_return_val_if_fail (vectors == NULL || GIMP_IS_VECTORS (vectors), NULL); + + return g_string_free (gimp_vectors_export (image, vectors), FALSE); +} + +static GString * +gimp_vectors_export (GimpImage *image, + GimpVectors *vectors) +{ + GString *str = g_string_new (NULL); + + g_string_append_printf (str, + "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n" + "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 20010904//EN\"\n" + " \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n" + "\n" + "<svg xmlns=\"http://www.w3.org/2000/svg\"\n"); + + g_string_append (str, " "); + gimp_vectors_export_image_size (image, str); + g_string_append_c (str, '\n'); + + g_string_append_printf (str, + " viewBox=\"0 0 %d %d\">\n", + gimp_image_get_width (image), + gimp_image_get_height (image)); + + if (vectors) + { + gimp_vectors_export_path (vectors, str); + } + else + { + GList *list; + + for (list = gimp_image_get_vectors_iter (image); + list; + list = list->next) + { + gimp_vectors_export_path (GIMP_VECTORS (list->data), str); + } + } + + g_string_append (str, "</svg>\n"); + + return str; +} + +static void +gimp_vectors_export_image_size (GimpImage *image, + GString *str) +{ + GimpUnit unit; + const gchar *abbrev; + gchar wbuf[G_ASCII_DTOSTR_BUF_SIZE]; + gchar hbuf[G_ASCII_DTOSTR_BUF_SIZE]; + gdouble xres; + gdouble yres; + gdouble w, h; + + gimp_image_get_resolution (image, &xres, &yres); + + w = (gdouble) gimp_image_get_width (image) / xres; + h = (gdouble) gimp_image_get_height (image) / yres; + + /* FIXME: should probably use the display unit here */ + unit = gimp_image_get_unit (image); + switch (unit) + { + case GIMP_UNIT_INCH: abbrev = "in"; break; + case GIMP_UNIT_MM: abbrev = "mm"; break; + case GIMP_UNIT_POINT: abbrev = "pt"; break; + case GIMP_UNIT_PICA: abbrev = "pc"; break; + default: abbrev = "cm"; + unit = GIMP_UNIT_MM; + w /= 10.0; + h /= 10.0; + break; + } + + g_ascii_formatd (wbuf, sizeof (wbuf), "%g", w * gimp_unit_get_factor (unit)); + g_ascii_formatd (hbuf, sizeof (hbuf), "%g", h * gimp_unit_get_factor (unit)); + + g_string_append_printf (str, + "width=\"%s%s\" height=\"%s%s\"", + wbuf, abbrev, hbuf, abbrev); +} + +static void +gimp_vectors_export_path (GimpVectors *vectors, + GString *str) +{ + const gchar *name = gimp_object_get_name (vectors); + gchar *data = gimp_vectors_export_path_data (vectors); + gchar *esc_name; + + esc_name = g_markup_escape_text (name, strlen (name)); + + g_string_append_printf (str, + " <path id=\"%s\"\n" + " fill=\"none\" stroke=\"black\" stroke-width=\"1\"\n" + " d=\"%s\" />\n", + esc_name, data); + + g_free (esc_name); + g_free (data); +} + + +#define NEWLINE "\n " + +static gchar * +gimp_vectors_export_path_data (GimpVectors *vectors) +{ + GString *str; + GList *strokes; + gchar x_string[G_ASCII_DTOSTR_BUF_SIZE]; + gchar y_string[G_ASCII_DTOSTR_BUF_SIZE]; + gboolean closed = FALSE; + + str = g_string_new (NULL); + + for (strokes = vectors->strokes->head; + strokes; + strokes = strokes->next) + { + GimpStroke *stroke = strokes->data; + GArray *control_points; + GimpAnchor *anchor; + gint i; + + if (closed) + g_string_append_printf (str, NEWLINE); + + control_points = gimp_stroke_control_points_get (stroke, &closed); + + if (GIMP_IS_BEZIER_STROKE (stroke)) + { + if (control_points->len >= 3) + { + anchor = &g_array_index (control_points, GimpAnchor, 1); + g_ascii_formatd (x_string, G_ASCII_DTOSTR_BUF_SIZE, + "%.2f", anchor->position.x); + g_ascii_formatd (y_string, G_ASCII_DTOSTR_BUF_SIZE, + "%.2f", anchor->position.y); + g_string_append_printf (str, "M %s,%s", x_string, y_string); + } + + if (control_points->len > 3) + { + g_string_append_printf (str, NEWLINE "C"); + } + + for (i = 2; i < (control_points->len + (closed ? 2 : - 1)); i++) + { + if (i > 2 && i % 3 == 2) + g_string_append_printf (str, NEWLINE " "); + + anchor = &g_array_index (control_points, GimpAnchor, + i % control_points->len); + g_ascii_formatd (x_string, G_ASCII_DTOSTR_BUF_SIZE, + "%.2f", anchor->position.x); + g_ascii_formatd (y_string, G_ASCII_DTOSTR_BUF_SIZE, + "%.2f", anchor->position.y); + g_string_append_printf (str, " %s,%s", x_string, y_string); + } + + if (closed && control_points->len > 3) + g_string_append_printf (str, " Z"); + } + else + { + g_printerr ("Unknown stroke type\n"); + + if (control_points->len >= 1) + { + anchor = &g_array_index (control_points, GimpAnchor, 0); + g_ascii_formatd (x_string, G_ASCII_DTOSTR_BUF_SIZE, + ".2f", anchor->position.x); + g_ascii_formatd (y_string, G_ASCII_DTOSTR_BUF_SIZE, + ".2f", anchor->position.y); + g_string_append_printf (str, "M %s,%s", x_string, y_string); + } + + if (control_points->len > 1) + { + g_string_append_printf (str, NEWLINE "L"); + } + + for (i = 1; i < control_points->len; i++) + { + if (i > 1 && i % 3 == 1) + g_string_append_printf (str, NEWLINE " "); + + anchor = &g_array_index (control_points, GimpAnchor, i); + g_ascii_formatd (x_string, G_ASCII_DTOSTR_BUF_SIZE, + "%.2f", anchor->position.x); + g_ascii_formatd (y_string, G_ASCII_DTOSTR_BUF_SIZE, + "%.2f", anchor->position.y); + g_string_append_printf (str, " %s,%s", x_string, y_string); + } + + if (closed && control_points->len > 1) + g_string_append_printf (str, " Z"); + } + + g_array_free (control_points, TRUE); + } + + return g_strchomp (g_string_free (str, FALSE)); +} diff --git a/app/vectors/gimpvectors-export.h b/app/vectors/gimpvectors-export.h new file mode 100644 index 0000000..d61eae2 --- /dev/null +++ b/app/vectors/gimpvectors-export.h @@ -0,0 +1,30 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_EXPORT_H__ +#define __GIMP_VECTORS_EXPORT_H__ + + +gboolean gimp_vectors_export_file (GimpImage *image, + GimpVectors *vectors, + GFile *file, + GError **error); +gchar * gimp_vectors_export_string (GimpImage *image, + GimpVectors *vectors); + + +#endif /* __GIMP_VECTORS_IMPORT_H__ */ diff --git a/app/vectors/gimpvectors-import.c b/app/vectors/gimpvectors-import.c new file mode 100644 index 0000000..fa631ee --- /dev/null +++ b/app/vectors/gimpvectors-import.c @@ -0,0 +1,1784 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * GimpVectors Import + * Copyright (C) 2003-2004 Sven Neumann <sven@gimp.org> + * + * Some code here is based on code from librsvg that was originally + * written by Raph Levien <raph@artofcode.com> for Gill. + * + * This SVG path importer implements a subset of SVG that is + * sufficient to parse path elements and basic shapes and to apply + * transformations as described by the SVG specification: + * http://www.w3.org/TR/SVG/. It must handle the SVG files exported + * by GIMP but it is also supposed to be able to extract paths and + * shapes from foreign SVG documents. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <string.h> +#include <errno.h> + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "libgimpbase/gimpbase.h" +#include "libgimpmath/gimpmath.h" + +#include "vectors-types.h" + +#include "config/gimpxmlparser.h" + +#include "core/gimperror.h" +#include "core/gimpimage.h" +#include "core/gimpimage-undo.h" + +#include "gimpbezierstroke.h" +#include "gimpstroke.h" +#include "gimpvectors.h" +#include "gimpvectors-import.h" + +#include "gimp-intl.h" + + +#define COORDS_INIT \ + { \ + .x = 0.0, \ + .y = 0.0, \ + .pressure = 1.0, \ + .xtilt = 0.0, \ + .ytilt = 0.0, \ + .wheel = 0.5, \ + .velocity = 0.0, \ + .direction = 0.0 \ + } + + +typedef struct +{ + GQueue *stack; + GimpImage *image; + gboolean scale; + gint svg_depth; +} SvgParser; + + +typedef struct _SvgHandler SvgHandler; + +struct _SvgHandler +{ + const gchar *name; + + void (* start) (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); + void (* end) (SvgHandler *handler, + SvgParser *parser); + + gdouble width; + gdouble height; + gchar *id; + GList *paths; + GimpMatrix3 *transform; +}; + + +typedef struct +{ + gchar *id; + GList *strokes; +} SvgPath; + + +static gboolean gimp_vectors_import (GimpImage *image, + GFile *file, + const gchar *str, + gsize len, + gboolean merge, + gboolean scale, + GimpVectors *parent, + gint position, + GList **ret_vectors, + GError **error); + +static void svg_parser_start_element (GMarkupParseContext *context, + const gchar *element_name, + const gchar **attribute_names, + const gchar **attribute_values, + gpointer user_data, + GError **error); +static void svg_parser_end_element (GMarkupParseContext *context, + const gchar *element_name, + gpointer user_data, + GError **error); + +static const GMarkupParser markup_parser = +{ + svg_parser_start_element, + svg_parser_end_element, + NULL, /* characters */ + NULL, /* passthrough */ + NULL /* error */ +}; + + +static void svg_handler_svg_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); +static void svg_handler_svg_end (SvgHandler *handler, + SvgParser *parser); +static void svg_handler_group_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); +static void svg_handler_path_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); +static void svg_handler_rect_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); +static void svg_handler_ellipse_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); +static void svg_handler_line_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); +static void svg_handler_poly_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser); + +static const SvgHandler svg_handlers[] = +{ + { "svg", svg_handler_svg_start, svg_handler_svg_end }, + { "g", svg_handler_group_start, NULL }, + { "path", svg_handler_path_start, NULL }, + { "rect", svg_handler_rect_start, NULL }, + { "circle", svg_handler_ellipse_start, NULL }, + { "ellipse", svg_handler_ellipse_start, NULL }, + { "line", svg_handler_line_start, NULL }, + { "polyline", svg_handler_poly_start, NULL }, + { "polygon", svg_handler_poly_start, NULL } +}; + + +static gboolean parse_svg_length (const gchar *value, + gdouble reference, + gdouble resolution, + gdouble *length); +static gboolean parse_svg_viewbox (const gchar *value, + gdouble *width, + gdouble *height, + GimpMatrix3 *matrix); +static gboolean parse_svg_transform (const gchar *value, + GimpMatrix3 *matrix); +static GList * parse_path_data (const gchar *data); + + +/** + * gimp_vectors_import_file: + * @image: the #GimpImage to add the paths to + * @file: a SVG file + * @merge: should multiple paths be merged into a single #GimpVectors object + * @scale: should the SVG be scaled to fit the image dimensions + * @position: position in the image's vectors stack where to add the vectors + * @error: location to store possible errors + * + * Imports one or more paths and basic shapes from a SVG file. + * + * Return value: %TRUE on success, %FALSE if an error occurred + **/ +gboolean +gimp_vectors_import_file (GimpImage *image, + GFile *file, + gboolean merge, + gboolean scale, + GimpVectors *parent, + gint position, + GList **ret_vectors, + GError **error) +{ + g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + GIMP_IS_VECTORS (parent), FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + gimp_item_is_attached (GIMP_ITEM (parent)), FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + gimp_item_get_image (GIMP_ITEM (parent)) == image, + FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + gimp_viewable_get_children (GIMP_VIEWABLE (parent)), + FALSE); + g_return_val_if_fail (ret_vectors == NULL || *ret_vectors == NULL, FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + + return gimp_vectors_import (image, file, NULL, 0, merge, scale, + parent, position, + ret_vectors, error); +} + +/** + * gimp_vectors_import_string: + * @image: the #GimpImage to add the paths to + * @buffer: a character buffer to parse + * @len: number of bytes in @str or -1 if @str is %NUL-terminated + * @merge: should multiple paths be merged into a single #GimpVectors object + * @scale: should the SVG be scaled to fit the image dimensions + * @error: location to store possible errors + * + * Imports one or more paths and basic shapes from a SVG file. + * + * Return value: %TRUE on success, %FALSE if an error occurred + **/ +gboolean +gimp_vectors_import_buffer (GimpImage *image, + const gchar *buffer, + gsize len, + gboolean merge, + gboolean scale, + GimpVectors *parent, + gint position, + GList **ret_vectors, + GError **error) +{ + g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); + g_return_val_if_fail (buffer != NULL || len == 0, FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + GIMP_IS_VECTORS (parent), FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + gimp_item_is_attached (GIMP_ITEM (parent)), FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + gimp_item_get_image (GIMP_ITEM (parent)) == image, + FALSE); + g_return_val_if_fail (parent == NULL || + parent == GIMP_IMAGE_ACTIVE_PARENT || + gimp_viewable_get_children (GIMP_VIEWABLE (parent)), + FALSE); + g_return_val_if_fail (ret_vectors == NULL || *ret_vectors == NULL, FALSE); + g_return_val_if_fail (error == NULL || *error == NULL, FALSE); + + return gimp_vectors_import (image, NULL, buffer, len, merge, scale, + parent, position, + ret_vectors, error); +} + +static gboolean +gimp_vectors_import (GimpImage *image, + GFile *file, + const gchar *str, + gsize len, + gboolean merge, + gboolean scale, + GimpVectors *parent, + gint position, + GList **ret_vectors, + GError **error) +{ + GimpXmlParser *xml_parser; + SvgParser parser; + GList *paths; + SvgHandler *base; + gboolean success = TRUE; + + parser.stack = g_queue_new (); + parser.image = image; + parser.scale = scale; + parser.svg_depth = 0; + + /* the base of the stack, defines the size of the view-port */ + base = g_slice_new0 (SvgHandler); + base->name = "image"; + base->width = gimp_image_get_width (image); + base->height = gimp_image_get_height (image); + + g_queue_push_head (parser.stack, base); + + xml_parser = gimp_xml_parser_new (&markup_parser, &parser); + + if (file) + success = gimp_xml_parser_parse_gfile (xml_parser, file, error); + else + success = gimp_xml_parser_parse_buffer (xml_parser, str, len, error); + + gimp_xml_parser_free (xml_parser); + + if (success) + { + if (base->paths) + { + GimpVectors *vectors = NULL; + + base->paths = g_list_reverse (base->paths); + + merge = merge && base->paths->next; + + gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_VECTORS_IMPORT, + _("Import Paths")); + + for (paths = base->paths; paths; paths = paths->next) + { + SvgPath *path = paths->data; + GList *list; + + if (! merge || ! vectors) + { + vectors = gimp_vectors_new (image, + ((merge || ! path->id) ? + _("Imported Path") : path->id)); + gimp_image_add_vectors (image, vectors, + parent, position, TRUE); + gimp_vectors_freeze (vectors); + + if (ret_vectors) + *ret_vectors = g_list_prepend (*ret_vectors, vectors); + + if (position != -1) + position++; + } + + for (list = path->strokes; list; list = list->next) + gimp_vectors_stroke_add (vectors, GIMP_STROKE (list->data)); + + if (! merge) + gimp_vectors_thaw (vectors); + + g_list_free_full (path->strokes, g_object_unref); + path->strokes = NULL; + } + + if (merge) + gimp_vectors_thaw (vectors); + + gimp_image_undo_group_end (image); + } + else + { + if (file) + g_set_error (error, GIMP_ERROR, GIMP_FAILED, + _("No paths found in '%s'"), + gimp_file_get_utf8_name (file)); + else + g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, + _("No paths found in the buffer")); + + success = FALSE; + } + } + else if (error && *error && file) /* parser reported an error */ + { + gchar *msg = (*error)->message; + + (*error)->message = + g_strdup_printf (_("Failed to import paths from '%s': %s"), + gimp_file_get_utf8_name (file), msg); + + g_free (msg); + } + + while ((base = g_queue_pop_head (parser.stack)) != NULL) + { + for (paths = base->paths; paths; paths = paths->next) + { + SvgPath *path = paths->data; + GList *list; + + g_free (path->id); + + for (list = path->strokes; list; list = list->next) + g_object_unref (list->data); + + g_list_free (path->strokes); + + g_slice_free (SvgPath, path); + } + + g_list_free (base->paths); + + g_slice_free (GimpMatrix3, base->transform); + g_slice_free (SvgHandler, base); + } + + g_queue_free (parser.stack); + + return success; +} + +static void +svg_parser_start_element (GMarkupParseContext *context, + const gchar *element_name, + const gchar **attribute_names, + const gchar **attribute_values, + gpointer user_data, + GError **error) +{ + SvgParser *parser = user_data; + SvgHandler *handler; + SvgHandler *base; + gint i = 0; + + handler = g_slice_new0 (SvgHandler); + base = g_queue_peek_head (parser->stack); + + /* if the element is not rendered, always use the generic handler */ + if (base->width <= 0.0 || base->height <= 0.0) + i = G_N_ELEMENTS (svg_handlers); + + for (; i < G_N_ELEMENTS (svg_handlers); i++) + if (strcmp (svg_handlers[i].name, element_name) == 0) + { + handler->name = svg_handlers[i].name; + handler->start = svg_handlers[i].start; + break; + } + + handler->width = base->width; + handler->height = base->height; + + g_queue_push_head (parser->stack, handler); + + if (handler->start) + handler->start (handler, attribute_names, attribute_values, parser); +} + +static void +svg_parser_end_element (GMarkupParseContext *context, + const gchar *element_name, + gpointer user_data, + GError **error) +{ + SvgParser *parser = user_data; + SvgHandler *handler; + SvgHandler *base; + GList *paths; + + handler = g_queue_pop_head (parser->stack); + + g_return_if_fail (handler != NULL && + (handler->name == NULL || + strcmp (handler->name, element_name) == 0)); + + if (handler->end) + handler->end (handler, parser); + + if (handler->paths) + { + if (handler->transform) + { + for (paths = handler->paths; paths; paths = paths->next) + { + SvgPath *path = paths->data; + GList *list; + + for (list = path->strokes; list; list = list->next) + gimp_stroke_transform (GIMP_STROKE (list->data), + handler->transform, NULL); + } + + g_slice_free (GimpMatrix3, handler->transform); + } + + base = g_queue_peek_head (parser->stack); + base->paths = g_list_concat (base->paths, handler->paths); + } + + g_slice_free (SvgHandler, handler); +} + +static void +svg_handler_svg_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser) +{ + GimpMatrix3 *matrix; + GimpMatrix3 box; + const gchar *viewbox = NULL; + gdouble x = 0; + gdouble y = 0; + gdouble w = handler->width; + gdouble h = handler->height; + gdouble xres; + gdouble yres; + + matrix = g_slice_new (GimpMatrix3); + gimp_matrix3_identity (matrix); + + gimp_image_get_resolution (parser->image, &xres, &yres); + + while (*names) + { + switch (*names[0]) + { + case 'x': + if (strcmp (*names, "x") == 0) + parse_svg_length (*values, handler->width, xres, &x); + break; + + case 'y': + if (strcmp (*names, "y") == 0) + parse_svg_length (*values, handler->height, yres, &y); + break; + + case 'w': + if (strcmp (*names, "width") == 0) + parse_svg_length (*values, handler->width, xres, &w); + break; + + case 'h': + if (strcmp (*names, "height") == 0) + parse_svg_length (*values, handler->height, yres, &h); + break; + + case 'v': + if (strcmp (*names, "viewBox") == 0) + viewbox = *values; + break; + } + + names++; + values++; + } + + if (x || y) + { + /* according to the spec offsets are meaningless on the outermost svg */ + if (parser->svg_depth > 0) + gimp_matrix3_translate (matrix, x, y); + } + + if (viewbox && parse_svg_viewbox (viewbox, &w, &h, &box)) + { + gimp_matrix3_mult (&box, matrix); + } + + /* optionally scale the outermost svg to image size */ + if (parser->scale && parser->svg_depth == 0) + { + if (w > 0.0 && h > 0.0) + gimp_matrix3_scale (matrix, + gimp_image_get_width (parser->image) / w, + gimp_image_get_height (parser->image) / h); + } + + handler->width = w; + handler->height = h; + + handler->transform = matrix; + + parser->svg_depth++; +} + +static void +svg_handler_svg_end (SvgHandler *handler, + SvgParser *parser) +{ + parser->svg_depth--; +} + +static void +svg_handler_group_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser) +{ + while (*names) + { + if (strcmp (*names, "transform") == 0 && ! handler->transform) + { + GimpMatrix3 matrix; + + if (parse_svg_transform (*values, &matrix)) + { + handler->transform = g_slice_dup (GimpMatrix3, &matrix); + +#ifdef DEBUG_VECTORS_IMPORT + g_printerr ("transform %s: %g %g %g %g %g %g %g %g %g\n", + handler->id ? handler->id : "(null)", + handler->transform->coeff[0][0], + handler->transform->coeff[0][1], + handler->transform->coeff[0][2], + handler->transform->coeff[1][0], + handler->transform->coeff[1][1], + handler->transform->coeff[1][2], + handler->transform->coeff[2][0], + handler->transform->coeff[2][1], + handler->transform->coeff[2][2]); +#endif + } + } + + names++; + values++; + } +} + +static void +svg_handler_path_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser) +{ + SvgPath *path = g_slice_new0 (SvgPath); + + while (*names) + { + switch (*names[0]) + { + case 'i': + if (strcmp (*names, "id") == 0 && ! path->id) + path->id = g_strdup (*values); + break; + + case 'd': + if (strcmp (*names, "d") == 0 && ! path->strokes) + path->strokes = parse_path_data (*values); + break; + + case 't': + if (strcmp (*names, "transform") == 0 && ! handler->transform) + { + GimpMatrix3 matrix; + + if (parse_svg_transform (*values, &matrix)) + { + handler->transform = g_slice_dup (GimpMatrix3, &matrix); + } + } + break; + } + + names++; + values++; + } + + handler->paths = g_list_prepend (handler->paths, path); +} + +static void +svg_handler_rect_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser) +{ + SvgPath *path = g_slice_new0 (SvgPath); + gdouble x = 0.0; + gdouble y = 0.0; + gdouble width = 0.0; + gdouble height = 0.0; + gdouble rx = 0.0; + gdouble ry = 0.0; + gdouble xres; + gdouble yres; + + gimp_image_get_resolution (parser->image, &xres, &yres); + + while (*names) + { + switch (*names[0]) + { + case 'i': + if (strcmp (*names, "id") == 0 && ! path->id) + path->id = g_strdup (*values); + break; + + case 'x': + if (strcmp (*names, "x") == 0) + parse_svg_length (*values, handler->width, xres, &x); + break; + + case 'y': + if (strcmp (*names, "y") == 0) + parse_svg_length (*values, handler->height, yres, &y); + break; + + case 'w': + if (strcmp (*names, "width") == 0) + parse_svg_length (*values, handler->width, xres, &width); + break; + + case 'h': + if (strcmp (*names, "height") == 0) + parse_svg_length (*values, handler->height, yres, &height); + break; + + case 'r': + if (strcmp (*names, "rx") == 0) + parse_svg_length (*values, handler->width, xres, &rx); + else if (strcmp (*names, "ry") == 0) + parse_svg_length (*values, handler->height, yres, &ry); + break; + + case 't': + if (strcmp (*names, "transform") == 0 && ! handler->transform) + { + GimpMatrix3 matrix; + + if (parse_svg_transform (*values, &matrix)) + { + handler->transform = g_slice_dup (GimpMatrix3, &matrix); + } + } + break; + } + + names++; + values++; + } + + if (width > 0.0 && height > 0.0 && rx >= 0.0 && ry >= 0.0) + { + GimpStroke *stroke; + GimpCoords point = COORDS_INIT; + + if (rx == 0.0) + rx = ry; + if (ry == 0.0) + ry = rx; + + rx = MIN (rx, width / 2); + ry = MIN (ry, height / 2); + + point.x = x + width - rx; + point.y = y; + stroke = gimp_bezier_stroke_new_moveto (&point); + + if (rx) + { + GimpCoords end = COORDS_INIT; + + end.x = x + width; + end.y = y + ry; + + gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end); + } + + point.x = x + width; + point.y = y + height - ry; + gimp_bezier_stroke_lineto (stroke, &point); + + if (rx) + { + GimpCoords end = COORDS_INIT; + + end.x = x + width - rx; + end.y = y + height; + + gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end); + } + + point.x = x + rx; + point.y = y + height; + gimp_bezier_stroke_lineto (stroke, &point); + + if (rx) + { + GimpCoords end = COORDS_INIT; + + end.x = x; + end.y = y + height - ry; + + gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end); + } + + point.x = x; + point.y = y + ry; + gimp_bezier_stroke_lineto (stroke, &point); + + if (rx) + { + GimpCoords end = COORDS_INIT; + + end.x = x + rx; + end.y = y; + + gimp_bezier_stroke_arcto (stroke, rx, ry, 0, FALSE, TRUE, &end); + } + + /* the last line is handled by closing the stroke */ + gimp_stroke_close (stroke); + + path->strokes = g_list_prepend (path->strokes, stroke); + } + + handler->paths = g_list_prepend (handler->paths, path); +} + +static void +svg_handler_ellipse_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser) +{ + SvgPath *path = g_slice_new0 (SvgPath); + GimpCoords center = COORDS_INIT; + gdouble rx = 0.0; + gdouble ry = 0.0; + gdouble xres; + gdouble yres; + + gimp_image_get_resolution (parser->image, &xres, &yres); + + while (*names) + { + switch (*names[0]) + { + case 'i': + if (strcmp (*names, "id") == 0 && ! path->id) + path->id = g_strdup (*values); + break; + + case 'c': + if (strcmp (*names, "cx") == 0) + parse_svg_length (*values, handler->width, xres, ¢er.x); + else if (strcmp (*names, "cy") == 0) + parse_svg_length (*values, handler->height, yres, ¢er.y); + break; + + case 'r': + if (strcmp (*names, "r") == 0) + { + parse_svg_length (*values, handler->width, xres, &rx); + parse_svg_length (*values, handler->height, yres, &ry); + } + else if (strcmp (*names, "rx") == 0) + { + parse_svg_length (*values, handler->width, xres, &rx); + } + else if (strcmp (*names, "ry") == 0) + { + parse_svg_length (*values, handler->height, yres, &ry); + } + break; + + case 't': + if (strcmp (*names, "transform") == 0 && ! handler->transform) + { + GimpMatrix3 matrix; + + if (parse_svg_transform (*values, &matrix)) + { + handler->transform = g_slice_dup (GimpMatrix3, &matrix); + } + } + break; + } + + names++; + values++; + } + + if (rx >= 0.0 && ry >= 0.0) + path->strokes = g_list_prepend (path->strokes, + gimp_bezier_stroke_new_ellipse (¢er, + rx, ry, + 0.0)); + + handler->paths = g_list_prepend (handler->paths, path); +} + +static void +svg_handler_line_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser) +{ + SvgPath *path = g_slice_new0 (SvgPath); + GimpCoords start = COORDS_INIT; + GimpCoords end = COORDS_INIT; + GimpStroke *stroke; + gdouble xres; + gdouble yres; + + gimp_image_get_resolution (parser->image, &xres, &yres); + + while (*names) + { + switch (*names[0]) + { + case 'i': + if (strcmp (*names, "id") == 0 && ! path->id) + path->id = g_strdup (*values); + break; + + case 'x': + if (strcmp (*names, "x1") == 0) + parse_svg_length (*values, handler->width, xres, &start.x); + else if (strcmp (*names, "x2") == 0) + parse_svg_length (*values, handler->width, xres, &end.x); + break; + + case 'y': + if (strcmp (*names, "y1") == 0) + parse_svg_length (*values, handler->height, yres, &start.y); + else if (strcmp (*names, "y2") == 0) + parse_svg_length (*values, handler->height, yres, &end.y); + break; + + case 't': + if (strcmp (*names, "transform") == 0 && ! handler->transform) + { + GimpMatrix3 matrix; + + if (parse_svg_transform (*values, &matrix)) + { + handler->transform = g_slice_dup (GimpMatrix3, &matrix); + } + } + break; + } + + names++; + values++; + } + + stroke = gimp_bezier_stroke_new_moveto (&start); + gimp_bezier_stroke_lineto (stroke, &end); + + path->strokes = g_list_prepend (path->strokes, stroke); + + handler->paths = g_list_prepend (handler->paths, path); +} + +static void +svg_handler_poly_start (SvgHandler *handler, + const gchar **names, + const gchar **values, + SvgParser *parser) +{ + SvgPath *path = g_slice_new0 (SvgPath); + GString *points = NULL; + + while (*names) + { + switch (*names[0]) + { + case 'i': + if (strcmp (*names, "id") == 0 && ! path->id) + path->id = g_strdup (*values); + break; + + case 'p': + if (strcmp (*names, "points") == 0 && ! points) + { + const gchar *p = *values; + const gchar *m = NULL; + const gchar *l = NULL; + gint n = 0; + + while (*p) + { + while (g_ascii_isspace (*p) || *p == ',') + p++; + + switch (n) + { + case 0: + m = p; + break; + case 2: + l = p; + break; + } + + if (*p) + n++; + + while (*p && ! g_ascii_isspace (*p) && *p != ',') + p++; + } + + if ((n > 3) && (n % 2 == 0)) + { + points = g_string_sized_new (p - *values + 8); + + g_string_append_len (points, "M ", 2); + g_string_append_len (points, m, l - m); + + g_string_append_len (points, "L ", 2); + g_string_append_len (points, l, p - l); + + if (strcmp (handler->name, "polygon") == 0) + g_string_append_c (points, 'Z'); + } + } + break; + + case 't': + if (strcmp (*names, "transform") == 0 && ! handler->transform) + { + GimpMatrix3 matrix; + + if (parse_svg_transform (*values, &matrix)) + { + handler->transform = g_slice_dup (GimpMatrix3, &matrix); + } + } + break; + } + + names++; + values++; + } + + if (points) + { + path->strokes = parse_path_data (points->str); + g_string_free (points, TRUE); + } + + handler->paths = g_list_prepend (handler->paths, path); +} + +static gboolean +parse_svg_length (const gchar *value, + gdouble reference, + gdouble resolution, + gdouble *length) +{ + GimpUnit unit = GIMP_UNIT_PIXEL; + gdouble len; + gchar *ptr; + + len = g_ascii_strtod (value, &ptr); + + while (g_ascii_isspace (*ptr)) + ptr++; + + switch (ptr[0]) + { + case '\0': + break; + + case 'p': + switch (ptr[1]) + { + case 'x': break; + case 't': unit = GIMP_UNIT_POINT; break; + case 'c': unit = GIMP_UNIT_PICA; break; + default: + return FALSE; + } + ptr += 2; + break; + + case 'c': + if (ptr[1] == 'm') + len *= 10.0, unit = GIMP_UNIT_MM; + else + return FALSE; + ptr += 2; + break; + + case 'm': + if (ptr[1] == 'm') + unit = GIMP_UNIT_MM; + else + return FALSE; + ptr += 2; + break; + + case 'i': + if (ptr[1] == 'n') + unit = GIMP_UNIT_INCH; + else + return FALSE; + ptr += 2; + break; + + case '%': + unit = GIMP_UNIT_PERCENT; + ptr += 1; + break; + + default: + return FALSE; + } + + while (g_ascii_isspace (*ptr)) + ptr++; + + if (*ptr) + return FALSE; + + switch (unit) + { + case GIMP_UNIT_PERCENT: + *length = len * reference / 100.0; + break; + + case GIMP_UNIT_PIXEL: + *length = len; + break; + + default: + *length = len * resolution / gimp_unit_get_factor (unit); + break; + } + + return TRUE; +} + +static gboolean +parse_svg_viewbox (const gchar *value, + gdouble *width, + gdouble *height, + GimpMatrix3 *matrix) +{ + gdouble x, y, w, h; + gchar *tok; + gchar *str = g_strdup (value); + gboolean success = FALSE; + + x = y = w = h = 0; + + tok = strtok (str, ", \t"); + if (tok) + { + x = g_ascii_strtod (tok, NULL); + tok = strtok (NULL, ", \t"); + if (tok) + { + y = g_ascii_strtod (tok, NULL); + tok = strtok (NULL, ", \t"); + if (tok != NULL) + { + w = g_ascii_strtod (tok, NULL); + tok = strtok (NULL, ", \t"); + if (tok) + { + h = g_ascii_strtod (tok, NULL); + success = TRUE; + } + } + } + } + + g_free (str); + + if (success) + { + gimp_matrix3_identity (matrix); + gimp_matrix3_translate (matrix, -x, -y); + + if (w > 0.0 && h > 0.0) + { + gimp_matrix3_scale (matrix, *width / w, *height / h); + } + else /* disable rendering of the element */ + { +#ifdef DEBUG_VECTORS_IMPORT + g_printerr ("empty viewBox"); +#endif + *width = *height = 0.0; + } + } + else + { + g_printerr ("SVG import: cannot parse viewBox attribute\n"); + } + + return success; +} + +static gboolean +parse_svg_transform (const gchar *value, + GimpMatrix3 *matrix) +{ + gint i; + + gimp_matrix3_identity (matrix); + + for (i = 0; value[i]; i++) + { + GimpMatrix3 trafo; + gchar keyword[32]; + gdouble args[6]; + gint n_args; + gint key_len; + + gimp_matrix3_identity (&trafo); + + /* skip initial whitespace */ + while (g_ascii_isspace (value[i])) + i++; + + /* parse keyword */ + for (key_len = 0; key_len < sizeof (keyword); key_len++) + { + gchar c = value[i]; + + if (g_ascii_isalpha (c) || c == '-') + keyword[key_len] = value[i++]; + else + break; + } + + if (key_len >= sizeof (keyword)) + return FALSE; + + keyword[key_len] = '\0'; + + /* skip whitespace */ + while (g_ascii_isspace (value[i])) + i++; + + if (value[i] != '(') + return FALSE; + i++; + + for (n_args = 0; ; n_args++) + { + gchar c; + gchar *end_ptr; + + /* skip whitespace */ + while (g_ascii_isspace (value[i])) + i++; + + c = value[i]; + if (g_ascii_isdigit (c) || c == '+' || c == '-' || c == '.') + { + if (n_args == G_N_ELEMENTS (args)) + return FALSE; /* too many args */ + + args[n_args] = g_ascii_strtod (value + i, &end_ptr); + i = end_ptr - value; + + while (g_ascii_isspace (value[i])) + i++; + + /* skip optional comma */ + if (value[i] == ',') + i++; + } + else if (c == ')') + break; + else + return FALSE; + } + + /* OK, have parsed keyword and args, now calculate the transform matrix */ + + if (strcmp (keyword, "matrix") == 0) + { + if (n_args != 6) + return FALSE; + + gimp_matrix3_affine (&trafo, + args[0], args[1], + args[2], args[3], + args[4], args[5]); + } + else if (strcmp (keyword, "translate") == 0) + { + if (n_args == 1) + args[1] = 0.0; + else if (n_args != 2) + return FALSE; + + gimp_matrix3_translate (&trafo, args[0], args[1]); + } + else if (strcmp (keyword, "scale") == 0) + { + if (n_args == 1) + args[1] = args[0]; + else if (n_args != 2) + return FALSE; + + gimp_matrix3_scale (&trafo, args[0], args[1]); + } + else if (strcmp (keyword, "rotate") == 0) + { + if (n_args == 1) + { + gimp_matrix3_rotate (&trafo, gimp_deg_to_rad (args[0])); + } + else if (n_args == 3) + { + gimp_matrix3_translate (&trafo, -args[1], -args[2]); + gimp_matrix3_rotate (&trafo, gimp_deg_to_rad (args[0])); + gimp_matrix3_translate (&trafo, args[1], args[2]); + } + else + return FALSE; + } + else if (strcmp (keyword, "skewX") == 0) + { + if (n_args != 1) + return FALSE; + + gimp_matrix3_xshear (&trafo, tan (gimp_deg_to_rad (args[0]))); + } + else if (strcmp (keyword, "skewY") == 0) + { + if (n_args != 1) + return FALSE; + + gimp_matrix3_yshear (&trafo, tan (gimp_deg_to_rad (args[0]))); + } + else + { + return FALSE; /* unknown keyword */ + } + + gimp_matrix3_invert (&trafo); + gimp_matrix3_mult (&trafo, matrix); + } + + gimp_matrix3_invert (matrix); + + return TRUE; +} + + +/**********************************************************/ +/* Below is the code that parses the actual path data. */ +/* */ +/* This code is taken from librsvg and was originally */ +/* written by Raph Levien <raph@artofcode.com> for Gill. */ +/**********************************************************/ + +typedef struct +{ + GList *strokes; + GimpStroke *stroke; + gdouble cpx, cpy; /* current point */ + gdouble rpx, rpy; /* reflection point (for 's' and 't' commands) */ + gchar cmd; /* current command (lowercase) */ + gint param; /* number of parameters */ + gboolean rel; /* true if relative coords */ + gdouble params[7]; /* parameters that have been parsed */ +} ParsePathContext; + + +static void parse_path_default_xy (ParsePathContext *ctx, + gint n_params); +static void parse_path_do_cmd (ParsePathContext *ctx, + gboolean final); + + +static GList * +parse_path_data (const gchar *data) +{ + ParsePathContext ctx; + + gboolean in_num = FALSE; + gboolean in_frac = FALSE; + gboolean in_exp = FALSE; + gboolean exp_wait_sign = FALSE; + gdouble val = 0.0; + gchar c = 0; + gint sign = 0; + gint exp = 0; + gint exp_sign = 0; + gdouble frac = 0.0; + gint i; + + memset (&ctx, 0, sizeof (ParsePathContext)); + + for (i = 0; ; i++) + { + c = data[i]; + + if (c >= '0' && c <= '9') + { + /* digit */ + if (in_num) + { + if (in_exp) + { + exp = (exp * 10) + c - '0'; + exp_wait_sign = FALSE; + } + else if (in_frac) + val += (frac *= 0.1) * (c - '0'); + else + val = (val * 10) + c - '0'; + } + else + { + in_num = TRUE; + in_frac = FALSE; + in_exp = FALSE; + exp = 0; + exp_sign = 1; + exp_wait_sign = FALSE; + val = c - '0'; + sign = 1; + } + } + else if (c == '.') + { + if (! in_num) + { + in_num = TRUE; + val = 0; + } + + in_frac = TRUE; + frac = 1; + } + else if ((c == 'E' || c == 'e') && in_num) + { + in_exp = TRUE; + exp_wait_sign = TRUE; + exp = 0; + exp_sign = 1; + } + else if ((c == '+' || c == '-') && in_exp) + { + exp_sign = c == '+' ? 1 : -1; + } + else if (in_num) + { + /* end of number */ + + val *= sign * pow (10, exp_sign * exp); + + if (ctx.rel) + { + /* Handle relative coordinates. This switch statement attempts + to determine _what_ the coords are relative to. This is + underspecified in the 12 Apr working draft. */ + switch (ctx.cmd) + { + case 'l': + case 'm': + case 'c': + case 's': + case 'q': + case 't': + /* rule: even-numbered params are x-relative, odd-numbered + are y-relative */ + if ((ctx.param & 1) == 0) + val += ctx.cpx; + else if ((ctx.param & 1) == 1) + val += ctx.cpy; + break; + + case 'a': + /* rule: sixth and seventh are x and y, rest are not + relative */ + if (ctx.param == 5) + val += ctx.cpx; + else if (ctx.param == 6) + val += ctx.cpy; + break; + + case 'h': + /* rule: x-relative */ + val += ctx.cpx; + break; + + case 'v': + /* rule: y-relative */ + val += ctx.cpy; + break; + } + } + + ctx.params[ctx.param++] = val; + parse_path_do_cmd (&ctx, FALSE); + in_num = FALSE; + } + + if (c == '\0') + { + break; + } + else if ((c == '+' || c == '-') && ! exp_wait_sign) + { + sign = c == '+' ? 1 : -1; + val = 0; + in_num = TRUE; + in_frac = FALSE; + in_exp = FALSE; + exp = 0; + exp_sign = 1; + exp_wait_sign = FALSE; + } + else if (c == 'z' || c == 'Z') + { + if (ctx.param) + parse_path_do_cmd (&ctx, TRUE); + + if (ctx.stroke) + gimp_stroke_close (ctx.stroke); + } + else if (c >= 'A' && c <= 'Z' && c != 'E') + { + if (ctx.param) + parse_path_do_cmd (&ctx, TRUE); + + ctx.cmd = c + 'a' - 'A'; + ctx.rel = FALSE; + } + else if (c >= 'a' && c <= 'z' && c != 'e') + { + if (ctx.param) + parse_path_do_cmd (&ctx, TRUE); + + ctx.cmd = c; + ctx.rel = TRUE; + } + /* else c _should_ be whitespace or , */ + } + + return g_list_reverse (ctx.strokes); +} + +/* supply defaults for missing parameters, assuming relative coordinates + are to be interpreted as x,y */ +static void +parse_path_default_xy (ParsePathContext *ctx, + gint n_params) +{ + gint i; + + if (ctx->rel) + { + for (i = ctx->param; i < n_params; i++) + { + if (i > 2) + ctx->params[i] = ctx->params[i - 2]; + else if (i == 1) + ctx->params[i] = ctx->cpy; + else if (i == 0) + /* we shouldn't get here (ctx->param > 0 as precondition) */ + ctx->params[i] = ctx->cpx; + } + } + else + { + for (i = ctx->param; i < n_params; i++) + ctx->params[i] = 0.0; + } +} + +static void +parse_path_do_cmd (ParsePathContext *ctx, + gboolean final) +{ + GimpCoords coords = COORDS_INIT; + + switch (ctx->cmd) + { + case 'm': + /* moveto */ + if (ctx->param == 2 || final) + { + parse_path_default_xy (ctx, 2); + + coords.x = ctx->cpx = ctx->rpx = ctx->params[0]; + coords.y = ctx->cpy = ctx->rpy = ctx->params[1]; + + ctx->stroke = gimp_bezier_stroke_new_moveto (&coords); + ctx->strokes = g_list_prepend (ctx->strokes, ctx->stroke); + + ctx->param = 0; + + /* If a moveto is followed by multiple pairs of coordinates, + * the subsequent pairs are treated as implicit lineto commands. + */ + ctx->cmd = 'l'; + } + break; + + case 'l': + /* lineto */ + if (ctx->param == 2 || final) + { + parse_path_default_xy (ctx, 2); + + coords.x = ctx->cpx = ctx->rpx = ctx->params[0]; + coords.y = ctx->cpy = ctx->rpy = ctx->params[1]; + + gimp_bezier_stroke_lineto (ctx->stroke, &coords); + + ctx->param = 0; + } + break; + + case 'c': + /* curveto */ + if (ctx->param == 6 || final) + { + GimpCoords ctrl1 = COORDS_INIT; + GimpCoords ctrl2 = COORDS_INIT; + + parse_path_default_xy (ctx, 6); + + ctrl1.x = ctx->params[0]; + ctrl1.y = ctx->params[1]; + ctrl2.x = ctx->rpx = ctx->params[2]; + ctrl2.y = ctx->rpy = ctx->params[3]; + coords.x = ctx->cpx = ctx->params[4]; + coords.y = ctx->cpy = ctx->params[5]; + + gimp_bezier_stroke_cubicto (ctx->stroke, &ctrl1, &ctrl2, &coords); + + ctx->param = 0; + } + break; + + case 's': + /* smooth curveto */ + if (ctx->param == 4 || final) + { + GimpCoords ctrl1 = COORDS_INIT; + GimpCoords ctrl2 = COORDS_INIT; + + parse_path_default_xy (ctx, 4); + + ctrl1.x = 2 * ctx->cpx - ctx->rpx; + ctrl1.y = 2 * ctx->cpy - ctx->rpy; + ctrl2.x = ctx->rpx = ctx->params[0]; + ctrl2.y = ctx->rpy = ctx->params[1]; + coords.x = ctx->cpx = ctx->params[2]; + coords.y = ctx->cpy = ctx->params[3]; + + gimp_bezier_stroke_cubicto (ctx->stroke, &ctrl1, &ctrl2, &coords); + + ctx->param = 0; + } + break; + + case 'h': + /* horizontal lineto */ + if (ctx->param == 1) + { + coords.x = ctx->cpx = ctx->rpx = ctx->params[0]; + coords.y = ctx->cpy; + + gimp_bezier_stroke_lineto (ctx->stroke, &coords); + + ctx->param = 0; + } + break; + + case 'v': + /* vertical lineto */ + if (ctx->param == 1) + { + coords.x = ctx->cpx; + coords.y = ctx->cpy = ctx->rpy = ctx->params[0]; + + gimp_bezier_stroke_lineto (ctx->stroke, &coords); + + ctx->param = 0; + } + break; + + case 'q': + /* quadratic bezier curveto */ + if (ctx->param == 4 || final) + { + GimpCoords ctrl = COORDS_INIT; + + parse_path_default_xy (ctx, 4); + + ctrl.x = ctx->rpx = ctx->params[0]; + ctrl.y = ctx->rpy = ctx->params[1]; + coords.x = ctx->cpx = ctx->params[2]; + coords.y = ctx->cpy = ctx->params[3]; + + gimp_bezier_stroke_conicto (ctx->stroke, &ctrl, &coords); + + ctx->param = 0; + } + break; + + case 't': + /* truetype quadratic bezier curveto */ + if (ctx->param == 2 || final) + { + GimpCoords ctrl = COORDS_INIT; + + parse_path_default_xy (ctx, 2); + + ctrl.x = ctx->rpx = 2 * ctx->cpx - ctx->rpx; + ctrl.y = ctx->rpy = 2 * ctx->cpy - ctx->rpy; + coords.x = ctx->cpx = ctx->params[0]; + coords.y = ctx->cpy = ctx->params[1]; + + gimp_bezier_stroke_conicto (ctx->stroke, &ctrl, &coords); + + ctx->param = 0; + } + else if (final) + { + if (ctx->param > 2) + { + GimpCoords ctrl = COORDS_INIT; + + parse_path_default_xy (ctx, 4); + + ctrl.x = ctx->rpx = ctx->params[0]; + ctrl.y = ctx->rpy = ctx->params[1]; + coords.x = ctx->cpx = ctx->params[2]; + coords.y = ctx->cpy = ctx->params[3]; + + gimp_bezier_stroke_conicto (ctx->stroke, &ctrl, &coords); + } + else + { + parse_path_default_xy (ctx, 2); + + coords.x = ctx->cpx = ctx->rpx = ctx->params[0]; + coords.y = ctx->cpy = ctx->rpy = ctx->params[1]; + + gimp_bezier_stroke_lineto (ctx->stroke, &coords); + } + + ctx->param = 0; + } + break; + + case 'a': + if (ctx->param == 7 || final) + { + coords.x = ctx->cpx = ctx->rpx = ctx->params[5]; + coords.y = ctx->cpy = ctx->rpy = ctx->params[6]; + + gimp_bezier_stroke_arcto (ctx->stroke, + ctx->params[0], ctx->params[1], + gimp_deg_to_rad (ctx->params[2]), + ctx->params[3], ctx->params[4], + &coords); + ctx->param = 0; + } + break; + + default: + ctx->param = 0; + break; + } +} diff --git a/app/vectors/gimpvectors-import.h b/app/vectors/gimpvectors-import.h new file mode 100644 index 0000000..1d7f8a6 --- /dev/null +++ b/app/vectors/gimpvectors-import.h @@ -0,0 +1,44 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * GimpVectors Import + * Copyright (C) 2003 Sven Neumann <sven@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_IMPORT_H__ +#define __GIMP_VECTORS_IMPORT_H__ + + +gboolean gimp_vectors_import_file (GimpImage *image, + GFile *file, + gboolean merge, + gboolean scale, + GimpVectors *parent, + gint position, + GList **ret_vectors, + GError **error); +gboolean gimp_vectors_import_buffer (GimpImage *image, + const gchar *buffer, + gsize len, + gboolean merge, + gboolean scale, + GimpVectors *parent, + gint position, + GList **ret_vectors, + GError **error); + + +#endif /* __GIMP_VECTORS_IMPORT_H__ */ diff --git a/app/vectors/gimpvectors-preview.c b/app/vectors/gimpvectors-preview.c new file mode 100644 index 0000000..988148a --- /dev/null +++ b/app/vectors/gimpvectors-preview.c @@ -0,0 +1,93 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <string.h> + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "vectors-types.h" + +#include "libgimpmath/gimpmath.h" + +#include "core/gimpimage.h" +#include "core/gimptempbuf.h" + +#include "gimpstroke.h" +#include "gimpvectors.h" +#include "gimpvectors-preview.h" + + +/* public functions */ + +GimpTempBuf * +gimp_vectors_get_new_preview (GimpViewable *viewable, + GimpContext *context, + gint width, + gint height) +{ + GimpVectors *vectors; + GimpItem *item; + GimpStroke *cur_stroke; + gdouble xscale, yscale; + guchar *data; + GimpTempBuf *temp_buf; + + vectors = GIMP_VECTORS (viewable); + item = GIMP_ITEM (viewable); + + xscale = ((gdouble) width) / gimp_image_get_width (gimp_item_get_image (item)); + yscale = ((gdouble) height) / gimp_image_get_height (gimp_item_get_image (item)); + + temp_buf = gimp_temp_buf_new (width, height, babl_format ("Y' u8")); + data = gimp_temp_buf_get_data (temp_buf); + memset (data, 255, width * height); + + for (cur_stroke = gimp_vectors_stroke_get_next (vectors, NULL); + cur_stroke; + cur_stroke = gimp_vectors_stroke_get_next (vectors, cur_stroke)) + { + GArray *coords; + gboolean closed; + gint i; + + coords = gimp_stroke_interpolate (cur_stroke, 0.5, &closed); + + if (coords) + { + for (i = 0; i < coords->len; i++) + { + GimpCoords point; + gint x, y; + + point = g_array_index (coords, GimpCoords, i); + + x = ROUND (point.x * xscale); + y = ROUND (point.y * yscale); + + if (x >= 0 && y >= 0 && x < width && y < height) + data[y * width + x] = 0; + } + + g_array_free (coords, TRUE); + } + } + + return temp_buf; +} diff --git a/app/vectors/gimpvectors-preview.h b/app/vectors/gimpvectors-preview.h new file mode 100644 index 0000000..f934d8e --- /dev/null +++ b/app/vectors/gimpvectors-preview.h @@ -0,0 +1,32 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_PREVIEW_H__ +#define __GIMP_VECTORS_PREVIEW_H__ + + +/* + * virtual function of GimpVectors -- don't call directly + */ + +GimpTempBuf * gimp_vectors_get_new_preview (GimpViewable *viewable, + GimpContext *context, + gint width, + gint height); + + +#endif /* __GIMP_VECTORS_PREVIEW_H__ */ diff --git a/app/vectors/gimpvectors-warp.c b/app/vectors/gimpvectors-warp.c new file mode 100644 index 0000000..aeb8dec --- /dev/null +++ b/app/vectors/gimpvectors-warp.c @@ -0,0 +1,210 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpvectors-warp.c + * Copyright (C) 2005 Bill Skaggs <weskaggs@primate.ucdavis.edu> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "vectors-types.h" + +#include "libgimpmath/gimpmath.h" + +#include "core/gimp-utils.h" +#include "core/gimpcoords.h" + +#include "gimpanchor.h" +#include "gimpstroke.h" +#include "gimpvectors.h" +#include "gimpvectors-warp.h" + + +#define EPSILON 0.2 +#define DX 2.0 + + +static void gimp_stroke_warp_point (GimpStroke *stroke, + gdouble x, + gdouble y, + GimpCoords *point_warped, + gdouble y_offset, + gdouble x_len); + +static void gimp_vectors_warp_stroke (GimpVectors *vectors, + GimpStroke *stroke, + gdouble y_offset); + + +void +gimp_vectors_warp_point (GimpVectors *vectors, + GimpCoords *point, + GimpCoords *point_warped, + gdouble y_offset) +{ + gdouble x = point->x; + gdouble y = point->y; + gdouble len; + GList *list; + GimpStroke *stroke; + + for (list = vectors->strokes->head; + list; + list = g_list_next (list)) + { + stroke = list->data; + + len = gimp_vectors_stroke_get_length (vectors, stroke); + + if (x < len || ! list->next) + break; + + x -= len; + } + + if (! list) + { + point_warped->x = 0; + point_warped->y = 0; + return; + } + + gimp_stroke_warp_point (stroke, x, y, point_warped, y_offset, len); +} + +static void +gimp_stroke_warp_point (GimpStroke *stroke, + gdouble x, + gdouble y, + GimpCoords *point_warped, + gdouble y_offset, + gdouble x_len) +{ + GimpCoords point_zero = { 0, }; + GimpCoords point_minus = { 0, }; + GimpCoords point_plus = { 0, }; + gdouble slope; + gdouble dx, dy, nx, ny, len; + + if (x + DX >= x_len) + { + gdouble tx, ty; + + if (! gimp_stroke_get_point_at_dist (stroke, x_len, EPSILON, + &point_zero, &slope)) + { + point_warped->x = 0; + point_warped->y = 0; + return; + } + + point_warped->x = point_zero.x; + point_warped->y = point_zero.y; + + if (! gimp_stroke_get_point_at_dist (stroke, x_len - DX, EPSILON, + &point_minus, &slope)) + return; + + dx = point_zero.x - point_minus.x; + dy = point_zero.y - point_minus.y; + + len = hypot (dx, dy); + + if (len < 0.01) + return; + + tx = dx / len; + ty = dy / len; + + nx = - dy / len; + ny = dx / len; + + point_warped->x += tx * (x - x_len) + nx * (y - y_offset); + point_warped->y += ty * (x - x_len) + ny * (y - y_offset); + + return; + } + + if (! gimp_stroke_get_point_at_dist (stroke, x, EPSILON, + &point_zero, &slope)) + { + point_warped->x = 0; + point_warped->y = 0; + return; + } + + point_warped->x = point_zero.x; + point_warped->y = point_zero.y; + + if (! gimp_stroke_get_point_at_dist (stroke, x - DX, EPSILON, + &point_minus, &slope)) + return; + + if (! gimp_stroke_get_point_at_dist (stroke, x + DX, EPSILON, + &point_plus, &slope)) + return; + + dx = point_plus.x - point_minus.x; + dy = point_plus.y - point_minus.y; + + len = hypot (dx, dy); + + if (len < 0.01) + return; + + nx = - dy / len; + ny = dx / len; + + point_warped->x = point_zero.x + nx * (y - y_offset); + point_warped->y = point_zero.y + ny * (y - y_offset); +} + +static void +gimp_vectors_warp_stroke (GimpVectors *vectors, + GimpStroke *stroke, + gdouble y_offset) +{ + GList *list; + + for (list = stroke->anchors->head; list; list = g_list_next (list)) + { + GimpAnchor *anchor = list->data; + + gimp_vectors_warp_point (vectors, + &anchor->position, &anchor->position, + y_offset); + } +} + +void +gimp_vectors_warp_vectors (GimpVectors *vectors, + GimpVectors *vectors_in, + gdouble y_offset) +{ + GList *list; + + for (list = vectors_in->strokes->head; + list; + list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_vectors_warp_stroke (vectors, stroke, y_offset); + } +} diff --git a/app/vectors/gimpvectors-warp.h b/app/vectors/gimpvectors-warp.h new file mode 100644 index 0000000..12b8993 --- /dev/null +++ b/app/vectors/gimpvectors-warp.h @@ -0,0 +1,36 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpvectors-warp.h + * Copyright (C) 2005 Bill Skaggs <weskaggs@primate.ucdavis.edu> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_WARP_H__ +#define __GIMP_VECTORS_WARP_H__ + + +void gimp_vectors_warp_point (GimpVectors *vectors, + GimpCoords *point, + GimpCoords *point_warped, + gdouble y_offset); + +void gimp_vectors_warp_vectors (GimpVectors *vectors, + GimpVectors *vectors_in, + gdouble yoffset); + + +#endif /* __GIMP_VECTORS_WARP_H__ */ + diff --git a/app/vectors/gimpvectors.c b/app/vectors/gimpvectors.c new file mode 100644 index 0000000..1a65eac --- /dev/null +++ b/app/vectors/gimpvectors.c @@ -0,0 +1,1255 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpvectors.c + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <cairo.h> +#include <gegl.h> +#include <gdk-pixbuf/gdk-pixbuf.h> + +#include "libgimpcolor/gimpcolor.h" +#include "libgimpmath/gimpmath.h" + +#include "vectors-types.h" + +#include "core/gimp.h" +#include "core/gimp-transform-utils.h" +#include "core/gimpbezierdesc.h" +#include "core/gimpchannel-select.h" +#include "core/gimpcontainer.h" +#include "core/gimpcontext.h" +#include "core/gimpdrawable-fill.h" +#include "core/gimpdrawable-stroke.h" +#include "core/gimperror.h" +#include "core/gimpimage.h" +#include "core/gimpimage-undo-push.h" +#include "core/gimpmarshal.h" +#include "core/gimppaintinfo.h" +#include "core/gimpstrokeoptions.h" + +#include "paint/gimppaintcore-stroke.h" +#include "paint/gimppaintoptions.h" + +#include "gimpanchor.h" +#include "gimpstroke.h" +#include "gimpvectors.h" +#include "gimpvectors-preview.h" + +#include "gimp-intl.h" + + +enum +{ + FREEZE, + THAW, + LAST_SIGNAL +}; + + +static void gimp_vectors_finalize (GObject *object); + +static gint64 gimp_vectors_get_memsize (GimpObject *object, + gint64 *gui_size); + +static gboolean gimp_vectors_is_attached (GimpItem *item); +static GimpItemTree * gimp_vectors_get_tree (GimpItem *item); +static gboolean gimp_vectors_bounds (GimpItem *item, + gdouble *x, + gdouble *y, + gdouble *width, + gdouble *height); +static GimpItem * gimp_vectors_duplicate (GimpItem *item, + GType new_type); +static void gimp_vectors_convert (GimpItem *item, + GimpImage *dest_image, + GType old_type); +static void gimp_vectors_translate (GimpItem *item, + gdouble offset_x, + gdouble offset_y, + gboolean push_undo); +static void gimp_vectors_scale (GimpItem *item, + gint new_width, + gint new_height, + gint new_offset_x, + gint new_offset_y, + GimpInterpolationType interp_type, + GimpProgress *progress); +static void gimp_vectors_resize (GimpItem *item, + GimpContext *context, + GimpFillType fill_type, + gint new_width, + gint new_height, + gint offset_x, + gint offset_y); +static void gimp_vectors_flip (GimpItem *item, + GimpContext *context, + GimpOrientationType flip_type, + gdouble axis, + gboolean clip_result); +static void gimp_vectors_rotate (GimpItem *item, + GimpContext *context, + GimpRotationType rotate_type, + gdouble center_x, + gdouble center_y, + gboolean clip_result); +static void gimp_vectors_transform (GimpItem *item, + GimpContext *context, + const GimpMatrix3 *matrix, + GimpTransformDirection direction, + GimpInterpolationType interp_type, + GimpTransformResize clip_result, + GimpProgress *progress); +static GimpTransformResize + gimp_vectors_get_clip (GimpItem *item, + GimpTransformResize clip_result); +static gboolean gimp_vectors_fill (GimpItem *item, + GimpDrawable *drawable, + GimpFillOptions *fill_options, + gboolean push_undo, + GimpProgress *progress, + GError **error); +static gboolean gimp_vectors_stroke (GimpItem *item, + GimpDrawable *drawable, + GimpStrokeOptions *stroke_options, + gboolean push_undo, + GimpProgress *progress, + GError **error); +static void gimp_vectors_to_selection (GimpItem *item, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y); + +static void gimp_vectors_real_freeze (GimpVectors *vectors); +static void gimp_vectors_real_thaw (GimpVectors *vectors); +static void gimp_vectors_real_stroke_add (GimpVectors *vectors, + GimpStroke *stroke); +static void gimp_vectors_real_stroke_remove (GimpVectors *vectors, + GimpStroke *stroke); +static GimpStroke * gimp_vectors_real_stroke_get (GimpVectors *vectors, + const GimpCoords *coord); +static GimpStroke *gimp_vectors_real_stroke_get_next(GimpVectors *vectors, + GimpStroke *prev); +static gdouble gimp_vectors_real_stroke_get_length (GimpVectors *vectors, + GimpStroke *prev); +static GimpAnchor * gimp_vectors_real_anchor_get (GimpVectors *vectors, + const GimpCoords *coord, + GimpStroke **ret_stroke); +static void gimp_vectors_real_anchor_delete (GimpVectors *vectors, + GimpAnchor *anchor); +static gdouble gimp_vectors_real_get_length (GimpVectors *vectors, + const GimpAnchor *start); +static gdouble gimp_vectors_real_get_distance (GimpVectors *vectors, + const GimpCoords *coord); +static gint gimp_vectors_real_interpolate (GimpVectors *vectors, + GimpStroke *stroke, + gdouble precision, + gint max_points, + GimpCoords *ret_coords); + +static GimpBezierDesc * gimp_vectors_make_bezier (GimpVectors *vectors); +static GimpBezierDesc * gimp_vectors_real_make_bezier (GimpVectors *vectors); + + +G_DEFINE_TYPE (GimpVectors, gimp_vectors, GIMP_TYPE_ITEM) + +#define parent_class gimp_vectors_parent_class + +static guint gimp_vectors_signals[LAST_SIGNAL] = { 0 }; + + +static void +gimp_vectors_class_init (GimpVectorsClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass); + GimpViewableClass *viewable_class = GIMP_VIEWABLE_CLASS (klass); + GimpItemClass *item_class = GIMP_ITEM_CLASS (klass); + + gimp_vectors_signals[FREEZE] = + g_signal_new ("freeze", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GimpVectorsClass, freeze), + NULL, NULL, + gimp_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + gimp_vectors_signals[THAW] = + g_signal_new ("thaw", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GimpVectorsClass, thaw), + NULL, NULL, + gimp_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + object_class->finalize = gimp_vectors_finalize; + + gimp_object_class->get_memsize = gimp_vectors_get_memsize; + + viewable_class->get_new_preview = gimp_vectors_get_new_preview; + viewable_class->default_icon_name = "gimp-path"; + + item_class->is_attached = gimp_vectors_is_attached; + item_class->get_tree = gimp_vectors_get_tree; + item_class->bounds = gimp_vectors_bounds; + item_class->duplicate = gimp_vectors_duplicate; + item_class->convert = gimp_vectors_convert; + item_class->translate = gimp_vectors_translate; + item_class->scale = gimp_vectors_scale; + item_class->resize = gimp_vectors_resize; + item_class->flip = gimp_vectors_flip; + item_class->rotate = gimp_vectors_rotate; + item_class->transform = gimp_vectors_transform; + item_class->get_clip = gimp_vectors_get_clip; + item_class->fill = gimp_vectors_fill; + item_class->stroke = gimp_vectors_stroke; + item_class->to_selection = gimp_vectors_to_selection; + item_class->default_name = _("Path"); + item_class->rename_desc = C_("undo-type", "Rename Path"); + item_class->translate_desc = C_("undo-type", "Move Path"); + item_class->scale_desc = C_("undo-type", "Scale Path"); + item_class->resize_desc = C_("undo-type", "Resize Path"); + item_class->flip_desc = C_("undo-type", "Flip Path"); + item_class->rotate_desc = C_("undo-type", "Rotate Path"); + item_class->transform_desc = C_("undo-type", "Transform Path"); + item_class->fill_desc = C_("undo-type", "Fill Path"); + item_class->stroke_desc = C_("undo-type", "Stroke Path"); + item_class->to_selection_desc = C_("undo-type", "Path to Selection"); + item_class->reorder_desc = C_("undo-type", "Reorder Path"); + item_class->raise_desc = C_("undo-type", "Raise Path"); + item_class->raise_to_top_desc = C_("undo-type", "Raise Path to Top"); + item_class->lower_desc = C_("undo-type", "Lower Path"); + item_class->lower_to_bottom_desc = C_("undo-type", "Lower Path to Bottom"); + item_class->raise_failed = _("Path cannot be raised higher."); + item_class->lower_failed = _("Path cannot be lowered more."); + + klass->freeze = gimp_vectors_real_freeze; + klass->thaw = gimp_vectors_real_thaw; + + klass->stroke_add = gimp_vectors_real_stroke_add; + klass->stroke_remove = gimp_vectors_real_stroke_remove; + klass->stroke_get = gimp_vectors_real_stroke_get; + klass->stroke_get_next = gimp_vectors_real_stroke_get_next; + klass->stroke_get_length = gimp_vectors_real_stroke_get_length; + + klass->anchor_get = gimp_vectors_real_anchor_get; + klass->anchor_delete = gimp_vectors_real_anchor_delete; + + klass->get_length = gimp_vectors_real_get_length; + klass->get_distance = gimp_vectors_real_get_distance; + klass->interpolate = gimp_vectors_real_interpolate; + + klass->make_bezier = gimp_vectors_real_make_bezier; +} + +static void +gimp_vectors_init (GimpVectors *vectors) +{ + gimp_item_set_visible (GIMP_ITEM (vectors), FALSE, FALSE); + + vectors->strokes = g_queue_new (); + vectors->stroke_to_list = g_hash_table_new (g_direct_hash, g_direct_equal); + vectors->last_stroke_ID = 0; + vectors->freeze_count = 0; + vectors->precision = 0.2; + + vectors->bezier_desc = NULL; + vectors->bounds_valid = FALSE; +} + +static void +gimp_vectors_finalize (GObject *object) +{ + GimpVectors *vectors = GIMP_VECTORS (object); + + if (vectors->bezier_desc) + { + gimp_bezier_desc_free (vectors->bezier_desc); + vectors->bezier_desc = NULL; + } + + if (vectors->strokes) + { + g_queue_free_full (vectors->strokes, (GDestroyNotify) g_object_unref); + vectors->strokes = NULL; + } + + if (vectors->stroke_to_list) + { + g_hash_table_destroy (vectors->stroke_to_list); + vectors->stroke_to_list = NULL; + } + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static gint64 +gimp_vectors_get_memsize (GimpObject *object, + gint64 *gui_size) +{ + GimpVectors *vectors; + GList *list; + gint64 memsize = 0; + + vectors = GIMP_VECTORS (object); + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + memsize += (gimp_object_get_memsize (GIMP_OBJECT (list->data), gui_size) + + sizeof (GList)); + + return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object, + gui_size); +} + +static gboolean +gimp_vectors_is_attached (GimpItem *item) +{ + GimpImage *image = gimp_item_get_image (item); + + return (GIMP_IS_IMAGE (image) && + gimp_container_have (gimp_image_get_vectors (image), + GIMP_OBJECT (item))); +} + +static GimpItemTree * +gimp_vectors_get_tree (GimpItem *item) +{ + if (gimp_item_is_attached (item)) + { + GimpImage *image = gimp_item_get_image (item); + + return gimp_image_get_vectors_tree (image); + } + + return NULL; +} + +static gboolean +gimp_vectors_bounds (GimpItem *item, + gdouble *x, + gdouble *y, + gdouble *width, + gdouble *height) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + + if (! vectors->bounds_valid) + { + GimpStroke *stroke; + + vectors->bounds_empty = TRUE; + vectors->bounds_x1 = vectors->bounds_x2 = 0.0; + vectors->bounds_y1 = vectors->bounds_y2 = 0.0; + + for (stroke = gimp_vectors_stroke_get_next (vectors, NULL); + stroke; + stroke = gimp_vectors_stroke_get_next (vectors, stroke)) + { + GArray *stroke_coords; + gboolean closed; + + stroke_coords = gimp_stroke_interpolate (stroke, 1.0, &closed); + + if (stroke_coords) + { + GimpCoords point; + gint i; + + if (vectors->bounds_empty && stroke_coords->len > 0) + { + point = g_array_index (stroke_coords, GimpCoords, 0); + + vectors->bounds_x1 = vectors->bounds_x2 = point.x; + vectors->bounds_y1 = vectors->bounds_y2 = point.y; + + vectors->bounds_empty = FALSE; + } + + for (i = 0; i < stroke_coords->len; i++) + { + point = g_array_index (stroke_coords, GimpCoords, i); + + vectors->bounds_x1 = MIN (vectors->bounds_x1, point.x); + vectors->bounds_y1 = MIN (vectors->bounds_y1, point.y); + vectors->bounds_x2 = MAX (vectors->bounds_x2, point.x); + vectors->bounds_y2 = MAX (vectors->bounds_y2, point.y); + } + + g_array_free (stroke_coords, TRUE); + } + } + + vectors->bounds_valid = TRUE; + } + + *x = vectors->bounds_x1; + *y = vectors->bounds_y1; + *width = vectors->bounds_x2 - vectors->bounds_x1; + *height = vectors->bounds_y2 - vectors->bounds_y1; + + return ! vectors->bounds_empty; +} + +static GimpItem * +gimp_vectors_duplicate (GimpItem *item, + GType new_type) +{ + GimpItem *new_item; + + g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_VECTORS), NULL); + + new_item = GIMP_ITEM_CLASS (parent_class)->duplicate (item, new_type); + + if (GIMP_IS_VECTORS (new_item)) + { + GimpVectors *vectors = GIMP_VECTORS (item); + GimpVectors *new_vectors = GIMP_VECTORS (new_item); + + gimp_vectors_copy_strokes (vectors, new_vectors); + } + + return new_item; +} + +static void +gimp_vectors_convert (GimpItem *item, + GimpImage *dest_image, + GType old_type) +{ + gimp_item_set_size (item, + gimp_image_get_width (dest_image), + gimp_image_get_height (dest_image)); + + GIMP_ITEM_CLASS (parent_class)->convert (item, dest_image, old_type); +} + +static void +gimp_vectors_translate (GimpItem *item, + gdouble offset_x, + gdouble offset_y, + gboolean push_undo) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + GList *list; + + gimp_vectors_freeze (vectors); + + if (push_undo) + gimp_image_undo_push_vectors_mod (gimp_item_get_image (item), + _("Move Path"), + vectors); + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_stroke_translate (stroke, offset_x, offset_y); + } + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_scale (GimpItem *item, + gint new_width, + gint new_height, + gint new_offset_x, + gint new_offset_y, + GimpInterpolationType interpolation_type, + GimpProgress *progress) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + GimpImage *image = gimp_item_get_image (item); + GList *list; + + gimp_vectors_freeze (vectors); + + if (gimp_item_is_attached (item)) + gimp_image_undo_push_vectors_mod (image, NULL, vectors); + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_stroke_scale (stroke, + (gdouble) new_width / (gdouble) gimp_item_get_width (item), + (gdouble) new_height / (gdouble) gimp_item_get_height (item)); + gimp_stroke_translate (stroke, new_offset_x, new_offset_y); + } + + GIMP_ITEM_CLASS (parent_class)->scale (item, + gimp_image_get_width (image), + gimp_image_get_height (image), + 0, 0, + interpolation_type, progress); + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_resize (GimpItem *item, + GimpContext *context, + GimpFillType fill_type, + gint new_width, + gint new_height, + gint offset_x, + gint offset_y) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + GimpImage *image = gimp_item_get_image (item); + GList *list; + + gimp_vectors_freeze (vectors); + + if (gimp_item_is_attached (item)) + gimp_image_undo_push_vectors_mod (image, NULL, vectors); + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_stroke_translate (stroke, offset_x, offset_y); + } + + GIMP_ITEM_CLASS (parent_class)->resize (item, context, fill_type, + gimp_image_get_width (image), + gimp_image_get_height (image), + 0, 0); + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_flip (GimpItem *item, + GimpContext *context, + GimpOrientationType flip_type, + gdouble axis, + gboolean clip_result) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + GList *list; + GimpMatrix3 matrix; + + gimp_matrix3_identity (&matrix); + gimp_transform_matrix_flip (&matrix, flip_type, axis); + + gimp_vectors_freeze (vectors); + + gimp_image_undo_push_vectors_mod (gimp_item_get_image (item), + _("Flip Path"), + vectors); + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_stroke_transform (stroke, &matrix, NULL); + } + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_rotate (GimpItem *item, + GimpContext *context, + GimpRotationType rotate_type, + gdouble center_x, + gdouble center_y, + gboolean clip_result) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + GList *list; + GimpMatrix3 matrix; + + gimp_matrix3_identity (&matrix); + gimp_transform_matrix_rotate (&matrix, rotate_type, center_x, center_y); + + gimp_vectors_freeze (vectors); + + gimp_image_undo_push_vectors_mod (gimp_item_get_image (item), + _("Rotate Path"), + vectors); + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_stroke_transform (stroke, &matrix, NULL); + } + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_transform (GimpItem *item, + GimpContext *context, + const GimpMatrix3 *matrix, + GimpTransformDirection direction, + GimpInterpolationType interpolation_type, + GimpTransformResize clip_result, + GimpProgress *progress) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + GimpMatrix3 local_matrix; + GQueue strokes; + GList *list; + + gimp_vectors_freeze (vectors); + + gimp_image_undo_push_vectors_mod (gimp_item_get_image (item), + _("Transform Path"), + vectors); + + local_matrix = *matrix; + + if (direction == GIMP_TRANSFORM_BACKWARD) + gimp_matrix3_invert (&local_matrix); + + g_queue_init (&strokes); + + while (! g_queue_is_empty (vectors->strokes)) + { + GimpStroke *stroke = g_queue_peek_head (vectors->strokes); + + g_object_ref (stroke); + + gimp_vectors_stroke_remove (vectors, stroke); + + gimp_stroke_transform (stroke, &local_matrix, &strokes); + + g_object_unref (stroke); + } + + vectors->last_stroke_ID = 0; + + for (list = strokes.head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_vectors_stroke_add (vectors, stroke); + + g_object_unref (stroke); + } + + g_queue_clear (&strokes); + + gimp_vectors_thaw (vectors); +} + +static GimpTransformResize +gimp_vectors_get_clip (GimpItem *item, + GimpTransformResize clip_result) +{ + return GIMP_TRANSFORM_RESIZE_ADJUST; +} + +static gboolean +gimp_vectors_fill (GimpItem *item, + GimpDrawable *drawable, + GimpFillOptions *fill_options, + gboolean push_undo, + GimpProgress *progress, + GError **error) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + + if (g_queue_is_empty (vectors->strokes)) + { + g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, + _("Not enough points to fill")); + return FALSE; + } + + return gimp_drawable_fill_vectors (drawable, fill_options, + vectors, push_undo, error); +} + +static gboolean +gimp_vectors_stroke (GimpItem *item, + GimpDrawable *drawable, + GimpStrokeOptions *stroke_options, + gboolean push_undo, + GimpProgress *progress, + GError **error) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + gboolean retval = FALSE; + + if (g_queue_is_empty (vectors->strokes)) + { + g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, + _("Not enough points to stroke")); + return FALSE; + } + + switch (gimp_stroke_options_get_method (stroke_options)) + { + case GIMP_STROKE_LINE: + retval = gimp_drawable_stroke_vectors (drawable, stroke_options, + vectors, push_undo, error); + break; + + case GIMP_STROKE_PAINT_METHOD: + { + GimpPaintInfo *paint_info; + GimpPaintCore *core; + GimpPaintOptions *paint_options; + gboolean emulate_dynamics; + + paint_info = gimp_context_get_paint_info (GIMP_CONTEXT (stroke_options)); + + core = g_object_new (paint_info->paint_type, NULL); + + paint_options = gimp_stroke_options_get_paint_options (stroke_options); + emulate_dynamics = gimp_stroke_options_get_emulate_dynamics (stroke_options); + + retval = gimp_paint_core_stroke_vectors (core, drawable, + paint_options, + emulate_dynamics, + vectors, push_undo, error); + + g_object_unref (core); + } + break; + + default: + g_return_val_if_reached (FALSE); + } + + return retval; +} + +static void +gimp_vectors_to_selection (GimpItem *item, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + GimpVectors *vectors = GIMP_VECTORS (item); + GimpImage *image = gimp_item_get_image (item); + + gimp_channel_select_vectors (gimp_image_get_mask (image), + GIMP_ITEM_GET_CLASS (item)->to_selection_desc, + vectors, + op, antialias, + feather, feather_radius_x, feather_radius_x, + TRUE); +} + +static void +gimp_vectors_real_freeze (GimpVectors *vectors) +{ + /* release cached bezier representation */ + if (vectors->bezier_desc) + { + gimp_bezier_desc_free (vectors->bezier_desc); + vectors->bezier_desc = NULL; + } + + /* invalidate bounds */ + vectors->bounds_valid = FALSE; +} + +static void +gimp_vectors_real_thaw (GimpVectors *vectors) +{ + gimp_viewable_invalidate_preview (GIMP_VIEWABLE (vectors)); +} + + +/* public functions */ + +GimpVectors * +gimp_vectors_new (GimpImage *image, + const gchar *name) +{ + GimpVectors *vectors; + + g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); + + vectors = GIMP_VECTORS (gimp_item_new (GIMP_TYPE_VECTORS, + image, name, + 0, 0, + gimp_image_get_width (image), + gimp_image_get_height (image))); + + return vectors; +} + +GimpVectors * +gimp_vectors_get_parent (GimpVectors *vectors) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + + return GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors))); +} + +void +gimp_vectors_freeze (GimpVectors *vectors) +{ + g_return_if_fail (GIMP_IS_VECTORS (vectors)); + + vectors->freeze_count++; + + if (vectors->freeze_count == 1) + g_signal_emit (vectors, gimp_vectors_signals[FREEZE], 0); +} + +void +gimp_vectors_thaw (GimpVectors *vectors) +{ + g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (vectors->freeze_count > 0); + + vectors->freeze_count--; + + if (vectors->freeze_count == 0) + g_signal_emit (vectors, gimp_vectors_signals[THAW], 0); +} + +void +gimp_vectors_copy_strokes (GimpVectors *src_vectors, + GimpVectors *dest_vectors) +{ + g_return_if_fail (GIMP_IS_VECTORS (src_vectors)); + g_return_if_fail (GIMP_IS_VECTORS (dest_vectors)); + + gimp_vectors_freeze (dest_vectors); + + g_queue_free_full (dest_vectors->strokes, (GDestroyNotify) g_object_unref); + dest_vectors->strokes = g_queue_new (); + g_hash_table_remove_all (dest_vectors->stroke_to_list); + + dest_vectors->last_stroke_ID = 0; + + gimp_vectors_add_strokes (src_vectors, dest_vectors); + + gimp_vectors_thaw (dest_vectors); +} + + +void +gimp_vectors_add_strokes (GimpVectors *src_vectors, + GimpVectors *dest_vectors) +{ + GList *stroke; + + g_return_if_fail (GIMP_IS_VECTORS (src_vectors)); + g_return_if_fail (GIMP_IS_VECTORS (dest_vectors)); + + gimp_vectors_freeze (dest_vectors); + + for (stroke = src_vectors->strokes->head; + stroke != NULL; + stroke = g_list_next (stroke)) + { + GimpStroke *newstroke = gimp_stroke_duplicate (stroke->data); + + g_queue_push_tail (dest_vectors->strokes, newstroke); + + /* Also add to {stroke: GList node} map */ + g_hash_table_insert (dest_vectors->stroke_to_list, + newstroke, + g_queue_peek_tail_link (dest_vectors->strokes)); + + dest_vectors->last_stroke_ID++; + gimp_stroke_set_ID (newstroke, + dest_vectors->last_stroke_ID); + } + + gimp_vectors_thaw (dest_vectors); +} + + +void +gimp_vectors_stroke_add (GimpVectors *vectors, + GimpStroke *stroke) +{ + g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + gimp_vectors_freeze (vectors); + + GIMP_VECTORS_GET_CLASS (vectors)->stroke_add (vectors, stroke); + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_real_stroke_add (GimpVectors *vectors, + GimpStroke *stroke) +{ + /* + * Don't prepend into vector->strokes. See ChangeLog 2003-05-21 + * --Mitch + */ + g_queue_push_tail (vectors->strokes, g_object_ref (stroke)); + + /* Also add to {stroke: GList node} map */ + g_hash_table_insert (vectors->stroke_to_list, + stroke, + g_queue_peek_tail_link (vectors->strokes)); + + vectors->last_stroke_ID++; + gimp_stroke_set_ID (stroke, vectors->last_stroke_ID); +} + +void +gimp_vectors_stroke_remove (GimpVectors *vectors, + GimpStroke *stroke) +{ + g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (GIMP_IS_STROKE (stroke)); + + gimp_vectors_freeze (vectors); + + GIMP_VECTORS_GET_CLASS (vectors)->stroke_remove (vectors, stroke); + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_real_stroke_remove (GimpVectors *vectors, + GimpStroke *stroke) +{ + GList *list = g_hash_table_lookup (vectors->stroke_to_list, stroke); + + if (list) + { + g_queue_delete_link (vectors->strokes, list); + g_hash_table_remove (vectors->stroke_to_list, stroke); + g_object_unref (stroke); + } +} + +gint +gimp_vectors_get_n_strokes (GimpVectors *vectors) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0); + + return g_queue_get_length (vectors->strokes); +} + + +GimpStroke * +gimp_vectors_stroke_get (GimpVectors *vectors, + const GimpCoords *coord) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + + return GIMP_VECTORS_GET_CLASS (vectors)->stroke_get (vectors, coord); +} + +static GimpStroke * +gimp_vectors_real_stroke_get (GimpVectors *vectors, + const GimpCoords *coord) +{ + GimpStroke *minstroke = NULL; + gdouble mindist = G_MAXDOUBLE; + GList *list; + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + GimpAnchor *anchor = gimp_stroke_anchor_get (stroke, coord); + + if (anchor) + { + gdouble dx = coord->x - anchor->position.x; + gdouble dy = coord->y - anchor->position.y; + + if (mindist > dx * dx + dy * dy) + { + mindist = dx * dx + dy * dy; + minstroke = stroke; + } + } + } + + return minstroke; +} + +GimpStroke * +gimp_vectors_stroke_get_by_ID (GimpVectors *vectors, + gint id) +{ + GList *list; + + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + if (gimp_stroke_get_ID (list->data) == id) + return list->data; + } + + return NULL; +} + + +GimpStroke * +gimp_vectors_stroke_get_next (GimpVectors *vectors, + GimpStroke *prev) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + + return GIMP_VECTORS_GET_CLASS (vectors)->stroke_get_next (vectors, prev); +} + +static GimpStroke * +gimp_vectors_real_stroke_get_next (GimpVectors *vectors, + GimpStroke *prev) +{ + if (! prev) + { + return g_queue_peek_head (vectors->strokes); + } + else + { + GList *stroke = g_hash_table_lookup (vectors->stroke_to_list, prev); + + g_return_val_if_fail (stroke != NULL, NULL); + + return stroke->next ? stroke->next->data : NULL; + } +} + + +gdouble +gimp_vectors_stroke_get_length (GimpVectors *vectors, + GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0); + + return GIMP_VECTORS_GET_CLASS (vectors)->stroke_get_length (vectors, stroke); +} + +static gdouble +gimp_vectors_real_stroke_get_length (GimpVectors *vectors, + GimpStroke *stroke) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + g_return_val_if_fail (GIMP_IS_STROKE (stroke), 0.0); + + return gimp_stroke_get_length (stroke, vectors->precision); +} + + +GimpAnchor * +gimp_vectors_anchor_get (GimpVectors *vectors, + const GimpCoords *coord, + GimpStroke **ret_stroke) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + + return GIMP_VECTORS_GET_CLASS (vectors)->anchor_get (vectors, coord, + ret_stroke); +} + +static GimpAnchor * +gimp_vectors_real_anchor_get (GimpVectors *vectors, + const GimpCoords *coord, + GimpStroke **ret_stroke) +{ + GimpAnchor *minanchor = NULL; + gdouble mindist = -1; + GList *list; + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + GimpAnchor *anchor = gimp_stroke_anchor_get (stroke, coord); + + if (anchor) + { + gdouble dx = coord->x - anchor->position.x; + gdouble dy = coord->y - anchor->position.y; + + if (mindist > dx * dx + dy * dy || mindist < 0) + { + mindist = dx * dx + dy * dy; + minanchor = anchor; + + if (ret_stroke) + *ret_stroke = stroke; + } + } + } + + return minanchor; +} + + +void +gimp_vectors_anchor_delete (GimpVectors *vectors, + GimpAnchor *anchor) +{ + g_return_if_fail (GIMP_IS_VECTORS (vectors)); + g_return_if_fail (anchor != NULL); + + GIMP_VECTORS_GET_CLASS (vectors)->anchor_delete (vectors, anchor); +} + +static void +gimp_vectors_real_anchor_delete (GimpVectors *vectors, + GimpAnchor *anchor) +{ +} + + +void +gimp_vectors_anchor_select (GimpVectors *vectors, + GimpStroke *target_stroke, + GimpAnchor *anchor, + gboolean selected, + gboolean exclusive) +{ + GList *list; + + for (list = vectors->strokes->head; list; list = g_list_next (list)) + { + GimpStroke *stroke = list->data; + + gimp_stroke_anchor_select (stroke, + stroke == target_stroke ? anchor : NULL, + selected, exclusive); + } +} + + +gdouble +gimp_vectors_get_length (GimpVectors *vectors, + const GimpAnchor *start) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + + return GIMP_VECTORS_GET_CLASS (vectors)->get_length (vectors, start); +} + +static gdouble +gimp_vectors_real_get_length (GimpVectors *vectors, + const GimpAnchor *start) +{ + g_printerr ("gimp_vectors_get_length: default implementation\n"); + + return 0; +} + + +gdouble +gimp_vectors_get_distance (GimpVectors *vectors, + const GimpCoords *coord) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0.0); + + return GIMP_VECTORS_GET_CLASS (vectors)->get_distance (vectors, coord); +} + +static gdouble +gimp_vectors_real_get_distance (GimpVectors *vectors, + const GimpCoords *coord) +{ + g_printerr ("gimp_vectors_get_distance: default implementation\n"); + + return 0; +} + +gint +gimp_vectors_interpolate (GimpVectors *vectors, + GimpStroke *stroke, + gdouble precision, + gint max_points, + GimpCoords *ret_coords) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), 0); + + return GIMP_VECTORS_GET_CLASS (vectors)->interpolate (vectors, stroke, + precision, max_points, + ret_coords); +} + +static gint +gimp_vectors_real_interpolate (GimpVectors *vectors, + GimpStroke *stroke, + gdouble precision, + gint max_points, + GimpCoords *ret_coords) +{ + g_printerr ("gimp_vectors_interpolate: default implementation\n"); + + return 0; +} + +const GimpBezierDesc * +gimp_vectors_get_bezier (GimpVectors *vectors) +{ + g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL); + + if (! vectors->bezier_desc) + { + vectors->bezier_desc = gimp_vectors_make_bezier (vectors); + } + + return vectors->bezier_desc; +} + +static GimpBezierDesc * +gimp_vectors_make_bezier (GimpVectors *vectors) +{ + return GIMP_VECTORS_GET_CLASS (vectors)->make_bezier (vectors); +} + +static GimpBezierDesc * +gimp_vectors_real_make_bezier (GimpVectors *vectors) +{ + GimpStroke *stroke; + GArray *cmd_array; + GimpBezierDesc *ret_bezdesc = NULL; + + cmd_array = g_array_new (FALSE, FALSE, sizeof (cairo_path_data_t)); + + for (stroke = gimp_vectors_stroke_get_next (vectors, NULL); + stroke; + stroke = gimp_vectors_stroke_get_next (vectors, stroke)) + { + GimpBezierDesc *bezdesc = gimp_stroke_make_bezier (stroke); + + if (bezdesc) + { + cmd_array = g_array_append_vals (cmd_array, bezdesc->data, + bezdesc->num_data); + gimp_bezier_desc_free (bezdesc); + } + } + + if (cmd_array->len > 0) + ret_bezdesc = gimp_bezier_desc_new ((cairo_path_data_t *) cmd_array->data, + cmd_array->len); + + g_array_free (cmd_array, FALSE); + + return ret_bezdesc; +} diff --git a/app/vectors/gimpvectors.h b/app/vectors/gimpvectors.h new file mode 100644 index 0000000..a0d8a64 --- /dev/null +++ b/app/vectors/gimpvectors.h @@ -0,0 +1,184 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpvectors.h + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_H__ +#define __GIMP_VECTORS_H__ + +#include "core/gimpitem.h" + +#define GIMP_TYPE_VECTORS (gimp_vectors_get_type ()) +#define GIMP_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VECTORS, GimpVectors)) +#define GIMP_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VECTORS, GimpVectorsClass)) +#define GIMP_IS_VECTORS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VECTORS)) +#define GIMP_IS_VECTORS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VECTORS)) +#define GIMP_VECTORS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VECTORS, GimpVectorsClass)) + + +typedef struct _GimpVectorsClass GimpVectorsClass; + +struct _GimpVectors +{ + GimpItem parent_instance; + + GQueue *strokes; /* Queue of GimpStrokes */ + GHashTable *stroke_to_list; /* Map from GimpStroke to strokes listnode */ + gint last_stroke_ID; + + gint freeze_count; + gdouble precision; + + GimpBezierDesc *bezier_desc; /* Cached bezier representation */ + + gboolean bounds_valid; /* Cached bounding box */ + gboolean bounds_empty; + gdouble bounds_x1; + gdouble bounds_y1; + gdouble bounds_x2; + gdouble bounds_y2; +}; + +struct _GimpVectorsClass +{ + GimpItemClass parent_class; + + /* signals */ + void (* freeze) (GimpVectors *vectors); + void (* thaw) (GimpVectors *vectors); + + /* virtual functions */ + void (* stroke_add) (GimpVectors *vectors, + GimpStroke *stroke); + void (* stroke_remove) (GimpVectors *vectors, + GimpStroke *stroke); + GimpStroke * (* stroke_get) (GimpVectors *vectors, + const GimpCoords *coord); + GimpStroke * (* stroke_get_next) (GimpVectors *vectors, + GimpStroke *prev); + gdouble (* stroke_get_length) (GimpVectors *vectors, + GimpStroke *stroke); + GimpAnchor * (* anchor_get) (GimpVectors *vectors, + const GimpCoords *coord, + GimpStroke **ret_stroke); + void (* anchor_delete) (GimpVectors *vectors, + GimpAnchor *anchor); + gdouble (* get_length) (GimpVectors *vectors, + const GimpAnchor *start); + gdouble (* get_distance) (GimpVectors *vectors, + const GimpCoords *coord); + gint (* interpolate) (GimpVectors *vectors, + GimpStroke *stroke, + gdouble precision, + gint max_points, + GimpCoords *ret_coords); + GimpBezierDesc * (* make_bezier) (GimpVectors *vectors); +}; + + +/* vectors utility functions */ + +GType gimp_vectors_get_type (void) G_GNUC_CONST; + +GimpVectors * gimp_vectors_new (GimpImage *image, + const gchar *name); + +GimpVectors * gimp_vectors_get_parent (GimpVectors *vectors); + +void gimp_vectors_freeze (GimpVectors *vectors); +void gimp_vectors_thaw (GimpVectors *vectors); + +void gimp_vectors_copy_strokes (GimpVectors *src_vectors, + GimpVectors *dest_vectors); +void gimp_vectors_add_strokes (GimpVectors *src_vectors, + GimpVectors *dest_vectors); + + +/* accessing / modifying the anchors */ + +GimpAnchor * gimp_vectors_anchor_get (GimpVectors *vectors, + const GimpCoords *coord, + GimpStroke **ret_stroke); + +/* prev == NULL: "first" anchor */ +GimpAnchor * gimp_vectors_anchor_get_next (GimpVectors *vectors, + const GimpAnchor *prev); + +/* type will be an xorable enum: + * VECTORS_NONE, VECTORS_FIX_ANGLE, VECTORS_FIX_RATIO, VECTORS_RESTRICT_ANGLE + * or so. + */ +void gimp_vectors_anchor_move_relative (GimpVectors *vectors, + GimpAnchor *anchor, + const GimpCoords *deltacoord, + gint type); +void gimp_vectors_anchor_move_absolute (GimpVectors *vectors, + GimpAnchor *anchor, + const GimpCoords *coord, + gint type); + +void gimp_vectors_anchor_delete (GimpVectors *vectors, + GimpAnchor *anchor); + +void gimp_vectors_anchor_select (GimpVectors *vectors, + GimpStroke *target_stroke, + GimpAnchor *anchor, + gboolean selected, + gboolean exclusive); + + +/* GimpStroke is a connected component of a GimpVectors object */ + +void gimp_vectors_stroke_add (GimpVectors *vectors, + GimpStroke *stroke); +void gimp_vectors_stroke_remove (GimpVectors *vectors, + GimpStroke *stroke); +gint gimp_vectors_get_n_strokes (GimpVectors *vectors); +GimpStroke * gimp_vectors_stroke_get (GimpVectors *vectors, + const GimpCoords *coord); +GimpStroke * gimp_vectors_stroke_get_by_ID (GimpVectors *vectors, + gint id); + +/* prev == NULL: "first" stroke */ +GimpStroke * gimp_vectors_stroke_get_next (GimpVectors *vectors, + GimpStroke *prev); +gdouble gimp_vectors_stroke_get_length (GimpVectors *vectors, + GimpStroke *stroke); + +/* accessing the shape of the curve */ + +gdouble gimp_vectors_get_length (GimpVectors *vectors, + const GimpAnchor *start); +gdouble gimp_vectors_get_distance (GimpVectors *vectors, + const GimpCoords *coord); + +/* returns the number of valid coordinates */ + +gint gimp_vectors_interpolate (GimpVectors *vectors, + GimpStroke *stroke, + gdouble precision, + gint max_points, + GimpCoords *ret_coords); + +/* usually overloaded */ + +/* returns a bezier representation */ +const GimpBezierDesc * gimp_vectors_get_bezier (GimpVectors *vectors); + + +#endif /* __GIMP_VECTORS_H__ */ diff --git a/app/vectors/gimpvectorsmodundo.c b/app/vectors/gimpvectorsmodundo.c new file mode 100644 index 0000000..b681ba9 --- /dev/null +++ b/app/vectors/gimpvectorsmodundo.c @@ -0,0 +1,141 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "vectors-types.h" + +#include "gimpvectors.h" +#include "gimpvectorsmodundo.h" + + +static void gimp_vectors_mod_undo_constructed (GObject *object); + +static gint64 gimp_vectors_mod_undo_get_memsize (GimpObject *object, + gint64 *gui_size); + +static void gimp_vectors_mod_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum); +static void gimp_vectors_mod_undo_free (GimpUndo *undo, + GimpUndoMode undo_mode); + + +G_DEFINE_TYPE (GimpVectorsModUndo, gimp_vectors_mod_undo, GIMP_TYPE_ITEM_UNDO) + +#define parent_class gimp_vectors_mod_undo_parent_class + + +static void +gimp_vectors_mod_undo_class_init (GimpVectorsModUndoClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass); + GimpUndoClass *undo_class = GIMP_UNDO_CLASS (klass); + + object_class->constructed = gimp_vectors_mod_undo_constructed; + + gimp_object_class->get_memsize = gimp_vectors_mod_undo_get_memsize; + + undo_class->pop = gimp_vectors_mod_undo_pop; + undo_class->free = gimp_vectors_mod_undo_free; +} + +static void +gimp_vectors_mod_undo_init (GimpVectorsModUndo *undo) +{ +} + +static void +gimp_vectors_mod_undo_constructed (GObject *object) +{ + GimpVectorsModUndo *vectors_mod_undo = GIMP_VECTORS_MOD_UNDO (object); + GimpVectors *vectors; + + G_OBJECT_CLASS (parent_class)->constructed (object); + + gimp_assert (GIMP_IS_VECTORS (GIMP_ITEM_UNDO (object)->item)); + + vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (object)->item); + + vectors_mod_undo->vectors = + GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors), + G_TYPE_FROM_INSTANCE (vectors))); +} + +static gint64 +gimp_vectors_mod_undo_get_memsize (GimpObject *object, + gint64 *gui_size) +{ + GimpVectorsModUndo *vectors_mod_undo = GIMP_VECTORS_MOD_UNDO (object); + gint64 memsize = 0; + + memsize += gimp_object_get_memsize (GIMP_OBJECT (vectors_mod_undo->vectors), + gui_size); + + return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object, + gui_size); +} + +static void +gimp_vectors_mod_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum) +{ + GimpVectorsModUndo *vectors_mod_undo = GIMP_VECTORS_MOD_UNDO (undo); + GimpVectors *vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (undo)->item); + GimpVectors *temp; + gint offset_x; + gint offset_y; + + GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); + + temp = vectors_mod_undo->vectors; + + vectors_mod_undo->vectors = + GIMP_VECTORS (gimp_item_duplicate (GIMP_ITEM (vectors), + G_TYPE_FROM_INSTANCE (vectors))); + + gimp_vectors_freeze (vectors); + + gimp_vectors_copy_strokes (temp, vectors); + + gimp_item_get_offset (GIMP_ITEM (temp), &offset_x, &offset_y); + gimp_item_set_offset (GIMP_ITEM (vectors), offset_x, offset_y); + + gimp_item_set_size (GIMP_ITEM (vectors), + gimp_item_get_width (GIMP_ITEM (temp)), + gimp_item_get_height (GIMP_ITEM (temp))); + + g_object_unref (temp); + + gimp_vectors_thaw (vectors); +} + +static void +gimp_vectors_mod_undo_free (GimpUndo *undo, + GimpUndoMode undo_mode) +{ + GimpVectorsModUndo *vectors_mod_undo = GIMP_VECTORS_MOD_UNDO (undo); + + g_clear_object (&vectors_mod_undo->vectors); + + GIMP_UNDO_CLASS (parent_class)->free (undo, undo_mode); +} diff --git a/app/vectors/gimpvectorsmodundo.h b/app/vectors/gimpvectorsmodundo.h new file mode 100644 index 0000000..e63a0ef --- /dev/null +++ b/app/vectors/gimpvectorsmodundo.h @@ -0,0 +1,52 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_MOD_UNDO_H__ +#define __GIMP_VECTORS_MOD_UNDO_H__ + + +#include "core/gimpitemundo.h" + + +#define GIMP_TYPE_VECTORS_MOD_UNDO (gimp_vectors_mod_undo_get_type ()) +#define GIMP_VECTORS_MOD_UNDO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VECTORS_MOD_UNDO, GimpVectorsModUndo)) +#define GIMP_VECTORS_MOD_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VECTORS_MOD_UNDO, GimpVectorsModUndoClass)) +#define GIMP_IS_VECTORS_MOD_UNDO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VECTORS_MOD_UNDO)) +#define GIMP_IS_VECTORS_MOD_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VECTORS_MOD_UNDO)) +#define GIMP_VECTORS_MOD_UNDO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VECTORS_MOD_UNDO, GimpVectorsModUndoClass)) + + +typedef struct _GimpVectorsModUndo GimpVectorsModUndo; +typedef struct _GimpVectorsModUndoClass GimpVectorsModUndoClass; + +struct _GimpVectorsModUndo +{ + GimpItemUndo parent_instance; + + GimpVectors *vectors; +}; + +struct _GimpVectorsModUndoClass +{ + GimpItemUndoClass parent_class; +}; + + +GType gimp_vectors_mod_undo_get_type (void) G_GNUC_CONST; + + +#endif /* __GIMP_VECTORS_MOD_UNDO_H__ */ diff --git a/app/vectors/gimpvectorspropundo.c b/app/vectors/gimpvectorspropundo.c new file mode 100644 index 0000000..1a093df --- /dev/null +++ b/app/vectors/gimpvectorspropundo.c @@ -0,0 +1,94 @@ +/* Gimp - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "vectors-types.h" + +#include "core/gimpimage.h" + +#include "gimpvectors.h" +#include "gimpvectorspropundo.h" + + +static void gimp_vectors_prop_undo_constructed (GObject *object); + +static void gimp_vectors_prop_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum); + + +G_DEFINE_TYPE (GimpVectorsPropUndo, gimp_vectors_prop_undo, GIMP_TYPE_ITEM_UNDO) + +#define parent_class gimp_vectors_prop_undo_parent_class + + +static void +gimp_vectors_prop_undo_class_init (GimpVectorsPropUndoClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpUndoClass *undo_class = GIMP_UNDO_CLASS (klass); + + object_class->constructed = gimp_vectors_prop_undo_constructed; + + undo_class->pop = gimp_vectors_prop_undo_pop; +} + +static void +gimp_vectors_prop_undo_init (GimpVectorsPropUndo *undo) +{ +} + +static void +gimp_vectors_prop_undo_constructed (GObject *object) +{ + /* GimpVectors *vectors; */ + + G_OBJECT_CLASS (parent_class)->constructed (object); + + gimp_assert (GIMP_IS_VECTORS (GIMP_ITEM_UNDO (object)->item)); + + /* vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (object)->item); */ + + switch (GIMP_UNDO (object)->undo_type) + { + default: + gimp_assert_not_reached (); + } +} + +static void +gimp_vectors_prop_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum) +{ +#if 0 + GimpVectorsPropUndo *vectors_prop_undo = GIMP_VECTORS_PROP_UNDO (undo); + GimpVectors *vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (undo)->item); +#endif + + GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); + + switch (undo->undo_type) + { + default: + gimp_assert_not_reached (); + } +} diff --git a/app/vectors/gimpvectorspropundo.h b/app/vectors/gimpvectorspropundo.h new file mode 100644 index 0000000..8909226 --- /dev/null +++ b/app/vectors/gimpvectorspropundo.h @@ -0,0 +1,50 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_PROP_UNDO_H__ +#define __GIMP_VECTORS_PROP_UNDO_H__ + + +#include "core/gimpitemundo.h" + + +#define GIMP_TYPE_VECTORS_PROP_UNDO (gimp_vectors_prop_undo_get_type ()) +#define GIMP_VECTORS_PROP_UNDO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VECTORS_PROP_UNDO, GimpVectorsPropUndo)) +#define GIMP_VECTORS_PROP_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VECTORS_PROP_UNDO, GimpVectorsPropUndoClass)) +#define GIMP_IS_VECTORS_PROP_UNDO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VECTORS_PROP_UNDO)) +#define GIMP_IS_VECTORS_PROP_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VECTORS_PROP_UNDO)) +#define GIMP_VECTORS_PROP_UNDO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VECTORS_PROP_UNDO, GimpVectorsPropUndoClass)) + + +typedef struct _GimpVectorsPropUndo GimpVectorsPropUndo; +typedef struct _GimpVectorsPropUndoClass GimpVectorsPropUndoClass; + +struct _GimpVectorsPropUndo +{ + GimpItemUndo parent_instance; +}; + +struct _GimpVectorsPropUndoClass +{ + GimpItemUndoClass parent_class; +}; + + +GType gimp_vectors_prop_undo_get_type (void) G_GNUC_CONST; + + +#endif /* __GIMP_VECTORS_PROP_UNDO_H__ */ diff --git a/app/vectors/gimpvectorsundo.c b/app/vectors/gimpvectorsundo.c new file mode 100644 index 0000000..646869f --- /dev/null +++ b/app/vectors/gimpvectorsundo.c @@ -0,0 +1,213 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#include "config.h" + +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gegl.h> + +#include "vectors-types.h" + +#include "core/gimpimage.h" + +#include "gimpvectors.h" +#include "gimpvectorsundo.h" + + +enum +{ + PROP_0, + PROP_PREV_PARENT, + PROP_PREV_POSITION, + PROP_PREV_VECTORS +}; + + +static void gimp_vectors_undo_constructed (GObject *object); +static void gimp_vectors_undo_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_vectors_undo_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + +static gint64 gimp_vectors_undo_get_memsize (GimpObject *object, + gint64 *gui_size); + +static void gimp_vectors_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum); + + +G_DEFINE_TYPE (GimpVectorsUndo, gimp_vectors_undo, GIMP_TYPE_ITEM_UNDO) + +#define parent_class gimp_vectors_undo_parent_class + + +static void +gimp_vectors_undo_class_init (GimpVectorsUndoClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass); + GimpUndoClass *undo_class = GIMP_UNDO_CLASS (klass); + + object_class->constructed = gimp_vectors_undo_constructed; + object_class->set_property = gimp_vectors_undo_set_property; + object_class->get_property = gimp_vectors_undo_get_property; + + gimp_object_class->get_memsize = gimp_vectors_undo_get_memsize; + + undo_class->pop = gimp_vectors_undo_pop; + + g_object_class_install_property (object_class, PROP_PREV_PARENT, + g_param_spec_object ("prev-parent", + NULL, NULL, + GIMP_TYPE_VECTORS, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + + g_object_class_install_property (object_class, PROP_PREV_POSITION, + g_param_spec_int ("prev-position", NULL, NULL, + 0, G_MAXINT, 0, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + + g_object_class_install_property (object_class, PROP_PREV_VECTORS, + g_param_spec_object ("prev-vectors", NULL, NULL, + GIMP_TYPE_VECTORS, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); +} + +static void +gimp_vectors_undo_init (GimpVectorsUndo *undo) +{ +} + +static void +gimp_vectors_undo_constructed (GObject *object) +{ + G_OBJECT_CLASS (parent_class)->constructed (object); + + gimp_assert (GIMP_IS_VECTORS (GIMP_ITEM_UNDO (object)->item)); +} + +static void +gimp_vectors_undo_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpVectorsUndo *vectors_undo = GIMP_VECTORS_UNDO (object); + + switch (property_id) + { + case PROP_PREV_PARENT: + vectors_undo->prev_parent = g_value_get_object (value); + break; + case PROP_PREV_POSITION: + vectors_undo->prev_position = g_value_get_int (value); + break; + case PROP_PREV_VECTORS: + vectors_undo->prev_vectors = g_value_get_object (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_vectors_undo_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpVectorsUndo *vectors_undo = GIMP_VECTORS_UNDO (object); + + switch (property_id) + { + case PROP_PREV_PARENT: + g_value_set_object (value, vectors_undo->prev_parent); + break; + case PROP_PREV_POSITION: + g_value_set_int (value, vectors_undo->prev_position); + break; + case PROP_PREV_VECTORS: + g_value_set_object (value, vectors_undo->prev_vectors); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static gint64 +gimp_vectors_undo_get_memsize (GimpObject *object, + gint64 *gui_size) +{ + GimpItemUndo *item_undo = GIMP_ITEM_UNDO (object); + gint64 memsize = 0; + + if (! gimp_item_is_attached (item_undo->item)) + memsize += gimp_object_get_memsize (GIMP_OBJECT (item_undo->item), + gui_size); + + return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object, + gui_size); +} + +static void +gimp_vectors_undo_pop (GimpUndo *undo, + GimpUndoMode undo_mode, + GimpUndoAccumulator *accum) +{ + GimpVectorsUndo *vectors_undo = GIMP_VECTORS_UNDO (undo); + GimpVectors *vectors = GIMP_VECTORS (GIMP_ITEM_UNDO (undo)->item); + + GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); + + if ((undo_mode == GIMP_UNDO_MODE_UNDO && + undo->undo_type == GIMP_UNDO_VECTORS_ADD) || + (undo_mode == GIMP_UNDO_MODE_REDO && + undo->undo_type == GIMP_UNDO_VECTORS_REMOVE)) + { + /* remove vectors */ + + /* record the current parent and position */ + vectors_undo->prev_parent = gimp_vectors_get_parent (vectors); + vectors_undo->prev_position = gimp_item_get_index (GIMP_ITEM (vectors)); + + gimp_image_remove_vectors (undo->image, vectors, FALSE, + vectors_undo->prev_vectors); + } + else + { + /* restore vectors */ + + /* record the active vectors */ + vectors_undo->prev_vectors = gimp_image_get_active_vectors (undo->image); + + gimp_image_add_vectors (undo->image, vectors, + vectors_undo->prev_parent, + vectors_undo->prev_position, FALSE); + } +} diff --git a/app/vectors/gimpvectorsundo.h b/app/vectors/gimpvectorsundo.h new file mode 100644 index 0000000..9b54346 --- /dev/null +++ b/app/vectors/gimpvectorsundo.h @@ -0,0 +1,54 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __GIMP_VECTORS_UNDO_H__ +#define __GIMP_VECTORS_UNDO_H__ + + +#include "core/gimpitemundo.h" + + +#define GIMP_TYPE_VECTORS_UNDO (gimp_vectors_undo_get_type ()) +#define GIMP_VECTORS_UNDO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_VECTORS_UNDO, GimpVectorsUndo)) +#define GIMP_VECTORS_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_VECTORS_UNDO, GimpVectorsUndoClass)) +#define GIMP_IS_VECTORS_UNDO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_VECTORS_UNDO)) +#define GIMP_IS_VECTORS_UNDO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_VECTORS_UNDO)) +#define GIMP_VECTORS_UNDO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_VECTORS_UNDO, GimpVectorsUndoClass)) + + +typedef struct _GimpVectorsUndo GimpVectorsUndo; +typedef struct _GimpVectorsUndoClass GimpVectorsUndoClass; + +struct _GimpVectorsUndo +{ + GimpItemUndo parent_instance; + + GimpVectors *prev_parent; + gint prev_position; /* former position in list */ + GimpVectors *prev_vectors; /* previous active vectors */ +}; + +struct _GimpVectorsUndoClass +{ + GimpItemUndoClass parent_class; +}; + + +GType gimp_vectors_undo_get_type (void) G_GNUC_CONST; + + +#endif /* __GIMP_VECTORS_UNDO_H__ */ diff --git a/app/vectors/vectors-enums.h b/app/vectors/vectors-enums.h new file mode 100644 index 0000000..c0c603b --- /dev/null +++ b/app/vectors/vectors-enums.h @@ -0,0 +1,46 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * vectors-enums.h + * Copyright (C) 2006 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __VECTORS_ENUMS_H__ +#define __VECTORS_ENUMS_H__ + + +typedef enum +{ + GIMP_ANCHOR_ANCHOR, + GIMP_ANCHOR_CONTROL +} GimpAnchorType; + +typedef enum +{ + GIMP_ANCHOR_FEATURE_NONE, + GIMP_ANCHOR_FEATURE_EDGE, + GIMP_ANCHOR_FEATURE_ALIGNED, + GIMP_ANCHOR_FEATURE_SYMMETRIC +} GimpAnchorFeatureType; + +typedef enum +{ + EXTEND_SIMPLE, + EXTEND_EDITABLE +} GimpVectorExtendMode; + + +#endif /* __VECTORS_ENUMS_H__ */ diff --git a/app/vectors/vectors-types.h b/app/vectors/vectors-types.h new file mode 100644 index 0000000..7c0d2d3 --- /dev/null +++ b/app/vectors/vectors-types.h @@ -0,0 +1,37 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * vectors-types.h + * Copyright (C) 2002 Simon Budig <simon@gimp.org> + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +#ifndef __VECTORS_TYPES_H__ +#define __VECTORS_TYPES_H__ + + +#include "core/core-types.h" + +#include "vectors/vectors-enums.h" + + +typedef struct _GimpAnchor GimpAnchor; + +typedef struct _GimpVectors GimpVectors; +typedef struct _GimpStroke GimpStroke; +typedef struct _GimpBezierStroke GimpBezierStroke; + + +#endif /* __VECTORS_TYPES_H__ */ |