Adding upstream version 2.10.22.upstream/2.10.22upstream

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

1 files changed, 450 insertions, 0 deletions

diff --git a/plug-ins/common/file-glob.c b/plug-ins/common/file-glob.c
new file mode 100644
index 0000000..6ce0e00
--- /dev/null
+++ b/plug-ins/common/file-glob.c
@@ -0,0 +1,450 @@
+/* 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/>.
+ */
+
+/* The idea is taken from a plug-in written by George Hartz; the code isn't.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include "libgimp/gimp.h"
+
+
+#define PLUG_IN_PROC "file-glob"
+
+
+static void      query        (void);
+static void      run          (const gchar      *name,
+                               gint              nparams,
+                               const GimpParam  *param,
+                               gint             *nreturn_vals,
+                               GimpParam       **return_vals);
+
+static gboolean  glob_match   (const gchar      *pattern,
+                               gboolean          filename_encoding,
+                               gint             *num_matches,
+                               gchar          ***matches);
+static gboolean  glob_fnmatch (const gchar      *pattern,
+                               const gchar      *string);
+
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+  NULL,
+  NULL,
+  query,
+  run,
+};
+
+MAIN ()
+
+static void
+query (void)
+{
+  static const GimpParamDef glob_args[] =
+  {
+    { GIMP_PDB_STRING,  "pattern" ,  "The glob pattern (in UTF-8 encoding)" },
+    { GIMP_PDB_INT32,   "encoding",  "Encoding of the returned names: "
+                                     "{ UTF-8 (0), filename encoding (1) }" }
+  };
+
+  static const GimpParamDef glob_return_vals[] =
+  {
+    { GIMP_PDB_INT32,       "num-files", "The number of returned names" },
+    { GIMP_PDB_STRINGARRAY, "files",     "The list of matching names"   }
+  };
+
+
+  gimp_install_procedure (PLUG_IN_PROC,
+                          "Returns a list of matching filenames",
+                          "This can be useful in scripts and other plug-ins "
+                          "(e.g., batch-conversion). See the glob(7) manpage "
+                          "for more info. Note however that this isn't a "
+                          "full-featured glob implementation. It only handles "
+                          "simple patterns like \"/home/foo/bar/*.jpg\".",
+                          "Sven Neumann",
+                          "Sven Neumann",
+                          "2004",
+                          NULL,
+                          NULL,
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (glob_args),
+                          G_N_ELEMENTS (glob_return_vals),
+                          glob_args,
+                          glob_return_vals);
+}
+
+static void
+run (const gchar      *name,
+     gint              nparams,
+     const GimpParam  *param,
+     gint             *nreturn_vals,
+     GimpParam       **return_vals)
+{
+  static GimpParam values[3];
+
+  *nreturn_vals = 1;
+  *return_vals  = values;
+
+  values[0].type          = GIMP_PDB_STATUS;
+  values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
+
+  if (strcmp (name, PLUG_IN_PROC) == 0 && nparams >= 1)
+    {
+      gchar    **matches;
+      gint       num_matches;
+      gboolean   filename_encoding = FALSE;
+
+      if (nparams > 1)
+        filename_encoding = param[0].data.d_int32 ? TRUE : FALSE;
+
+      if (! glob_match (param[0].data.d_string, filename_encoding,
+                        &num_matches, &matches))
+        {
+          values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
+          return;
+        }
+
+      *nreturn_vals = 3;
+
+      values[0].type               = GIMP_PDB_STATUS;
+      values[0].data.d_status      = GIMP_PDB_SUCCESS;
+
+      values[1].type               = GIMP_PDB_INT32;
+      values[1].data.d_int32       = num_matches;
+
+      values[2].type               = GIMP_PDB_STRINGARRAY;
+      values[2].data.d_stringarray = matches;
+    }
+}
+
+static gboolean
+glob_match (const gchar   *pattern,
+            gboolean       filename_encoding,
+            gint          *num_matches,
+            gchar       ***matches)
+{
+  GDir        *dir;
+  GPtrArray   *array;
+  const gchar *filename;
+  gchar       *dirname;
+  gchar       *tmp;
+
+  g_return_val_if_fail (pattern != NULL, FALSE);
+  g_return_val_if_fail (num_matches != NULL, FALSE);
+  g_return_val_if_fail (matches != NULL, FALSE);
+
+  *num_matches = 0;
+  *matches     = NULL;
+
+  /*  This is not a complete glob() implementation but rather a very
+   *  simplistic approach. However it works for the most common use
+   *  case and is better than nothing.
+   */
+
+  tmp = g_filename_from_utf8 (pattern, -1, NULL, NULL, NULL);
+  if (! tmp)
+    return FALSE;
+
+  dirname = g_path_get_dirname (tmp);
+
+  dir = g_dir_open (dirname, 0, NULL);
+  g_free (tmp);
+
+  if (! dir)
+    {
+      g_free (dirname);
+      return TRUE;
+    }
+
+  /*  check if the pattern has a directory part at all  */
+  tmp = g_path_get_basename (pattern);
+  if (strcmp (pattern, tmp) == 0)
+    {
+      g_free (dirname);
+      dirname = NULL;
+    }
+  g_free (tmp);
+
+  array = g_ptr_array_new ();
+
+  for (filename = g_dir_read_name (dir);
+       filename;
+       filename = g_dir_read_name (dir))
+    {
+      gchar *path;
+      gchar *name;
+
+      if (dirname)
+        path = g_build_filename (dirname, filename, NULL);
+      else
+        path = g_strdup (filename);
+
+      name = g_filename_to_utf8 (path, -1, NULL, NULL, NULL);
+
+      if (name && glob_fnmatch (pattern, name))
+        {
+          if (filename_encoding)
+            {
+              g_ptr_array_add (array, path);
+              path = NULL;
+            }
+          else
+            {
+              g_ptr_array_add (array, name);
+              name = NULL;
+            }
+        }
+
+      g_free (path);
+      g_free (name);
+    }
+
+  g_dir_close (dir);
+  g_free (dirname);
+
+  *num_matches = array->len;
+  *matches     = (gchar **) g_ptr_array_free (array, FALSE);
+
+  return TRUE;
+}
+
+
+/*
+ * The following code is borrowed from GTK+.
+ *
+ * GTK+ used to use a old version of GNU fnmatch() that was buggy
+ * in various ways and didn't handle UTF-8. The following is
+ * converted to UTF-8. To simplify the process of making it
+ * correct, this is special-cased to the combinations of flags
+ * that gtkfilesel.c uses.
+ *
+ *   FNM_FILE_NAME   - always set
+ *   FNM_LEADING_DIR - never set
+ *   FNM_NOESCAPE    - set only on windows
+ *   FNM_CASEFOLD    - set only on windows
+ */
+
+/* We need to make sure that all constants are defined
+ * to properly compile this file
+ */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+static gunichar
+get_char (const char **str)
+{
+  gunichar c = g_utf8_get_char (*str);
+  *str = g_utf8_next_char (*str);
+
+#ifdef G_PLATFORM_WIN32
+  c = g_unichar_tolower (c);
+#endif
+
+  return c;
+}
+
+#if defined(G_OS_WIN32) || defined(G_WITH_CYGWIN)
+#define DO_ESCAPE 0
+#else
+#define DO_ESCAPE 1
+#endif
+
+static gunichar
+get_unescaped_char (const char **str,
+                    gboolean    *was_escaped)
+{
+  gunichar c = get_char (str);
+
+  *was_escaped = DO_ESCAPE && c == '\\';
+  if (*was_escaped)
+    c = get_char (str);
+
+  return c;
+}
+
+/* Match STRING against the filename pattern PATTERN,
+ * returning TRUE if it matches, FALSE otherwise.
+ */
+static gboolean
+fnmatch_intern (const gchar *pattern,
+                const gchar *string,
+                gboolean     component_start,
+                gboolean     no_leading_period)
+{
+  const char *p = pattern, *n = string;
+
+  while (*p)
+    {
+      const char *last_n = n;
+
+      gunichar c = get_char (&p);
+      gunichar nc = get_char (&n);
+
+      switch (c)
+        {
+        case '?':
+          if (nc == '\0')
+            return FALSE;
+          else if (nc == G_DIR_SEPARATOR)
+            return FALSE;
+          else if (nc == '.' && component_start && no_leading_period)
+            return FALSE;
+          break;
+        case '\\':
+          if (DO_ESCAPE)
+            c = get_char (&p);
+          if (nc != c)
+            return FALSE;
+          break;
+        case '*':
+          if (nc == '.' && component_start && no_leading_period)
+            return FALSE;
+
+          {
+            const char *last_p = p;
+
+            for (last_p = p, c = get_char (&p);
+                 c == '?' || c == '*';
+                 last_p = p, c = get_char (&p))
+              {
+                if (c == '?')
+                  {
+                    if (nc == '\0')
+                      return FALSE;
+                    else if (nc == G_DIR_SEPARATOR)
+                      return FALSE;
+                    else
+                      {
+                        last_n = n; nc = get_char (&n);
+                      }
+                  }
+              }
+
+            /* If the pattern ends with wildcards, we have a
+             * guaranteed match unless there is a dir separator
+             * in the remainder of the string.
+             */
+            if (c == '\0')
+              {
+                if (strchr (last_n, G_DIR_SEPARATOR) != NULL)
+                  return FALSE;
+                else
+                  return TRUE;
+              }
+
+            if (DO_ESCAPE && c == '\\')
+              c = get_char (&p);
+
+            for (p = last_p; nc != '\0';)
+              {
+                if ((c == '[' || nc == c) &&
+                    fnmatch_intern (p, last_n,
+                                    component_start, no_leading_period))
+                  return TRUE;
+
+                component_start = (nc == G_DIR_SEPARATOR);
+                last_n = n;
+                nc = get_char (&n);
+              }
+
+            return FALSE;
+          }
+
+        case '[':
+          {
+            /* Nonzero if the sense of the character class is inverted.  */
+            gboolean not;
+            gboolean was_escaped;
+
+            if (nc == '\0' || nc == G_DIR_SEPARATOR)
+              return FALSE;
+
+            if (nc == '.' && component_start && no_leading_period)
+              return FALSE;
+
+            not = (*p == '!' || *p == '^');
+            if (not)
+              ++p;
+
+            c = get_unescaped_char (&p, &was_escaped);
+            for (;;)
+              {
+                register gunichar cstart = c, cend = c;
+                if (c == '\0')
+                  /* [ (unterminated) loses.  */
+                  return FALSE;
+
+                c = get_unescaped_char (&p, &was_escaped);
+
+                if (!was_escaped && c == '-' && *p != ']')
+                  {
+                    cend = get_unescaped_char (&p, &was_escaped);
+                    if (cend == '\0')
+                      return FALSE;
+
+                    c = get_char (&p);
+                  }
+
+                if (nc >= cstart && nc <= cend)
+                  goto matched;
+
+                if (!was_escaped && c == ']')
+                  break;
+              }
+            if (!not)
+              return FALSE;
+            break;
+
+          matched:;
+            /* Skip the rest of the [...] that already matched.  */
+            /* XXX 1003.2d11 is unclear if was_escaped is right.  */
+            while (was_escaped || c != ']')
+              {
+                if (c == '\0')
+                  /* [... (unterminated) loses.  */
+                  return FALSE;
+
+                c = get_unescaped_char (&p, &was_escaped);
+              }
+            if (not)
+              return FALSE;
+          }
+          break;
+
+        default:
+          if (c != nc)
+            return FALSE;
+        }
+
+      component_start = (nc == G_DIR_SEPARATOR);
+    }
+
+  if (*n == '\0')
+    return TRUE;
+
+  return FALSE;
+}
+
+static gboolean
+glob_fnmatch (const gchar *pattern,
+              const gchar *string)
+{
+  return fnmatch_intern (pattern, string, TRUE, TRUE);
+}