Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 551 insertions, 0 deletions

diff --git a/plug-ins/ifs-compose/ifs-compose-storage.c b/plug-ins/ifs-compose/ifs-compose-storage.c
new file mode 100644
index 0000000..24705be
--- /dev/null
+++ b/plug-ins/ifs-compose/ifs-compose-storage.c
@@ -0,0 +1,551 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * IfsCompose is a interface for creating IFS fractals by
+ * direct manipulation.
+ * Copyright (C) 1997 Owen Taylor
+ *
+ * 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
+ * MERCHANTBILITY 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> /* strlen */
+
+#include <gdk/gdk.h>
+
+#include <libgimp/gimp.h>
+
+#include "ifs-compose.h"
+
+
+typedef enum {
+  TOKEN_INVALID = G_TOKEN_LAST,
+  TOKEN_ITERATIONS,
+  TOKEN_MAX_MEMORY,
+  TOKEN_SUBDIVIDE,
+  TOKEN_RADIUS,
+  TOKEN_ASPECT_RATIO,
+  TOKEN_CENTER_X,
+  TOKEN_CENTER_Y,
+  TOKEN_ELEMENT,
+  TOKEN_X,
+  TOKEN_Y,
+  TOKEN_THETA,
+  TOKEN_SCALE,
+  TOKEN_ASYM,
+  TOKEN_SHEAR,
+  TOKEN_FLIP,
+  TOKEN_RED_COLOR,
+  TOKEN_GREEN_COLOR,
+  TOKEN_BLUE_COLOR,
+  TOKEN_BLACK_COLOR,
+  TOKEN_TARGET_COLOR,
+  TOKEN_HUE_SCALE,
+  TOKEN_VALUE_SCALE,
+  TOKEN_SIMPLE_COLOR,
+  TOKEN_PROB
+} IfsComposeToken;
+
+static struct
+{
+  const gchar     *name;
+  IfsComposeToken  token;
+} symbols[] = {
+  { "iterations",   TOKEN_ITERATIONS },
+  { "max_memory",   TOKEN_MAX_MEMORY },
+  { "subdivide",    TOKEN_SUBDIVIDE },
+  { "radius",       TOKEN_RADIUS },
+  { "aspect_ratio", TOKEN_ASPECT_RATIO },
+  { "center_x",     TOKEN_CENTER_X },
+  { "center_y",     TOKEN_CENTER_Y },
+  { "element",      TOKEN_ELEMENT },
+  { "x",            TOKEN_X },
+  { "y",            TOKEN_Y },
+  { "theta",        TOKEN_THETA },
+  { "scale",        TOKEN_SCALE },
+  { "asym",         TOKEN_ASYM },
+  { "shear",        TOKEN_SHEAR },
+  { "flip",         TOKEN_FLIP },
+  { "red_color",    TOKEN_RED_COLOR },
+  { "green_color",  TOKEN_GREEN_COLOR },
+  { "blue_color",   TOKEN_BLUE_COLOR },
+  { "black_color",  TOKEN_BLACK_COLOR },
+  { "target_color", TOKEN_TARGET_COLOR },
+  { "hue_scale",    TOKEN_HUE_SCALE },
+  { "value_scale",  TOKEN_VALUE_SCALE },
+  { "simple_color", TOKEN_SIMPLE_COLOR },
+  { "prob",         TOKEN_PROB }
+};
+
+static GTokenType
+ifsvals_parse_color (GScanner *scanner,
+		     GimpRGB  *result)
+{
+  GTokenType token;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token != G_TOKEN_LEFT_CURLY)
+    return G_TOKEN_LEFT_CURLY;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token == G_TOKEN_FLOAT)
+    result->r = scanner->value.v_float;
+  else if (token == G_TOKEN_INT)
+    result->r = scanner->value.v_int;
+  else
+    return G_TOKEN_FLOAT;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token != G_TOKEN_COMMA)
+    return G_TOKEN_COMMA;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token == G_TOKEN_FLOAT)
+    result->g = scanner->value.v_float;
+  else if (token == G_TOKEN_INT)
+    result->g = scanner->value.v_int;
+  else
+    return G_TOKEN_FLOAT;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token != G_TOKEN_COMMA)
+    return G_TOKEN_COMMA;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token == G_TOKEN_FLOAT)
+    result->b = scanner->value.v_float;
+  else if (token == G_TOKEN_INT)
+    result->b = scanner->value.v_int;
+  else
+    return G_TOKEN_FLOAT;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token != G_TOKEN_RIGHT_CURLY)
+    return G_TOKEN_RIGHT_CURLY;
+
+  return G_TOKEN_NONE;
+}
+
+/* Parse a float which (unlike G_TOKEN_FLOAT) can be negative
+ */
+static GTokenType
+parse_genuine_float (GScanner *scanner,
+                     gdouble  *result)
+{
+  gboolean negate = FALSE;
+  GTokenType token;
+
+  token = g_scanner_get_next_token (scanner);
+
+  if (token == '-')
+    {
+      negate = TRUE;
+      token = g_scanner_get_next_token (scanner);
+    }
+
+  if (token == G_TOKEN_FLOAT)
+    {
+      *result = negate ? -scanner->value.v_float : scanner->value.v_float;
+      return G_TOKEN_NONE;
+    }
+  else if (token == G_TOKEN_INT)
+    {
+      *result = negate ? -scanner->value.v_int : scanner->value.v_int;
+      return G_TOKEN_NONE;
+    }
+  else
+    return G_TOKEN_FLOAT;
+}
+
+static GTokenType
+ifsvals_parse_element (GScanner       *scanner,
+                       AffElementVals *result)
+{
+  GTokenType token;
+  GTokenType expected_token;
+
+  token = g_scanner_get_next_token (scanner);
+  if (token != G_TOKEN_LEFT_CURLY)
+    return G_TOKEN_LEFT_CURLY;
+
+  token = g_scanner_get_next_token (scanner);
+  while (token != G_TOKEN_RIGHT_CURLY)
+    {
+      switch ((IfsComposeToken) token)
+	{
+	case TOKEN_X:
+	  expected_token = parse_genuine_float (scanner, &result->x);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_Y:
+	  expected_token = parse_genuine_float (scanner, &result->y);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_THETA:
+	  expected_token = parse_genuine_float (scanner, &result->theta);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_SCALE:
+	  expected_token = parse_genuine_float (scanner, &result->scale);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_ASYM:
+	  expected_token = parse_genuine_float (scanner, &result->asym);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_SHEAR:
+	  expected_token = parse_genuine_float (scanner, &result->shear);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_FLIP:
+	  token = g_scanner_get_next_token (scanner);
+	  if (token != G_TOKEN_INT)
+	    return G_TOKEN_INT;
+
+	  result->flip = scanner->value.v_int;
+	  break;
+
+	case TOKEN_RED_COLOR:
+	  token = ifsvals_parse_color (scanner, &result->red_color);
+	  if (token != G_TOKEN_NONE)
+	    return token;
+	  break;
+
+	case TOKEN_GREEN_COLOR:
+	  token = ifsvals_parse_color (scanner, &result->green_color);
+	  if (token != G_TOKEN_NONE)
+	    return token;
+	  break;
+
+	case TOKEN_BLUE_COLOR:
+	  token = ifsvals_parse_color (scanner, &result->blue_color);
+	  if (token != G_TOKEN_NONE)
+	    return token;
+	  break;
+
+	case TOKEN_BLACK_COLOR:
+	  token = ifsvals_parse_color (scanner, &result->black_color);
+	  if (token != G_TOKEN_NONE)
+	    return token;
+	  break;
+
+	case TOKEN_TARGET_COLOR:
+	  token = ifsvals_parse_color (scanner, &result->target_color);
+	  if (token != G_TOKEN_NONE)
+	    return token;
+	  break;
+
+	case TOKEN_HUE_SCALE:
+	  expected_token = parse_genuine_float (scanner, &result->hue_scale);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_VALUE_SCALE:
+	  expected_token = parse_genuine_float (scanner, &result->value_scale);
+	  if (expected_token != G_TOKEN_NONE)
+	    return expected_token;
+	  break;
+
+	case TOKEN_SIMPLE_COLOR:
+	  token = g_scanner_get_next_token (scanner);
+	  if (token != G_TOKEN_INT)
+	    return G_TOKEN_INT;
+
+	  result->simple_color = scanner->value.v_int;
+	  break;
+
+	case TOKEN_PROB:
+	  token = g_scanner_get_next_token (scanner);
+	  if (token == G_TOKEN_FLOAT)
+            result->prob = scanner->value.v_float;
+          else if (token == G_TOKEN_INT)
+            result->prob = scanner->value.v_int;
+          else
+	    return G_TOKEN_FLOAT;
+
+	  break;
+
+	default:
+	  return G_TOKEN_SYMBOL;
+	}
+
+      token = g_scanner_get_next_token (scanner);
+    }
+
+  return G_TOKEN_NONE;
+}
+
+/*************************************************************
+ * ifsvals_parse:
+ *     Read in ifsvalues from a GScanner
+ *   arguments:
+ *     scanner:
+ *     vals:
+ *     elements:
+ *
+ *   results:
+ *     If parsing succeeded, TRUE; otherwise FALSE, in which
+ *     case vals and elements are unchanged
+ *************************************************************/
+
+static gboolean
+ifsvals_parse (GScanner         *scanner,
+               IfsComposeVals   *vals,
+               AffElement     ***elements)
+{
+  GTokenType      token, expected_token;
+  AffElement     *el;
+  IfsComposeVals  new_vals;
+  GimpRGB         color;
+
+  GList *el_list = NULL;
+  GList *tmp_list;
+  gint   i;
+
+  new_vals = *vals;
+  new_vals.num_elements = 0;
+  i = 0;
+
+  expected_token = G_TOKEN_NONE;
+  while (expected_token == G_TOKEN_NONE)
+    {
+      token = g_scanner_get_next_token (scanner);
+
+      if (g_scanner_eof (scanner))
+	  break;
+
+      switch ((IfsComposeToken) token)
+	{
+	case TOKEN_ITERATIONS:
+	  token = g_scanner_get_next_token (scanner);
+	  if (token == G_TOKEN_INT)
+	    new_vals.iterations = scanner->value.v_int;
+	  else
+	    expected_token = G_TOKEN_INT;
+	  break;
+
+	case TOKEN_MAX_MEMORY:
+	  token = g_scanner_get_next_token (scanner);
+	  if (token == G_TOKEN_INT)
+	    new_vals.max_memory = scanner->value.v_int;
+	  else
+	    expected_token = G_TOKEN_INT;
+	  break;
+
+	case TOKEN_SUBDIVIDE:
+	  token = g_scanner_get_next_token (scanner);
+	  if (token == G_TOKEN_INT)
+	    new_vals.subdivide = scanner->value.v_int;
+	  else
+	    expected_token = G_TOKEN_INT;
+	  break;
+
+	case TOKEN_RADIUS:
+	  expected_token = parse_genuine_float (scanner, &new_vals.radius);
+	  break;
+
+	case TOKEN_ASPECT_RATIO:
+	  expected_token = parse_genuine_float (scanner, &new_vals.aspect_ratio);
+	  break;
+
+	case TOKEN_CENTER_X:
+	  expected_token = parse_genuine_float (scanner, &new_vals.center_x);
+	  break;
+
+	case TOKEN_CENTER_Y:
+	  expected_token = parse_genuine_float (scanner, &new_vals.center_y);
+	  break;
+
+	case TOKEN_ELEMENT:
+	  el = aff_element_new (0.0,0.0, &color, ++i);
+	  expected_token = ifsvals_parse_element (scanner, &el->v);
+
+	  if (expected_token == G_TOKEN_NONE)
+	    {
+	      el_list = g_list_prepend (el_list, el);
+	      new_vals.num_elements++;
+	    }
+	  else
+	    aff_element_free (el);
+
+	  break;
+
+	default:
+	  expected_token = G_TOKEN_SYMBOL;
+	}
+    }
+
+  if (expected_token != G_TOKEN_NONE)
+    {
+      g_scanner_unexp_token (scanner,
+			     expected_token,
+			     NULL,
+			     NULL,
+			     NULL,
+			     "using default values...",
+			     TRUE);
+      g_list_free_full (el_list, (GDestroyNotify) g_free);
+      return FALSE;
+    }
+
+  *vals = new_vals;
+
+  el_list = g_list_reverse (el_list);
+  *elements = g_new (AffElement *, new_vals.num_elements);
+
+  tmp_list = el_list;
+  for (i=0; i<new_vals.num_elements; i++)
+    {
+      (*elements)[i] = tmp_list->data;
+      tmp_list = tmp_list->next;
+    }
+
+  g_list_free (el_list);
+
+  return TRUE;
+}
+
+gboolean
+ifsvals_parse_string (const gchar      *str,
+                      IfsComposeVals   *vals,
+                      AffElement     ***elements)
+{
+  GScanner *scanner = g_scanner_new (NULL);
+  gboolean  result;
+  gint      i;
+
+  scanner->config->symbol_2_token = TRUE;
+  scanner->config->scan_identifier_1char = TRUE;
+  scanner->input_name = "IfsCompose Saved Data";
+
+  for (i = 0; i < G_N_ELEMENTS (symbols); i++)
+    g_scanner_scope_add_symbol (scanner, 0,
+                                symbols[i].name,
+                                GINT_TO_POINTER (symbols[i].token));
+
+  g_scanner_input_text (scanner, str, strlen (str));
+
+  result = ifsvals_parse (scanner, vals, elements);
+
+  g_scanner_destroy (scanner);
+
+  return result;
+}
+
+/*************************************************************
+ * ifsvals_stringify:
+ *     Stringify a set of vals and elements
+ *   arguments:
+ *     vals:
+ *     elements
+ *   results:
+ *     The stringified result (free with g_free)
+ *************************************************************/
+
+gchar *
+ifsvals_stringify (IfsComposeVals  *vals,
+                   AffElement     **elements)
+{
+  gint     i;
+  gchar    buf[G_ASCII_DTOSTR_BUF_SIZE];
+  gchar    cbuf[3][G_ASCII_DTOSTR_BUF_SIZE];
+  GString *result;
+
+  result = g_string_new (NULL);
+
+  g_string_append_printf (result, "iterations %d\n", vals->iterations);
+  g_string_append_printf (result, "max_memory %d\n", vals->max_memory);
+  g_string_append_printf (result, "subdivide %d\n", vals->subdivide);
+  g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, vals->radius);
+  g_string_append_printf (result, "radius %s\n", buf);
+  g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, vals->aspect_ratio);
+  g_string_append_printf (result, "aspect_ratio %s\n", buf);
+  g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, vals->center_x);
+  g_string_append_printf (result, "center_x %s\n", buf);
+  g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, vals->center_y);
+  g_string_append_printf (result, "center_y %s\n", buf);
+
+  for (i=0; i<vals->num_elements; i++)
+    {
+      g_string_append (result, "element {\n");
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.x);
+      g_string_append_printf (result, "    x %s\n", buf);
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.y);
+      g_string_append_printf (result, "    y %s\n", buf);
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.theta);
+      g_string_append_printf (result, "    theta %s\n", buf);
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.scale);
+      g_string_append_printf (result, "    scale %s\n", buf);
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.asym);
+      g_string_append_printf (result, "    asym %s\n", buf);
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.shear);
+      g_string_append_printf (result, "    shear %s\n", buf);
+      g_string_append_printf (result, "    flip %d\n", elements[i]->v.flip);
+
+      g_ascii_dtostr (cbuf[0], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.red_color.r);
+      g_ascii_dtostr (cbuf[1], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.red_color.g);
+      g_ascii_dtostr (cbuf[2], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.red_color.b);
+      g_string_append_printf (result, "    red_color { %s,%s,%s }\n",
+                              cbuf[0], cbuf[1], cbuf[2]);
+
+      g_ascii_dtostr (cbuf[0], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.green_color.r);
+      g_ascii_dtostr (cbuf[1], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.green_color.g);
+      g_ascii_dtostr (cbuf[2], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.green_color.b);
+      g_string_append_printf (result, "    green_color { %s,%s,%s }\n",
+                              cbuf[0], cbuf[1], cbuf[2]);
+
+      g_ascii_dtostr (cbuf[0], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.blue_color.r);
+      g_ascii_dtostr (cbuf[1], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.blue_color.g);
+      g_ascii_dtostr (cbuf[2], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.blue_color.b);
+      g_string_append_printf (result, "    blue_color { %s,%s,%s }\n",
+                              cbuf[0], cbuf[1], cbuf[2]);
+
+      g_ascii_dtostr (cbuf[0], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.black_color.r);
+      g_ascii_dtostr (cbuf[1], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.black_color.g);
+      g_ascii_dtostr (cbuf[2], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.black_color.b);
+      g_string_append_printf (result, "    black_color { %s,%s,%s }\n",
+                              cbuf[0], cbuf[1], cbuf[2]);
+
+      g_ascii_dtostr (cbuf[0], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.target_color.r);
+      g_ascii_dtostr (cbuf[1], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.target_color.g);
+      g_ascii_dtostr (cbuf[2], G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.target_color.b);
+      g_string_append_printf (result, "    target_color { %s,%s,%s }\n",
+                              cbuf[0], cbuf[1], cbuf[2]);
+
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.hue_scale);
+      g_string_append_printf (result, "    hue_scale %s\n", buf);
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.value_scale);
+      g_string_append_printf (result, "    value_scale %s\n", buf);
+      g_string_append_printf (result, "    simple_color %d\n",
+                              elements[i]->v.simple_color);
+      g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, elements[i]->v.prob);
+      g_string_append_printf (result, "    prob %s\n", buf);
+      g_string_append (result, "}\n");
+    }
+
+  return g_string_free (result, FALSE);
+}