1
/* GIMP - The GNU Image Manipulation Program
2
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
4
* gimppluginprocedure.c
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software
18
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25
#include <glib-object.h>
26
#include <gdk-pixbuf/gdk-pixbuf.h>
28
#include "libgimpbase/gimpbase.h"
30
#include "plug-in-types.h"
32
#include "core/gimp.h"
33
#include "core/gimpmarshal.h"
34
#include "core/gimpparamspecs.h"
36
#define __YES_I_NEED_GIMP_PLUG_IN_MANAGER_CALL__
37
#include "gimppluginmanager-call.h"
38
#include "gimppluginprocedure.h"
40
#include "gimp-intl.h"
50
static void gimp_plug_in_procedure_finalize (GObject *object);
52
static gint64 gimp_plug_in_procedure_get_memsize (GimpObject *object,
55
static GValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure,
58
GimpProgress *progress,
60
static void gimp_plug_in_procedure_execute_async (GimpProcedure *procedure,
63
GimpProgress *progress,
67
const gchar * gimp_plug_in_procedure_real_get_progname (const GimpPlugInProcedure *procedure);
70
G_DEFINE_TYPE (GimpPlugInProcedure, gimp_plug_in_procedure,
73
#define parent_class gimp_plug_in_procedure_parent_class
75
static guint gimp_plug_in_procedure_signals[LAST_SIGNAL] = { 0 };
79
gimp_plug_in_procedure_class_init (GimpPlugInProcedureClass *klass)
81
GObjectClass *object_class = G_OBJECT_CLASS (klass);
82
GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
83
GimpProcedureClass *proc_class = GIMP_PROCEDURE_CLASS (klass);
85
gimp_plug_in_procedure_signals[MENU_PATH_ADDED] =
86
g_signal_new ("menu-path-added",
87
G_TYPE_FROM_CLASS (klass),
89
G_STRUCT_OFFSET (GimpPlugInProcedureClass, menu_path_added),
91
gimp_marshal_VOID__STRING,
95
object_class->finalize = gimp_plug_in_procedure_finalize;
97
gimp_object_class->get_memsize = gimp_plug_in_procedure_get_memsize;
99
proc_class->execute = gimp_plug_in_procedure_execute;
100
proc_class->execute_async = gimp_plug_in_procedure_execute_async;
102
klass->get_progname = gimp_plug_in_procedure_real_get_progname;
103
klass->menu_path_added = NULL;
107
gimp_plug_in_procedure_init (GimpPlugInProcedure *proc)
109
GIMP_PROCEDURE (proc)->proc_type = GIMP_PLUGIN;
112
proc->icon_data_length = -1;
116
gimp_plug_in_procedure_finalize (GObject *object)
118
GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (object);
121
g_free (proc->menu_label);
123
g_list_foreach (proc->menu_paths, (GFunc) g_free, NULL);
124
g_list_free (proc->menu_paths);
126
g_free (proc->label);
128
g_free (proc->icon_data);
129
g_free (proc->image_types);
131
g_free (proc->extensions);
132
g_free (proc->prefixes);
133
g_free (proc->magics);
134
g_free (proc->mime_type);
136
g_slist_foreach (proc->extensions_list, (GFunc) g_free, NULL);
137
g_slist_free (proc->extensions_list);
139
g_slist_foreach (proc->prefixes_list, (GFunc) g_free, NULL);
140
g_slist_free (proc->prefixes_list);
142
g_slist_foreach (proc->magics_list, (GFunc) g_free, NULL);
143
g_slist_free (proc->magics_list);
145
g_free (proc->thumb_loader);
147
G_OBJECT_CLASS (parent_class)->finalize (object);
151
gimp_plug_in_procedure_get_memsize (GimpObject *object,
154
GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (object);
160
memsize += strlen (proc->prog) + 1;
162
if (proc->menu_label)
163
memsize += strlen (proc->menu_label) + 1;
165
for (list = proc->menu_paths; list; list = g_list_next (list))
166
memsize += sizeof (GList) + strlen (list->data) + 1;
168
switch (proc->icon_type)
170
case GIMP_ICON_TYPE_STOCK_ID:
171
case GIMP_ICON_TYPE_IMAGE_FILE:
173
memsize += strlen ((gchar *) proc->icon_data) + 1;
176
case GIMP_ICON_TYPE_INLINE_PIXBUF:
177
memsize += proc->icon_data_length;
181
if (proc->extensions)
182
memsize += strlen (proc->extensions) + 1;
185
memsize += strlen (proc->prefixes) + 1;
188
memsize += strlen (proc->magics) + 1;
191
memsize += strlen (proc->mime_type) + 1;
193
if (proc->thumb_loader)
194
memsize += strlen (proc->thumb_loader) + 1;
196
for (slist = proc->extensions_list; slist; slist = g_slist_next (slist))
197
memsize += sizeof (GSList) + strlen (slist->data) + 1;
199
for (slist = proc->prefixes_list; slist; slist = g_slist_next (slist))
200
memsize += sizeof (GSList) + strlen (slist->data) + 1;
202
for (slist = proc->magics_list; slist; slist = g_slist_next (slist))
203
memsize += sizeof (GSList) + strlen (slist->data) + 1;
205
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
210
gimp_plug_in_procedure_execute (GimpProcedure *procedure,
212
GimpContext *context,
213
GimpProgress *progress,
216
if (procedure->proc_type == GIMP_INTERNAL)
217
return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
221
return gimp_plug_in_manager_call_run (gimp->plug_in_manager,
223
GIMP_PLUG_IN_PROCEDURE (procedure),
224
args, TRUE, FALSE, NULL);
228
gimp_plug_in_procedure_execute_async (GimpProcedure *procedure,
230
GimpContext *context,
231
GimpProgress *progress,
235
gimp_plug_in_manager_call_run (gimp->plug_in_manager,
237
GIMP_PLUG_IN_PROCEDURE (procedure),
238
args, FALSE, TRUE, display);
242
gimp_plug_in_procedure_real_get_progname (const GimpPlugInProcedure *procedure)
244
return procedure->prog;
248
/* public functions */
251
gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
254
GimpPlugInProcedure *proc;
256
g_return_val_if_fail (proc_type == GIMP_PLUGIN ||
257
proc_type == GIMP_EXTENSION, NULL);
258
g_return_val_if_fail (prog != NULL, NULL);
260
proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
262
proc->prog = g_strdup (prog);
264
GIMP_PROCEDURE (proc)->proc_type = proc_type;
266
return GIMP_PROCEDURE (proc);
269
GimpPlugInProcedure *
270
gimp_plug_in_procedure_find (GSList *list,
271
const gchar *proc_name)
275
for (l = list; l; l = g_slist_next (l))
277
GimpObject *object = l->data;
279
if (! strcmp (proc_name, object->name))
280
return GIMP_PLUG_IN_PROCEDURE (object);
287
gimp_plug_in_procedure_get_progname (const GimpPlugInProcedure *proc)
289
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
291
return GIMP_PLUG_IN_PROCEDURE_GET_CLASS (proc)->get_progname (proc);
295
gimp_plug_in_procedure_set_locale_domain (GimpPlugInProcedure *proc,
296
const gchar *locale_domain)
298
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
300
proc->locale_domain = locale_domain ? g_quark_from_string (locale_domain) : 0;
304
gimp_plug_in_procedure_get_locale_domain (const GimpPlugInProcedure *proc)
306
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
308
return g_quark_to_string (proc->locale_domain);
312
gimp_plug_in_procedure_set_help_domain (GimpPlugInProcedure *proc,
313
const gchar *help_domain)
315
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
317
proc->help_domain = help_domain ? g_quark_from_string (help_domain) : 0;
321
gimp_plug_in_procedure_get_help_domain (const GimpPlugInProcedure *proc)
323
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
325
return g_quark_to_string (proc->help_domain);
329
gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
330
const gchar *menu_path,
333
GimpProcedure *procedure;
334
gchar *basename = NULL;
335
const gchar *required = NULL;
338
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), FALSE);
339
g_return_val_if_fail (menu_path != NULL, FALSE);
340
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
342
procedure = GIMP_PROCEDURE (proc);
344
p = strchr (menu_path, '>');
345
if (p == NULL || (*(++p) && *p != '/'))
347
basename = g_filename_display_basename (proc->prog);
349
g_set_error (error, 0, 0,
350
"Plug-In \"%s\"\n(%s)\n"
351
"attempted to install procedure \"%s\"\n"
352
"in the invalid menu location \"%s\".\n"
353
"The menu path must look like either \"<Prefix>\" "
354
"or \"<Prefix>/path/to/item\".",
355
basename, gimp_filename_to_utf8 (proc->prog),
356
GIMP_OBJECT (proc)->name,
361
if (g_str_has_prefix (menu_path, "<Toolbox>") ||
362
g_str_has_prefix (menu_path, "<Image>"))
364
if ((procedure->num_args < 1) ||
365
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]))
371
else if (g_str_has_prefix (menu_path, "<Layers>"))
373
if ((procedure->num_args < 3) ||
374
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
375
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
376
! (G_TYPE_FROM_INSTANCE (procedure->args[2])
377
== GIMP_TYPE_PARAM_LAYER_ID ||
378
G_TYPE_FROM_INSTANCE (procedure->args[2])
379
== GIMP_TYPE_PARAM_DRAWABLE_ID))
381
required = "INT32, IMAGE, (LAYER | DRAWABLE)";
385
else if (g_str_has_prefix (menu_path, "<Channels>"))
387
if ((procedure->num_args < 3) ||
388
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
389
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
390
! (G_TYPE_FROM_INSTANCE (procedure->args[2])
391
== GIMP_TYPE_PARAM_CHANNEL_ID ||
392
G_TYPE_FROM_INSTANCE (procedure->args[2])
393
== GIMP_TYPE_PARAM_DRAWABLE_ID))
395
required = "INT32, IMAGE, (CHANNEL | DRAWABLE)";
399
else if (g_str_has_prefix (menu_path, "<Vectors>"))
401
if ((procedure->num_args < 3) ||
402
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
403
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
404
! GIMP_IS_PARAM_SPEC_VECTORS_ID (procedure->args[2]))
406
required = "INT32, IMAGE, VECTORS";
410
else if (g_str_has_prefix (menu_path, "<Colormap>"))
412
if ((procedure->num_args < 2) ||
413
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
414
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]))
416
required = "INT32, IMAGE";
420
else if (g_str_has_prefix (menu_path, "<Load>"))
422
if ((procedure->num_args < 3) ||
423
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
424
! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
425
! G_IS_PARAM_SPEC_STRING (procedure->args[2]))
427
required = "INT32, STRING, STRING";
431
if ((procedure->num_values < 1) ||
432
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->values[0]))
438
else if (g_str_has_prefix (menu_path, "<Save>"))
440
if ((procedure->num_args < 5) ||
441
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
442
! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
443
! GIMP_IS_PARAM_SPEC_DRAWABLE_ID (procedure->args[2]) ||
444
! G_IS_PARAM_SPEC_STRING (procedure->args[3]) ||
445
! G_IS_PARAM_SPEC_STRING (procedure->args[4]))
447
required = "INT32, IMAGE, DRAWABLE, STRING, STRING";
451
else if (g_str_has_prefix (menu_path, "<Brushes>") ||
452
g_str_has_prefix (menu_path, "<Gradients>") ||
453
g_str_has_prefix (menu_path, "<Palettes>") ||
454
g_str_has_prefix (menu_path, "<Patterns>") ||
455
g_str_has_prefix (menu_path, "<Fonts>") ||
456
g_str_has_prefix (menu_path, "<Buffers>"))
458
if ((procedure->num_args < 1) ||
459
! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]))
467
basename = g_filename_display_basename (proc->prog);
469
g_set_error (error, 0, 0,
470
"Plug-In \"%s\"\n(%s)\n"
471
"attempted to install procedure \"%s\" "
472
"in the invalid menu location \"%s\".\n"
473
"Use either \"<Toolbox>\", \"<Image>\", "
474
"\"<Layers>\", \"<Channels>\", \"<Vectors>\", "
475
"\"<Colormap>\", \"<Load>\", \"<Save>\", "
476
"\"<Brushes>\", \"<Gradients>\", \"<Palettes>\", "
477
"\"<Patterns>\" or \"<Buffers>\".",
478
basename, gimp_filename_to_utf8 (proc->prog),
479
GIMP_OBJECT (proc)->name,
486
proc->menu_paths = g_list_append (proc->menu_paths, g_strdup (menu_path));
488
g_signal_emit (proc, gimp_plug_in_procedure_signals[MENU_PATH_ADDED], 0,
496
gchar *prefix = g_strdup (menu_path);
498
p = strchr (prefix, '>') + 1;
501
basename = g_filename_display_basename (proc->prog);
503
g_set_error (error, 0, 0,
504
"Plug-In \"%s\"\n(%s)\n\n"
505
"attempted to install %s procedure \"%s\" "
506
"which does not take the standard %s Plug-In "
508
basename, gimp_filename_to_utf8 (proc->prog),
509
prefix, GIMP_OBJECT (proc)->name, prefix,
521
gimp_plug_in_procedure_get_label (GimpPlugInProcedure *proc)
528
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
533
if (proc->menu_label)
534
path = dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
536
else if (proc->menu_paths)
537
path = dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
538
proc->menu_paths->data);
542
stripped = gimp_strip_uline (path);
544
if (proc->menu_label)
545
label = g_strdup (stripped);
547
label = g_path_get_basename (stripped);
551
ellipsis = strstr (label, "...");
554
ellipsis = strstr (label, "\342\200\246" /* U+2026 HORIZONTAL ELLIPSIS */);
556
if (ellipsis && ellipsis == (label + strlen (label) - 3))
565
gimp_plug_in_procedure_get_blurb (const GimpPlugInProcedure *proc)
567
GimpProcedure *procedure;
569
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
571
procedure = GIMP_PROCEDURE (proc);
573
/* do not to pass the empty string to gettext() */
574
if (procedure->blurb && strlen (procedure->blurb))
575
return dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
582
gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
583
GimpIconType icon_type,
584
const guint8 *icon_data,
585
gint icon_data_length)
587
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
588
g_return_if_fail (icon_type == -1 || icon_data != NULL);
589
g_return_if_fail (icon_type == -1 || icon_data_length > 0);
593
g_free (proc->icon_data);
594
proc->icon_data_length = -1;
595
proc->icon_data = NULL;
598
proc->icon_type = icon_type;
600
switch (proc->icon_type)
602
case GIMP_ICON_TYPE_STOCK_ID:
603
case GIMP_ICON_TYPE_IMAGE_FILE:
604
proc->icon_data_length = -1;
605
proc->icon_data = (guint8 *) g_strdup ((gchar *) icon_data);
608
case GIMP_ICON_TYPE_INLINE_PIXBUF:
609
proc->icon_data_length = icon_data_length;
610
proc->icon_data = g_memdup (icon_data, icon_data_length);
616
gimp_plug_in_procedure_get_stock_id (const GimpPlugInProcedure *proc)
618
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
620
switch (proc->icon_type)
622
case GIMP_ICON_TYPE_STOCK_ID:
623
return (gchar *) proc->icon_data;
631
gimp_plug_in_procedure_get_pixbuf (const GimpPlugInProcedure *proc)
633
GdkPixbuf *pixbuf = NULL;
634
GError *error = NULL;
636
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
638
switch (proc->icon_type)
640
case GIMP_ICON_TYPE_INLINE_PIXBUF:
641
pixbuf = gdk_pixbuf_new_from_inline (proc->icon_data_length,
642
proc->icon_data, TRUE, &error);
645
case GIMP_ICON_TYPE_IMAGE_FILE:
646
pixbuf = gdk_pixbuf_new_from_file ((gchar *) proc->icon_data,
654
if (! pixbuf && error)
656
g_printerr (error->message);
657
g_clear_error (&error);
664
gimp_plug_in_procedure_get_help_id (const GimpPlugInProcedure *proc)
668
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
670
domain = gimp_plug_in_procedure_get_help_domain (proc);
673
return g_strconcat (domain, "?", GIMP_OBJECT (proc)->name, NULL);
675
return g_strdup (GIMP_OBJECT (proc)->name);
679
gimp_plug_in_procedure_get_sensitive (const GimpPlugInProcedure *proc,
680
GimpImageType image_type)
684
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), FALSE);
689
sensitive = proc->image_types_val & GIMP_PLUG_IN_RGB_IMAGE;
691
case GIMP_RGBA_IMAGE:
692
sensitive = proc->image_types_val & GIMP_PLUG_IN_RGBA_IMAGE;
694
case GIMP_GRAY_IMAGE:
695
sensitive = proc->image_types_val & GIMP_PLUG_IN_GRAY_IMAGE;
697
case GIMP_GRAYA_IMAGE:
698
sensitive = proc->image_types_val & GIMP_PLUG_IN_GRAYA_IMAGE;
700
case GIMP_INDEXED_IMAGE:
701
sensitive = proc->image_types_val & GIMP_PLUG_IN_INDEXED_IMAGE;
703
case GIMP_INDEXEDA_IMAGE:
704
sensitive = proc->image_types_val & GIMP_PLUG_IN_INDEXEDA_IMAGE;
711
return sensitive ? TRUE : FALSE;
714
static GimpPlugInImageType
715
image_types_parse (const gchar *name,
716
const gchar *image_types)
718
const gchar *type_spec = image_types;
719
GimpPlugInImageType types = 0;
721
/* If the plug_in registers with image_type == NULL or "", return 0
722
* By doing so it won't be touched by plug_in_set_menu_sensitivity()
729
while (*image_types &&
730
((*image_types == ' ') ||
731
(*image_types == '\t') ||
732
(*image_types == ',')))
737
if (g_str_has_prefix (image_types, "RGBA"))
739
types |= GIMP_PLUG_IN_RGBA_IMAGE;
740
image_types += strlen ("RGBA");
742
else if (g_str_has_prefix (image_types, "RGB*"))
744
types |= GIMP_PLUG_IN_RGB_IMAGE | GIMP_PLUG_IN_RGBA_IMAGE;
745
image_types += strlen ("RGB*");
747
else if (g_str_has_prefix (image_types, "RGB"))
749
types |= GIMP_PLUG_IN_RGB_IMAGE;
750
image_types += strlen ("RGB");
752
else if (g_str_has_prefix (image_types, "GRAYA"))
754
types |= GIMP_PLUG_IN_GRAYA_IMAGE;
755
image_types += strlen ("GRAYA");
757
else if (g_str_has_prefix (image_types, "GRAY*"))
759
types |= GIMP_PLUG_IN_GRAY_IMAGE | GIMP_PLUG_IN_GRAYA_IMAGE;
760
image_types += strlen ("GRAY*");
762
else if (g_str_has_prefix (image_types, "GRAY"))
764
types |= GIMP_PLUG_IN_GRAY_IMAGE;
765
image_types += strlen ("GRAY");
767
else if (g_str_has_prefix (image_types, "INDEXEDA"))
769
types |= GIMP_PLUG_IN_INDEXEDA_IMAGE;
770
image_types += strlen ("INDEXEDA");
772
else if (g_str_has_prefix (image_types, "INDEXED*"))
774
types |= GIMP_PLUG_IN_INDEXED_IMAGE | GIMP_PLUG_IN_INDEXEDA_IMAGE;
775
image_types += strlen ("INDEXED*");
777
else if (g_str_has_prefix (image_types, "INDEXED"))
779
types |= GIMP_PLUG_IN_INDEXED_IMAGE;
780
image_types += strlen ("INDEXED");
782
else if (g_str_has_prefix (image_types, "*"))
784
types |= (GIMP_PLUG_IN_RGB_IMAGE | GIMP_PLUG_IN_RGBA_IMAGE |
785
GIMP_PLUG_IN_GRAY_IMAGE | GIMP_PLUG_IN_GRAYA_IMAGE |
786
GIMP_PLUG_IN_INDEXED_IMAGE | GIMP_PLUG_IN_INDEXEDA_IMAGE);
787
image_types += strlen ("*");
791
g_printerr ("%s: image-type contains unrecognizable parts:"
792
"'%s'\n", name, type_spec);
794
while (*image_types &&
795
((*image_types != ' ') ||
796
(*image_types != '\t') ||
797
(*image_types != ',')))
809
gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
810
const gchar *image_types)
812
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
814
if (proc->image_types)
815
g_free (proc->image_types);
817
proc->image_types = g_strdup (image_types);
818
proc->image_types_val = image_types_parse (gimp_object_get_name (GIMP_OBJECT (proc)),
823
extensions_parse (gchar *extensions)
827
/* EXTENSIONS can be NULL. Avoid calling strtok if it is. */
833
extensions = g_strdup (extensions);
835
next_token = extensions;
836
extension = strtok (next_token, " \t,");
840
list = g_slist_prepend (list, g_strdup (extension));
841
extension = strtok (NULL, " \t,");
847
return g_slist_reverse (list);
851
gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
852
const gchar *extensions,
853
const gchar *prefixes,
856
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
858
proc->file_proc = TRUE;
860
if (proc->extensions != extensions)
862
if (proc->extensions)
863
g_free (proc->extensions);
864
proc->extensions = g_strdup (extensions);
867
proc->extensions_list = extensions_parse (proc->extensions);
869
if (proc->prefixes != prefixes)
872
g_free (proc->prefixes);
873
proc->prefixes = g_strdup (prefixes);
876
proc->prefixes_list = extensions_parse (proc->prefixes);
878
if (proc->magics != magics)
881
g_free (proc->magics);
882
proc->magics = g_strdup (magics);
885
proc->magics_list = extensions_parse (proc->magics);
889
gimp_plug_in_procedure_set_mime_type (GimpPlugInProcedure *proc,
890
const gchar *mime_type)
892
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
894
proc->file_proc = TRUE;
897
g_free (proc->mime_type);
899
proc->mime_type = g_strdup (mime_type);
903
gimp_plug_in_procedure_set_thumb_loader (GimpPlugInProcedure *proc,
904
const gchar *thumb_loader)
906
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
908
proc->file_proc = TRUE;
910
if (proc->thumb_loader)
911
g_free (proc->thumb_loader);
913
proc->thumb_loader = g_strdup (thumb_loader);