dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Issue #15152: Export to bzip2, gzip, xz gives warnings.

Browse source 
We could have tweaked further the code to guess what is a meta file
procedure or not (what we have done until now) but I decided to be more
explicit and added gimp_file_procedure_[gs]et_meta() functions to
libgimp to tag a specific import/export procedure to implement a meta
format.

gimp_file_procedure_set_extensions() would still be used to list well
known formats using this meta format, for instance "hgt.zip" or
"xcf.xz,xcfxz" but the meta extension (simply "zip" or "xz"
respectively) would be used as such. No more "guessing" using the list
of extensions and assuming that at least one of them would have a dot
within.
This commit is contained in:
Jehan 2025-10-28 01:20:45 +01:00
parent 3e19611609
commit 9a36698915
22 changed files with 530 additions and 161 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
app/file-data/file-data.c
View file

@ -64,7 +64,7 @@ file_data_init (Gimp *gimp)
strlen ("gimp-brush") + 1,
NULL);
gimp_plug_in_procedure_set_image_types (proc, NULL);
gimp_plug_in_procedure_set_file_proc (proc, "gbr, gbp", "",
gimp_plug_in_procedure_set_file_proc (proc, "gbr, gbp", NULL, "",
"20, string, GIMP");
gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-gbr");
gimp_plug_in_procedure_set_handles_remote (proc);
@ -124,7 +124,7 @@ file_data_init (Gimp *gimp)
#if 0
/* do not register as file procedure */
gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*");
gimp_plug_in_procedure_set_file_proc (proc, "gbr", "", NULL);
gimp_plug_in_procedure_set_file_proc (proc, "gbr", NULL, "", NULL);
gimp_plug_in_procedure_set_mime_types (proc, "image/x-gimp-gbr");
gimp_plug_in_procedure_set_handles_remote (proc);
#endif
@ -198,7 +198,7 @@ file_data_init (Gimp *gimp)
strlen ("gimp-brush") + 1,
NULL);
gimp_plug_in_procedure_set_image_types (proc, NULL);
gimp_plug_in_procedure_set_file_proc (proc, "gih", "", "");
gimp_plug_in_procedure_set_file_proc (proc, "gih", NULL, "", "");
gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-gih");
gimp_plug_in_procedure_set_handles_remote (proc);
@ -255,7 +255,7 @@ file_data_init (Gimp *gimp)
#if 0
/* do not register as file procedure */
gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*");
gimp_plug_in_procedure_set_file_proc (proc, "gih", "", NULL);
gimp_plug_in_procedure_set_file_proc (proc, "gih", NULL, "", NULL);
gimp_plug_in_procedure_set_mime_types (proc, "image/x-gimp-gih");
gimp_plug_in_procedure_set_handles_remote (proc);
#endif
@ -336,7 +336,7 @@ file_data_init (Gimp *gimp)
strlen ("gimp-pattern") + 1,
NULL);
gimp_plug_in_procedure_set_image_types (proc, NULL);
gimp_plug_in_procedure_set_file_proc (proc, "pat", "",
gimp_plug_in_procedure_set_file_proc (proc, "pat", NULL, "",
"20,string,GPAT");
gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-pat");
gimp_plug_in_procedure_set_handles_remote (proc);
@ -392,7 +392,7 @@ file_data_init (Gimp *gimp)
#if 0
/* do not register as file procedure */
gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*");
gimp_plug_in_procedure_set_file_proc (proc, "pat", "", NULL);
gimp_plug_in_procedure_set_file_proc (proc, "pat", NULL, "", NULL);
gimp_plug_in_procedure_set_mime_types (proc, "image/x-gimp-pat");
gimp_plug_in_procedure_set_handles_remote (proc);
#endif
@ -459,7 +459,7 @@ file_data_init (Gimp *gimp)
(const guint8 *) "gimp-plugin",
strlen ("gimp-plugin") + 1,
NULL);
gimp_plug_in_procedure_set_file_proc (proc, "gex", "",
gimp_plug_in_procedure_set_file_proc (proc, "gex", NULL, "",
"20, string, GIMP");
gimp_plug_in_procedure_set_generic_file_proc (proc, TRUE);
gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-gex");

40
app/pdb/pdb-cmds.c
View file

@ -850,13 +850,15 @@ pdb_set_file_proc_load_handler_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
const gchar *procedure_name;
const gchar *extensions;
const gchar *meta_extensions;
const gchar *prefixes;
const gchar *magics;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
extensions = g_value_get_string (gimp_value_array_index (args, 1));
prefixes = g_value_get_string (gimp_value_array_index (args, 2));
magics = g_value_get_string (gimp_value_array_index (args, 3));
meta_extensions = g_value_get_string (gimp_value_array_index (args, 2));
prefixes = g_value_get_string (gimp_value_array_index (args, 3));
magics = g_value_get_string (gimp_value_array_index (args, 4));
if (success)
{
@ -867,11 +869,13 @@ pdb_set_file_proc_load_handler_invoker (GimpProcedure *procedure,
{
success = gimp_plug_in_set_file_proc_load_handler (plug_in,
procedure_name,
extensions, prefixes,
magics, error);
extensions, meta_extensions,
prefixes, magics, error);
}
else
success = FALSE;
{
success = FALSE;
}
}
return gimp_procedure_get_return_values (procedure, success,
@ -889,11 +893,13 @@ pdb_set_file_proc_export_handler_invoker (GimpProcedure *procedure,
gboolean success = TRUE;
const gchar *procedure_name;
const gchar *extensions;
const gchar *meta_extensions;
const gchar *prefixes;
procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
extensions = g_value_get_string (gimp_value_array_index (args, 1));
prefixes = g_value_get_string (gimp_value_array_index (args, 2));
meta_extensions = g_value_get_string (gimp_value_array_index (args, 2));
prefixes = g_value_get_string (gimp_value_array_index (args, 3));
if (success)
{
@ -904,11 +910,13 @@ pdb_set_file_proc_export_handler_invoker (GimpProcedure *procedure,
{
success = gimp_plug_in_set_file_proc_save_handler (plug_in,
procedure_name,
extensions, prefixes,
error);
extensions, meta_extensions,
prefixes, error);
}
else
success = FALSE;
{
success = FALSE;
}
}
return gimp_procedure_get_return_values (procedure, success,
@ -1963,6 +1971,13 @@ register_pdb_procs (GimpPDB *pdb)
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("meta-extensions",
"meta extensions",
"comma separated list of meta extensions this handler can load (i.e. \"gz\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("prefixes",
"prefixes",
@ -2008,6 +2023,13 @@ register_pdb_procs (GimpPDB *pdb)
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("meta-extensions",
"meta extensions",
"comma separated list of meta extensions this handler can load (i.e. \"gz\")",
FALSE, FALSE, FALSE,
NULL,
GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("prefixes",
"prefixes",

6
app/plug-in/gimpplugin-proc.c
View file

@ -305,6 +305,7 @@ gboolean
gimp_plug_in_set_file_proc_load_handler (GimpPlugIn *plug_in,
const gchar *proc_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
const gchar *magics,
GError **error)
@ -354,7 +355,7 @@ gimp_plug_in_set_file_proc_load_handler (GimpPlugIn *plug_in,
return FALSE;
}
gimp_plug_in_procedure_set_file_proc (proc, extensions, prefixes, magics);
gimp_plug_in_procedure_set_file_proc (proc, extensions, meta_extensions, prefixes, magics);
gimp_plug_in_manager_add_load_procedure (plug_in->manager, proc);
@ -365,6 +366,7 @@ gboolean
gimp_plug_in_set_file_proc_save_handler (GimpPlugIn *plug_in,
const gchar *proc_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
GError **error)
{
@ -412,7 +414,7 @@ gimp_plug_in_set_file_proc_save_handler (GimpPlugIn *plug_in,
return FALSE;
}
gimp_plug_in_procedure_set_file_proc (proc, extensions, prefixes, NULL);
gimp_plug_in_procedure_set_file_proc (proc, extensions, meta_extensions, prefixes, NULL);
gimp_plug_in_manager_add_save_procedure (plug_in->manager, proc);

2
app/plug-in/gimpplugin-proc.h
View file

@ -58,12 +58,14 @@ gboolean gimp_plug_in_set_proc_attribution (GimpPlugIn *plug_in,
gboolean gimp_plug_in_set_file_proc_load_handler (GimpPlugIn *plug_in,
const gchar *proc_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
const gchar *magics,
GError **error);
gboolean gimp_plug_in_set_file_proc_save_handler (GimpPlugIn *plug_in,
const gchar *proc_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
GError **error);
gboolean gimp_plug_in_set_file_proc_priority (GimpPlugIn *plug_in,

29
app/plug-in/gimppluginmanager-file.c
View file

@ -485,9 +485,11 @@ file_proc_find_by_extension (GSList *procs,
if (ext)
{
GSList *p;
GimpPlugInProcedure *meta_proc = NULL;
gchar *dot = g_strrstr (ext, ".");
gboolean known_sub_ext = FALSE;
for (p = procs; p; p = g_slist_next (p))
for (GSList *p = procs; p; p = g_slist_next (p))
{
GimpPlugInProcedure *proc = p->data;
@ -502,9 +504,32 @@ file_proc_find_by_extension (GSList *procs,
return proc;
}
if (dot && dot != ext)
{
if (! meta_proc && proc->meta_extensions_list &&
g_slist_find_custom (proc->meta_extensions_list,
dot + 1,
(GCompareFunc) g_ascii_strcasecmp))
{
meta_proc = proc;
}
else if (! known_sub_ext)
{
*dot = '\0';
if (g_slist_find_custom (proc->extensions_list,
ext + 1,
(GCompareFunc) g_ascii_strcasecmp))
known_sub_ext = TRUE;
*dot = '.';
}
}
}
g_free (ext);
if (known_sub_ext && meta_proc)
return meta_proc;
}
return NULL;

2
app/plug-in/gimppluginmanager-restore.c
View file

@ -801,6 +801,7 @@ gimp_plug_in_manager_add_to_db (GimpPlugInManager *manager,
{
gimp_plug_in_procedure_set_file_proc (proc,
proc->extensions,
proc->meta_extensions,
proc->prefixes,
NULL);
@ -810,6 +811,7 @@ gimp_plug_in_manager_add_to_db (GimpPlugInManager *manager,
{
gimp_plug_in_procedure_set_file_proc (proc,
proc->extensions,
proc->meta_extensions,
proc->prefixes,
proc->magics);

116
app/plug-in/gimppluginprocedure.c
View file

@ -162,11 +162,13 @@ gimp_plug_in_procedure_finalize (GObject *object)
g_free (proc->insensitive_reason);
g_free (proc->extensions);
g_free (proc->meta_extensions);
g_free (proc->prefixes);
g_free (proc->magics);
g_free (proc->mime_types);
g_slist_free_full (proc->extensions_list, (GDestroyNotify) g_free);
g_slist_free_full (proc->meta_extensions_list, (GDestroyNotify) g_free);
g_slist_free_full (proc->prefixes_list, (GDestroyNotify) g_free);
g_slist_free_full (proc->magics_list, (GDestroyNotify) g_free);
g_slist_free_full (proc->mime_types_list, (GDestroyNotify) g_free);
@ -1138,6 +1140,7 @@ extensions_parse (gchar *extensions)
void
gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
const gchar *magics)
{
@ -1151,8 +1154,7 @@ gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
if (proc->extensions != extensions)
{
if (proc->extensions)
g_free (proc->extensions);
g_free (proc->extensions);
proc->extensions = g_strdup (extensions);
}
@ -1162,6 +1164,18 @@ gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
proc->extensions_list = extensions_parse (proc->extensions);
if (proc->meta_extensions != meta_extensions)
{
g_free (proc->meta_extensions);
proc->meta_extensions = g_strdup (meta_extensions);
}
if (proc->meta_extensions_list)
g_slist_free_full (proc->meta_extensions_list, (GDestroyNotify) g_free);
proc->meta_extensions_list = extensions_parse (proc->meta_extensions);
/* prefixes */
if (proc->prefixes != prefixes)
@ -1206,6 +1220,104 @@ gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
proc->magics_list = extensions_parse (proc->magics);
}
gchar *
gimp_plug_in_procedure_get_save_extensions (GimpPlugInProcedure *proc,
gboolean one_full)
{
GString *str = g_string_new ("");
for (GSList *iter = proc->extensions_list; iter; iter = iter->next)
if (g_str_has_prefix (iter->data, "xcf"))
{
g_string_append (str, iter->data);
if (one_full)
break;
if (iter->next && ! one_full)
g_string_append (str, ",");
}
return g_string_free (str, (str->len == 0));
}
gchar *
gimp_plug_in_procedure_get_export_extensions (GimpPlugInProcedure *proc,
gboolean one_full)
{
GString *str = g_string_new ("");
for (GSList *iter = proc->extensions_list; iter; iter = iter->next)
if (! g_str_has_prefix (iter->data, "xcf"))
{
g_string_append (str, iter->data);
if (one_full)
break;
if (iter->next)
g_string_append (str, ",");
}
if ((str->len == 0 || ! one_full) && proc->meta_extensions_list)
{
if (str->len > 0)
g_string_append (str, ",");
for (GSList *iter = proc->meta_extensions_list; iter; iter = iter->next)
{
/* The one_full case is used to actually set an extension. If
* we don't have a good common export format using this meta
* format, then let's use PNG.
* The other case is for displaying full listing of supported
* export extensions. We use a glob '*' for display.
*/
if (one_full)
g_string_append_printf (str, "png.%s", (gchar *) iter->data);
else
g_string_append_printf (str, "*.%s", (gchar *) iter->data);
if (one_full)
break;
if (iter->next)
g_string_append (str, ",");
}
}
return g_string_free (str, (str->len == 0));
}
gchar *
gimp_plug_in_procedure_get_open_extensions (GimpPlugInProcedure *proc)
{
GString *str = g_string_new ("");
for (GSList *iter = proc->extensions_list; iter; iter = iter->next)
{
g_string_append (str, iter->data);
if (iter->next)
g_string_append (str, ",");
}
if (proc->meta_extensions_list)
{
if (str->len > 0)
g_string_append (str, ",");
for (GSList *iter = proc->meta_extensions_list; iter; iter = iter->next)
{
g_string_append_printf (str, "*.%s", (gchar *) iter->data);
if (iter->next)
g_string_append (str, ",");
}
}
return g_string_free (str, (str->len == 0));
}
void
gimp_plug_in_procedure_set_generic_file_proc (GimpPlugInProcedure *proc,
gboolean is_generic_file_proc)

108
app/plug-in/gimppluginprocedure.h
View file

@ -56,6 +56,7 @@ struct _GimpPlugInProcedure
gboolean file_proc;
gboolean generic_file_proc; /* not returning an image. */
gchar *extensions;
gchar *meta_extensions;
gchar *prefixes;
gchar *magics;
gint priority;
@ -66,6 +67,7 @@ struct _GimpPlugInProcedure
gboolean batch_interpreter;
gchar *batch_interpreter_name;
GSList *extensions_list;
GSList *meta_extensions_list;
GSList *prefixes_list;
GSList *magics_list;
GSList *mime_types_list;
@ -85,65 +87,71 @@ struct _GimpPlugInProcedureClass
};
GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
GType gimp_plug_in_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
GFile *file);
GimpProcedure * gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
GFile *file);
GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name);
GimpPlugInProcedure * gimp_plug_in_procedure_find (GSList *list,
const gchar *proc_name);
GFile * gimp_plug_in_procedure_get_file (GimpPlugInProcedure *proc);
GFile * gimp_plug_in_procedure_get_file (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_help_domain (GimpPlugInProcedure *proc,
const gchar *help_domain);
const gchar * gimp_plug_in_procedure_get_help_domain (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_help_domain (GimpPlugInProcedure *proc,
const gchar *help_domain);
const gchar * gimp_plug_in_procedure_get_help_domain (GimpPlugInProcedure *proc);
gboolean gimp_plug_in_procedure_set_menu_label (GimpPlugInProcedure *proc,
const gchar *menu_label,
GError **error);
gboolean gimp_plug_in_procedure_set_menu_label (GimpPlugInProcedure *proc,
const gchar *menu_label,
GError **error);
gboolean gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
const gchar *menu_path,
GError **error);
gboolean gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
const gchar *menu_path,
GError **error);
gboolean gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
GimpIconType type,
const guint8 *data,
gint data_length,
GError **error);
gboolean gimp_plug_in_procedure_take_icon (GimpPlugInProcedure *proc,
GimpIconType type,
guint8 *data,
gint data_length,
GError **error);
gboolean gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
GimpIconType type,
const guint8 *data,
gint data_length,
GError **error);
gboolean gimp_plug_in_procedure_take_icon (GimpPlugInProcedure *proc,
GimpIconType type,
guint8 *data,
gint data_length,
GError **error);
void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
const gchar *image_types);
void gimp_plug_in_procedure_set_sensitivity_mask (GimpPlugInProcedure *proc,
gint sensitivity_mask);
void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
const gchar *image_types);
void gimp_plug_in_procedure_set_sensitivity_mask (GimpPlugInProcedure *proc,
gint sensitivity_mask);
void gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
const gchar *extensions,
const gchar *prefixes,
const gchar *magics);
void gimp_plug_in_procedure_set_generic_file_proc (GimpPlugInProcedure *proc,
gboolean is_generic_file_proc);
void gimp_plug_in_procedure_set_priority (GimpPlugInProcedure *proc,
gint priority);
void gimp_plug_in_procedure_set_mime_types (GimpPlugInProcedure *proc,
const gchar *mime_ypes);
void gimp_plug_in_procedure_set_handles_remote(GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_handles_raw (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_handles_vector (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_thumb_loader (GimpPlugInProcedure *proc,
const gchar *thumbnailer);
void gimp_plug_in_procedure_set_batch_interpreter (GimpPlugInProcedure *proc,
const gchar *name);
void gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
const gchar *magics);
gchar * gimp_plug_in_procedure_get_save_extensions (GimpPlugInProcedure *proc,
gboolean one_full);
gchar * gimp_plug_in_procedure_get_export_extensions (GimpPlugInProcedure *proc,
gboolean one_full);
gchar * gimp_plug_in_procedure_get_open_extensions (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_handle_return_values (GimpPlugInProcedure *proc,
Gimp *gimp,
GimpProgress *progress,
void gimp_plug_in_procedure_set_generic_file_proc (GimpPlugInProcedure *proc,
gboolean is_generic_file_proc);
void gimp_plug_in_procedure_set_priority (GimpPlugInProcedure *proc,
gint priority);
void gimp_plug_in_procedure_set_mime_types (GimpPlugInProcedure *proc,
const gchar *mime_ypes);
void gimp_plug_in_procedure_set_handles_remote (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_handles_raw (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_handles_vector (GimpPlugInProcedure *proc);
void gimp_plug_in_procedure_set_thumb_loader (GimpPlugInProcedure *proc,
const gchar *thumbnailer);
void gimp_plug_in_procedure_set_batch_interpreter (GimpPlugInProcedure *proc,
const gchar *name);
GimpValueArray *return_vals);
void gimp_plug_in_procedure_handle_return_values (GimpPlugInProcedure *proc,
Gimp *gimp,
GimpProgress *progress,
GimpValueArray *return_vals);

70
app/widgets/gimpfiledialog.c
View file

@ -278,9 +278,10 @@ gimp_file_dialog_set_property (GObject *object,
dialog->file_filter_label = g_value_dup_string (value);
break;
case PROP_FILE_PROCS:
dialog->file_proc_group = g_value_get_enum (value);
dialog->file_procs =
gimp_plug_in_manager_get_file_procedures (dialog->gimp->plug_in_manager,
g_value_get_enum (value));
dialog->file_proc_group);
break;
case PROP_FILE_PROCS_ALL_IMAGES:
dialog->file_procs_all_images =
@ -770,6 +771,7 @@ gimp_file_dialog_add_proc_selection (GimpFileDialog *dialog)
dialog->proc_view = gimp_file_proc_view_new (dialog->gimp,
dialog->file_procs,
dialog->file_proc_group,
dialog->automatic_label,
dialog->automatic_help_id);
gtk_container_add (GTK_CONTAINER (scrolled_window), dialog->proc_view);
@ -849,16 +851,17 @@ gimp_file_dialog_proc_changed (GimpFileProcView *view,
if (uri && strlen (uri))
{
const gchar *last_dot = strrchr (uri, '.');
const gchar *img_dot = strrchr (uri, '.');
const gchar *meta_dot = NULL;
/* if the dot is before the last slash, ignore it */
if (last_dot && strrchr (uri, '/') > last_dot)
last_dot = NULL;
if (img_dot && strrchr (uri, '/') > img_dot)
img_dot = NULL;
/* check if the uri has a "meta extension" (e.g. foo.bar.gz)
* and try to truncate both extensions away.
*/
if (last_dot && last_dot != uri)
if (img_dot && img_dot != uri)
{
GList *list;
@ -868,33 +871,68 @@ gimp_file_dialog_proc_changed (GimpFileProcView *view,
{
const gchar *ext = list->data;
if (! strcmp (ext, last_dot + 1))
if (! strcmp (ext, img_dot + 1))
{
const gchar *p = last_dot - 1;
const gchar *p = img_dot - 1;
while (p > uri && *p != '.')
p--;
if (p != uri && *p == '.')
{
last_dot = p;
meta_dot = img_dot;
img_dot = p;
break;
}
}
}
}
if (last_dot != uri)
if (img_dot != uri)
{
GString *s = g_string_new (uri);
GFile *file;
gchar *basename;
GString *s = g_string_new (uri);
GFile *file;
gchar *basename;
gboolean proc_is_meta;
if (last_dot)
g_string_truncate (s, last_dot - uri);
proc_is_meta = (proc->meta_extensions != NULL);
if (meta_dot)
g_string_truncate (s, meta_dot - uri);
if (img_dot && ! proc_is_meta)
g_string_truncate (s, img_dot - uri);
g_string_append (s, ".");
g_string_append (s, (gchar *) proc->extensions_list->data);
if (proc_is_meta)
{
if (img_dot)
{
g_string_append (s, (gchar *) proc->meta_extensions_list->data);
}
else
{
gchar *ext = NULL;
switch (dialog->file_proc_group)
{
case GIMP_FILE_PROCEDURE_GROUP_EXPORT:
ext = gimp_plug_in_procedure_get_export_extensions (proc, TRUE);
break;
case GIMP_FILE_PROCEDURE_GROUP_SAVE:
ext = gimp_plug_in_procedure_get_save_extensions (proc, TRUE);
break;
default:
}
g_string_append (s, ext);
g_free (ext);
}
}
else
{
g_string_append (s, (gchar *) proc->extensions_list->data);
}
file = g_file_new_for_uri (s->str);
g_string_free (s, TRUE);
@ -903,6 +941,8 @@ gimp_file_dialog_proc_changed (GimpFileProcView *view,
basename = g_path_get_basename (gimp_file_get_utf8_name (file));
gtk_file_chooser_set_current_name (chooser, basename);
g_object_unref (file);
g_free (basename);
}
}

41
app/widgets/gimpfiledialog.h
View file

@ -33,34 +33,35 @@ typedef struct _GimpFileDialogClass GimpFileDialogClass;
struct _GimpFileDialog
{
GtkFileChooserDialog parent_instance;
GtkFileChooserDialog parent_instance;
GBytes *window_handle;
GBytes *window_handle;
Gimp *gimp;
GimpImage *image;
Gimp *gimp;
GimpImage *image;
GimpPlugInProcedure *file_proc;
GimpPlugInProcedure *file_proc;
GtkWidget *thumb_box;
GtkWidget *extra_vbox;
GtkWidget *proc_expander;
GtkWidget *proc_view;
GtkWidget *progress;
GtkWidget *thumb_box;
GtkWidget *extra_vbox;
GtkWidget *proc_expander;
GtkWidget *proc_view;
GtkWidget *progress;
gboolean busy;
gboolean canceled;
gboolean busy;
gboolean canceled;
gchar *help_id;
gchar *ok_button_label;
gchar *automatic_help_id;
gchar *automatic_label;
gchar *file_filter_label;
gchar *help_id;
gchar *ok_button_label;
gchar *automatic_help_id;
gchar *automatic_label;
gchar *file_filter_label;
GSList *file_procs;
GSList *file_procs_all_images;
GimpFileProcedureGroup file_proc_group;
GSList *file_procs;
GSList *file_procs_all_images;
gboolean show_all_files;
gboolean show_all_files;
};
struct _GimpFileDialogClass

95
app/widgets/gimpfileprocview.c
View file

@ -62,7 +62,8 @@ static void gimp_file_proc_view_selection_changed (GtkTreeSelect
static GtkFileFilter * gimp_file_proc_view_process_procedure (GimpPlugInProcedure *file_proc,
GtkFileFilter *all);
static gchar * gimp_file_proc_view_pattern_from_extension (const gchar *extension);
static gchar * gimp_file_proc_view_pattern_from_extension (const gchar *extension,
gboolean is_meta);
G_DEFINE_TYPE (GimpFileProcView, gimp_file_proc_view, GTK_TYPE_TREE_VIEW)
@ -110,13 +111,15 @@ gimp_file_proc_view_finalize (GObject *object)
}
GtkWidget *
gimp_file_proc_view_new (Gimp *gimp,
GSList *procedures,
const gchar *automatic,
const gchar *automatic_help_id)
gimp_file_proc_view_new (Gimp *gimp,
GSList *procedures,
GimpFileProcedureGroup file_proc_group,
const gchar *automatic,
const gchar *automatic_help_id)
{
GtkFileFilter *all_filter;
GtkTreeView *view;
GimpFileProcView *proc_view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *store;
@ -136,9 +139,9 @@ gimp_file_proc_view_new (Gimp *gimp,
"model", store,
"rules-hint", TRUE,
NULL);
g_object_unref (store);
proc_view = GIMP_FILE_PROC_VIEW (view);
all_filter = gtk_file_filter_new ();
for (list = procedures; list; list = g_slist_next (list))
@ -154,33 +157,38 @@ gimp_file_proc_view_new (Gimp *gimp,
if (label)
{
GtkFileFilter *filter;
gchar *extensions;
switch (file_proc_group)
{
case GIMP_FILE_PROCEDURE_GROUP_SAVE:
extensions = gimp_plug_in_procedure_get_save_extensions (proc, FALSE);
break;
case GIMP_FILE_PROCEDURE_GROUP_EXPORT:
extensions = gimp_plug_in_procedure_get_export_extensions (proc, FALSE);
break;
default:
extensions = gimp_plug_in_procedure_get_open_extensions (proc);
break;
}
filter = gimp_file_proc_view_process_procedure (proc, all_filter);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COLUMN_PROC, proc,
COLUMN_LABEL, label,
COLUMN_EXTENSIONS, proc->extensions,
COLUMN_EXTENSIONS, extensions,
COLUMN_HELP_ID, help_id,
COLUMN_FILTER, filter,
-1);
if (filter != NULL)
g_object_unref (filter);
g_free (extensions);
}
for (list2 = proc->extensions_list;
list2;
list2 = g_slist_next (list2))
{
GimpFileProcView *proc_view = GIMP_FILE_PROC_VIEW (view);
const gchar *ext = list2->data;
const gchar *dot = strchr (ext, '.');
if (dot && dot != ext)
proc_view->meta_extensions =
g_list_append (proc_view->meta_extensions,
g_strdup (dot + 1));
}
for (list2 = proc->meta_extensions_list; list2; list2 = list2->next)
proc_view->meta_extensions = g_list_append (proc_view->meta_extensions, g_strdup (list2->data));
}
}
@ -405,7 +413,7 @@ gimp_file_proc_view_process_procedure (GimpPlugInProcedure *file_proc,
const gchar *extension = list->data;
gchar *pattern;
pattern = gimp_file_proc_view_pattern_from_extension (extension);
pattern = gimp_file_proc_view_pattern_from_extension (extension, FALSE);
gtk_file_filter_add_pattern (filter, pattern);
gtk_file_filter_add_pattern (all, pattern);
g_free (pattern);
@ -435,6 +443,41 @@ gimp_file_proc_view_process_procedure (GimpPlugInProcedure *file_proc,
}
}
for (list = file_proc->meta_extensions_list;
list;
list = g_slist_next (list), i++)
{
const gchar *extension = list->data;
gchar *pattern;
pattern = gimp_file_proc_view_pattern_from_extension (extension, TRUE);
gtk_file_filter_add_pattern (filter, pattern);
gtk_file_filter_add_pattern (all, pattern);
g_free (pattern);
if (i == 0)
{
g_string_append (str, " (");
}
else if (i <= MAX_EXTENSIONS)
{
g_string_append (str, ", ");
}
if (i < MAX_EXTENSIONS)
{
g_string_append (str, "*.");
g_string_append (str, extension);
}
else if (i == MAX_EXTENSIONS)
{
g_string_append (str, "...");
}
}
if (i > 0)
g_string_append (str, ")");
gtk_file_filter_set_name (filter, str->str);
g_string_free (str, TRUE);
@ -442,7 +485,8 @@ gimp_file_proc_view_process_procedure (GimpPlugInProcedure *file_proc,
}
static gchar *
gimp_file_proc_view_pattern_from_extension (const gchar *extension)
gimp_file_proc_view_pattern_from_extension (const gchar *extension,
gboolean is_meta)
{
gchar *pattern;
gchar *p;
@ -457,9 +501,12 @@ gimp_file_proc_view_pattern_from_extension (const gchar *extension)
len = strlen (extension);
pattern = g_new (gchar, 4 + 4 * len);
pattern = g_new (gchar, 6 + 4 * len);
strcpy (pattern, "*.");
if (is_meta)
strcpy (pattern, "*.*.");
else
strcpy (pattern, "*.");
for (i = 0, p = pattern + 2; i < len; i++, p+= 4)
{

21
app/widgets/gimpfileprocview.h
View file

@ -48,15 +48,16 @@ struct _GimpFileProcViewClass
GType gimp_file_proc_view_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_file_proc_view_new (Gimp *gimp,
GSList *procedures,
const gchar *automatic,
const gchar *automatic_help_id);
GtkWidget * gimp_file_proc_view_new (Gimp *gimp,
GSList *procedures,
GimpFileProcedureGroup file_proc_group,
const gchar *automatic,
const gchar *automatic_help_id);
GimpPlugInProcedure * gimp_file_proc_view_get_proc (GimpFileProcView *view,
gchar **label,
GtkFileFilter **filter);
gboolean gimp_file_proc_view_set_proc (GimpFileProcView *view,
GimpPlugInProcedure *proc);
GimpPlugInProcedure * gimp_file_proc_view_get_proc (GimpFileProcView *view,
gchar **label,
GtkFileFilter **filter);
gboolean gimp_file_proc_view_set_proc (GimpFileProcView *view,
GimpPlugInProcedure *proc);
gchar * gimp_file_proc_view_get_help_id (GimpFileProcView *view);
gchar * gimp_file_proc_view_get_help_id (GimpFileProcView *view);

4
app/xcf/xcf.c
View file

@ -130,7 +130,7 @@ xcf_init (Gimp *gimp)
strlen ("gimp-wilber") + 1,
NULL);
gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*");
gimp_plug_in_procedure_set_file_proc (proc, "xcf", "", NULL);
gimp_plug_in_procedure_set_file_proc (proc, "xcf", NULL, "", NULL);
gimp_plug_in_procedure_set_mime_types (proc, "image/x-xcf");
gimp_plug_in_procedure_set_handles_remote (proc);
@ -186,7 +186,7 @@ xcf_init (Gimp *gimp)
strlen ("gimp-wilber") + 1,
NULL);
gimp_plug_in_procedure_set_image_types (proc, NULL);
gimp_plug_in_procedure_set_file_proc (proc, "xcf", "",
gimp_plug_in_procedure_set_file_proc (proc, "xcf", NULL, "",
"0,string,gimp\\040xcf\\040");
gimp_plug_in_procedure_set_mime_types (proc, "image/x-xcf");
gimp_plug_in_procedure_set_handles_remote (proc);

2
libgimp/gimp.def
View file

@ -329,6 +329,7 @@ EXPORTS
gimp_file_procedure_get_format_name
gimp_file_procedure_get_handles_remote
gimp_file_procedure_get_magics
gimp_file_procedure_get_meta
gimp_file_procedure_get_mime_types
gimp_file_procedure_get_prefixes
gimp_file_procedure_get_priority
@ -337,6 +338,7 @@ EXPORTS
gimp_file_procedure_set_format_name
gimp_file_procedure_set_handles_remote
gimp_file_procedure_set_magics
gimp_file_procedure_set_meta
gimp_file_procedure_set_mime_types
gimp_file_procedure_set_prefixes
gimp_file_procedure_set_priority

5
libgimp/gimpexportprocedure.c
View file

@ -348,15 +348,18 @@ gimp_export_procedure_get_property (GObject *object,
static void
gimp_export_procedure_install (GimpProcedure *procedure)
{
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *meta_extensions = NULL;
const gchar *mime_types;
gint priority;
gimp_export_procedure_add_metadata (GIMP_EXPORT_PROCEDURE (procedure));
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
(void) gimp_file_procedure_get_meta (file_proc, &meta_extensions),
_gimp_pdb_set_file_proc_export_handler (gimp_procedure_get_name (procedure),
gimp_file_procedure_get_extensions (file_proc),
meta_extensions,
gimp_file_procedure_get_prefixes (file_proc));
if (gimp_file_procedure_get_handles_remote (file_proc))

84
libgimp/gimpfileprocedure.c
View file

@ -38,6 +38,8 @@ typedef struct _GimpFileProcedurePrivate
gchar *format_name;
gchar *mime_types;
gchar *extensions;
gboolean is_meta;
gchar *meta_extensions;
gchar *prefixes;
gchar *magics;
gint priority;
@ -93,11 +95,12 @@ gimp_file_procedure_finalize (GObject *object)
procedure = GIMP_FILE_PROCEDURE (object);
priv = gimp_file_procedure_get_instance_private (procedure);
g_clear_pointer (&priv->format_name, g_free);
g_clear_pointer (&priv->mime_types, g_free);
g_clear_pointer (&priv->extensions, g_free);
g_clear_pointer (&priv->prefixes, g_free);
g_clear_pointer (&priv->magics, g_free);
g_clear_pointer (&priv->format_name, g_free);
g_clear_pointer (&priv->mime_types, g_free);
g_clear_pointer (&priv->extensions, g_free);
g_clear_pointer (&priv->meta_extensions, g_free);
g_clear_pointer (&priv->prefixes, g_free);
g_clear_pointer (&priv->magics, g_free);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
@ -264,6 +267,77 @@ gimp_file_procedure_get_extensions (GimpFileProcedure *procedure)
return priv->extensions;
}
/**
* gimp_file_procedure_set_meta:
* @procedure: A file procedure.
* @is_meta: Whether @procedure is a meta file procedure.
* @meta_extensions: A comma separated list of generic extensions this procedure can
* handle (i.e. "gz").
*
* Some [class@Gimp.LoadProcedure] or [class@Gimp.ExportProcedure] may
* actually be a *meta* procedure. Meta procedures are typically
* supporting container formats which will call another procedure for
* the actual format within the container.
*
* Note that you should still call [method@FileProcedure.set_extensions],
* usually with a list of standard full formats, such as "xcf.gz,xcfgz",
* or again "hgt.zip". Nevertheless the @meta_extensions should be only
* "gz" or "zip" respectively. This would allow this meta format to work
* even on less common combinations. For instance, I could export an
* image as "png.gz" even though it is not explicitly listed.
*
* Since: 3.2
**/
void
gimp_file_procedure_set_meta (GimpFileProcedure *procedure,
gboolean is_meta,
const gchar *meta_extensions)
{
GimpFileProcedurePrivate *priv;
g_return_if_fail (GIMP_IS_FILE_PROCEDURE (procedure));
g_return_if_fail ((! is_meta && meta_extensions == NULL) ||
(is_meta && meta_extensions != NULL && strlen (meta_extensions) > 0));
priv = gimp_file_procedure_get_instance_private (procedure);
g_clear_pointer (&priv->meta_extensions, g_free);
priv->is_meta = is_meta;
if (is_meta)
priv->meta_extensions = g_strdup (meta_extensions);
}
/**
* gimp_file_procedure_get_meta:
* @procedure: A file procedure object.
* @meta_extensions: (out) (nullable): The generic meta extensions,
* optionally.
*
* Returns whether @procedure is a meta file procedure as set with
* [method@FileProcedure.set_meta]. If @meta_extensions is not %NULL,
* the generic extensions will be returned too.
*
* Returns: %TRUE is @procedure is a meta file procedure.
*
* Since: 3.2
**/
gboolean
gimp_file_procedure_get_meta (GimpFileProcedure *procedure,
const gchar **meta_extensions)
{
GimpFileProcedurePrivate *priv;
g_return_val_if_fail (GIMP_IS_FILE_PROCEDURE (procedure), FALSE);
g_return_val_if_fail (meta_extensions == NULL || *meta_extensions == NULL, FALSE);
priv = gimp_file_procedure_get_instance_private (procedure);
if (meta_extensions)
*meta_extensions = priv->meta_extensions;
return priv->is_meta;
}
/**
* gimp_file_procedure_set_prefixes:
* @procedure: A file procedure object.

5
libgimp/gimpfileprocedure.h
View file

@ -61,6 +61,11 @@ const gchar * gimp_file_procedure_get_mime_types (GimpFileProcedure *procedur
void gimp_file_procedure_set_extensions (GimpFileProcedure *procedure,
const gchar *extensions);
const gchar * gimp_file_procedure_get_extensions (GimpFileProcedure *procedure);
void gimp_file_procedure_set_meta (GimpFileProcedure *procedure,
gboolean is_meta,
const gchar *meta_extensions);
gboolean gimp_file_procedure_get_meta (GimpFileProcedure *procedure,
const gchar **meta_extensions);
void gimp_file_procedure_set_prefixes (GimpFileProcedure *procedure,
const gchar *prefixes);

7
libgimp/gimploadprocedure.c
View file

@ -145,8 +145,9 @@ static void
gimp_load_procedure_install (GimpProcedure *procedure)
{
GimpLoadProcedurePrivate *priv;
GimpLoadProcedure *load_proc = GIMP_LOAD_PROCEDURE (procedure);
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
GimpLoadProcedure *load_proc = GIMP_LOAD_PROCEDURE (procedure);
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *meta_extensions = NULL;
const gchar *mime_types;
gint priority;
@ -154,8 +155,10 @@ gimp_load_procedure_install (GimpProcedure *procedure)
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
(void) gimp_file_procedure_get_meta (file_proc, &meta_extensions),
_gimp_pdb_set_file_proc_load_handler (gimp_procedure_get_name (procedure),
gimp_file_procedure_get_extensions (file_proc),
meta_extensions,
gimp_file_procedure_get_prefixes (file_proc),
gimp_file_procedure_get_magics (file_proc));

6
libgimp/gimppdb_pdb.c
View file

@ -850,6 +850,7 @@ _gimp_pdb_get_proc_attribution (const gchar *procedure_name,
* _gimp_pdb_set_file_proc_load_handler:
* @procedure_name: The name of the procedure to be used for loading.
* @extensions: comma separated list of extensions this handler can load (i.e. \"jpg,jpeg\").
* @meta_extensions: comma separated list of meta extensions this handler can load (i.e. \"gz\").
* @prefixes: comma separated list of prefixes this handler can load (i.e. \"http:,ftp:\").
* @magics: comma separated list of magic file information this handler can load (i.e. \"0,string,GIF\").
*
@ -863,6 +864,7 @@ _gimp_pdb_get_proc_attribution (const gchar *procedure_name,
gboolean
_gimp_pdb_set_file_proc_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
const gchar *magics)
{
@ -873,6 +875,7 @@ _gimp_pdb_set_file_proc_load_handler (const gchar *procedure_name,
args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, procedure_name,
G_TYPE_STRING, extensions,
G_TYPE_STRING, meta_extensions,
G_TYPE_STRING, prefixes,
G_TYPE_STRING, magics,
G_TYPE_NONE);
@ -893,6 +896,7 @@ _gimp_pdb_set_file_proc_load_handler (const gchar *procedure_name,
* _gimp_pdb_set_file_proc_export_handler:
* @procedure_name: The name of the procedure to be used for saving.
* @extensions: comma separated list of extensions this handler can export as (i.e. \"jpg,jpeg\").
* @meta_extensions: comma separated list of meta extensions this handler can load (i.e. \"gz\").
* @prefixes: comma separated list of prefixes this handler can export to (i.e. \"http:,ftp:\").
*
* Registers a file export handler procedure.
@ -905,6 +909,7 @@ _gimp_pdb_set_file_proc_load_handler (const gchar *procedure_name,
gboolean
_gimp_pdb_set_file_proc_export_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes)
{
GimpValueArray *args;
@ -914,6 +919,7 @@ _gimp_pdb_set_file_proc_export_handler (const gchar *procedure_name,
args = gimp_value_array_new_from_types (NULL,
G_TYPE_STRING, procedure_name,
G_TYPE_STRING, extensions,
G_TYPE_STRING, meta_extensions,
G_TYPE_STRING, prefixes,
G_TYPE_NONE);

2
libgimp/gimppdb_pdb.h
View file

@ -83,10 +83,12 @@ G_GNUC_INTERNAL gboolean _gimp_pdb_get_proc_attribution (const gcha
gchar **date);
G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_load_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes,
const gchar *magics);
G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_export_handler (const gchar *procedure_name,
const gchar *extensions,
const gchar *meta_extensions,
const gchar *prefixes);
G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_priority (const gchar *procedure_name,
gint priority);

22
pdb/groups/pdb.pdb
View file

@ -888,6 +888,9 @@ HELP
{ name => 'extensions', type => 'string', no_validate => 1,
desc => 'comma separated list of extensions this handler
can load (i.e. "jpg,jpeg")' },
{ name => 'meta_extensions', type => 'string', no_validate => 1,
desc => 'comma separated list of meta extensions this handler
can load (i.e. "gz")' },
{ name => 'prefixes', type => 'string', no_validate => 1,
desc => 'comma separated list of prefixes this handler
can load (i.e. "http:,ftp:")' },
@ -906,11 +909,13 @@ HELP
{
success = gimp_plug_in_set_file_proc_load_handler (plug_in,
procedure_name,
extensions, prefixes,
magics, error);
extensions, meta_extensions,
prefixes, magics, error);
}
else
success = FALSE;
{
success = FALSE;
}
}
CODE
);
@ -934,6 +939,9 @@ HELP
{ name => 'extensions', type => 'string', no_validate => 1,
desc => 'comma separated list of extensions this handler
can export as (i.e. "jpg,jpeg")' },
{ name => 'meta_extensions', type => 'string', no_validate => 1,
desc => 'comma separated list of meta extensions this handler
can load (i.e. "gz")' },
{ name => 'prefixes', type => 'string', no_validate => 1,
desc => 'comma separated list of prefixes this handler
can export to (i.e. "http:,ftp:")' }
@ -949,11 +957,13 @@ HELP
{
success = gimp_plug_in_set_file_proc_save_handler (plug_in,
procedure_name,
extensions, prefixes,
error);
extensions, meta_extensions,
prefixes, error);
}
else
success = FALSE;
{
success = FALSE;
}
}
CODE
);

10
plug-ins/common/file-compressor.c
View file

@ -220,7 +220,7 @@ static const CompressorEntry compressors[] =
{
N_("gzip archive"),
"application/x-gzip",
"gz,xcf.gz,xcfgz",
"xcf.gz,xcfgz",
"0,string,\037\213",
".xcfgz",
".gz",
@ -239,7 +239,7 @@ static const CompressorEntry compressors[] =
{
N_("bzip archive"),
"application/x-bzip",
"bz2,xcf.bz2,xcfbz2",
"xcf.bz2,xcfbz2",
"0,string,BZh",
".xcfbz2",
".bz2",
@ -258,7 +258,7 @@ static const CompressorEntry compressors[] =
{
N_("xz archive"),
"application/x-xz",
"xz,xcf.xz,xcfxz",
"xcf.xz,xcfxz",
"0,string,\3757zXZ\x00",
".xcfxz",
".xz",
@ -277,7 +277,7 @@ static const CompressorEntry compressors[] =
{
N_("zip archive"),
"application/zip",
"zip,hgt.zip",
"hgt.zip",
"0,string,PK\x03\x04",
".xcfzip",
".zip",
@ -383,6 +383,8 @@ compressor_create_procedure (GimpPlugIn *plug_in,
compressor->mime_type);
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
compressor->extensions);
gimp_file_procedure_set_meta (GIMP_FILE_PROCEDURE (procedure),
TRUE, compressor->generic_extension + 1);
return procedure;
}