dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app/Makefile.am removed. 

2001-10-18  Michael Natterer  <mitch@gimp.org>

	* app/Makefile.am
	* app/module_db.[ch]: removed.

	* app/core/Makefile.am
	* app/core/core-types.h
	* app/core/gimpmoduleinfo.[ch]
	* app/core/gimpmodules.[ch]: new files containing the module info
	object and the module list handling code.

	* app/gui/Makefile.am
	* app/gui/module-browser.[ch]: new files containing the GUI.

	* app/xcf/xcf.[ch]: pass a "Gimp" pointer to xcf_exit().

	* app/core/gimp.[ch]: handle modules and xcf init/exit here too.

	* app/app_procs.c: don't touch the modules and xcf stuff any more.

	* app/gui/dialogs-constructors.c: changed accordingly.

2001-10-18  Michael Natterer  <mitch@gimp.org>

	* POTFILES.in: module_db.c has moved.
This commit is contained in:
Michael Natterer 2001-10-18 17:27:36 +00:00 committed by Michael Natterer
parent 31f690cf24
commit be86df2a69
29 changed files with 2744 additions and 3086 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
ChangeLog
View File

@ -1,3 +1,25 @@
2001-10-18 Michael Natterer <mitch@gimp.org>
* app/Makefile.am
* app/module_db.[ch]: removed.
* app/core/Makefile.am
* app/core/core-types.h
* app/core/gimpmoduleinfo.[ch]
* app/core/gimpmodules.[ch]: new files containing the module info
object and the module list handling code.
* app/gui/Makefile.am
* app/gui/module-browser.[ch]: new files containing the GUI.
* app/xcf/xcf.[ch]: pass a "Gimp" pointer to xcf_exit().
* app/core/gimp.[ch]: handle modules and xcf init/exit here too.
* app/app_procs.c: don't touch the modules and xcf stuff any more.
* app/gui/dialogs-constructors.c: changed accordingly.
2001-10-18 Michael Natterer <mitch@gimp.org>
* app/core/gimpcontainer.[ch]: added properties for "children_type"

4
app/Makefile.am
View File

@ -31,8 +31,6 @@ gimp_SOURCES = @STRIP_BEGIN@ \
##
image_map.c \
image_map.h \
module_db.c \
module_db.h \
user_install.c \
user_install.h \
##
@ -130,10 +128,10 @@ gimp_LDADD = @STRIP_BEGIN@ \
tools/libapptools.a \
display/libappdisplay.a \
widgets/libappwidgets.a \
xcf/libappxcf.a \
plug-in/libappplug-in.a \
pdb/libapppdb.a \
core/libappcore.a \
xcf/libappxcf.a \
paint-funcs/libapppaint-funcs.a \
base/libappbase.a \
$(top_builddir)/libgimpcolor/libgimpcolor-$(LT_RELEASE).la \

13
app/app_procs.c
View File

@ -43,8 +43,6 @@
#include "pdb/internal_procs.h"
#include "xcf/xcf.h"
#include "display/gimpdisplay-foreach.h"
#include "tools/tool_manager.h"
@ -60,7 +58,6 @@
#include "docindex.h"
#include "errors.h"
#include "gimprc.h"
#include "module_db.h"
#include "plug_in.h"
#include "undo.h"
#include "user_install.h"
@ -99,7 +96,7 @@ app_init (gint gimp_argc,
/* Create an instance of the "Gimp" object which is the root of the
* core object system
*/
the_gimp = gimp_new ();
the_gimp = gimp_new (be_verbose);
/* Check if the user's gimp_directory exists
*/
@ -162,10 +159,6 @@ app_init (gint gimp_argc,
app_init_update_status (_("Procedural Database"), NULL, -1);
internal_procs_init (the_gimp);
/* Initialize the xcf file format routines
*/
xcf_init (the_gimp);
/* Now we are ready to draw the splash-screen-image
* to the start-up window
*/
@ -179,7 +172,6 @@ app_init (gint gimp_argc,
gimp_restore (the_gimp, no_data);
plug_in_init (); /* initialize the plug in structures */
module_db_init (); /* load any modules we need */
if (! no_interface)
{
@ -241,7 +233,6 @@ app_exit_finish (void)
gui_shutdown (the_gimp);
}
module_db_free ();
plug_in_kill ();
tool_manager_exit (the_gimp);
@ -251,8 +242,6 @@ app_exit_finish (void)
gui_exit (the_gimp);
}
xcf_exit ();
gimp_shutdown (the_gimp);
g_object_unref (G_OBJECT (the_gimp));

4
app/core/Makefile.am
View File

@ -89,6 +89,10 @@ libappcore_a_sources = @STRIP_BEGIN@ \
gimplayermask.h \
gimplist.c \
gimplist.h \
gimpmoduleinfo.c \
gimpmoduleinfo.h \
gimpmodules.c \
gimpmodules.h \
gimpobject.c \
gimpobject.h \
gimppattern.c \

2
app/core/core-types.h
View File

@ -165,6 +165,8 @@ typedef struct _Gimp Gimp;
typedef struct _GimpParasiteList GimpParasiteList;
typedef struct _GimpModuleInfoObj GimpModuleInfoObj;
typedef struct _GimpContainer GimpContainer;
typedef struct _GimpList GimpList;
typedef struct _GimpDataList GimpDataList;

400
app/core/gimp-modules.c Normal file
View File

@ -0,0 +1,400 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmodules.c
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <time.h>
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "core-types.h"
#include "core/gimp.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimplist.h"
#include "core/gimpmoduleinfo.h"
#include "core/gimpmodules.h"
#include "gimprc.h"
#include "libgimp/gimpintl.h"
static void gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data);
static GimpModuleInfoObj * gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath);
#ifdef DUMP_DB
static void print_module_info (gpointer data,
gpointer user_data);
#endif
static gboolean gimp_modules_write_modulerc (Gimp *gimp);
static void gimp_modules_module_free_func (gpointer data,
gpointer user_data);
static void gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data);
static void gimp_modules_module_remove_func (gpointer data,
gpointer user_data);
void
gimp_modules_init (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp->modules = gimp_list_new (GIMP_TYPE_MODULE_INFO,
GIMP_CONTAINER_POLICY_STRONG);
gimp->write_modulerc = FALSE;
}
void
gimp_modules_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->modules)
{
g_object_unref (G_OBJECT (gimp->modules));
gimp->modules = NULL;
}
}
void
gimp_modules_load (Gimp *gimp)
{
gchar *filename;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = gimp_personal_rc_file ("modulerc");
gimprc_parse_file (filename);
g_free (filename);
if (g_module_supported ())
gimp_datafiles_read_directories (gimp->config->module_path,
0 /* no flags */,
gimp_modules_module_initialize,
gimp);
#ifdef DUMP_DB
gimp_container_foreach (modules, print_module_info, NULL);
#endif
}
void
gimp_modules_unload (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->write_modulerc)
{
if (gimp_modules_write_modulerc (gimp))
{
gimp->write_modulerc = FALSE;
}
}
gimp_container_foreach (gimp->modules, gimp_modules_module_free_func, NULL);
}
void
gimp_modules_refresh (Gimp *gimp)
{
GList *kill_list = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* remove modules we don't have on disk anymore */
gimp_container_foreach (gimp->modules,
gimp_modules_module_on_disk_func,
&kill_list);
g_list_foreach (kill_list,
gimp_modules_module_remove_func,
gimp);
g_list_free (kill_list);
/* walk filesystem and add new things we find */
gimp_datafiles_read_directories (gimp->config->module_path,
0 /* no flags */,
gimp_modules_module_initialize,
gimp);
}
static void
gimp_modules_module_free_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info = data;
if (module_info->module &&
module_info->unload &&
module_info->state == GIMP_MODULE_STATE_LOADED_OK)
{
gimp_module_info_module_unload (module_info, FALSE);
}
}
static void
add_to_inhibit_string (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info = data;
GString *str = user_data;
if (module_info->load_inhibit)
{
str = g_string_append_c (str, G_SEARCHPATH_SEPARATOR);
str = g_string_append (str, module_info->fullpath);
}
}
static gboolean
gimp_modules_write_modulerc (Gimp *gimp)
{
GString *str;
gchar *p;
gchar *filename;
FILE *fp;
gboolean saved = FALSE;
str = g_string_new (NULL);
gimp_container_foreach (gimp->modules, add_to_inhibit_string, str);
if (str->len > 0)
p = str->str + 1;
else
p = "";
filename = gimp_personal_rc_file ("modulerc");
fp = fopen (filename, "wt");
g_free (filename);
if (fp)
{
fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
fclose (fp);
saved = TRUE;
}
g_string_free (str, TRUE);
return saved;
}
/* name must be of the form lib*.so (Unix) or *.dll (Win32) */
static gboolean
valid_module_name (const gchar *filename)
{
gchar *basename;
gint len;
basename = g_path_get_basename (filename);
len = strlen (basename);
#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN) && !defined(__EMX__)
if (len < 3 + 1 + 3)
goto no_module;
if (strncmp (basename, "lib", 3))
goto no_module;
if (strcmp (basename + len - 3, ".so"))
goto no_module;
#else
if (len < 1 + 4)
goto no_module;
if (g_strcasecmp (basename + len - 4, ".dll"))
goto no_module;
#endif
g_free (basename);
return TRUE;
no_module:
g_free (basename);
return FALSE;
}
static void
gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data)
{
GimpModuleInfoObj *module_info;
Gimp *gimp;
gimp = GIMP (loader_data);
if (! valid_module_name (filename))
return;
/* don't load if we already know about it */
if (gimp_modules_module_find_by_path (gimp, filename))
return;
module_info = gimp_module_info_new (filename);
gimp_module_info_set_load_inhibit (module_info,
gimp->config->module_db_load_inhibit);
if (! module_info->load_inhibit)
{
if (gimp->be_verbose)
g_print (_("load module: \"%s\"\n"), filename);
gimp_module_info_module_load (module_info, TRUE);
}
else
{
if (gimp->be_verbose)
g_print (_("skipping module: \"%s\"\n"), filename);
module_info->state = GIMP_MODULE_STATE_UNLOADED_OK;
}
gimp_container_add (gimp->modules, GIMP_OBJECT (module_info));
g_object_unref (G_OBJECT (module_info));
}
typedef struct
{
const gchar *search_key;
GimpModuleInfoObj *found;
} find_by_path_closure;
static void
gimp_modules_module_path_cmp_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
find_by_path_closure *closure;
module_info = (GimpModuleInfoObj *) data;
closure = (find_by_path_closure *) user_data;
if (! strcmp (module_info->fullpath, closure->search_key))
closure->found = module_info;
}
static GimpModuleInfoObj *
gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath)
{
find_by_path_closure cl;
cl.found = NULL;
cl.search_key = fullpath;
gimp_container_foreach (gimp->modules,
gimp_modules_module_path_cmp_func, &cl);
return cl.found;
}
#ifdef DUMP_DB
static void
print_module_info (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *i = data;
g_print ("\n%s: %s\n",
i->fullpath, statename[i->state]);
g_print (" module:%p lasterr:%s init:%p unload:%p\n",
i->module, i->last_module_error? i->last_module_error : "NONE",
i->init, i->unload);
if (i->info)
{
g_print (" shutdown_data: %p\n"
" purpose: %s\n"
" author: %s\n"
" version: %s\n"
" copyright: %s\n"
" date: %s\n",
i->info->shutdown_data,
i->info->purpose, i->info->author, i->info->version,
i->info->copyright, i->info->date);
}
}
#endif
static void
gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
GList **kill_list;
gint old_on_disk;
struct stat statbuf;
gint ret;
module_info = (GimpModuleInfoObj *) data;
kill_list = (GList **) user_data;
old_on_disk = module_info->on_disk;
ret = stat (module_info->fullpath, &statbuf);
if (ret != 0)
module_info->on_disk = FALSE;
else
module_info->on_disk = TRUE;
/* if it's not on the disk, and it isn't in memory, mark it to be
* removed later.
*/
if (! module_info->on_disk && ! module_info->module)
{
*kill_list = g_list_append (*kill_list, module_info);
module_info = NULL;
}
if (module_info && module_info->on_disk != old_on_disk)
gimp_module_info_modified (module_info);
}
static void
gimp_modules_module_remove_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
Gimp *gimp;
module_info = (GimpModuleInfoObj *) data;
gimp = (Gimp *) user_data;
gimp_container_remove (gimp->modules, GIMP_OBJECT (module_info));
}

18
app/module_db.h → app/core/gimp-modules.h
View File

@ -1,7 +1,8 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* module_db.h (C) 1999 Austin Donnelly <austin@gimp.org>
* gimpmodules.h
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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
@ -18,16 +19,17 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __MODULE_DB_H__
#ifndef __GIMP_MODULES_H__
#define __GIMP_MODULES_H__
/* Load any modules we find on the module-path set in the gimprc */
void module_db_init (void);
void gimp_modules_init (Gimp *gimp);
void gimp_modules_exit (Gimp *gimp);
/* Unload all modules, in case a module needs some cleanups */
void module_db_free (void);
void gimp_modules_load (Gimp *gimp);
void gimp_modules_unload (Gimp *gimp);
GtkWidget * module_db_browser_new (void);
void gimp_modules_refresh (Gimp *gimp);
#endif /* __MODULE_DB_H__ */
#endif /* __GIMP_MODULES_H__ */

21
app/core/gimp.c
View File

@ -31,6 +31,8 @@
#include "pdb/procedural_db.h"
#include "xcf/xcf.h"
#include "gimp.h"
#include "gimpbrush.h"
#include "gimpbrushgenerated.h"
@ -45,6 +47,7 @@
#include "gimpimage-new.h"
#include "gimpimagefile.h"
#include "gimplist.h"
#include "gimpmodules.h"
#include "gimppalette.h"
#include "gimppattern.h"
#include "gimpparasite.h"
@ -115,6 +118,8 @@ gimp_init (Gimp *gimp)
{
gimp_core_config_init (gimp);
gimp->be_verbose = FALSE;
gimp->create_display_func = NULL;
gimp->gui_set_busy_func = NULL;
gimp->gui_unset_busy_func = NULL;
@ -126,6 +131,8 @@ gimp_init (Gimp *gimp)
gimp_parasites_init (gimp);
gimp_modules_init (gimp);
gimp->images = gimp_list_new (GIMP_TYPE_IMAGE,
GIMP_CONTAINER_POLICY_WEAK);
gimp->next_image_ID = 1;
@ -145,6 +152,8 @@ gimp_init (Gimp *gimp)
procedural_db_init (gimp);
xcf_init (gimp);
gimp->tool_info_list = gimp_list_new (GIMP_TYPE_TOOL_INFO,
GIMP_CONTAINER_POLICY_STRONG);
gimp->standard_tool_info = NULL;
@ -220,6 +229,8 @@ gimp_finalize (GObject *object)
gimp->tool_info_list = NULL;
}
xcf_exit (gimp);
if (gimp->procedural_ht)
procedural_db_free (gimp);
@ -277,6 +288,9 @@ gimp_finalize (GObject *object)
gimp->images = NULL;
}
if (gimp->modules)
gimp_modules_exit (gimp);
if (gimp->parasites)
gimp_parasites_exit (gimp);
@ -287,12 +301,14 @@ gimp_finalize (GObject *object)
}
Gimp *
gimp_new (void)
gimp_new (gboolean be_verbose)
{
Gimp *gimp;
gimp = g_object_new (GIMP_TYPE_GIMP, NULL);
gimp->be_verbose = be_verbose ? TRUE : FALSE;
return gimp;
}
@ -412,6 +428,8 @@ gimp_restore (Gimp *gimp,
gimp_documents_load (gimp);
app_init_update_status (NULL, NULL, 1.00);
gimp_modules_load (gimp);
}
void
@ -419,6 +437,7 @@ gimp_shutdown (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp_modules_unload (gimp);
gimp_data_factory_data_save (gimp->brush_factory);
gimp_data_factory_data_save (gimp->pattern_factory);
gimp_data_factory_data_save (gimp->gradient_factory);

7
app/core/gimp.h
View File

@ -44,6 +44,8 @@ struct _Gimp
GimpCoreConfig *config;
gboolean be_verbose;
GimpCreateDisplayFunc create_display_func;
GimpSetBusyFunc gui_set_busy_func;
GimpUnsetBusyFunc gui_unset_busy_func;
@ -56,6 +58,9 @@ struct _Gimp
GimpParasiteList *parasites;
GimpContainer *modules;
gboolean write_modulerc;
GimpContainer *images;
gint next_image_ID;
guint32 next_guide_ID;
@ -110,7 +115,7 @@ struct _GimpClass
GType gimp_get_type (void);
Gimp * gimp_new (void);
Gimp * gimp_new (gboolean be_verbose);
void gimp_initialize (Gimp *gimp);

400
app/core/gimpmoduleinfo.c Normal file
View File

@ -0,0 +1,400 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmoduleinfo.c
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#include <glib-object.h>
#include "libgimp/gimpmodule.h"
#include "core-types.h"
#include "gimpmoduleinfo.h"
#include "libgimp/gimpintl.h"
enum
{
MODIFIED,
LAST_SIGNAL
};
static void gimp_module_info_class_init (GimpModuleInfoObjClass *klass);
static void gimp_module_info_init (GimpModuleInfoObj *mod);
static void gimp_module_info_finalize (GObject *object);
static guint module_info_signals[LAST_SIGNAL];
static GimpObjectClass *parent_class = NULL;
GType
gimp_module_info_get_type (void)
{
static GType module_info_type = 0;
if (! module_info_type)
{
static const GTypeInfo module_info_info =
{
sizeof (GimpModuleInfoObjClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_module_info_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpModuleInfoObj),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_module_info_init,
};
module_info_type = g_type_register_static (GIMP_TYPE_OBJECT,
"GimpModuleInfoObj",
&module_info_info, 0);
}
return module_info_type;
}
static void
gimp_module_info_class_init (GimpModuleInfoObjClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
module_info_signals[MODIFIED] =
g_signal_new ("modified",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpModuleInfoObjClass, modified),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->finalize = gimp_module_info_finalize;
klass->modified = NULL;
}
static void
gimp_module_info_init (GimpModuleInfoObj *module_info)
{
module_info->fullpath = NULL;
module_info->state = GIMP_MODULE_STATE_ERROR;
module_info->on_disk = FALSE;
module_info->load_inhibit = FALSE;
module_info->refs = 0;
module_info->info = NULL;
module_info->module = NULL;
module_info->last_module_error = NULL;
module_info->init = NULL;
module_info->unload = NULL;
}
static void
gimp_module_info_finalize (GObject *object)
{
GimpModuleInfoObj *mod;
mod = GIMP_MODULE_INFO (object);
/* if this trips, then we're onto some serious lossage in a moment */
g_return_if_fail (mod->refs == 0);
if (mod->last_module_error)
{
g_free (mod->last_module_error);
mod->last_module_error = NULL;
}
if (mod->fullpath)
{
g_free (mod->fullpath);
mod->fullpath = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GimpModuleInfoObj *
gimp_module_info_new (const gchar *filename)
{
GimpModuleInfoObj *module_info;
g_return_val_if_fail (filename != NULL, NULL);
module_info = g_object_new (GIMP_TYPE_MODULE_INFO, NULL);
module_info->fullpath = g_strdup (filename);
module_info->on_disk = TRUE;
return module_info;
}
void
gimp_module_info_modified (GimpModuleInfoObj *module_info)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_signal_emit (G_OBJECT (module_info), module_info_signals[MODIFIED], 0);
}
void
gimp_module_info_set_load_inhibit (GimpModuleInfoObj *module_info,
const gchar *inhibit_list)
{
gchar *p;
gint pathlen;
const gchar *start;
const gchar *end;
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->fullpath != NULL);
module_info->load_inhibit = FALSE;
if (! inhibit_list || ! strlen (inhibit_list))
return;
p = strstr (inhibit_list, module_info->fullpath);
if (!p)
return;
/* we have a substring, but check for colons either side */
start = p;
while (start != inhibit_list && *start != G_SEARCHPATH_SEPARATOR)
start--;
if (*start == G_SEARCHPATH_SEPARATOR)
start++;
end = strchr (p, G_SEARCHPATH_SEPARATOR);
if (! end)
end = inhibit_list + strlen (inhibit_list);
pathlen = strlen (module_info->fullpath);
if ((end - start) == pathlen)
module_info->load_inhibit = TRUE;
}
static void
gimp_module_info_set_last_error (GimpModuleInfoObj *module_info,
const gchar *error_str)
{
if (module_info->last_module_error)
g_free (module_info->last_module_error);
module_info->last_module_error = g_strdup (error_str);
}
/*
* FIXME: currently this will fail badly on EMX
*/
#ifdef __EMX__
extern void gimp_color_selector_register (void);
extern void gimp_color_selector_unregister (void);
extern void dialog_register (void);
extern void dialog_unregister (void);
static struct main_funcs_struc
{
gchar *name;
void (* func) (void);
}
gimp_main_funcs[] =
{
{ "gimp_color_selector_register", gimp_color_selector_register },
{ "gimp_color_selector_unregister", gimp_color_selector_unregister },
{ "dialog_register", dialog_register },
{ "dialog_unregister", dialog_unregister },
{ NULL, NULL }
};
#endif
void
gimp_module_info_module_load (GimpModuleInfoObj *module_info,
gboolean verbose)
{
gpointer symbol;
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->fullpath != NULL);
g_return_if_fail (module_info->module == NULL);
module_info->module = g_module_open (module_info->fullpath,
G_MODULE_BIND_LAZY);
if (! module_info->module)
{
module_info->state = GIMP_MODULE_STATE_ERROR;
gimp_module_info_set_last_error (module_info, g_module_error ());
if (verbose)
g_warning (_("module load error: %s: %s"),
module_info->fullpath, module_info->last_module_error);
return;
}
#ifdef __EMX__
if (g_module_symbol (module_info->module, "gimp_main_funcs", &symbol))
{
*(struct main_funcs_struc **) symbol = gimp_main_funcs;
}
#endif
/* find the module_init symbol */
if (! g_module_symbol (module_info->module, "module_init", &symbol))
{
module_info->state = GIMP_MODULE_STATE_ERROR;
gimp_module_info_set_last_error (module_info,
"missing module_init() symbol");
if (verbose)
g_warning ("%s: module_init() symbol not found",
module_info->fullpath);
g_module_close (module_info->module);
module_info->module = NULL;
return;
}
module_info->init = symbol;
/* loaded modules are assumed to have a ref of 1 */
gimp_module_info_module_ref (module_info);
/* run module's initialisation */
if (module_info->init (&module_info->info) == GIMP_MODULE_UNLOAD)
{
module_info->state = GIMP_MODULE_STATE_LOAD_FAILED;
gimp_module_info_module_unref (module_info);
module_info->info = NULL;
return;
}
/* module is now happy */
module_info->state = GIMP_MODULE_STATE_LOADED_OK;
/* do we have an unload function? */
if (g_module_symbol (module_info->module, "module_unload", &symbol))
{
module_info->unload = symbol;
}
}
static void
gimp_module_info_module_unload_completed_callback (gpointer data)
{
GimpModuleInfoObj *module_info;
module_info = (GimpModuleInfoObj *) data;
g_return_if_fail (module_info->state == GIMP_MODULE_STATE_UNLOAD_REQUESTED);
/* lose the ref we gave this module when we loaded it,
* since the module's now happy to be unloaded.
*/
gimp_module_info_module_unref (module_info);
module_info->info = NULL;
module_info->state = GIMP_MODULE_STATE_UNLOADED_OK;
gimp_module_info_modified (module_info);
}
static gboolean
gimp_module_info_module_idle_unref (gpointer data)
{
GimpModuleInfoObj *module_info;
module_info = (GimpModuleInfoObj *) data;
gimp_module_info_module_unref (module_info);
return FALSE;
}
void
gimp_module_info_module_unload (GimpModuleInfoObj *module_info,
gboolean verbose)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->module != NULL);
g_return_if_fail (module_info->unload != NULL);
if (module_info->state == GIMP_MODULE_STATE_UNLOAD_REQUESTED)
return;
module_info->state = GIMP_MODULE_STATE_UNLOAD_REQUESTED;
/* Send the unload request. Need to ref the module so we don't
* accidentally unload it while this call is in progress (eg if the
* callback is called before the unload function returns).
*/
gimp_module_info_module_ref (module_info);
module_info->unload (module_info->info->shutdown_data,
gimp_module_info_module_unload_completed_callback,
module_info);
g_idle_add (gimp_module_info_module_idle_unref, module_info);
}
void
gimp_module_info_module_ref (GimpModuleInfoObj *module_info)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->refs >= 0);
g_return_if_fail (module_info->module != NULL);
module_info->refs++;
}
void
gimp_module_info_module_unref (GimpModuleInfoObj *module_info)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->refs > 0);
g_return_if_fail (module_info->module != NULL);
module_info->refs--;
if (module_info->refs == 0)
{
g_module_close (module_info->module);
module_info->module = NULL;
}
}

102
app/core/gimpmoduleinfo.h Normal file
View File

@ -0,0 +1,102 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmoduleinfo.h
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_MODULE_INFO_H__
#define __GIMP_MODULE_INFO_H__
#include "libgimp/gimpmodule.h"
#include "gimpobject.h"
typedef enum
{
GIMP_MODULE_STATE_ERROR, /* missing module_load function or other error */
GIMP_MODULE_STATE_LOADED_OK, /* happy and running (normal state of affairs) */
GIMP_MODULE_STATE_LOAD_FAILED, /* module_load returned GIMP_MODULE_UNLOAD */
GIMP_MODULE_STATE_UNLOAD_REQUESTED, /* sent unload request, waiting for callback */
GIMP_MODULE_STATE_UNLOADED_OK /* callback arrived, module not in memory anymore */
} GimpModuleState;
#define GIMP_TYPE_MODULE_INFO (gimp_module_info_get_type ())
#define GIMP_MODULE_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_MODULE_INFO, GimpModuleInfoObj))
#define GIMP_MODULE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_MODULE_INFO, GimpModuleInfoObjClass))
#define GIMP_IS_MODULE_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_MODULE_INFO))
#define GIMP_IS_MODULE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_MODULE_INFO))
#define GIMP_MODULE_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_MODULE_INFO, GimpModuleInfoObjClass))
typedef struct _GimpModuleInfoObjClass GimpModuleInfoObjClass;
struct _GimpModuleInfoObj
{
GimpObject parent_instance;
gchar *fullpath; /* path to the module */
GimpModuleState state; /* what's happened to the module */
gboolean on_disk; /* TRUE if file still exists */
gboolean load_inhibit; /* user requests not to load at boot time */
/* Count of times main gimp is within the module. Normally, this
* will be 1, and we assume that the module won't call its
* unload callback until it is satisfied that it's not in use any
* more. refs can be 2 temporarily while we're running the module's
* unload function, to stop the module attempting to unload
* itself.
*/
gint refs;
/* stuff from now on may be NULL depending on the state the module is in */
GimpModuleInfo *info; /* returned values from module_init */
GModule *module; /* handle on the module */
gchar *last_module_error;
GimpModuleInitFunc init;
GimpModuleUnloadFunc unload;
};
struct _GimpModuleInfoObjClass
{
GimpObjectClass parent_class;
void (* modified) (GimpModuleInfoObj *module_info);
};
GType gimp_module_info_get_type (void);
GimpModuleInfoObj * gimp_module_info_new (const gchar *filename);
void gimp_module_info_modified (GimpModuleInfoObj *module);
void gimp_module_info_set_load_inhibit (GimpModuleInfoObj *module,
const gchar *inhibit_list);
void gimp_module_info_module_load (GimpModuleInfoObj *module_info,
gboolean verbose);
void gimp_module_info_module_unload (GimpModuleInfoObj *module_info,
gboolean verbose);
void gimp_module_info_module_ref (GimpModuleInfoObj *module_info);
void gimp_module_info_module_unref (GimpModuleInfoObj *module_info);
#endif /* __GIMP_MODULE_INFO_H__ */

400
app/core/gimpmodules.c Normal file
View File

@ -0,0 +1,400 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmodules.c
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <time.h>
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "core-types.h"
#include "core/gimp.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimplist.h"
#include "core/gimpmoduleinfo.h"
#include "core/gimpmodules.h"
#include "gimprc.h"
#include "libgimp/gimpintl.h"
static void gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data);
static GimpModuleInfoObj * gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath);
#ifdef DUMP_DB
static void print_module_info (gpointer data,
gpointer user_data);
#endif
static gboolean gimp_modules_write_modulerc (Gimp *gimp);
static void gimp_modules_module_free_func (gpointer data,
gpointer user_data);
static void gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data);
static void gimp_modules_module_remove_func (gpointer data,
gpointer user_data);
void
gimp_modules_init (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp->modules = gimp_list_new (GIMP_TYPE_MODULE_INFO,
GIMP_CONTAINER_POLICY_STRONG);
gimp->write_modulerc = FALSE;
}
void
gimp_modules_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->modules)
{
g_object_unref (G_OBJECT (gimp->modules));
gimp->modules = NULL;
}
}
void
gimp_modules_load (Gimp *gimp)
{
gchar *filename;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = gimp_personal_rc_file ("modulerc");
gimprc_parse_file (filename);
g_free (filename);
if (g_module_supported ())
gimp_datafiles_read_directories (gimp->config->module_path,
0 /* no flags */,
gimp_modules_module_initialize,
gimp);
#ifdef DUMP_DB
gimp_container_foreach (modules, print_module_info, NULL);
#endif
}
void
gimp_modules_unload (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->write_modulerc)
{
if (gimp_modules_write_modulerc (gimp))
{
gimp->write_modulerc = FALSE;
}
}
gimp_container_foreach (gimp->modules, gimp_modules_module_free_func, NULL);
}
void
gimp_modules_refresh (Gimp *gimp)
{
GList *kill_list = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* remove modules we don't have on disk anymore */
gimp_container_foreach (gimp->modules,
gimp_modules_module_on_disk_func,
&kill_list);
g_list_foreach (kill_list,
gimp_modules_module_remove_func,
gimp);
g_list_free (kill_list);
/* walk filesystem and add new things we find */
gimp_datafiles_read_directories (gimp->config->module_path,
0 /* no flags */,
gimp_modules_module_initialize,
gimp);
}
static void
gimp_modules_module_free_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info = data;
if (module_info->module &&
module_info->unload &&
module_info->state == GIMP_MODULE_STATE_LOADED_OK)
{
gimp_module_info_module_unload (module_info, FALSE);
}
}
static void
add_to_inhibit_string (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info = data;
GString *str = user_data;
if (module_info->load_inhibit)
{
str = g_string_append_c (str, G_SEARCHPATH_SEPARATOR);
str = g_string_append (str, module_info->fullpath);
}
}
static gboolean
gimp_modules_write_modulerc (Gimp *gimp)
{
GString *str;
gchar *p;
gchar *filename;
FILE *fp;
gboolean saved = FALSE;
str = g_string_new (NULL);
gimp_container_foreach (gimp->modules, add_to_inhibit_string, str);
if (str->len > 0)
p = str->str + 1;
else
p = "";
filename = gimp_personal_rc_file ("modulerc");
fp = fopen (filename, "wt");
g_free (filename);
if (fp)
{
fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
fclose (fp);
saved = TRUE;
}
g_string_free (str, TRUE);
return saved;
}
/* name must be of the form lib*.so (Unix) or *.dll (Win32) */
static gboolean
valid_module_name (const gchar *filename)
{
gchar *basename;
gint len;
basename = g_path_get_basename (filename);
len = strlen (basename);
#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN) && !defined(__EMX__)
if (len < 3 + 1 + 3)
goto no_module;
if (strncmp (basename, "lib", 3))
goto no_module;
if (strcmp (basename + len - 3, ".so"))
goto no_module;
#else
if (len < 1 + 4)
goto no_module;
if (g_strcasecmp (basename + len - 4, ".dll"))
goto no_module;
#endif
g_free (basename);
return TRUE;
no_module:
g_free (basename);
return FALSE;
}
static void
gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data)
{
GimpModuleInfoObj *module_info;
Gimp *gimp;
gimp = GIMP (loader_data);
if (! valid_module_name (filename))
return;
/* don't load if we already know about it */
if (gimp_modules_module_find_by_path (gimp, filename))
return;
module_info = gimp_module_info_new (filename);
gimp_module_info_set_load_inhibit (module_info,
gimp->config->module_db_load_inhibit);
if (! module_info->load_inhibit)
{
if (gimp->be_verbose)
g_print (_("load module: \"%s\"\n"), filename);
gimp_module_info_module_load (module_info, TRUE);
}
else
{
if (gimp->be_verbose)
g_print (_("skipping module: \"%s\"\n"), filename);
module_info->state = GIMP_MODULE_STATE_UNLOADED_OK;
}
gimp_container_add (gimp->modules, GIMP_OBJECT (module_info));
g_object_unref (G_OBJECT (module_info));
}
typedef struct
{
const gchar *search_key;
GimpModuleInfoObj *found;
} find_by_path_closure;
static void
gimp_modules_module_path_cmp_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
find_by_path_closure *closure;
module_info = (GimpModuleInfoObj *) data;
closure = (find_by_path_closure *) user_data;
if (! strcmp (module_info->fullpath, closure->search_key))
closure->found = module_info;
}
static GimpModuleInfoObj *
gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath)
{
find_by_path_closure cl;
cl.found = NULL;
cl.search_key = fullpath;
gimp_container_foreach (gimp->modules,
gimp_modules_module_path_cmp_func, &cl);
return cl.found;
}
#ifdef DUMP_DB
static void
print_module_info (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *i = data;
g_print ("\n%s: %s\n",
i->fullpath, statename[i->state]);
g_print (" module:%p lasterr:%s init:%p unload:%p\n",
i->module, i->last_module_error? i->last_module_error : "NONE",
i->init, i->unload);
if (i->info)
{
g_print (" shutdown_data: %p\n"
" purpose: %s\n"
" author: %s\n"
" version: %s\n"
" copyright: %s\n"
" date: %s\n",
i->info->shutdown_data,
i->info->purpose, i->info->author, i->info->version,
i->info->copyright, i->info->date);
}
}
#endif
static void
gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
GList **kill_list;
gint old_on_disk;
struct stat statbuf;
gint ret;
module_info = (GimpModuleInfoObj *) data;
kill_list = (GList **) user_data;
old_on_disk = module_info->on_disk;
ret = stat (module_info->fullpath, &statbuf);
if (ret != 0)
module_info->on_disk = FALSE;
else
module_info->on_disk = TRUE;
/* if it's not on the disk, and it isn't in memory, mark it to be
* removed later.
*/
if (! module_info->on_disk && ! module_info->module)
{
*kill_list = g_list_append (*kill_list, module_info);
module_info = NULL;
}
if (module_info && module_info->on_disk != old_on_disk)
gimp_module_info_modified (module_info);
}
static void
gimp_modules_module_remove_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
Gimp *gimp;
module_info = (GimpModuleInfoObj *) data;
gimp = (Gimp *) user_data;
gimp_container_remove (gimp->modules, GIMP_OBJECT (module_info));
}

35
app/core/gimpmodules.h Normal file
View File

@ -0,0 +1,35 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmodules.h
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_MODULES_H__
#define __GIMP_MODULES_H__
void gimp_modules_init (Gimp *gimp);
void gimp_modules_exit (Gimp *gimp);
void gimp_modules_load (Gimp *gimp);
void gimp_modules_unload (Gimp *gimp);
void gimp_modules_refresh (Gimp *gimp);
#endif /* __GIMP_MODULES_H__ */

4
app/dialogs/dialogs-constructors.c
View File

@ -64,6 +64,7 @@
#include "gradients-commands.h"
#include "layers-commands.h"
#include "menus.h"
#include "module-browser.h"
#include "palette-editor.h"
#include "palette-select.h"
#include "palettes-commands.h"
@ -79,7 +80,6 @@
#include "devices.h"
#include "docindex.h"
#include "gimprc.h"
#include "module_db.h"
#include "undo_history.h"
#ifdef DISPLAY_FILTERS
@ -230,7 +230,7 @@ GtkWidget *
dialogs_module_browser_get (GimpDialogFactory *factory,
GimpContext *context)
{
return module_db_browser_new ();
return module_browser_new ();
}
GtkWidget *

1107
app/dialogs/module-dialog.c
View File

File diff suppressed because it is too large Load Diff

15
app/dialogs/module-dialog.h
View File

@ -1,7 +1,8 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* module_db.h (C) 1999 Austin Donnelly <austin@gimp.org>
* module-browser.h
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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
@ -18,16 +19,10 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __MODULE_DB_H__
#ifndef __MODULE_BROWSER_H__
/* Load any modules we find on the module-path set in the gimprc */
void module_db_init (void);
/* Unload all modules, in case a module needs some cleanups */
void module_db_free (void);
GtkWidget * module_db_browser_new (void);
GtkWidget * module_browser_new (void);
#endif /* __MODULE_DB_H__ */
#endif /* __MODULE_BROWSER_H__ */

2
app/gui/Makefile.am
View File

@ -71,6 +71,8 @@ libappgui_a_SOURCES = @STRIP_BEGIN@ \
layers-commands.h \
menus.c \
menus.h \
module-browser.c \
module-browser.h \
offset-dialog.c \
offset-dialog.h \
palette-editor.c \

4
app/gui/dialogs-constructors.c
View File

@ -64,6 +64,7 @@
#include "gradients-commands.h"
#include "layers-commands.h"
#include "menus.h"
#include "module-browser.h"
#include "palette-editor.h"
#include "palette-select.h"
#include "palettes-commands.h"
@ -79,7 +80,6 @@
#include "devices.h"
#include "docindex.h"
#include "gimprc.h"
#include "module_db.h"
#include "undo_history.h"
#ifdef DISPLAY_FILTERS
@ -230,7 +230,7 @@ GtkWidget *
dialogs_module_browser_get (GimpDialogFactory *factory,
GimpContext *context)
{
return module_db_browser_new ();
return module_browser_new ();
}
GtkWidget *

1107
app/gui/module-browser.c
View File

File diff suppressed because it is too large Load Diff

15
app/gui/module-browser.h
View File

@ -1,7 +1,8 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* module_db.h (C) 1999 Austin Donnelly <austin@gimp.org>
* module-browser.h
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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
@ -18,16 +19,10 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __MODULE_DB_H__
#ifndef __MODULE_BROWSER_H__
/* Load any modules we find on the module-path set in the gimprc */
void module_db_init (void);
/* Unload all modules, in case a module needs some cleanups */
void module_db_free (void);
GtkWidget * module_db_browser_new (void);
GtkWidget * module_browser_new (void);
#endif /* __MODULE_DB_H__ */
#endif /* __MODULE_BROWSER_H__ */

1198
app/module_db.c
View File

File diff suppressed because it is too large Load Diff

5
app/xcf/xcf.c
View File

@ -158,6 +158,8 @@ static gint n_xcf_loaders = sizeof (xcf_loaders) / sizeof (xcf_loaders[0]);
void
xcf_init (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* So this is sort of a hack, but its better than it was before. To do this
* right there would be a file load-save handler type and the whole interface
* would change but there isn't, and currently the plug-in structure contains
@ -178,8 +180,9 @@ xcf_init (Gimp *gimp)
}
void
xcf_exit (void)
xcf_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
}
static Argument*

2
app/xcf/xcf.h
View File

@ -21,7 +21,7 @@
void xcf_init (Gimp *gimp);
void xcf_exit (void);
void xcf_exit (Gimp *gimp);
#endif /* __XCF_H__ */

400
libgimpmodule/gimpmodule.c Normal file
View File

@ -0,0 +1,400 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmoduleinfo.c
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <string.h>
#include <glib-object.h>
#include "libgimp/gimpmodule.h"
#include "core-types.h"
#include "gimpmoduleinfo.h"
#include "libgimp/gimpintl.h"
enum
{
MODIFIED,
LAST_SIGNAL
};
static void gimp_module_info_class_init (GimpModuleInfoObjClass *klass);
static void gimp_module_info_init (GimpModuleInfoObj *mod);
static void gimp_module_info_finalize (GObject *object);
static guint module_info_signals[LAST_SIGNAL];
static GimpObjectClass *parent_class = NULL;
GType
gimp_module_info_get_type (void)
{
static GType module_info_type = 0;
if (! module_info_type)
{
static const GTypeInfo module_info_info =
{
sizeof (GimpModuleInfoObjClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_module_info_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpModuleInfoObj),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_module_info_init,
};
module_info_type = g_type_register_static (GIMP_TYPE_OBJECT,
"GimpModuleInfoObj",
&module_info_info, 0);
}
return module_info_type;
}
static void
gimp_module_info_class_init (GimpModuleInfoObjClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
module_info_signals[MODIFIED] =
g_signal_new ("modified",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpModuleInfoObjClass, modified),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
object_class->finalize = gimp_module_info_finalize;
klass->modified = NULL;
}
static void
gimp_module_info_init (GimpModuleInfoObj *module_info)
{
module_info->fullpath = NULL;
module_info->state = GIMP_MODULE_STATE_ERROR;
module_info->on_disk = FALSE;
module_info->load_inhibit = FALSE;
module_info->refs = 0;
module_info->info = NULL;
module_info->module = NULL;
module_info->last_module_error = NULL;
module_info->init = NULL;
module_info->unload = NULL;
}
static void
gimp_module_info_finalize (GObject *object)
{
GimpModuleInfoObj *mod;
mod = GIMP_MODULE_INFO (object);
/* if this trips, then we're onto some serious lossage in a moment */
g_return_if_fail (mod->refs == 0);
if (mod->last_module_error)
{
g_free (mod->last_module_error);
mod->last_module_error = NULL;
}
if (mod->fullpath)
{
g_free (mod->fullpath);
mod->fullpath = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GimpModuleInfoObj *
gimp_module_info_new (const gchar *filename)
{
GimpModuleInfoObj *module_info;
g_return_val_if_fail (filename != NULL, NULL);
module_info = g_object_new (GIMP_TYPE_MODULE_INFO, NULL);
module_info->fullpath = g_strdup (filename);
module_info->on_disk = TRUE;
return module_info;
}
void
gimp_module_info_modified (GimpModuleInfoObj *module_info)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_signal_emit (G_OBJECT (module_info), module_info_signals[MODIFIED], 0);
}
void
gimp_module_info_set_load_inhibit (GimpModuleInfoObj *module_info,
const gchar *inhibit_list)
{
gchar *p;
gint pathlen;
const gchar *start;
const gchar *end;
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->fullpath != NULL);
module_info->load_inhibit = FALSE;
if (! inhibit_list || ! strlen (inhibit_list))
return;
p = strstr (inhibit_list, module_info->fullpath);
if (!p)
return;
/* we have a substring, but check for colons either side */
start = p;
while (start != inhibit_list && *start != G_SEARCHPATH_SEPARATOR)
start--;
if (*start == G_SEARCHPATH_SEPARATOR)
start++;
end = strchr (p, G_SEARCHPATH_SEPARATOR);
if (! end)
end = inhibit_list + strlen (inhibit_list);
pathlen = strlen (module_info->fullpath);
if ((end - start) == pathlen)
module_info->load_inhibit = TRUE;
}
static void
gimp_module_info_set_last_error (GimpModuleInfoObj *module_info,
const gchar *error_str)
{
if (module_info->last_module_error)
g_free (module_info->last_module_error);
module_info->last_module_error = g_strdup (error_str);
}
/*
* FIXME: currently this will fail badly on EMX
*/
#ifdef __EMX__
extern void gimp_color_selector_register (void);
extern void gimp_color_selector_unregister (void);
extern void dialog_register (void);
extern void dialog_unregister (void);
static struct main_funcs_struc
{
gchar *name;
void (* func) (void);
}
gimp_main_funcs[] =
{
{ "gimp_color_selector_register", gimp_color_selector_register },
{ "gimp_color_selector_unregister", gimp_color_selector_unregister },
{ "dialog_register", dialog_register },
{ "dialog_unregister", dialog_unregister },
{ NULL, NULL }
};
#endif
void
gimp_module_info_module_load (GimpModuleInfoObj *module_info,
gboolean verbose)
{
gpointer symbol;
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->fullpath != NULL);
g_return_if_fail (module_info->module == NULL);
module_info->module = g_module_open (module_info->fullpath,
G_MODULE_BIND_LAZY);
if (! module_info->module)
{
module_info->state = GIMP_MODULE_STATE_ERROR;
gimp_module_info_set_last_error (module_info, g_module_error ());
if (verbose)
g_warning (_("module load error: %s: %s"),
module_info->fullpath, module_info->last_module_error);
return;
}
#ifdef __EMX__
if (g_module_symbol (module_info->module, "gimp_main_funcs", &symbol))
{
*(struct main_funcs_struc **) symbol = gimp_main_funcs;
}
#endif
/* find the module_init symbol */
if (! g_module_symbol (module_info->module, "module_init", &symbol))
{
module_info->state = GIMP_MODULE_STATE_ERROR;
gimp_module_info_set_last_error (module_info,
"missing module_init() symbol");
if (verbose)
g_warning ("%s: module_init() symbol not found",
module_info->fullpath);
g_module_close (module_info->module);
module_info->module = NULL;
return;
}
module_info->init = symbol;
/* loaded modules are assumed to have a ref of 1 */
gimp_module_info_module_ref (module_info);
/* run module's initialisation */
if (module_info->init (&module_info->info) == GIMP_MODULE_UNLOAD)
{
module_info->state = GIMP_MODULE_STATE_LOAD_FAILED;
gimp_module_info_module_unref (module_info);
module_info->info = NULL;
return;
}
/* module is now happy */
module_info->state = GIMP_MODULE_STATE_LOADED_OK;
/* do we have an unload function? */
if (g_module_symbol (module_info->module, "module_unload", &symbol))
{
module_info->unload = symbol;
}
}
static void
gimp_module_info_module_unload_completed_callback (gpointer data)
{
GimpModuleInfoObj *module_info;
module_info = (GimpModuleInfoObj *) data;
g_return_if_fail (module_info->state == GIMP_MODULE_STATE_UNLOAD_REQUESTED);
/* lose the ref we gave this module when we loaded it,
* since the module's now happy to be unloaded.
*/
gimp_module_info_module_unref (module_info);
module_info->info = NULL;
module_info->state = GIMP_MODULE_STATE_UNLOADED_OK;
gimp_module_info_modified (module_info);
}
static gboolean
gimp_module_info_module_idle_unref (gpointer data)
{
GimpModuleInfoObj *module_info;
module_info = (GimpModuleInfoObj *) data;
gimp_module_info_module_unref (module_info);
return FALSE;
}
void
gimp_module_info_module_unload (GimpModuleInfoObj *module_info,
gboolean verbose)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->module != NULL);
g_return_if_fail (module_info->unload != NULL);
if (module_info->state == GIMP_MODULE_STATE_UNLOAD_REQUESTED)
return;
module_info->state = GIMP_MODULE_STATE_UNLOAD_REQUESTED;
/* Send the unload request. Need to ref the module so we don't
* accidentally unload it while this call is in progress (eg if the
* callback is called before the unload function returns).
*/
gimp_module_info_module_ref (module_info);
module_info->unload (module_info->info->shutdown_data,
gimp_module_info_module_unload_completed_callback,
module_info);
g_idle_add (gimp_module_info_module_idle_unref, module_info);
}
void
gimp_module_info_module_ref (GimpModuleInfoObj *module_info)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->refs >= 0);
g_return_if_fail (module_info->module != NULL);
module_info->refs++;
}
void
gimp_module_info_module_unref (GimpModuleInfoObj *module_info)
{
g_return_if_fail (GIMP_IS_MODULE_INFO (module_info));
g_return_if_fail (module_info->refs > 0);
g_return_if_fail (module_info->module != NULL);
module_info->refs--;
if (module_info->refs == 0)
{
g_module_close (module_info->module);
module_info->module = NULL;
}
}

102
libgimpmodule/gimpmodule.h Normal file
View File

@ -0,0 +1,102 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmoduleinfo.h
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_MODULE_INFO_H__
#define __GIMP_MODULE_INFO_H__
#include "libgimp/gimpmodule.h"
#include "gimpobject.h"
typedef enum
{
GIMP_MODULE_STATE_ERROR, /* missing module_load function or other error */
GIMP_MODULE_STATE_LOADED_OK, /* happy and running (normal state of affairs) */
GIMP_MODULE_STATE_LOAD_FAILED, /* module_load returned GIMP_MODULE_UNLOAD */
GIMP_MODULE_STATE_UNLOAD_REQUESTED, /* sent unload request, waiting for callback */
GIMP_MODULE_STATE_UNLOADED_OK /* callback arrived, module not in memory anymore */
} GimpModuleState;
#define GIMP_TYPE_MODULE_INFO (gimp_module_info_get_type ())
#define GIMP_MODULE_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_MODULE_INFO, GimpModuleInfoObj))
#define GIMP_MODULE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_MODULE_INFO, GimpModuleInfoObjClass))
#define GIMP_IS_MODULE_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_MODULE_INFO))
#define GIMP_IS_MODULE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_MODULE_INFO))
#define GIMP_MODULE_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_MODULE_INFO, GimpModuleInfoObjClass))
typedef struct _GimpModuleInfoObjClass GimpModuleInfoObjClass;
struct _GimpModuleInfoObj
{
GimpObject parent_instance;
gchar *fullpath; /* path to the module */
GimpModuleState state; /* what's happened to the module */
gboolean on_disk; /* TRUE if file still exists */
gboolean load_inhibit; /* user requests not to load at boot time */
/* Count of times main gimp is within the module. Normally, this
* will be 1, and we assume that the module won't call its
* unload callback until it is satisfied that it's not in use any
* more. refs can be 2 temporarily while we're running the module's
* unload function, to stop the module attempting to unload
* itself.
*/
gint refs;
/* stuff from now on may be NULL depending on the state the module is in */
GimpModuleInfo *info; /* returned values from module_init */
GModule *module; /* handle on the module */
gchar *last_module_error;
GimpModuleInitFunc init;
GimpModuleUnloadFunc unload;
};
struct _GimpModuleInfoObjClass
{
GimpObjectClass parent_class;
void (* modified) (GimpModuleInfoObj *module_info);
};
GType gimp_module_info_get_type (void);
GimpModuleInfoObj * gimp_module_info_new (const gchar *filename);
void gimp_module_info_modified (GimpModuleInfoObj *module);
void gimp_module_info_set_load_inhibit (GimpModuleInfoObj *module,
const gchar *inhibit_list);
void gimp_module_info_module_load (GimpModuleInfoObj *module_info,
gboolean verbose);
void gimp_module_info_module_unload (GimpModuleInfoObj *module_info,
gboolean verbose);
void gimp_module_info_module_ref (GimpModuleInfoObj *module_info);
void gimp_module_info_module_unref (GimpModuleInfoObj *module_info);
#endif /* __GIMP_MODULE_INFO_H__ */

400
libgimpmodule/gimpmoduledb.c Normal file
View File

@ -0,0 +1,400 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmodules.c
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <time.h>
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "core-types.h"
#include "core/gimp.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimplist.h"
#include "core/gimpmoduleinfo.h"
#include "core/gimpmodules.h"
#include "gimprc.h"
#include "libgimp/gimpintl.h"
static void gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data);
static GimpModuleInfoObj * gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath);
#ifdef DUMP_DB
static void print_module_info (gpointer data,
gpointer user_data);
#endif
static gboolean gimp_modules_write_modulerc (Gimp *gimp);
static void gimp_modules_module_free_func (gpointer data,
gpointer user_data);
static void gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data);
static void gimp_modules_module_remove_func (gpointer data,
gpointer user_data);
void
gimp_modules_init (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
gimp->modules = gimp_list_new (GIMP_TYPE_MODULE_INFO,
GIMP_CONTAINER_POLICY_STRONG);
gimp->write_modulerc = FALSE;
}
void
gimp_modules_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->modules)
{
g_object_unref (G_OBJECT (gimp->modules));
gimp->modules = NULL;
}
}
void
gimp_modules_load (Gimp *gimp)
{
gchar *filename;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = gimp_personal_rc_file ("modulerc");
gimprc_parse_file (filename);
g_free (filename);
if (g_module_supported ())
gimp_datafiles_read_directories (gimp->config->module_path,
0 /* no flags */,
gimp_modules_module_initialize,
gimp);
#ifdef DUMP_DB
gimp_container_foreach (modules, print_module_info, NULL);
#endif
}
void
gimp_modules_unload (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->write_modulerc)
{
if (gimp_modules_write_modulerc (gimp))
{
gimp->write_modulerc = FALSE;
}
}
gimp_container_foreach (gimp->modules, gimp_modules_module_free_func, NULL);
}
void
gimp_modules_refresh (Gimp *gimp)
{
GList *kill_list = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* remove modules we don't have on disk anymore */
gimp_container_foreach (gimp->modules,
gimp_modules_module_on_disk_func,
&kill_list);
g_list_foreach (kill_list,
gimp_modules_module_remove_func,
gimp);
g_list_free (kill_list);
/* walk filesystem and add new things we find */
gimp_datafiles_read_directories (gimp->config->module_path,
0 /* no flags */,
gimp_modules_module_initialize,
gimp);
}
static void
gimp_modules_module_free_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info = data;
if (module_info->module &&
module_info->unload &&
module_info->state == GIMP_MODULE_STATE_LOADED_OK)
{
gimp_module_info_module_unload (module_info, FALSE);
}
}
static void
add_to_inhibit_string (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info = data;
GString *str = user_data;
if (module_info->load_inhibit)
{
str = g_string_append_c (str, G_SEARCHPATH_SEPARATOR);
str = g_string_append (str, module_info->fullpath);
}
}
static gboolean
gimp_modules_write_modulerc (Gimp *gimp)
{
GString *str;
gchar *p;
gchar *filename;
FILE *fp;
gboolean saved = FALSE;
str = g_string_new (NULL);
gimp_container_foreach (gimp->modules, add_to_inhibit_string, str);
if (str->len > 0)
p = str->str + 1;
else
p = "";
filename = gimp_personal_rc_file ("modulerc");
fp = fopen (filename, "wt");
g_free (filename);
if (fp)
{
fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
fclose (fp);
saved = TRUE;
}
g_string_free (str, TRUE);
return saved;
}
/* name must be of the form lib*.so (Unix) or *.dll (Win32) */
static gboolean
valid_module_name (const gchar *filename)
{
gchar *basename;
gint len;
basename = g_path_get_basename (filename);
len = strlen (basename);
#if !defined(G_OS_WIN32) && !defined(G_WITH_CYGWIN) && !defined(__EMX__)
if (len < 3 + 1 + 3)
goto no_module;
if (strncmp (basename, "lib", 3))
goto no_module;
if (strcmp (basename + len - 3, ".so"))
goto no_module;
#else
if (len < 1 + 4)
goto no_module;
if (g_strcasecmp (basename + len - 4, ".dll"))
goto no_module;
#endif
g_free (basename);
return TRUE;
no_module:
g_free (basename);
return FALSE;
}
static void
gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data)
{
GimpModuleInfoObj *module_info;
Gimp *gimp;
gimp = GIMP (loader_data);
if (! valid_module_name (filename))
return;
/* don't load if we already know about it */
if (gimp_modules_module_find_by_path (gimp, filename))
return;
module_info = gimp_module_info_new (filename);
gimp_module_info_set_load_inhibit (module_info,
gimp->config->module_db_load_inhibit);
if (! module_info->load_inhibit)
{
if (gimp->be_verbose)
g_print (_("load module: \"%s\"\n"), filename);
gimp_module_info_module_load (module_info, TRUE);
}
else
{
if (gimp->be_verbose)
g_print (_("skipping module: \"%s\"\n"), filename);
module_info->state = GIMP_MODULE_STATE_UNLOADED_OK;
}
gimp_container_add (gimp->modules, GIMP_OBJECT (module_info));
g_object_unref (G_OBJECT (module_info));
}
typedef struct
{
const gchar *search_key;
GimpModuleInfoObj *found;
} find_by_path_closure;
static void
gimp_modules_module_path_cmp_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
find_by_path_closure *closure;
module_info = (GimpModuleInfoObj *) data;
closure = (find_by_path_closure *) user_data;
if (! strcmp (module_info->fullpath, closure->search_key))
closure->found = module_info;
}
static GimpModuleInfoObj *
gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath)
{
find_by_path_closure cl;
cl.found = NULL;
cl.search_key = fullpath;
gimp_container_foreach (gimp->modules,
gimp_modules_module_path_cmp_func, &cl);
return cl.found;
}
#ifdef DUMP_DB
static void
print_module_info (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *i = data;
g_print ("\n%s: %s\n",
i->fullpath, statename[i->state]);
g_print (" module:%p lasterr:%s init:%p unload:%p\n",
i->module, i->last_module_error? i->last_module_error : "NONE",
i->init, i->unload);
if (i->info)
{
g_print (" shutdown_data: %p\n"
" purpose: %s\n"
" author: %s\n"
" version: %s\n"
" copyright: %s\n"
" date: %s\n",
i->info->shutdown_data,
i->info->purpose, i->info->author, i->info->version,
i->info->copyright, i->info->date);
}
}
#endif
static void
gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
GList **kill_list;
gint old_on_disk;
struct stat statbuf;
gint ret;
module_info = (GimpModuleInfoObj *) data;
kill_list = (GList **) user_data;
old_on_disk = module_info->on_disk;
ret = stat (module_info->fullpath, &statbuf);
if (ret != 0)
module_info->on_disk = FALSE;
else
module_info->on_disk = TRUE;
/* if it's not on the disk, and it isn't in memory, mark it to be
* removed later.
*/
if (! module_info->on_disk && ! module_info->module)
{
*kill_list = g_list_append (*kill_list, module_info);
module_info = NULL;
}
if (module_info && module_info->on_disk != old_on_disk)
gimp_module_info_modified (module_info);
}
static void
gimp_modules_module_remove_func (gpointer data,
gpointer user_data)
{
GimpModuleInfoObj *module_info;
Gimp *gimp;
module_info = (GimpModuleInfoObj *) data;
gimp = (Gimp *) user_data;
gimp_container_remove (gimp->modules, GIMP_OBJECT (module_info));
}

35
libgimpmodule/gimpmoduledb.h Normal file
View File

@ -0,0 +1,35 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpmodules.h
* (C) 1999 Austin Donnelly <austin@gimp.org>
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_MODULES_H__
#define __GIMP_MODULES_H__
void gimp_modules_init (Gimp *gimp);
void gimp_modules_exit (Gimp *gimp);
void gimp_modules_load (Gimp *gimp);
void gimp_modules_unload (Gimp *gimp);
void gimp_modules_refresh (Gimp *gimp);
#endif /* __GIMP_MODULES_H__ */

4
po/ChangeLog
View File

@ -1,3 +1,7 @@
2001-10-18 Michael Natterer <mitch@gimp.org>
* POTFILES.in: module_db.c has moved.
2001-10-09 Sven Neumann <sven@gimp.org>
* Makefile.in.in: forgot to add this file which is needed now that

2
po/POTFILES.in
View File

@ -12,7 +12,6 @@ app/gimphelp.c
app/gimpprogress.c
app/gimprc.c
app/main.c
app/module_db.c
app/nav_window.c
app/plug_in.c
app/qmask.c
@ -67,6 +66,7 @@ app/gui/info-window.c
app/gui/layer-select.c
app/gui/layers-commands.c
app/gui/menus.c
app/gui/module-browser.c
app/gui/offset-dialog.c
app/gui/palette-editor.c
app/gui/palette-import-dialog.c