summaryrefslogtreecommitdiffstats
path: root/plug-ins/gfig/gfig.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--plug-ins/gfig/gfig.c809
1 files changed, 809 insertions, 0 deletions
diff --git a/plug-ins/gfig/gfig.c b/plug-ins/gfig/gfig.c
new file mode 100644
index 0000000..118930f
--- /dev/null
+++ b/plug-ins/gfig/gfig.c
@@ -0,0 +1,809 @@
+/*
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This is a plug-in for GIMP.
+ *
+ * Generates images containing vector type drawings.
+ *
+ * Copyright (C) 1997 Andy Thomas alt@picnic.demon.co.uk
+ *
+ * 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 <stdlib.h>
+#include <errno.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib/gstdio.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "gfig.h"
+#include "gfig-style.h"
+#include "gfig-dialog.h"
+#include "gfig-arc.h"
+#include "gfig-bezier.h"
+#include "gfig-circle.h"
+#include "gfig-dobject.h"
+#include "gfig-ellipse.h"
+#include "gfig-grid.h"
+#include "gfig-line.h"
+#include "gfig-poly.h"
+#include "gfig-preview.h"
+#include "gfig-spiral.h"
+#include "gfig-star.h"
+#include "gfig-stock.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define GFIG_HEADER "GFIG Version 0.2\n"
+
+static void query (void);
+static void run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals);
+
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+ NULL, /* init_proc */
+ NULL, /* quit_proc */
+ query, /* query_proc */
+ run, /* run_proc */
+};
+
+
+gint line_no;
+
+gint obj_show_single = -1; /* -1 all >= 0 object number */
+
+/* Structures etc for the objects */
+/* Points used to draw the object */
+
+GfigObject *obj_creating; /* Object we are creating */
+GfigObject *tmp_line; /* Needed when drawing lines */
+
+gboolean need_to_scale;
+
+static gint load_options (GFigObj *gfig,
+ FILE *fp);
+/* globals */
+
+GfigObjectClass dobj_class[10];
+GFigContext *gfig_context;
+GtkWidget *top_level_dlg;
+GList *gfig_list;
+gdouble org_scale_x_factor, org_scale_y_factor;
+
+
+/* Stuff for the preview bit */
+static gint sel_x, sel_y;
+static gint sel_width, sel_height;
+gint preview_width, preview_height;
+gdouble scale_x_factor, scale_y_factor;
+GdkPixbuf *back_pixbuf = NULL;
+
+MAIN ()
+
+static void
+query (void)
+{
+ static const GimpParamDef args[] =
+ {
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+ { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
+ { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
+ { GIMP_PDB_INT32, "dummy", "dummy" }
+ };
+
+ gimp_install_procedure (PLUG_IN_PROC,
+ N_("Create geometric shapes"),
+ "Draw Vector Graphics and paint them onto your images. "
+ "Gfig allows you to draw many types of objects "
+ "including Lines, Circles, Ellipses, Curves, Polygons, "
+ "pointed stars, Bezier curves, and Spirals. "
+ "Objects can be painted using Brushes or other tools"
+ "or filled using colors or patterns. "
+ "Gfig objects can also be used to create selections. ",
+ "Andy Thomas",
+ "Andy Thomas",
+ "1997",
+ N_("_Gfig..."),
+ "RGB*, GRAY*",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (args), 0,
+ args, NULL);
+
+ gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Render");
+}
+
+static void
+run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals)
+{
+ static GimpParam values[1];
+ gint32 drawable_id;
+ GimpRunMode run_mode;
+ GimpPDBStatusType status = GIMP_PDB_SUCCESS;
+ gint pwidth, pheight;
+
+ INIT_I18N ();
+
+ gfig_context = g_new0 (GFigContext, 1);
+ gfig_context->show_background = TRUE;
+ gfig_context->selected_obj = NULL;
+
+ drawable_id = param[2].data.d_drawable;
+
+ run_mode = param[0].data.d_int32;
+
+ gfig_context->image_id = param[1].data.d_image;
+ gfig_context->drawable_id = drawable_id;
+
+ *nreturn_vals = 1;
+ *return_vals = values;
+
+ values[0].type = GIMP_PDB_STATUS;
+ values[0].data.d_status = status;
+
+ gimp_image_undo_group_start (gfig_context->image_id);
+
+ gimp_context_push ();
+
+ /* TMP Hack - clear any selections */
+ if (! gimp_selection_is_empty (gfig_context->image_id))
+ gimp_selection_none (gfig_context->image_id);
+
+ if (! gimp_drawable_mask_intersect (drawable_id, &sel_x, &sel_y,
+ &sel_width, &sel_height))
+ {
+ gimp_context_pop ();
+
+ gimp_image_undo_group_end (gfig_context->image_id);
+ return;
+ }
+
+ /* Calculate preview size */
+
+ if (sel_width > sel_height)
+ {
+ pwidth = MIN (sel_width, PREVIEW_SIZE);
+ pheight = sel_height * pwidth / sel_width;
+ }
+ else
+ {
+ pheight = MIN (sel_height, PREVIEW_SIZE);
+ pwidth = sel_width * pheight / sel_height;
+ }
+
+
+ preview_width = MAX (pwidth, 2); /* Min size is 2 */
+ preview_height = MAX (pheight, 2);
+
+ org_scale_x_factor = scale_x_factor =
+ (gdouble) sel_width / (gdouble) preview_width;
+ org_scale_y_factor = scale_y_factor =
+ (gdouble) sel_height / (gdouble) preview_height;
+
+ /* initialize */
+ gfig_init_object_classes ();
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ case GIMP_RUN_WITH_LAST_VALS:
+ /*gimp_get_data (PLUG_IN_PROC, &selvals);*/
+ if (! gfig_dialog ())
+ {
+ gimp_image_undo_group_end (gfig_context->image_id);
+
+ return;
+ }
+ break;
+
+ case GIMP_RUN_NONINTERACTIVE:
+ status = GIMP_PDB_CALLING_ERROR;
+ break;
+
+ default:
+ break;
+ }
+
+ gimp_context_pop ();
+
+ gimp_image_undo_group_end (gfig_context->image_id);
+
+ if (run_mode != GIMP_RUN_NONINTERACTIVE)
+ gimp_displays_flush ();
+ else
+#if 0
+ if (run_mode == GIMP_RUN_INTERACTIVE)
+ gimp_set_data (PLUG_IN_PROC, &selvals, sizeof (SelectItVals));
+ else
+#endif /* 0 */
+ {
+ status = GIMP_PDB_EXECUTION_ERROR;
+ }
+
+ values[0].data.d_status = status;
+}
+
+/*
+ Translate SPACE to "\\040", etc.
+ Taken from gflare plugin
+ */
+void
+gfig_name_encode (gchar *dest,
+ gchar *src)
+{
+ gint cnt = MAX_LOAD_LINE - 1;
+
+ while (*src && cnt--)
+ {
+ if (g_ascii_iscntrl (*src) || g_ascii_isspace (*src) || *src == '\\')
+ {
+ sprintf (dest, "\\%03o", *src++);
+ dest += 4;
+ }
+ else
+ *dest++ = *src++;
+ }
+ *dest = '\0';
+}
+
+/*
+ Translate "\\040" to SPACE, etc.
+ */
+void
+gfig_name_decode (gchar *dest,
+ const gchar *src)
+{
+ gint cnt = MAX_LOAD_LINE - 1;
+ guint tmp;
+
+ while (*src && cnt--)
+ {
+ if (*src == '\\' && *(src+1) && *(src+2) && *(src+3))
+ {
+ sscanf (src+1, "%3o", &tmp);
+ *dest++ = tmp;
+ src += 4;
+ }
+ else
+ *dest++ = *src++;
+ }
+ *dest = '\0';
+}
+
+
+/*
+ * Load all gfig, which are founded in gfig-path-list, into gfig_list.
+ * gfig-path-list must be initialized first. (plug_in_parse_gfig_path ())
+ * based on code from Gflare.
+ */
+
+gint
+gfig_list_pos (GFigObj *gfig)
+{
+ GFigObj *g;
+ gint n;
+ GList *tmp;
+
+ n = 0;
+
+ for (tmp = gfig_list; tmp; tmp = g_list_next (tmp))
+ {
+ g = tmp->data;
+
+ if (strcmp (gfig->draw_name, g->draw_name) <= 0)
+ break;
+
+ n++;
+ }
+ return n;
+}
+
+/*
+ * Insert gfigs in alphabetical order
+ */
+
+gint
+gfig_list_insert (GFigObj *gfig)
+{
+ gint n;
+
+ n = gfig_list_pos (gfig);
+
+ gfig_list = g_list_insert (gfig_list, gfig, n);
+
+ return n;
+}
+
+void
+gfig_free (GFigObj *gfig)
+{
+ g_assert (gfig != NULL);
+
+ free_all_objs (gfig->obj_list);
+
+ g_free (gfig->name);
+ g_free (gfig->filename);
+ g_free (gfig->draw_name);
+
+ g_free (gfig);
+}
+
+GFigObj *
+gfig_new (void)
+{
+ return g_new0 (GFigObj, 1);
+}
+
+static void
+gfig_load_objs (GFigObj *gfig,
+ gint load_count,
+ FILE *fp)
+{
+ GfigObject *obj;
+ gchar load_buf[MAX_LOAD_LINE];
+ glong offset;
+ glong offset2;
+ Style style;
+
+ while (load_count-- > 0)
+ {
+ obj = NULL;
+ get_line (load_buf, MAX_LOAD_LINE, fp, 0);
+
+ /* kludge */
+ offset = ftell (fp);
+ gfig_skip_style (&style, fp);
+
+ obj = d_load_object (load_buf, fp);
+
+ if (obj)
+ {
+ add_to_all_obj (gfig, obj);
+ offset2 = ftell (fp);
+ fseek (fp, offset, SEEK_SET);
+ gfig_load_style (&obj->style, fp);
+ fseek (fp, offset2, SEEK_SET);
+ }
+ else
+ {
+ g_message ("Failed to load object, load count = %d", load_count);
+ }
+ }
+}
+
+GFigObj *
+gfig_load (const gchar *filename,
+ const gchar *name)
+{
+ GFigObj *gfig;
+ FILE *fp;
+ gchar load_buf[MAX_LOAD_LINE];
+ gchar str_buf[MAX_LOAD_LINE];
+ gint chk_count;
+ gint load_count = 0;
+ gdouble version;
+ gchar magic1[20];
+ gchar magic2[20];
+
+ g_assert (filename != NULL);
+
+#ifdef DEBUG
+ printf ("Loading %s (%s)\n", filename, name);
+#endif /* DEBUG */
+
+ fp = g_fopen (filename, "rb");
+ if (!fp)
+ {
+ g_message (_("Could not open '%s' for reading: %s"),
+ gimp_filename_to_utf8 (filename), g_strerror (errno));
+ return NULL;
+ }
+
+ gfig = gfig_new ();
+
+ gfig->name = g_strdup (name);
+ gfig->filename = g_strdup (filename);
+
+
+ /* HEADER
+ * draw_name
+ * version
+ * obj_list
+ */
+
+ get_line (load_buf, MAX_LOAD_LINE, fp, 1);
+
+ sscanf (load_buf, "%10s %10s %lf", magic1, magic2, &version);
+
+ if (strcmp (magic1, "GFIG") || strcmp (magic2, "Version"))
+ {
+ g_message ("File '%s' is not a gfig file",
+ gimp_filename_to_utf8 (gfig->filename));
+ gfig_free (gfig);
+ fclose (fp);
+ return NULL;
+ }
+
+ get_line (load_buf, MAX_LOAD_LINE, fp, 0);
+ sscanf (load_buf, "Name: %100s", str_buf);
+ gfig_name_decode (load_buf, str_buf);
+ gfig->draw_name = g_strdup (load_buf);
+
+ get_line (load_buf, MAX_LOAD_LINE, fp, 0);
+ if (strncmp (load_buf, "Version: ", 9) == 0)
+ gfig->version = g_ascii_strtod (load_buf + 9, NULL);
+
+ get_line (load_buf, MAX_LOAD_LINE, fp, 0);
+ sscanf (load_buf, "ObjCount: %d", &load_count);
+
+ if (load_options (gfig, fp))
+ {
+ g_message ("File '%s' corrupt file - Line %d Option section incorrect",
+ gimp_filename_to_utf8 (filename), line_no);
+ gfig_free (gfig);
+ fclose (fp);
+ return NULL;
+ }
+
+ if (gfig_load_styles (gfig, fp))
+ {
+ g_message ("File '%s' corrupt file - Line %d Option section incorrect",
+ gimp_filename_to_utf8 (filename), line_no);
+ gfig_free (gfig);
+ fclose (fp);
+ return NULL;
+ }
+
+
+
+ gfig_load_objs (gfig, load_count, fp);
+
+ /* Check count ? */
+
+ chk_count = g_list_length (gfig->obj_list);
+
+ if (chk_count != load_count)
+ {
+ g_message ("File '%s' corrupt file - Line %d Object count to small",
+ gimp_filename_to_utf8 (filename), line_no);
+ gfig_free (gfig);
+ fclose (fp);
+ return NULL;
+ }
+
+ fclose (fp);
+
+ if (!gfig_context->current_obj)
+ gfig_context->current_obj = gfig;
+
+ gfig->obj_status = GFIG_OK;
+
+ return gfig;
+}
+
+void
+save_options (GString *string)
+{
+ /* Save options */
+ g_string_append_printf (string, "<OPTIONS>\n");
+ g_string_append_printf (string, "GridSpacing: %d\n",
+ selvals.opts.gridspacing);
+ if (selvals.opts.gridtype == RECT_GRID)
+ {
+ g_string_append_printf (string, "GridType: RECT_GRID\n");
+ }
+ else if (selvals.opts.gridtype == POLAR_GRID)
+ {
+ g_string_append_printf (string, "GridType: POLAR_GRID\n");
+ }
+ else if (selvals.opts.gridtype == ISO_GRID)
+ {
+ g_string_append_printf (string, "GridType: ISO_GRID\n");
+ }
+ else
+ {
+ /* default to RECT_GRID */
+ g_string_append_printf (string, "GridType: RECT_GRID\n");
+ }
+
+ g_string_append_printf (string, "DrawGrid: %s\n",
+ (selvals.opts.drawgrid) ? "TRUE" : "FALSE");
+ g_string_append_printf (string, "Snap2Grid: %s\n",
+ (selvals.opts.snap2grid) ? "TRUE" : "FALSE");
+ g_string_append_printf (string, "LockOnGrid: %s\n",
+ (selvals.opts.lockongrid) ? "TRUE" : "FALSE");
+ g_string_append_printf (string, "ShowControl: %s\n",
+ (selvals.opts.showcontrol) ? "TRUE" : "FALSE");
+ g_string_append_printf (string, "</OPTIONS>\n");
+}
+
+static void
+gfig_save_obj_start (GfigObject *obj,
+ GString *string)
+{
+ g_string_append_printf (string, "<%s ", obj->class->name);
+ gfig_style_save_as_attributes (&obj->style, string);
+ g_string_append_printf (string, ">\n");
+}
+
+static void
+gfig_save_obj_end (GfigObject *obj,
+ GString *string)
+{
+ g_string_append_printf (string, "</%s>\n",obj->class->name);
+}
+
+static gboolean
+load_bool (gchar *opt_buf,
+ gint *toset)
+{
+ if (!strcmp (opt_buf, "TRUE"))
+ *toset = 1;
+ else if (!strcmp (opt_buf, "FALSE"))
+ *toset = 0;
+ else
+ return TRUE;
+
+ return FALSE;
+}
+
+static gint
+load_options (GFigObj *gfig,
+ FILE *fp)
+{
+ gchar load_buf[MAX_LOAD_LINE];
+ gchar str_buf[MAX_LOAD_LINE];
+ gchar opt_buf[MAX_LOAD_LINE];
+
+ get_line (load_buf, MAX_LOAD_LINE, fp, 0);
+
+#ifdef DEBUG
+ printf ("load '%s'\n", load_buf);
+#endif /* DEBUG */
+
+ if (strcmp (load_buf, "<OPTIONS>"))
+ return (-1);
+
+ get_line (load_buf, MAX_LOAD_LINE, fp, 0);
+
+#ifdef DEBUG
+ printf ("opt line '%s'\n", load_buf);
+#endif /* DEBUG */
+
+ while (strcmp (load_buf, "</OPTIONS>"))
+ {
+ /* Get option name */
+#ifdef DEBUG
+ printf ("num = %d\n", sscanf (load_buf, "%255s %255s", str_buf, opt_buf));
+
+ printf ("option %s val %s\n", str_buf, opt_buf);
+#else
+ sscanf (load_buf, "%255s %255s", str_buf, opt_buf);
+#endif /* DEBUG */
+
+ if (!strcmp (str_buf, "GridSpacing:"))
+ {
+ /* Value is decimal */
+ int sp = 0;
+ sp = atoi (opt_buf);
+ if (sp <= 0)
+ return (-1);
+ gfig->opts.gridspacing = sp;
+ }
+ else if (!strcmp (str_buf, "DrawGrid:"))
+ {
+ /* Value is bool */
+ if (load_bool (opt_buf, &gfig->opts.drawgrid))
+ return (-1);
+ }
+ else if (!strcmp (str_buf, "Snap2Grid:"))
+ {
+ /* Value is bool */
+ if (load_bool (opt_buf, &gfig->opts.snap2grid))
+ return (-1);
+ }
+ else if (!strcmp (str_buf, "LockOnGrid:"))
+ {
+ /* Value is bool */
+ if (load_bool (opt_buf, &gfig->opts.lockongrid))
+ return (-1);
+ }
+ else if (!strcmp (str_buf, "ShowControl:"))
+ {
+ /* Value is bool */
+ if (load_bool (opt_buf, &gfig->opts.showcontrol))
+ return (-1);
+ }
+ else if (!strcmp (str_buf, "GridType:"))
+ {
+ /* Value is string */
+ if (!strcmp (opt_buf, "RECT_GRID"))
+ gfig->opts.gridtype = RECT_GRID;
+ else if (!strcmp (opt_buf, "POLAR_GRID"))
+ gfig->opts.gridtype = POLAR_GRID;
+ else if (!strcmp (opt_buf, "ISO_GRID"))
+ gfig->opts.gridtype = ISO_GRID;
+ else
+ return (-1);
+ }
+
+ get_line (load_buf, MAX_LOAD_LINE, fp, 0);
+
+#ifdef DEBUG
+ printf ("opt line '%s'\n", load_buf);
+#endif /* DEBUG */
+ }
+ return (0);
+}
+
+GString *
+gfig_save_as_string (void)
+{
+ GList *objs;
+ gint count;
+ gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
+ gchar conv_buf[MAX_LOAD_LINE * 3 + 1];
+ GString *string;
+
+ string = g_string_new (GFIG_HEADER);
+
+ gfig_name_encode (conv_buf, gfig_context->current_obj->draw_name);
+ g_string_append_printf (string, "Name: %s\n", conv_buf);
+ g_string_append_printf (string, "Version: %s\n",
+ g_ascii_formatd (buf, G_ASCII_DTOSTR_BUF_SIZE, "%f",
+ gfig_context->current_obj->version));
+ objs = gfig_context->current_obj->obj_list;
+
+ count = g_list_length (objs);
+
+ g_string_append_printf (string, "ObjCount: %d\n", count);
+
+ save_options (string);
+
+ gfig_save_styles (string);
+
+ for (objs = gfig_context->current_obj->obj_list;
+ objs;
+ objs = g_list_next (objs))
+ {
+ GfigObject *object = objs->data;
+
+ gfig_save_obj_start (object, string);
+
+ gfig_save_style (&object->style, string);
+
+ if (object->points)
+ d_save_object (object, string);
+
+ gfig_save_obj_end (object, string);
+ }
+
+ return string;
+}
+
+
+gboolean
+gfig_save_as_parasite (void)
+{
+ GimpParasite *parasite;
+ GString *string;
+
+ string = gfig_save_as_string ();
+
+ parasite = gimp_parasite_new ("gfig",
+ GIMP_PARASITE_PERSISTENT |
+ GIMP_PARASITE_UNDOABLE,
+ string->len, string->str);
+
+ g_string_free (string, TRUE);
+
+ if (!gimp_item_attach_parasite (gfig_context->drawable_id, parasite))
+ {
+ g_message (_("Error trying to save figure as a parasite: "
+ "can't attach parasite to drawable."));
+ gimp_parasite_free (parasite);
+ return FALSE;
+ }
+
+ gimp_parasite_free (parasite);
+ return TRUE;
+}
+
+GFigObj *
+gfig_load_from_parasite (void)
+{
+ FILE *fp;
+ gchar *fname;
+ GimpParasite *parasite;
+ GFigObj *gfig;
+
+ parasite = gimp_item_get_parasite (gfig_context->drawable_id, "gfig");
+ if (! parasite)
+ return NULL;
+
+ fname = gimp_temp_name ("gfigtmp");
+
+ fp = g_fopen (fname, "wb");
+ if (!fp)
+ {
+ g_message (_("Error trying to open temporary file '%s' "
+ "for parasite loading: %s"),
+ gimp_filename_to_utf8 (fname), g_strerror (errno));
+ return NULL;
+ }
+
+ fwrite (gimp_parasite_data (parasite),
+ sizeof (guchar),
+ gimp_parasite_data_size (parasite),
+ fp);
+ fclose (fp);
+
+ gimp_parasite_free (parasite);
+
+ gfig = gfig_load (fname, "(none)");
+
+ g_unlink (fname);
+
+ g_free (fname);
+
+ return gfig;
+}
+
+void
+gfig_save_callbk (void)
+{
+ FILE *fp;
+ gchar *savename;
+ GString *string;
+
+ savename = gfig_context->current_obj->filename;
+
+ fp = g_fopen (savename, "w+b");
+
+ if (!fp)
+ {
+ g_message (_("Could not open '%s' for writing: %s"),
+ gimp_filename_to_utf8 (savename), g_strerror (errno));
+ return;
+ }
+
+ string = gfig_save_as_string ();
+
+ fwrite (string->str, string->len, 1, fp);
+
+ if (ferror (fp))
+ g_message ("Failed to write file.");
+ else
+ gfig_context->current_obj->obj_status &= ~(GFIG_MODIFIED | GFIG_READONLY);
+
+ fclose (fp);
+}