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

Moved generic datafile loading to LibGimpBase: 

2002-10-23  Michael Natterer  <mitch@gimp.org>

	Moved generic datafile loading to LibGimpBase:

	* app/core/gimpdatafiles.[ch]: removed...

	* libgimpbase/gimpdatafiles.[ch]: ...and add here with a changed
	API which requires no more global variables.

	* libgimpbase/Makefile.am
	* libgimpbase/gimpbase.h
	* libgimpbase/gimpbasetypes.h
	* app/core/Makefile.am
	* app/core/core-types.h
	* app/core/gimpdatafactory.c
	* app/gui/gui.c
	* app/plug-in/plug-in.c
	* app/plug-in/plug-ins.c
	* app/tools/tools.c: changed accordingly.

	Moved module loading to LibGimpModule:

	* app/core/gimpmodules.c: removed lots of code...

	* libgimpmodule/gimpmoduledb.[ch]: ...and added it here as
	GimpModuleDB object.

	* libgimpmodule/Makefile.am
	* libgimpmodule/gimpmoduletypes.h: changed accordingly.

	* app/core/gimp.[ch]: replaced gimp->modules by gimp->module_db.

	* libgimpmodule/gimpmodule.[ch]: added
	gimp_module_query(). Internal cleanup. Stuff...

	* app/gui/module-browser.c: changed accordingly. Unfinished...

	* app/core/gimpcontainer.c
	* app/core/gimplist.c: reverted the HACKS introduced recently.

	* app/core/gimpobject.[ch]: added gimp_g_object_get_memsize()
	utility function.

	* libgimpproxy/gimpobject.[ch]: regenerated.

	Changed display filter configuration stuff:

	* libgimpwidgets/gimpcolordisplay.[ch]: made the virtual
	configure() function return a GtkWidget instead of opening a
	dialog. Changed configure_cancel() to configure_reset(). Added
	"changed" signal.

	* app/display/gimpdisplayshell-filter-dialog.c: embed the filters'
	config GUI in the dialog. Connect to "changed" and added a "Reset"
	button which resets the filter.

	* modules/cdisplay_gamma.c
	* modules/cdisplay_highcontrast.c: changed accordingly.

	* modules/colorsel_triangle.c
	* modules/colorsel_water.c: minor fixes.

2002-10-23  Michael Natterer  <mitch@gimp.org>

	* libgimpbase/libgimpbase-docs.sgml
	* libgimpbase/libgimpbase-sections.txt
	* libgimpbase/tmpl/gimpbasetypes.sgml
	* libgimpbase/tmpl/gimpdatafiles.sgml: added GimpDatafiles

	* libgimpmodule/libgimpmodule-docs.sgml
	* libgimpmodule/libgimpmodule-sections.txt
	* libgimpmodule/tmpl/gimpmoduledb.sgml: added GimpModuleDB.

	* libgimpwidgets/libgimpwidgets.types: added gimp_dialog_get_type

	* libgimpmodule/tmpl/gimpmodule.sgml
	* libgimpwidgets/tmpl/gimpcolordisplay.sgml
	* libgimpwidgets/tmpl/gimpdialog.sgml: updated.
This commit is contained in:
Michael Natterer 2002-10-23 14:55:07 +00:00 committed by Michael Natterer
parent 5f5e05a805
commit c7ac6aff52
63 changed files with 1790 additions and 1827 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
ChangeLog
View File

@ -1,3 +1,65 @@
2002-10-23 Michael Natterer <mitch@gimp.org>
Moved generic datafile loading to LibGimpBase:
* app/core/gimpdatafiles.[ch]: removed...
* libgimpbase/gimpdatafiles.[ch]: ...and add here with a changed
API which requires no more global variables.
* libgimpbase/Makefile.am
* libgimpbase/gimpbase.h
* libgimpbase/gimpbasetypes.h
* app/core/Makefile.am
* app/core/core-types.h
* app/core/gimpdatafactory.c
* app/gui/gui.c
* app/plug-in/plug-in.c
* app/plug-in/plug-ins.c
* app/tools/tools.c: changed accordingly.
Moved module loading to LibGimpModule:
* app/core/gimpmodules.c: removed lots of code...
* libgimpmodule/gimpmoduledb.[ch]: ...and added it here as
GimpModuleDB object.
* libgimpmodule/Makefile.am
* libgimpmodule/gimpmoduletypes.h: changed accordingly.
* app/core/gimp.[ch]: replaced gimp->modules by gimp->module_db.
* libgimpmodule/gimpmodule.[ch]: added
gimp_module_query(). Internal cleanup. Stuff...
* app/gui/module-browser.c: changed accordingly. Unfinished...
* app/core/gimpcontainer.c
* app/core/gimplist.c: reverted the HACKS introduced recently.
* app/core/gimpobject.[ch]: added gimp_g_object_get_memsize()
utility function.
* libgimpproxy/gimpobject.[ch]: regenerated.
Changed display filter configuration stuff:
* libgimpwidgets/gimpcolordisplay.[ch]: made the virtual
configure() function return a GtkWidget instead of opening a
dialog. Changed configure_cancel() to configure_reset(). Added
"changed" signal.
* app/display/gimpdisplayshell-filter-dialog.c: embed the filters'
config GUI in the dialog. Connect to "changed" and added a "Reset"
button which resets the filter.
* modules/cdisplay_gamma.c
* modules/cdisplay_highcontrast.c: changed accordingly.
* modules/colorsel_triangle.c
* modules/colorsel_water.c: minor fixes.
2002-10-22 Sven Neumann <sven@gimp.org>
* app/gui/offset-dialog.c (offset_ok_callback): don't free the

2
app/core/Makefile.am
View File

@ -50,8 +50,6 @@ libappcore_a_sources = \
gimpdata.h \
gimpdatafactory.c \
gimpdatafactory.h \
gimpdatafiles.c \
gimpdatafiles.h \
gimpdatalist.c \
gimpdatalist.h \
gimpdocumentlist.c \

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

@ -203,8 +203,6 @@ typedef GimpToolOptions * (* GimpToolOptionsNewFunc) (GimpToolInfo *tool_info);
typedef void (* GimpInitStatusFunc) (const gchar *text1,
const gchar *text2,
gdouble percentage);
typedef void (* GimpDataFileLoaderFunc) (const gchar *filename,
gpointer loader_data);
typedef GimpData * (* GimpDataObjectLoaderFunc) (const gchar *filename);

282
app/core/gimp-modules.c
View File

@ -38,7 +38,6 @@
#include "gimp.h"
#include "gimpcoreconfig.h"
#include "gimpdatafiles.h"
#include "gimplist.h"
#include "gimpmodules.h"
@ -47,37 +46,12 @@
#include "libgimp/gimpintl.h"
#define DUMP_DB 1
static void gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data);
static GimpModule * gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath);
#ifdef DUMP_DB
static void gimp_modules_dump_module (gpointer data,
gpointer user_data);
#endif
static gboolean gimp_modules_write_modulerc (Gimp *gimp);
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,
GIMP_CONTAINER_POLICY_STRONG);
gimp_object_set_name (GIMP_OBJECT (gimp->modules), "modules");
gimp->module_db = gimp_module_db_new (gimp->be_verbose);
gimp->write_modulerc = FALSE;
}
@ -86,10 +60,10 @@ gimp_modules_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->modules)
if (gimp->module_db)
{
g_object_unref (G_OBJECT (gimp->modules));
gimp->modules = NULL;
g_object_unref (G_OBJECT (gimp->module_db));
gimp->module_db = NULL;
}
}
@ -104,52 +78,11 @@ gimp_modules_load (Gimp *gimp)
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);
gimp_module_db_set_load_inhibit (gimp->module_db,
gimp->config->module_db_load_inhibit);
#ifdef DUMP_DB
gimp_container_foreach (gimp->modules, gimp_modules_dump_module, 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;
}
}
}
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);
gimp_module_db_load (gimp->module_db,
gimp->config->module_path);
}
static void
@ -166,186 +99,49 @@ add_to_inhibit_string (gpointer data,
}
}
static gboolean
gimp_modules_write_modulerc (Gimp *gimp)
void
gimp_modules_unload (Gimp *gimp)
{
GString *str;
gchar *p;
gchar *filename;
FILE *fp;
gboolean saved = FALSE;
g_return_if_fail (GIMP_IS_GIMP (gimp));
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)
if (gimp->write_modulerc)
{
fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
fclose (fp);
saved = TRUE;
}
GString *str;
gchar *p;
gchar *filename;
FILE *fp;
g_string_free (str, TRUE);
str = g_string_new (NULL);
g_list_foreach (gimp->module_db->modules, add_to_inhibit_string, str);
if (str->len > 0)
p = str->str + 1;
else
p = "";
return saved;
}
filename = gimp_personal_rc_file ("modulerc");
fp = fopen (filename, "wt");
g_free (filename);
/* name must be of the form lib*.so (Unix) or *.dll (Win32) */
static gboolean
valid_module_name (const gchar *filename)
{
gchar *basename;
gint len;
if (fp)
{
fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
fclose (fp);
basename = g_path_get_basename (filename);
gimp->write_modulerc = FALSE;
}
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)
{
GimpModule *module;
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 = gimp_module_new (filename,
gimp->config->module_db_load_inhibit,
gimp->be_verbose);
gimp_container_add (gimp->modules, (GimpObject *) module);
}
static GimpModule *
gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath)
{
GimpModule *module;
GList *list;
for (list = GIMP_LIST (gimp->modules)->list; list; list = g_list_next (list))
{
module = (GimpModule *) list->data;
if (! strcmp (module->filename, fullpath))
return module;
}
return NULL;
}
#ifdef DUMP_DB
static void
gimp_modules_dump_module (gpointer data,
gpointer user_data)
{
GimpModule *i = data;
g_print ("\n%s: %i\n",
i->filename,
i->state /* statename[i->state] */);
g_print (" module:%p lasterr:%s query:%p register:%p\n",
i->module,
i->last_module_error ? i->last_module_error : "NONE",
i->query_module,
i->register_module);
if (i->info)
{
g_print (" purpose: %s\n"
" author: %s\n"
" version: %s\n"
" copyright: %s\n"
" date: %s\n",
i->info->purpose ? i->info->purpose : "NONE",
i->info->author ? i->info->author : "NONE",
i->info->version ? i->info->version : "NONE",
i->info->copyright ? i->info->copyright : "NONE",
i->info->date ? i->info->date : "NONE");
g_string_free (str, TRUE);
}
}
#endif
static void
gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data)
void
gimp_modules_refresh (Gimp *gimp)
{
GimpModule *module;
GList **kill_list;
gint old_on_disk;
g_return_if_fail (GIMP_IS_GIMP (gimp));
module = (GimpModule *) data;
kill_list = (GList **) user_data;
gimp_module_db_set_load_inhibit (gimp->module_db,
gimp->config->module_db_load_inhibit);
old_on_disk = module->on_disk;
module->on_disk = g_file_test (module->filename, G_FILE_TEST_IS_REGULAR);
/* if it's not on the disk, and it isn't in memory, mark it to be
* removed later.
*/
if (! module->on_disk && ! module->module)
{
*kill_list = g_list_append (*kill_list, module);
module = NULL;
}
if (module && module->on_disk != old_on_disk)
gimp_module_modified (module);
}
static void
gimp_modules_module_remove_func (gpointer data,
gpointer user_data)
{
GimpModule *module;
Gimp *gimp;
module = (GimpModule *) data;
gimp = (Gimp *) user_data;
gimp_container_remove (gimp->modules, (GimpObject *) module);
gimp_module_db_refresh (gimp->module_db,
gimp->config->module_path);
}

7
app/core/gimp.c
View File

@ -328,7 +328,7 @@ gimp_finalize (GObject *object)
gimp->images = NULL;
}
if (gimp->modules)
if (gimp->module_db)
gimp_modules_exit (gimp);
paint_exit (gimp);
@ -355,8 +355,9 @@ gimp_get_memsize (GimpObject *object)
memsize += g_list_length (gimp->user_units) * sizeof (GList); /* FIXME */
memsize += (gimp_object_get_memsize (GIMP_OBJECT (gimp->parasites)) +
gimp_object_get_memsize (GIMP_OBJECT (gimp->modules)));
memsize += gimp_object_get_memsize (GIMP_OBJECT (gimp->parasites));
memsize += gimp_g_object_get_memsize (G_OBJECT (gimp->module_db));
memsize += (g_hash_table_size (gimp->image_table) *
3 * sizeof (gpointer)); /* FIXME */

2
app/core/gimp.h
View File

@ -73,7 +73,7 @@ struct _Gimp
GimpContainer *paint_info_list;
GimpContainer *modules;
GimpModuleDB *module_db;
gboolean write_modulerc;
GimpContainer *images;

11
app/core/gimpcontainer.c
View File

@ -195,7 +195,7 @@ gimp_container_class_init (GimpContainerClass *klass)
NULL, NULL,
gimp_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
GIMP_TYPE_OBJECT);
container_signals[REMOVE] =
g_signal_new ("remove",
@ -205,7 +205,7 @@ gimp_container_class_init (GimpContainerClass *klass)
NULL, NULL,
gimp_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
GIMP_TYPE_OBJECT);
container_signals[REORDER] =
g_signal_new ("reorder",
@ -215,7 +215,7 @@ gimp_container_class_init (GimpContainerClass *klass)
NULL, NULL,
gimp_marshal_VOID__OBJECT_INT,
G_TYPE_NONE, 2,
G_TYPE_OBJECT,
GIMP_TYPE_OBJECT,
G_TYPE_INT);
container_signals[FREEZE] =
@ -396,7 +396,7 @@ gimp_container_serialize_foreach (GObject *object,
{
GimpConfigInterface *config_iface;
GString *str;
const gchar *name = NULL;
const gchar *name;
config_iface = GIMP_GET_CONFIG_INTERFACE (object);
@ -413,8 +413,7 @@ gimp_container_serialize_foreach (GObject *object,
g_string_append_printf (str, "(%s ",
g_type_name (G_TYPE_FROM_INSTANCE (object)));
if (GIMP_IS_OBJECT (object))
name = gimp_object_get_name (GIMP_OBJECT (object));
name = gimp_object_get_name (GIMP_OBJECT (object));
if (name)
{

22
app/core/gimpdatafactory.c
View File

@ -23,12 +23,13 @@
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "core-types.h"
#include "gimpcontext.h"
#include "gimpdata.h"
#include "gimpdatafactory.h"
#include "gimpdatafiles.h"
#include "gimpdatalist.h"
#include "libgimp/gimpintl.h"
@ -41,8 +42,7 @@ static void gimp_data_factory_finalize (GObject *object);
static gsize gimp_data_factory_get_memsize (GimpObject *object);
static void gimp_data_factory_data_load_callback (const gchar *filename,
gpointer callback_data);
static void gimp_data_factory_data_load_callback (GimpDatafileData *file_data);
static GimpObjectClass *parent_class = NULL;
@ -174,7 +174,8 @@ gimp_data_factory_data_init (GimpDataFactory *factory,
if (factory->data_path && *factory->data_path)
{
gimp_datafiles_read_directories (*factory->data_path, 0,
gimp_datafiles_read_directories (*factory->data_path,
G_FILE_TEST_EXISTS,
gimp_data_factory_data_load_callback,
factory);
}
@ -303,19 +304,18 @@ gimp_data_factory_data_get_standard (GimpDataFactory *factory)
}
static void
gimp_data_factory_data_load_callback (const gchar *filename,
gpointer callback_data)
gimp_data_factory_data_load_callback (GimpDatafileData *file_data)
{
GimpDataFactory *factory;
gint i;
factory = (GimpDataFactory *) callback_data;
factory = (GimpDataFactory *) file_data->user_data;
for (i = 0; i < factory->n_loader_entries; i++)
{
if (factory->loader_entries[i].extension)
{
if (gimp_datafiles_check_extension (filename,
if (gimp_datafiles_check_extension (file_data->filename,
factory->loader_entries[i].extension))
{
goto insert;
@ -326,7 +326,7 @@ gimp_data_factory_data_load_callback (const gchar *filename,
g_message (_("Trying legacy loader on\n"
"file '%s'\n"
"with unknown extension."),
filename);
file_data->filename);
goto insert;
}
}
@ -337,11 +337,11 @@ gimp_data_factory_data_load_callback (const gchar *filename,
{
GimpData *data;
data = (GimpData *) (* factory->loader_entries[i].load_func) (filename);
data = (GimpData *) (* factory->loader_entries[i].load_func) (file_data->filename);
if (! data)
{
g_message (_("Warning: Failed to load data from\n'%s'"), filename);
g_message (_("Warning: Failed to load data from\n'%s'"), file_data->filename);
}
else
{

226
app/core/gimpdatafiles.c
View File

@ -1,226 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Datafiles module copyight (C) 1996 Federico Mena Quintero
* federico@nuclecu.unam.mx
*
* 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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <glib-object.h>
#ifdef G_OS_WIN32
#ifndef S_ISDIR
#define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
#endif
#ifndef S_IXUSR
#define S_IXUSR _S_IEXEC
#endif
#endif /* G_OS_WIN32 */
#include "libgimpbase/gimpbase.h"
#include "core-types.h"
#include "gimpdatafiles.h"
static gboolean filestat_valid = FALSE;
static struct stat filestat;
#ifdef G_OS_WIN32
/*
* On Windows there is no concept like the Unix executable flag.
* There is a weak emulation provided by the MS C Runtime using file
* extensions (com, exe, cmd, bat). This needs to be extended to treat
* scripts (Python, Perl, ...) as executables, too. We use the PATHEXT
* variable, which is also used by cmd.exe.
*/
static gboolean
is_script (const gchar *filename)
{
static gchar **exts = NULL;
const gchar *ext = strrchr (filename, '.');
gchar *pathext;
gint i;
if (exts == NULL)
{
pathext = g_getenv ("PATHEXT");
if (pathext != NULL)
{
exts = g_strsplit (pathext, G_SEARCHPATH_SEPARATOR_S, 100);
}
else
{
exts = g_new (gchar *, 1);
exts[0] = NULL;
}
}
i = 0;
while (exts[i] != NULL)
{
if (g_strcasecmp (ext, exts[i]) == 0)
return TRUE;
i++;
}
return FALSE;
}
#else /* !G_OS_WIN32 */
#define is_script(filename) FALSE
#endif
gboolean
gimp_datafiles_check_extension (const gchar *filename,
const gchar *extension)
{
gint name_len;
gint ext_len;
g_return_val_if_fail (filename != NULL, FALSE);
g_return_val_if_fail (extension != NULL, FALSE);
name_len = strlen (filename);
ext_len = strlen (extension);
if (! (name_len && ext_len && (name_len > ext_len)))
return FALSE;
return (strcmp (&filename[name_len - ext_len], extension) == 0);
}
void
gimp_datafiles_read_directories (const gchar *path_str,
GimpDataFileFlags flags,
GimpDataFileLoaderFunc loader_func,
gpointer loader_data)
{
gchar *local_path;
GList *path;
GList *list;
gchar *filename;
gint err;
GDir *dir;
const gchar *dir_ent;
g_return_if_fail (path_str != NULL);
g_return_if_fail (loader_func != NULL);
local_path = g_strdup (path_str);
#ifdef __EMX__
/*
* Change drive so opendir works.
*/
if (local_path[1] == ':')
{
_chdrive (local_path[0]);
}
#endif
path = gimp_path_parse (local_path, 16, TRUE, NULL);
for (list = path; list; list = g_list_next (list))
{
/* Open directory */
dir = g_dir_open ((gchar *) list->data, 0, NULL);
if (!dir)
{
g_message ("error reading datafiles directory \"%s\"",
(gchar *) list->data);
}
else
{
while ((dir_ent = g_dir_read_name (dir)))
{
filename = g_build_filename ((gchar *) list->data,
dir_ent, NULL);
/* Check the file and see that it is not a sub-directory */
err = stat (filename, &filestat);
if (! err)
{
filestat_valid = TRUE;
if (S_ISDIR (filestat.st_mode) && (flags & TYPE_DIRECTORY))
{
(* loader_func) (filename, loader_data);
}
else if (S_ISREG (filestat.st_mode) &&
(!(flags & MODE_EXECUTABLE) ||
(filestat.st_mode & S_IXUSR) ||
is_script (filename)))
{
(* loader_func) (filename, loader_data);
}
filestat_valid = FALSE;
}
g_free (filename);
}
g_dir_close (dir);
}
}
gimp_path_free (path);
g_free (local_path);
}
time_t
gimp_datafile_atime (void)
{
if (filestat_valid)
return filestat.st_atime;
return 0;
}
time_t
gimp_datafile_mtime (void)
{
if (filestat_valid)
return filestat.st_mtime;
return 0;
}
time_t
gimp_datafile_ctime (void)
{
if (filestat_valid)
return filestat.st_ctime;
return 0;
}

53
app/core/gimpdatafiles.h
View File

@ -1,53 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* Datafiles module copyight (C) 1996 Federico Mena Quintero
* federico@nuclecu.unam.mx
*
* 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_DATAFILES_H__
#define __GIMP_DATAFILES_H__
#include <time.h>
typedef enum
{
MODE_EXECUTABLE = 1 << 0,
TYPE_DIRECTORY = 1 << 1
} GimpDataFileFlags;
gboolean gimp_datafiles_check_extension (const gchar *filename,
const gchar *extension);
void gimp_datafiles_read_directories (const gchar *path_str,
GimpDataFileFlags flags,
GimpDataFileLoaderFunc loader_func,
gpointer loader_data);
/* Return the current datafiles access, modification
* or change time. The current datafile is the one for
* which the "DataFileLoaderFunc" function has been called
* on.
*/
time_t gimp_datafile_atime (void);
time_t gimp_datafile_mtime (void);
time_t gimp_datafile_ctime (void);
#endif /* __GIMP_DATAFILES_H__ */

7
app/core/gimplist.c
View File

@ -131,7 +131,7 @@ gimp_list_dispose (GObject *object)
while (list->list)
{
gimp_container_remove (GIMP_CONTAINER (list),
(GimpObject *) list->list->data);
GIMP_OBJECT (list->list->data));
}
G_OBJECT_CLASS (parent_class)->dispose (object);
@ -155,8 +155,7 @@ gimp_list_get_memsize (GimpObject *object)
for (list = gimp_list->list; list; list = g_list_next (list))
{
if (GIMP_IS_OBJECT (list->data))
memsize += gimp_object_get_memsize (GIMP_OBJECT (list->data));
memsize += gimp_object_get_memsize (GIMP_OBJECT (list->data));
}
}
@ -280,7 +279,7 @@ gimp_list_new (GType children_type,
{
GimpList *list;
g_return_val_if_fail (g_type_is_a (children_type, G_TYPE_OBJECT), NULL);
g_return_val_if_fail (g_type_is_a (children_type, GIMP_TYPE_OBJECT), NULL);
g_return_val_if_fail (policy == GIMP_CONTAINER_POLICY_STRONG ||
policy == GIMP_CONTAINER_POLICY_WEAK, NULL);

282
app/core/gimpmodules.c
View File

@ -38,7 +38,6 @@
#include "gimp.h"
#include "gimpcoreconfig.h"
#include "gimpdatafiles.h"
#include "gimplist.h"
#include "gimpmodules.h"
@ -47,37 +46,12 @@
#include "libgimp/gimpintl.h"
#define DUMP_DB 1
static void gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data);
static GimpModule * gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath);
#ifdef DUMP_DB
static void gimp_modules_dump_module (gpointer data,
gpointer user_data);
#endif
static gboolean gimp_modules_write_modulerc (Gimp *gimp);
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,
GIMP_CONTAINER_POLICY_STRONG);
gimp_object_set_name (GIMP_OBJECT (gimp->modules), "modules");
gimp->module_db = gimp_module_db_new (gimp->be_verbose);
gimp->write_modulerc = FALSE;
}
@ -86,10 +60,10 @@ gimp_modules_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (gimp->modules)
if (gimp->module_db)
{
g_object_unref (G_OBJECT (gimp->modules));
gimp->modules = NULL;
g_object_unref (G_OBJECT (gimp->module_db));
gimp->module_db = NULL;
}
}
@ -104,52 +78,11 @@ gimp_modules_load (Gimp *gimp)
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);
gimp_module_db_set_load_inhibit (gimp->module_db,
gimp->config->module_db_load_inhibit);
#ifdef DUMP_DB
gimp_container_foreach (gimp->modules, gimp_modules_dump_module, 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;
}
}
}
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);
gimp_module_db_load (gimp->module_db,
gimp->config->module_path);
}
static void
@ -166,186 +99,49 @@ add_to_inhibit_string (gpointer data,
}
}
static gboolean
gimp_modules_write_modulerc (Gimp *gimp)
void
gimp_modules_unload (Gimp *gimp)
{
GString *str;
gchar *p;
gchar *filename;
FILE *fp;
gboolean saved = FALSE;
g_return_if_fail (GIMP_IS_GIMP (gimp));
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)
if (gimp->write_modulerc)
{
fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
fclose (fp);
saved = TRUE;
}
GString *str;
gchar *p;
gchar *filename;
FILE *fp;
g_string_free (str, TRUE);
str = g_string_new (NULL);
g_list_foreach (gimp->module_db->modules, add_to_inhibit_string, str);
if (str->len > 0)
p = str->str + 1;
else
p = "";
return saved;
}
filename = gimp_personal_rc_file ("modulerc");
fp = fopen (filename, "wt");
g_free (filename);
/* name must be of the form lib*.so (Unix) or *.dll (Win32) */
static gboolean
valid_module_name (const gchar *filename)
{
gchar *basename;
gint len;
if (fp)
{
fprintf (fp, "(module-load-inhibit \"%s\")\n", p);
fclose (fp);
basename = g_path_get_basename (filename);
gimp->write_modulerc = FALSE;
}
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)
{
GimpModule *module;
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 = gimp_module_new (filename,
gimp->config->module_db_load_inhibit,
gimp->be_verbose);
gimp_container_add (gimp->modules, (GimpObject *) module);
}
static GimpModule *
gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath)
{
GimpModule *module;
GList *list;
for (list = GIMP_LIST (gimp->modules)->list; list; list = g_list_next (list))
{
module = (GimpModule *) list->data;
if (! strcmp (module->filename, fullpath))
return module;
}
return NULL;
}
#ifdef DUMP_DB
static void
gimp_modules_dump_module (gpointer data,
gpointer user_data)
{
GimpModule *i = data;
g_print ("\n%s: %i\n",
i->filename,
i->state /* statename[i->state] */);
g_print (" module:%p lasterr:%s query:%p register:%p\n",
i->module,
i->last_module_error ? i->last_module_error : "NONE",
i->query_module,
i->register_module);
if (i->info)
{
g_print (" purpose: %s\n"
" author: %s\n"
" version: %s\n"
" copyright: %s\n"
" date: %s\n",
i->info->purpose ? i->info->purpose : "NONE",
i->info->author ? i->info->author : "NONE",
i->info->version ? i->info->version : "NONE",
i->info->copyright ? i->info->copyright : "NONE",
i->info->date ? i->info->date : "NONE");
g_string_free (str, TRUE);
}
}
#endif
static void
gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data)
void
gimp_modules_refresh (Gimp *gimp)
{
GimpModule *module;
GList **kill_list;
gint old_on_disk;
g_return_if_fail (GIMP_IS_GIMP (gimp));
module = (GimpModule *) data;
kill_list = (GList **) user_data;
gimp_module_db_set_load_inhibit (gimp->module_db,
gimp->config->module_db_load_inhibit);
old_on_disk = module->on_disk;
module->on_disk = g_file_test (module->filename, G_FILE_TEST_IS_REGULAR);
/* if it's not on the disk, and it isn't in memory, mark it to be
* removed later.
*/
if (! module->on_disk && ! module->module)
{
*kill_list = g_list_append (*kill_list, module);
module = NULL;
}
if (module && module->on_disk != old_on_disk)
gimp_module_modified (module);
}
static void
gimp_modules_module_remove_func (gpointer data,
gpointer user_data)
{
GimpModule *module;
Gimp *gimp;
module = (GimpModule *) data;
gimp = (Gimp *) user_data;
gimp_container_remove (gimp->modules, (GimpObject *) module);
gimp_module_db_refresh (gimp->module_db,
gimp->config->module_path);
}

16
app/core/gimpobject.c
View File

@ -314,18 +314,28 @@ gimp_object_get_memsize (GimpObject *object)
return GIMP_OBJECT_GET_CLASS (object)->get_memsize (object);
}
static gsize
gimp_object_real_get_memsize (GimpObject *object)
gsize
gimp_g_object_get_memsize (GObject *object)
{
GTypeQuery type_query;
gsize memsize = 0;
g_return_val_if_fail (G_IS_OBJECT (object), 0);
g_type_query (G_TYPE_FROM_INSTANCE (object), &type_query);
memsize += type_query.instance_size;
return memsize;
}
static gsize
gimp_object_real_get_memsize (GimpObject *object)
{
gsize memsize = 0;
if (object->name)
memsize += strlen (object->name) + 1;
return memsize;
return memsize + gimp_g_object_get_memsize ((GObject *) object);
}

13
app/core/gimpobject.h
View File

@ -50,14 +50,15 @@ struct _GimpObjectClass
};
GType gimp_object_get_type (void) G_GNUC_CONST;
GType gimp_object_get_type (void) G_GNUC_CONST;
void gimp_object_set_name (GimpObject *object,
const gchar *name);
const gchar * gimp_object_get_name (const GimpObject *object);
void gimp_object_name_changed (GimpObject *object);
void gimp_object_set_name (GimpObject *object,
const gchar *name);
const gchar * gimp_object_get_name (const GimpObject *object);
void gimp_object_name_changed (GimpObject *object);
gsize gimp_object_get_memsize (GimpObject *object);
gsize gimp_object_get_memsize (GimpObject *object);
gsize gimp_g_object_get_memsize (GObject *object);
#endif /* __GIMP_OBJECT_H__ */

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

@ -30,19 +30,21 @@
#include "gui-types.h"
#include "core/gimp.h"
#include "core/gimpcontainer.h"
#include "core/gimpmodules.h"
#include "widgets/gimpviewabledialog.h"
#include "module-browser.h"
#include "libgimp/gimpintl.h"
#define NUM_INFO_LINES 8
#define NUM_INFO_LINES 9
enum
{
PATH_COLUMN,
AUTO_COLUMN,
MODULE_COLUMN,
NUM_COLUMNS
};
@ -57,7 +59,6 @@ struct _ModuleBrowser
GimpModule *last_update;
GtkWidget *button;
GtkListStore *list;
GtkWidget *load_inhibit_check;
GQuark modules_handler_id;
Gimp *gimp;
@ -66,30 +67,32 @@ struct _ModuleBrowser
/* local function prototypes */
static void browser_popdown_callback (GtkWidget *widget,
gpointer data);
static void browser_destroy_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_load_inhibit_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_select_callback (GtkTreeSelection *sel,
ModuleBrowser *browser);
static void browser_load_unload_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_refresh_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void make_list_item (gpointer data,
gpointer user_data);
static void browser_info_add (GimpContainer *container,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_remove (GimpContainer *container,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_update (GimpModule *module,
ModuleBrowser *browser);
static void browser_info_init (ModuleBrowser *browser,
GtkWidget *table);
static void browser_popdown_callback (GtkWidget *widget,
gpointer data);
static void browser_destroy_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_select_callback (GtkTreeSelection *sel,
ModuleBrowser *browser);
static void browser_autoload_toggled (GtkCellRendererToggle *celltoggle,
gchar *path_string,
ModuleBrowser *browser);
static void browser_load_unload_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_refresh_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void make_list_item (gpointer data,
gpointer user_data);
static void browser_info_add (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_remove (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_update (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_init (ModuleBrowser *browser,
GtkWidget *table);
/* public functions */
@ -97,31 +100,40 @@ static void browser_info_init (ModuleBrowser *browser,
GtkWidget *
module_browser_new (Gimp *gimp)
{
GtkWidget *shell;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *listbox;
GtkWidget *button;
GtkWidget *tv;
ModuleBrowser *browser;
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkWidget *shell;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *listbox;
GtkWidget *tv;
ModuleBrowser *browser;
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
shell = gimp_dialog_new (_("Module DB"), "module_db_dialog",
gimp_standard_help_func,
"dialogs/module_browser.html",
GTK_WIN_POS_NONE,
FALSE, TRUE, FALSE,
browser = g_new0 (ModuleBrowser, 1);
GTK_STOCK_CLOSE, browser_popdown_callback,
NULL, NULL, NULL, TRUE, TRUE,
browser->gimp = gimp;
NULL);
shell = gimp_viewable_dialog_new (NULL,
_("Module Browser"), "module_db_dialog",
GTK_STOCK_EXECUTE,
_("Browse & Manage Loadable Modules"),
gimp_standard_help_func,
"dialogs/module_browser.html",
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
GTK_STOCK_REFRESH, browser_refresh_callback,
browser, NULL, NULL, FALSE, FALSE,
GTK_STOCK_CLOSE, browser_popdown_callback,
NULL, NULL, NULL, TRUE, TRUE,
NULL);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (shell)->vbox), vbox);
gtk_widget_show (vbox);
@ -135,45 +147,47 @@ module_browser_new (Gimp *gimp)
gtk_widget_set_size_request (listbox, 125, 100);
gtk_widget_show (listbox);
browser = g_new0 (ModuleBrowser, 1);
browser->gimp = gimp;
browser->list = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_STRING, G_TYPE_POINTER);
G_TYPE_STRING, G_TYPE_BOOLEAN,
G_TYPE_POINTER);
tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (browser->list));
g_object_unref (browser->list);
gimp_container_foreach (gimp->modules, make_list_item, browser);
g_list_foreach (gimp->module_db->modules, make_list_item, browser);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
-1, NULL,
gtk_cell_renderer_text_new (),
"text", PATH_COLUMN,
NULL);
rend = gtk_cell_renderer_toggle_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tv), FALSE);
g_signal_connect (G_OBJECT (rend), "toggled",
G_CALLBACK (browser_autoload_toggled),
browser);
col = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (col, _("Autoload"));
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "active", AUTO_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Module Path"), rend,
"text", PATH_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col);
gtk_container_add (GTK_CONTAINER (listbox), tv);
gtk_widget_show (tv);
browser->table = gtk_table_new (5, NUM_INFO_LINES + 1, FALSE);
browser->table = gtk_table_new (2, NUM_INFO_LINES, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (browser->table), 4);
gtk_box_pack_start (GTK_BOX (vbox), browser->table, FALSE, FALSE, 0);
gtk_widget_show (browser->table);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0);
gtk_widget_show (hbox);
button = gtk_button_new_with_label (_("Refresh"));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (browser_refresh_callback),
browser);
browser->button = gtk_button_new_with_label ("");
browser->button_label = gtk_bin_get_child (GTK_BIN (browser->button));
@ -185,7 +199,8 @@ module_browser_new (Gimp *gimp)
browser);
browser_info_init (browser, browser->table);
browser_info_update (browser->last_update, browser);
browser_info_update (gimp->module_db, browser->last_update, browser);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv));
@ -196,20 +211,18 @@ module_browser_new (Gimp *gimp)
if (gtk_tree_model_get_iter_root (GTK_TREE_MODEL (browser->list), &iter))
gtk_tree_selection_select_iter (sel, &iter);
/* hook the GimpContainer signals so we can refresh the display
/* hook the GimpModuleDB signals so we can refresh the display
* appropriately.
*/
browser->modules_handler_id =
gimp_container_add_handler (gimp->modules, "modified",
G_CALLBACK (browser_info_update),
browser);
g_signal_connect (G_OBJECT (gimp->modules), "add",
g_signal_connect (G_OBJECT (gimp->module_db), "add",
G_CALLBACK (browser_info_add),
browser);
g_signal_connect (G_OBJECT (gimp->modules), "remove",
g_signal_connect (G_OBJECT (gimp->module_db), "remove",
G_CALLBACK (browser_info_remove),
browser);
g_signal_connect (G_OBJECT (gimp->module_db), "module_modified",
G_CALLBACK (browser_info_update),
browser);
g_signal_connect (G_OBJECT (shell), "destroy",
G_CALLBACK (browser_destroy_callback),
@ -232,36 +245,19 @@ static void
browser_destroy_callback (GtkWidget *widget,
ModuleBrowser *browser)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->modules),
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->module_db),
browser_info_add,
browser);
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->modules),
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->module_db),
browser_info_remove,
browser);
gimp_container_remove_handler (browser->gimp->modules,
browser->modules_handler_id);
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->module_db),
browser_info_update,
browser);
g_free (browser);
}
static void
browser_load_inhibit_callback (GtkWidget *widget,
ModuleBrowser *browser)
{
gboolean new_value;
g_return_if_fail (browser->last_update != NULL);
new_value = ! GTK_TOGGLE_BUTTON (widget)->active;
if (new_value == browser->last_update->load_inhibit)
return;
browser->last_update->load_inhibit = new_value;
gimp_module_modified (browser->last_update);
browser->gimp->write_modulerc = TRUE;
}
static void
browser_select_callback (GtkTreeSelection *sel,
ModuleBrowser *browser)
@ -278,7 +274,42 @@ browser_select_callback (GtkTreeSelection *sel,
browser->last_update = module;
browser_info_update (browser->last_update, browser);
browser_info_update (browser->gimp->module_db, browser->last_update, browser);
}
static void
browser_autoload_toggled (GtkCellRendererToggle *celltoggle,
gchar *path_string,
ModuleBrowser *browser)
{
GtkTreePath *path;
GtkTreeIter iter;
gboolean active = FALSE;
GimpModule *module = NULL;
path = gtk_tree_path_new_from_string (path_string);
if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (browser->list), &iter, path))
{
g_warning ("%s: bad tree path?", G_STRLOC);
return;
}
gtk_tree_path_free (path);
gtk_tree_model_get (GTK_TREE_MODEL (browser->list), &iter,
AUTO_COLUMN, &active,
MODULE_COLUMN, &module,
-1);
if (module)
{
gimp_module_set_load_inhibit (module, active);
browser->gimp->write_modulerc = TRUE;
gtk_list_store_set (GTK_LIST_STORE (browser->list), &iter,
AUTO_COLUMN, ! active,
-1);
}
}
static void
@ -287,8 +318,15 @@ browser_load_unload_callback (GtkWidget *widget,
{
if (browser->last_update->state != GIMP_MODULE_STATE_LOADED_OK)
{
if (g_type_module_use (G_TYPE_MODULE (browser->last_update)))
g_type_module_unuse (G_TYPE_MODULE (browser->last_update));
if (browser->last_update->info)
{
if (g_type_module_use (G_TYPE_MODULE (browser->last_update)))
g_type_module_unuse (G_TYPE_MODULE (browser->last_update));
}
else
{
gimp_module_query_module (browser->last_update);
}
}
gimp_module_modified (browser->last_update);
@ -315,20 +353,21 @@ make_list_item (gpointer data,
gtk_list_store_append (browser->list, &iter);
gtk_list_store_set (browser->list, &iter,
PATH_COLUMN, module->filename,
AUTO_COLUMN, ! module->load_inhibit,
MODULE_COLUMN, module,
-1);
}
static void
browser_info_add (GimpContainer *container,
GimpModule *module,
ModuleBrowser *browser)
browser_info_add (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser*browser)
{
make_list_item (module, browser);
}
static void
browser_info_remove (GimpContainer *container,
browser_info_remove (GimpModuleDB *db,
GimpModule *mod,
ModuleBrowser *browser)
{
@ -359,19 +398,15 @@ browser_info_remove (GimpContainer *container,
}
static void
browser_info_update (GimpModule *module,
browser_info_update (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser)
{
GTypeModule *g_type_module;
const gchar *text[NUM_INFO_LINES];
gint i;
static const gchar * const statename[] =
{
N_("Module error"),
N_("Loaded OK"),
N_("Load failed"),
N_("Unloaded OK")
};
g_type_module = G_TYPE_MODULE (module);
/* only update the info if we're actually showing it */
if (module != browser->last_update)
@ -383,7 +418,6 @@ browser_info_update (GimpModule *module,
gtk_label_set_text (GTK_LABEL (browser->label[i]), "");
gtk_label_set_text (GTK_LABEL (browser->button_label), _("<No modules>"));
gtk_widget_set_sensitive (GTK_WIDGET (browser->button), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (browser->load_inhibit_check), FALSE);
return;
}
@ -406,19 +440,31 @@ browser_info_update (GimpModule *module,
text[5] = module->on_disk ? _("On disk") : _("No longer available");
}
text[6] = gettext (statename[module->state]);
text[6] = gimp_module_state_name (module->state);
if (module->state == GIMP_MODULE_STATE_ERROR && module->last_module_error)
text[7] = module->last_module_error;
else
text[7] = "--";
for (i = 0; i < NUM_INFO_LINES; i++)
gtk_label_set_text (GTK_LABEL (browser->label[i]), gettext (text[i]));
if (g_type_module->type_infos || g_type_module->interface_infos)
{
gchar *str;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (browser->load_inhibit_check),
! module->load_inhibit);
gtk_widget_set_sensitive (GTK_WIDGET (browser->load_inhibit_check), TRUE);
str = g_strdup_printf ("%d Types, %d Interfaces",
g_slist_length (g_type_module->type_infos),
g_slist_length (g_type_module->interface_infos));
gtk_label_set_text (GTK_LABEL (browser->label[NUM_INFO_LINES - 1]), str);
g_free (str);
}
else
{
gtk_label_set_text (GTK_LABEL (browser->label[NUM_INFO_LINES - 1]),
"---");
}
for (i = 0; i < NUM_INFO_LINES - 1; i++)
gtk_label_set_text (GTK_LABEL (browser->label[i]), gettext (text[i]));
/* work out what the button should do (if anything) */
switch (module->state)
@ -426,8 +472,13 @@ browser_info_update (GimpModule *module,
case GIMP_MODULE_STATE_ERROR:
case GIMP_MODULE_STATE_LOAD_FAILED:
case GIMP_MODULE_STATE_UNLOADED_OK:
gtk_label_set_text (GTK_LABEL (browser->button_label), _("Load"));
gtk_widget_set_sensitive (GTK_WIDGET (browser->button), module->on_disk);
if (module->info)
gtk_label_set_text (GTK_LABEL (browser->button_label), _("Load"));
else
gtk_label_set_text (GTK_LABEL (browser->button_label), _("Query"));
gtk_widget_set_sensitive (GTK_WIDGET (browser->button),
module->on_disk);
break;
case GIMP_MODULE_STATE_LOADED_OK:
@ -444,7 +495,7 @@ browser_info_init (ModuleBrowser *browser,
GtkWidget *label;
gint i;
static const gchar *text[] =
static const gchar * const text[] =
{
N_("Purpose:"),
N_("Author:"),
@ -453,7 +504,8 @@ browser_info_init (ModuleBrowser *browser,
N_("Date:"),
N_("Location:"),
N_("State:"),
N_("Last Error:")
N_("Last Error:"),
N_("Available Types:")
};
for (i = 0; i < G_N_ELEMENTS (text); i++)
@ -471,15 +523,4 @@ browser_info_init (ModuleBrowser *browser,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 2);
gtk_widget_show (browser->label[i]);
}
browser->load_inhibit_check =
gtk_check_button_new_with_label (_("Autoload during start-up"));
gtk_table_attach (GTK_TABLE (table), browser->load_inhibit_check,
0, 2, i, i + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 2);
gtk_widget_show (browser->load_inhibit_check);
g_signal_connect (G_OBJECT (browser->load_inhibit_check), "toggled",
G_CALLBACK (browser_load_inhibit_callback),
browser);
}

187
app/display/gimpdisplayshell-filter-dialog.c
View File

@ -40,11 +40,11 @@
#define LIST_WIDTH 150
#define LIST_HEIGHT 100
#define UPDATE_DISPLAY(shell) G_STMT_START \
{ \
gimp_display_shell_expose_full (shell); \
gimp_display_shell_flush (shell); \
} G_STMT_END
#define UPDATE_DISPLAY(cdd) G_STMT_START \
{ \
gimp_display_shell_expose_full ((cdd)->shell); \
gimp_display_shell_flush ((cdd)->shell); \
} G_STMT_END
typedef struct _ColorDisplayDialog ColorDisplayDialog;
@ -61,16 +61,22 @@ struct _ColorDisplayDialog
GtkTreeSelection *src_sel;
GtkTreeSelection *dest_sel;
GimpColorDisplay *selected;
gboolean modified;
GList *old_nodes;
GList *conf_nodes;
GtkWidget *add_button;
GtkWidget *remove_button;
GtkWidget *up_button;
GtkWidget *down_button;
GtkWidget *configure_button;
GtkWidget *config_frame;
GtkWidget *config_box;
GtkWidget *config_widget;
GtkWidget *reset_button;
};
@ -88,8 +94,6 @@ static void color_display_up_callback (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void color_display_down_callback (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void color_display_configure_callback (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void dest_list_populate (GList *node_list,
GtkTreeStore *dest);
@ -99,12 +103,18 @@ static void src_selection_changed (GtkTreeSelection *sel,
static void dest_selection_changed (GtkTreeSelection *sel,
ColorDisplayDialog *cdd);
static void selected_filter_changed (GimpColorDisplay *filter,
ColorDisplayDialog *cdd);
static void selected_filter_reset (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void color_display_update_up_and_down (ColorDisplayDialog *cdd);
static void
make_dialog (ColorDisplayDialog *cdd)
{
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *editor;
GtkWidget *scrolled_win;
@ -126,11 +136,15 @@ make_dialog (ColorDisplayDialog *cdd)
NULL);
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cdd->dialog)->vbox), hbox,
main_vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cdd->dialog)->vbox), main_vbox,
TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_SHADOW_IN);
@ -220,18 +234,8 @@ make_dialog (ColorDisplayDialog *cdd)
NULL,
cdd);
cdd->configure_button =
gimp_editor_add_button (GIMP_EDITOR (editor),
GIMP_STOCK_EDIT,
_("Configure the selected filter"),
NULL,
G_CALLBACK (color_display_configure_callback),
NULL,
cdd);
gtk_widget_set_sensitive (cdd->up_button, FALSE);
gtk_widget_set_sensitive (cdd->down_button, FALSE);
gtk_widget_set_sensitive (cdd->configure_button, FALSE);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
@ -262,7 +266,36 @@ make_dialog (ColorDisplayDialog *cdd)
G_CALLBACK (dest_selection_changed),
cdd);
/* the config frame */
cdd->config_frame = gtk_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), cdd->config_frame, FALSE, FALSE, 0);
gtk_widget_show (cdd->config_frame);
cdd->config_box = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (cdd->config_box), 4);
gtk_container_add (GTK_CONTAINER (cdd->config_frame), cdd->config_box);
gtk_widget_show (cdd->config_box);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (cdd->config_box), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
cdd->reset_button = gtk_button_new_from_stock (GIMP_STOCK_RESET);
gtk_box_pack_end (GTK_BOX (hbox), cdd->reset_button, FALSE, FALSE, 0);
gtk_widget_show (cdd->reset_button);
gimp_help_set_help_data (cdd->reset_button,
_("Reset the selected filter to default values"),
NULL);
g_signal_connect (G_OBJECT (cdd->reset_button), "clicked",
G_CALLBACK (selected_filter_reset),
cdd);
dest_selection_changed (cdd->dest_sel, cdd);
gtk_widget_show (main_vbox);
}
static void
@ -284,7 +317,7 @@ color_display_ok_callback (GtkWidget *widget,
g_list_free (cdd->old_nodes);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -313,7 +346,7 @@ color_display_cancel_callback (GtkWidget *widget,
list = next;
}
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -373,7 +406,7 @@ color_display_add_callback (GtkWidget *widget,
color_display_update_up_and_down (cdd);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -406,7 +439,7 @@ color_display_remove_callback (GtkWidget *widget,
color_display_update_up_and_down (cdd);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -447,7 +480,7 @@ color_display_up_callback (GtkWidget *widget,
gtk_tree_selection_select_iter (cdd->dest_sel, &iter2);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -488,36 +521,7 @@ color_display_down_callback (GtkWidget *widget,
gtk_tree_selection_select_iter (cdd->dest_sel, &iter2);
UPDATE_DISPLAY (cdd->shell);
}
}
static void
color_display_configure_callback (GtkWidget *widget,
ColorDisplayDialog *cdd)
{
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (cdd->dest_sel, &model, &iter))
{
GimpColorDisplay *filter;
GValue val = { 0, };
gtk_tree_model_get_value (model, &iter, 1, &val);
filter = g_value_get_pointer (&val);
g_value_unset (&val);
if (! g_list_find (cdd->conf_nodes, filter))
cdd->conf_nodes = g_list_append (cdd->conf_nodes, filter);
gimp_color_display_configure (filter, NULL, NULL, NULL, NULL);
cdd->modified = TRUE;
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -614,6 +618,16 @@ dest_selection_changed (GtkTreeSelection *sel,
GtkTreeIter iter;
GimpColorDisplay *filter = NULL;
if (cdd->selected)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (cdd->selected),
selected_filter_changed,
cdd);
g_object_remove_weak_pointer (G_OBJECT (cdd->selected),
(gpointer) &cdd->selected);
cdd->selected = NULL;
}
if (gtk_tree_selection_get_selected (sel, &model, &iter))
{
GValue val = { 0, };
@ -625,8 +639,63 @@ dest_selection_changed (GtkTreeSelection *sel,
g_value_unset (&val);
}
gtk_widget_set_sensitive (cdd->remove_button, (filter != NULL));
gtk_widget_set_sensitive (cdd->configure_button, (filter != NULL));
gtk_widget_set_sensitive (cdd->remove_button, (filter != NULL));
gtk_widget_set_sensitive (cdd->reset_button, (filter != NULL));
if (cdd->config_widget)
gtk_container_remove (GTK_CONTAINER (cdd->config_box), cdd->config_widget);
if (filter)
{
gchar *str;
cdd->selected = filter;
g_object_add_weak_pointer (G_OBJECT (filter), (gpointer) &cdd->selected);
g_signal_connect (G_OBJECT (cdd->selected), "changed",
G_CALLBACK (selected_filter_changed),
cdd);
cdd->config_widget = gimp_color_display_configure (filter);
str = g_strdup_printf (_("Configure Selected Filter: %s"),
GIMP_COLOR_DISPLAY_GET_CLASS (filter)->name);
gtk_frame_set_label (GTK_FRAME (cdd->config_frame), str);
g_free (str);
}
else
{
cdd->config_widget = gtk_label_new (_("No Filter Selected"));
gtk_widget_set_sensitive (cdd->config_widget, FALSE);
gtk_frame_set_label (GTK_FRAME (cdd->config_frame),
_("Configure Selected Filter"));
}
if (cdd->config_widget)
{
gtk_box_pack_start (GTK_BOX (cdd->config_box), cdd->config_widget,
FALSE, FALSE, 0);
gtk_widget_show (cdd->config_widget);
g_object_add_weak_pointer (G_OBJECT (cdd->config_widget),
(gpointer) &cdd->config_widget);
}
color_display_update_up_and_down (cdd);
}
static void
selected_filter_changed (GimpColorDisplay *filter,
ColorDisplayDialog *cdd)
{
UPDATE_DISPLAY (cdd);
}
static void
selected_filter_reset (GtkWidget *widget,
ColorDisplayDialog *cdd)
{
if (cdd->selected)
gimp_color_display_configure_reset (cdd->selected);
}

17
app/gui/gui.c
View File

@ -31,7 +31,6 @@
#include "core/gimp.h"
#include "core/gimpcontainer.h"
#include "core/gimpcontext.h"
#include "core/gimpdatafiles.h"
#include "core/gimpimage.h"
#include "display/gimpdisplay.h"
@ -72,8 +71,7 @@ static void gui_message (Gimp *gimp,
static GimpObject * gui_display_new (GimpImage *gimage,
guint scale);
static void gui_themes_dir_foreach_func (const gchar *filename,
gpointer loader_data);
static void gui_themes_dir_foreach_func (GimpDatafileData *file_data);
static gint gui_rotate_the_shield_harmonics (GtkWidget *widget,
GdkEvent *eevent,
gpointer data);
@ -136,7 +134,7 @@ gui_themes_init (Gimp *gimp)
if (gimprc.theme_path)
{
gimp_datafiles_read_directories (gimprc.theme_path,
TYPE_DIRECTORY,
G_FILE_TEST_IS_DIR,
gui_themes_dir_foreach_func,
gimp);
}
@ -463,22 +461,21 @@ gui_display_new (GimpImage *gimage,
}
static void
gui_themes_dir_foreach_func (const gchar *filename,
gpointer loader_data)
gui_themes_dir_foreach_func (GimpDatafileData *file_data)
{
Gimp *gimp;
gchar *basename;
gimp = (Gimp *) loader_data;
gimp = (Gimp *) file_data->user_data;
basename = g_path_get_basename (filename);
basename = g_path_get_basename (file_data->filename);
if (gimp->be_verbose)
g_print (_("Adding theme '%s' (%s)\n"), basename, filename);
g_print (_("Adding theme '%s' (%s)\n"), basename, file_data->filename);
g_hash_table_insert (themes_hash,
basename,
g_strdup (filename));
g_strdup (file_data->filename));
}
static gint

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

@ -30,19 +30,21 @@
#include "gui-types.h"
#include "core/gimp.h"
#include "core/gimpcontainer.h"
#include "core/gimpmodules.h"
#include "widgets/gimpviewabledialog.h"
#include "module-browser.h"
#include "libgimp/gimpintl.h"
#define NUM_INFO_LINES 8
#define NUM_INFO_LINES 9
enum
{
PATH_COLUMN,
AUTO_COLUMN,
MODULE_COLUMN,
NUM_COLUMNS
};
@ -57,7 +59,6 @@ struct _ModuleBrowser
GimpModule *last_update;
GtkWidget *button;
GtkListStore *list;
GtkWidget *load_inhibit_check;
GQuark modules_handler_id;
Gimp *gimp;
@ -66,30 +67,32 @@ struct _ModuleBrowser
/* local function prototypes */
static void browser_popdown_callback (GtkWidget *widget,
gpointer data);
static void browser_destroy_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_load_inhibit_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_select_callback (GtkTreeSelection *sel,
ModuleBrowser *browser);
static void browser_load_unload_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_refresh_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void make_list_item (gpointer data,
gpointer user_data);
static void browser_info_add (GimpContainer *container,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_remove (GimpContainer *container,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_update (GimpModule *module,
ModuleBrowser *browser);
static void browser_info_init (ModuleBrowser *browser,
GtkWidget *table);
static void browser_popdown_callback (GtkWidget *widget,
gpointer data);
static void browser_destroy_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_select_callback (GtkTreeSelection *sel,
ModuleBrowser *browser);
static void browser_autoload_toggled (GtkCellRendererToggle *celltoggle,
gchar *path_string,
ModuleBrowser *browser);
static void browser_load_unload_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void browser_refresh_callback (GtkWidget *widget,
ModuleBrowser *browser);
static void make_list_item (gpointer data,
gpointer user_data);
static void browser_info_add (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_remove (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_update (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser);
static void browser_info_init (ModuleBrowser *browser,
GtkWidget *table);
/* public functions */
@ -97,31 +100,40 @@ static void browser_info_init (ModuleBrowser *browser,
GtkWidget *
module_browser_new (Gimp *gimp)
{
GtkWidget *shell;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *listbox;
GtkWidget *button;
GtkWidget *tv;
ModuleBrowser *browser;
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkWidget *shell;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *listbox;
GtkWidget *tv;
ModuleBrowser *browser;
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
shell = gimp_dialog_new (_("Module DB"), "module_db_dialog",
gimp_standard_help_func,
"dialogs/module_browser.html",
GTK_WIN_POS_NONE,
FALSE, TRUE, FALSE,
browser = g_new0 (ModuleBrowser, 1);
GTK_STOCK_CLOSE, browser_popdown_callback,
NULL, NULL, NULL, TRUE, TRUE,
browser->gimp = gimp;
NULL);
shell = gimp_viewable_dialog_new (NULL,
_("Module Browser"), "module_db_dialog",
GTK_STOCK_EXECUTE,
_("Browse & Manage Loadable Modules"),
gimp_standard_help_func,
"dialogs/module_browser.html",
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
GTK_STOCK_REFRESH, browser_refresh_callback,
browser, NULL, NULL, FALSE, FALSE,
GTK_STOCK_CLOSE, browser_popdown_callback,
NULL, NULL, NULL, TRUE, TRUE,
NULL);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (shell)->vbox), vbox);
gtk_widget_show (vbox);
@ -135,45 +147,47 @@ module_browser_new (Gimp *gimp)
gtk_widget_set_size_request (listbox, 125, 100);
gtk_widget_show (listbox);
browser = g_new0 (ModuleBrowser, 1);
browser->gimp = gimp;
browser->list = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_STRING, G_TYPE_POINTER);
G_TYPE_STRING, G_TYPE_BOOLEAN,
G_TYPE_POINTER);
tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (browser->list));
g_object_unref (browser->list);
gimp_container_foreach (gimp->modules, make_list_item, browser);
g_list_foreach (gimp->module_db->modules, make_list_item, browser);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv),
-1, NULL,
gtk_cell_renderer_text_new (),
"text", PATH_COLUMN,
NULL);
rend = gtk_cell_renderer_toggle_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tv), FALSE);
g_signal_connect (G_OBJECT (rend), "toggled",
G_CALLBACK (browser_autoload_toggled),
browser);
col = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (col, _("Autoload"));
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "active", AUTO_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Module Path"), rend,
"text", PATH_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col);
gtk_container_add (GTK_CONTAINER (listbox), tv);
gtk_widget_show (tv);
browser->table = gtk_table_new (5, NUM_INFO_LINES + 1, FALSE);
browser->table = gtk_table_new (2, NUM_INFO_LINES, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (browser->table), 4);
gtk_box_pack_start (GTK_BOX (vbox), browser->table, FALSE, FALSE, 0);
gtk_widget_show (browser->table);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0);
gtk_widget_show (hbox);
button = gtk_button_new_with_label (_("Refresh"));
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (browser_refresh_callback),
browser);
browser->button = gtk_button_new_with_label ("");
browser->button_label = gtk_bin_get_child (GTK_BIN (browser->button));
@ -185,7 +199,8 @@ module_browser_new (Gimp *gimp)
browser);
browser_info_init (browser, browser->table);
browser_info_update (browser->last_update, browser);
browser_info_update (gimp->module_db, browser->last_update, browser);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv));
@ -196,20 +211,18 @@ module_browser_new (Gimp *gimp)
if (gtk_tree_model_get_iter_root (GTK_TREE_MODEL (browser->list), &iter))
gtk_tree_selection_select_iter (sel, &iter);
/* hook the GimpContainer signals so we can refresh the display
/* hook the GimpModuleDB signals so we can refresh the display
* appropriately.
*/
browser->modules_handler_id =
gimp_container_add_handler (gimp->modules, "modified",
G_CALLBACK (browser_info_update),
browser);
g_signal_connect (G_OBJECT (gimp->modules), "add",
g_signal_connect (G_OBJECT (gimp->module_db), "add",
G_CALLBACK (browser_info_add),
browser);
g_signal_connect (G_OBJECT (gimp->modules), "remove",
g_signal_connect (G_OBJECT (gimp->module_db), "remove",
G_CALLBACK (browser_info_remove),
browser);
g_signal_connect (G_OBJECT (gimp->module_db), "module_modified",
G_CALLBACK (browser_info_update),
browser);
g_signal_connect (G_OBJECT (shell), "destroy",
G_CALLBACK (browser_destroy_callback),
@ -232,36 +245,19 @@ static void
browser_destroy_callback (GtkWidget *widget,
ModuleBrowser *browser)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->modules),
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->module_db),
browser_info_add,
browser);
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->modules),
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->module_db),
browser_info_remove,
browser);
gimp_container_remove_handler (browser->gimp->modules,
browser->modules_handler_id);
g_signal_handlers_disconnect_by_func (G_OBJECT (browser->gimp->module_db),
browser_info_update,
browser);
g_free (browser);
}
static void
browser_load_inhibit_callback (GtkWidget *widget,
ModuleBrowser *browser)
{
gboolean new_value;
g_return_if_fail (browser->last_update != NULL);
new_value = ! GTK_TOGGLE_BUTTON (widget)->active;
if (new_value == browser->last_update->load_inhibit)
return;
browser->last_update->load_inhibit = new_value;
gimp_module_modified (browser->last_update);
browser->gimp->write_modulerc = TRUE;
}
static void
browser_select_callback (GtkTreeSelection *sel,
ModuleBrowser *browser)
@ -278,7 +274,42 @@ browser_select_callback (GtkTreeSelection *sel,
browser->last_update = module;
browser_info_update (browser->last_update, browser);
browser_info_update (browser->gimp->module_db, browser->last_update, browser);
}
static void
browser_autoload_toggled (GtkCellRendererToggle *celltoggle,
gchar *path_string,
ModuleBrowser *browser)
{
GtkTreePath *path;
GtkTreeIter iter;
gboolean active = FALSE;
GimpModule *module = NULL;
path = gtk_tree_path_new_from_string (path_string);
if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (browser->list), &iter, path))
{
g_warning ("%s: bad tree path?", G_STRLOC);
return;
}
gtk_tree_path_free (path);
gtk_tree_model_get (GTK_TREE_MODEL (browser->list), &iter,
AUTO_COLUMN, &active,
MODULE_COLUMN, &module,
-1);
if (module)
{
gimp_module_set_load_inhibit (module, active);
browser->gimp->write_modulerc = TRUE;
gtk_list_store_set (GTK_LIST_STORE (browser->list), &iter,
AUTO_COLUMN, ! active,
-1);
}
}
static void
@ -287,8 +318,15 @@ browser_load_unload_callback (GtkWidget *widget,
{
if (browser->last_update->state != GIMP_MODULE_STATE_LOADED_OK)
{
if (g_type_module_use (G_TYPE_MODULE (browser->last_update)))
g_type_module_unuse (G_TYPE_MODULE (browser->last_update));
if (browser->last_update->info)
{
if (g_type_module_use (G_TYPE_MODULE (browser->last_update)))
g_type_module_unuse (G_TYPE_MODULE (browser->last_update));
}
else
{
gimp_module_query_module (browser->last_update);
}
}
gimp_module_modified (browser->last_update);
@ -315,20 +353,21 @@ make_list_item (gpointer data,
gtk_list_store_append (browser->list, &iter);
gtk_list_store_set (browser->list, &iter,
PATH_COLUMN, module->filename,
AUTO_COLUMN, ! module->load_inhibit,
MODULE_COLUMN, module,
-1);
}
static void
browser_info_add (GimpContainer *container,
GimpModule *module,
ModuleBrowser *browser)
browser_info_add (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser*browser)
{
make_list_item (module, browser);
}
static void
browser_info_remove (GimpContainer *container,
browser_info_remove (GimpModuleDB *db,
GimpModule *mod,
ModuleBrowser *browser)
{
@ -359,19 +398,15 @@ browser_info_remove (GimpContainer *container,
}
static void
browser_info_update (GimpModule *module,
browser_info_update (GimpModuleDB *db,
GimpModule *module,
ModuleBrowser *browser)
{
GTypeModule *g_type_module;
const gchar *text[NUM_INFO_LINES];
gint i;
static const gchar * const statename[] =
{
N_("Module error"),
N_("Loaded OK"),
N_("Load failed"),
N_("Unloaded OK")
};
g_type_module = G_TYPE_MODULE (module);
/* only update the info if we're actually showing it */
if (module != browser->last_update)
@ -383,7 +418,6 @@ browser_info_update (GimpModule *module,
gtk_label_set_text (GTK_LABEL (browser->label[i]), "");
gtk_label_set_text (GTK_LABEL (browser->button_label), _("<No modules>"));
gtk_widget_set_sensitive (GTK_WIDGET (browser->button), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (browser->load_inhibit_check), FALSE);
return;
}
@ -406,19 +440,31 @@ browser_info_update (GimpModule *module,
text[5] = module->on_disk ? _("On disk") : _("No longer available");
}
text[6] = gettext (statename[module->state]);
text[6] = gimp_module_state_name (module->state);
if (module->state == GIMP_MODULE_STATE_ERROR && module->last_module_error)
text[7] = module->last_module_error;
else
text[7] = "--";
for (i = 0; i < NUM_INFO_LINES; i++)
gtk_label_set_text (GTK_LABEL (browser->label[i]), gettext (text[i]));
if (g_type_module->type_infos || g_type_module->interface_infos)
{
gchar *str;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (browser->load_inhibit_check),
! module->load_inhibit);
gtk_widget_set_sensitive (GTK_WIDGET (browser->load_inhibit_check), TRUE);
str = g_strdup_printf ("%d Types, %d Interfaces",
g_slist_length (g_type_module->type_infos),
g_slist_length (g_type_module->interface_infos));
gtk_label_set_text (GTK_LABEL (browser->label[NUM_INFO_LINES - 1]), str);
g_free (str);
}
else
{
gtk_label_set_text (GTK_LABEL (browser->label[NUM_INFO_LINES - 1]),
"---");
}
for (i = 0; i < NUM_INFO_LINES - 1; i++)
gtk_label_set_text (GTK_LABEL (browser->label[i]), gettext (text[i]));
/* work out what the button should do (if anything) */
switch (module->state)
@ -426,8 +472,13 @@ browser_info_update (GimpModule *module,
case GIMP_MODULE_STATE_ERROR:
case GIMP_MODULE_STATE_LOAD_FAILED:
case GIMP_MODULE_STATE_UNLOADED_OK:
gtk_label_set_text (GTK_LABEL (browser->button_label), _("Load"));
gtk_widget_set_sensitive (GTK_WIDGET (browser->button), module->on_disk);
if (module->info)
gtk_label_set_text (GTK_LABEL (browser->button_label), _("Load"));
else
gtk_label_set_text (GTK_LABEL (browser->button_label), _("Query"));
gtk_widget_set_sensitive (GTK_WIDGET (browser->button),
module->on_disk);
break;
case GIMP_MODULE_STATE_LOADED_OK:
@ -444,7 +495,7 @@ browser_info_init (ModuleBrowser *browser,
GtkWidget *label;
gint i;
static const gchar *text[] =
static const gchar * const text[] =
{
N_("Purpose:"),
N_("Author:"),
@ -453,7 +504,8 @@ browser_info_init (ModuleBrowser *browser,
N_("Date:"),
N_("Location:"),
N_("State:"),
N_("Last Error:")
N_("Last Error:"),
N_("Available Types:")
};
for (i = 0; i < G_N_ELEMENTS (text); i++)
@ -471,15 +523,4 @@ browser_info_init (ModuleBrowser *browser,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 2);
gtk_widget_show (browser->label[i]);
}
browser->load_inhibit_check =
gtk_check_button_new_with_label (_("Autoload during start-up"));
gtk_table_attach (GTK_TABLE (table), browser->load_inhibit_check,
0, 2, i, i + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 2);
gtk_widget_show (browser->load_inhibit_check);
g_signal_connect (G_OBJECT (browser->load_inhibit_check), "toggled",
G_CALLBACK (browser_load_inhibit_callback),
browser);
}

1
app/plug-in/gimpplugin-message.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

1
app/plug-in/gimpplugin.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

1
app/plug-in/gimppluginmanager-call.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

1
app/plug-in/gimppluginmanager-run.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

18
app/plug-in/gimppluginmanager.c
View File

@ -31,7 +31,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
@ -57,8 +56,7 @@ struct _PlugInHelpPathDef
};
static void plug_ins_init_file (const gchar *filename,
gpointer loader_data);
static void plug_ins_init_file (GimpDatafileData *file_data);
static void plug_ins_add_to_db (Gimp *gimp);
static void plug_ins_proc_def_insert (PlugInProcDef *proc_def,
void (* superceed_fn) (void *));
@ -95,7 +93,7 @@ plug_ins_init (Gimp *gimp,
/* search for binaries in the plug-in directory path */
gimp_datafiles_read_directories (gimp->config->plug_in_path,
MODE_EXECUTABLE,
G_FILE_TEST_IS_EXECUTABLE,
plug_ins_init_file, NULL);
/* read the pluginrc file for cached data */
@ -515,15 +513,14 @@ plug_ins_help_path (gchar *prog_name)
}
static void
plug_ins_init_file (const gchar *filename,
gpointer loader_data)
plug_ins_init_file (GimpDatafileData *file_data)
{
GSList *tmp;
PlugInDef *plug_in_def;
gchar *plug_in_name;
gchar *basename;
basename = g_path_get_basename (filename);
basename = g_path_get_basename (file_data->filename);
for (tmp = plug_in_defs; tmp; tmp = g_slist_next (tmp))
{
@ -533,7 +530,8 @@ plug_ins_init_file (const gchar *filename,
if (g_ascii_strcasecmp (basename, plug_in_name) == 0)
{
g_print ("duplicate plug-in: \"%s\" (skipping)\n", filename);
g_print ("duplicate plug-in: \"%s\" (skipping)\n",
file_data->filename);
return;
}
@ -542,8 +540,8 @@ plug_ins_init_file (const gchar *filename,
g_free (basename);
plug_in_def = plug_in_def_new (filename);
plug_in_def->mtime = gimp_datafile_mtime ();
plug_in_def = plug_in_def_new (file_data->filename);
plug_in_def->mtime = file_data->mtime;
plug_in_def->query = TRUE;
plug_in_defs = g_slist_append (plug_in_defs, plug_in_def);

1
app/plug-in/gimppluginshm.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

1
app/plug-in/plug-in-message.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

1
app/plug-in/plug-in-run.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

1
app/plug-in/plug-in-shm.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

1
app/plug-in/plug-in.c
View File

@ -86,7 +86,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"

18
app/plug-in/plug-ins.c
View File

@ -31,7 +31,6 @@
#include "core/gimp.h"
#include "core/gimpcontext.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage.h"
@ -57,8 +56,7 @@ struct _PlugInHelpPathDef
};
static void plug_ins_init_file (const gchar *filename,
gpointer loader_data);
static void plug_ins_init_file (GimpDatafileData *file_data);
static void plug_ins_add_to_db (Gimp *gimp);
static void plug_ins_proc_def_insert (PlugInProcDef *proc_def,
void (* superceed_fn) (void *));
@ -95,7 +93,7 @@ plug_ins_init (Gimp *gimp,
/* search for binaries in the plug-in directory path */
gimp_datafiles_read_directories (gimp->config->plug_in_path,
MODE_EXECUTABLE,
G_FILE_TEST_IS_EXECUTABLE,
plug_ins_init_file, NULL);
/* read the pluginrc file for cached data */
@ -515,15 +513,14 @@ plug_ins_help_path (gchar *prog_name)
}
static void
plug_ins_init_file (const gchar *filename,
gpointer loader_data)
plug_ins_init_file (GimpDatafileData *file_data)
{
GSList *tmp;
PlugInDef *plug_in_def;
gchar *plug_in_name;
gchar *basename;
basename = g_path_get_basename (filename);
basename = g_path_get_basename (file_data->filename);
for (tmp = plug_in_defs; tmp; tmp = g_slist_next (tmp))
{
@ -533,7 +530,8 @@ plug_ins_init_file (const gchar *filename,
if (g_ascii_strcasecmp (basename, plug_in_name) == 0)
{
g_print ("duplicate plug-in: \"%s\" (skipping)\n", filename);
g_print ("duplicate plug-in: \"%s\" (skipping)\n",
file_data->filename);
return;
}
@ -542,8 +540,8 @@ plug_ins_init_file (const gchar *filename,
g_free (basename);
plug_in_def = plug_in_def_new (filename);
plug_in_def->mtime = gimp_datafile_mtime ();
plug_in_def = plug_in_def_new (file_data->filename);
plug_in_def->mtime = file_data->mtime;
plug_in_def->query = TRUE;
plug_in_defs = g_slist_append (plug_in_defs, plug_in_def);

10
app/tools/tools.c
View File

@ -20,12 +20,13 @@
#include <gtk/gtk.h>
#include "libgimpbase/gimpbase.h"
#include "tools-types.h"
/*FIXME: remove when proper module loading is in place */
#include "core/gimp.h"
#include "core/gimpcoreconfig.h"
#include "core/gimpdatafiles.h"
/*end remove */
#include "libgimptool/gimptool.h"
@ -74,10 +75,11 @@
#include "gimpvectortool.h"
void
cheesey_module_loading_hack (const gchar *filename,
gpointer loader_data)
cheesey_module_loading_hack (GimpDatafileData *file_data)
{
gimp_tool_module_new (filename, tool_manager_register_tool, loader_data);
gimp_tool_module_new (file_data->filename,
tool_manager_register_tool,
file_data->user_data);
}
void

187
app/widgets/gimpcolordisplayeditor.c
View File

@ -40,11 +40,11 @@
#define LIST_WIDTH 150
#define LIST_HEIGHT 100
#define UPDATE_DISPLAY(shell) G_STMT_START \
{ \
gimp_display_shell_expose_full (shell); \
gimp_display_shell_flush (shell); \
} G_STMT_END
#define UPDATE_DISPLAY(cdd) G_STMT_START \
{ \
gimp_display_shell_expose_full ((cdd)->shell); \
gimp_display_shell_flush ((cdd)->shell); \
} G_STMT_END
typedef struct _ColorDisplayDialog ColorDisplayDialog;
@ -61,16 +61,22 @@ struct _ColorDisplayDialog
GtkTreeSelection *src_sel;
GtkTreeSelection *dest_sel;
GimpColorDisplay *selected;
gboolean modified;
GList *old_nodes;
GList *conf_nodes;
GtkWidget *add_button;
GtkWidget *remove_button;
GtkWidget *up_button;
GtkWidget *down_button;
GtkWidget *configure_button;
GtkWidget *config_frame;
GtkWidget *config_box;
GtkWidget *config_widget;
GtkWidget *reset_button;
};
@ -88,8 +94,6 @@ static void color_display_up_callback (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void color_display_down_callback (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void color_display_configure_callback (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void dest_list_populate (GList *node_list,
GtkTreeStore *dest);
@ -99,12 +103,18 @@ static void src_selection_changed (GtkTreeSelection *sel,
static void dest_selection_changed (GtkTreeSelection *sel,
ColorDisplayDialog *cdd);
static void selected_filter_changed (GimpColorDisplay *filter,
ColorDisplayDialog *cdd);
static void selected_filter_reset (GtkWidget *widget,
ColorDisplayDialog *cdd);
static void color_display_update_up_and_down (ColorDisplayDialog *cdd);
static void
make_dialog (ColorDisplayDialog *cdd)
{
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *editor;
GtkWidget *scrolled_win;
@ -126,11 +136,15 @@ make_dialog (ColorDisplayDialog *cdd)
NULL);
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cdd->dialog)->vbox), hbox,
main_vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cdd->dialog)->vbox), main_vbox,
TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_SHADOW_IN);
@ -220,18 +234,8 @@ make_dialog (ColorDisplayDialog *cdd)
NULL,
cdd);
cdd->configure_button =
gimp_editor_add_button (GIMP_EDITOR (editor),
GIMP_STOCK_EDIT,
_("Configure the selected filter"),
NULL,
G_CALLBACK (color_display_configure_callback),
NULL,
cdd);
gtk_widget_set_sensitive (cdd->up_button, FALSE);
gtk_widget_set_sensitive (cdd->down_button, FALSE);
gtk_widget_set_sensitive (cdd->configure_button, FALSE);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
@ -262,7 +266,36 @@ make_dialog (ColorDisplayDialog *cdd)
G_CALLBACK (dest_selection_changed),
cdd);
/* the config frame */
cdd->config_frame = gtk_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), cdd->config_frame, FALSE, FALSE, 0);
gtk_widget_show (cdd->config_frame);
cdd->config_box = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (cdd->config_box), 4);
gtk_container_add (GTK_CONTAINER (cdd->config_frame), cdd->config_box);
gtk_widget_show (cdd->config_box);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (cdd->config_box), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
cdd->reset_button = gtk_button_new_from_stock (GIMP_STOCK_RESET);
gtk_box_pack_end (GTK_BOX (hbox), cdd->reset_button, FALSE, FALSE, 0);
gtk_widget_show (cdd->reset_button);
gimp_help_set_help_data (cdd->reset_button,
_("Reset the selected filter to default values"),
NULL);
g_signal_connect (G_OBJECT (cdd->reset_button), "clicked",
G_CALLBACK (selected_filter_reset),
cdd);
dest_selection_changed (cdd->dest_sel, cdd);
gtk_widget_show (main_vbox);
}
static void
@ -284,7 +317,7 @@ color_display_ok_callback (GtkWidget *widget,
g_list_free (cdd->old_nodes);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -313,7 +346,7 @@ color_display_cancel_callback (GtkWidget *widget,
list = next;
}
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -373,7 +406,7 @@ color_display_add_callback (GtkWidget *widget,
color_display_update_up_and_down (cdd);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -406,7 +439,7 @@ color_display_remove_callback (GtkWidget *widget,
color_display_update_up_and_down (cdd);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -447,7 +480,7 @@ color_display_up_callback (GtkWidget *widget,
gtk_tree_selection_select_iter (cdd->dest_sel, &iter2);
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -488,36 +521,7 @@ color_display_down_callback (GtkWidget *widget,
gtk_tree_selection_select_iter (cdd->dest_sel, &iter2);
UPDATE_DISPLAY (cdd->shell);
}
}
static void
color_display_configure_callback (GtkWidget *widget,
ColorDisplayDialog *cdd)
{
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (cdd->dest_sel, &model, &iter))
{
GimpColorDisplay *filter;
GValue val = { 0, };
gtk_tree_model_get_value (model, &iter, 1, &val);
filter = g_value_get_pointer (&val);
g_value_unset (&val);
if (! g_list_find (cdd->conf_nodes, filter))
cdd->conf_nodes = g_list_append (cdd->conf_nodes, filter);
gimp_color_display_configure (filter, NULL, NULL, NULL, NULL);
cdd->modified = TRUE;
UPDATE_DISPLAY (cdd->shell);
UPDATE_DISPLAY (cdd);
}
}
@ -614,6 +618,16 @@ dest_selection_changed (GtkTreeSelection *sel,
GtkTreeIter iter;
GimpColorDisplay *filter = NULL;
if (cdd->selected)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (cdd->selected),
selected_filter_changed,
cdd);
g_object_remove_weak_pointer (G_OBJECT (cdd->selected),
(gpointer) &cdd->selected);
cdd->selected = NULL;
}
if (gtk_tree_selection_get_selected (sel, &model, &iter))
{
GValue val = { 0, };
@ -625,8 +639,63 @@ dest_selection_changed (GtkTreeSelection *sel,
g_value_unset (&val);
}
gtk_widget_set_sensitive (cdd->remove_button, (filter != NULL));
gtk_widget_set_sensitive (cdd->configure_button, (filter != NULL));
gtk_widget_set_sensitive (cdd->remove_button, (filter != NULL));
gtk_widget_set_sensitive (cdd->reset_button, (filter != NULL));
if (cdd->config_widget)
gtk_container_remove (GTK_CONTAINER (cdd->config_box), cdd->config_widget);
if (filter)
{
gchar *str;
cdd->selected = filter;
g_object_add_weak_pointer (G_OBJECT (filter), (gpointer) &cdd->selected);
g_signal_connect (G_OBJECT (cdd->selected), "changed",
G_CALLBACK (selected_filter_changed),
cdd);
cdd->config_widget = gimp_color_display_configure (filter);
str = g_strdup_printf (_("Configure Selected Filter: %s"),
GIMP_COLOR_DISPLAY_GET_CLASS (filter)->name);
gtk_frame_set_label (GTK_FRAME (cdd->config_frame), str);
g_free (str);
}
else
{
cdd->config_widget = gtk_label_new (_("No Filter Selected"));
gtk_widget_set_sensitive (cdd->config_widget, FALSE);
gtk_frame_set_label (GTK_FRAME (cdd->config_frame),
_("Configure Selected Filter"));
}
if (cdd->config_widget)
{
gtk_box_pack_start (GTK_BOX (cdd->config_box), cdd->config_widget,
FALSE, FALSE, 0);
gtk_widget_show (cdd->config_widget);
g_object_add_weak_pointer (G_OBJECT (cdd->config_widget),
(gpointer) &cdd->config_widget);
}
color_display_update_up_and_down (cdd);
}
static void
selected_filter_changed (GimpColorDisplay *filter,
ColorDisplayDialog *cdd)
{
UPDATE_DISPLAY (cdd);
}
static void
selected_filter_reset (GtkWidget *widget,
ColorDisplayDialog *cdd)
{
if (cdd->selected)
gimp_color_display_configure_reset (cdd->selected);
}

17
devel-docs/ChangeLog
View File

@ -1,3 +1,20 @@
2002-10-23 Michael Natterer <mitch@gimp.org>
* libgimpbase/libgimpbase-docs.sgml
* libgimpbase/libgimpbase-sections.txt
* libgimpbase/tmpl/gimpbasetypes.sgml
* libgimpbase/tmpl/gimpdatafiles.sgml: added GimpDatafiles
* libgimpmodule/libgimpmodule-docs.sgml
* libgimpmodule/libgimpmodule-sections.txt
* libgimpmodule/tmpl/gimpmoduledb.sgml: added GimpModuleDB.
* libgimpwidgets/libgimpwidgets.types: added gimp_dialog_get_type
* libgimpmodule/tmpl/gimpmodule.sgml
* libgimpwidgets/tmpl/gimpcolordisplay.sgml
* libgimpwidgets/tmpl/gimpdialog.sgml: updated.
2002-10-21 Michael Natterer <mitch@gimp.org>
* libgimpmodule/tmpl/gimpmoduletypes.sgml: removed because we

2
devel-docs/libgimpbase/libgimpbase-docs.sgml
View File

@ -1,6 +1,7 @@
<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
<!entity GimpBaseTypes SYSTEM "sgml/gimpbasetypes.sgml">
<!entity GimpLimits SYSTEM "sgml/gimplimits.sgml">
<!entity GimpDatafiles SYSTEM "sgml/gimpdatafiles.sgml">
<!entity GimpEnv SYSTEM "sgml/gimpenv.sgml">
<!entity GimpParasite SYSTEM "sgml/gimpparasite.sgml">
<!entity GimpParasiteIO SYSTEM "sgml/gimpparasiteio.sgml">
@ -20,6 +21,7 @@
&GimpBaseTypes;
&GimpVersion;
&GimpLimits;
&GimpDatafiles;
&GimpEnv;
&GimpParasite;
&GimpParasiteIO;

7
devel-docs/libgimpbase/libgimpbase-sections.txt
View File

@ -5,6 +5,7 @@ GimpPDBProcType
GimpPDBStatusType
GimpMessageHandlerType
GimpStackTraceMode
GimpDatafileLoaderFunc
</SECTION>
<SECTION>
@ -162,3 +163,9 @@ GIMP_VERSION
GIMP_CHECK_VERSION
</SECTION>
<SECTION>
<FILE>gimpdatafiles</FILE>
GimpDatafileData
gimp_datafiles_check_extension
gimp_datafiles_read_directories
</SECTION>

8
devel-docs/libgimpbase/tmpl/gimpbasetypes.sgml
View File

@ -82,3 +82,11 @@ gimpbasetypes
@GIMP_STACK_TRACE_QUERY:
@GIMP_STACK_TRACE_ALWAYS:
<!-- ##### USER_FUNCTION GimpDatafileLoaderFunc ##### -->
<para>
</para>
@file_data:

48
devel-docs/libgimpbase/tmpl/gimpdatafiles.sgml Normal file
View File

@ -0,0 +1,48 @@
<!-- ##### SECTION Title ##### -->
gimpdatafiles
<!-- ##### SECTION Short_Description ##### -->
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### STRUCT GimpDatafileData ##### -->
<para>
</para>
@filename:
@atime:
@mtime:
@ctime:
@user_data:
<!-- ##### FUNCTION gimp_datafiles_check_extension ##### -->
<para>
</para>
@filename:
@extension:
@Returns:
<!-- ##### FUNCTION gimp_datafiles_read_directories ##### -->
<para>
</para>
@path_str:
@flags:
@loader_func:
@user_data:

2
devel-docs/libgimpmodule/libgimpmodule-docs.sgml
View File

@ -1,5 +1,6 @@
<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
<!entity GimpModule SYSTEM "sgml/gimpmodule.sgml">
<!entity GimpModuleDB SYSTEM "sgml/gimpmoduledb.sgml">
]>
<book id="index">
<bookinfo>
@ -9,5 +10,6 @@
<chapter id="libgimpmodule">
<title>GIMP Module Library</title>
&GimpModule;
&GimpModuleDB;
</chapter>
</book>

19
devel-docs/libgimpmodule/libgimpmodule-sections.txt
View File

@ -21,3 +21,22 @@ GIMP_MODULE_CLASS
GIMP_IS_MODULE_CLASS
GIMP_MODULE_GET_CLASS
</SECTION>
<SECTION>
<FILE>gimpmoduledb</FILE>
GimpModuleDB
<TITLE>GimpModuleDB</TITLE>
gimp_module_db_new
gimp_module_db_set_load_inhibit
gimp_module_db_get_load_inhibit
gimp_module_db_load
gimp_module_db_refresh
<SUBSECTION Standard>
GIMP_MODULE_DB
GIMP_IS_MODULE_DB
GIMP_TYPE_MODULE_DB
gimp_module_db_get_type
GIMP_MODULE_DB_CLASS
GIMP_IS_MODULE_DB_CLASS
GIMP_MODULE_DB_GET_CLASS
</SECTION>

2
devel-docs/libgimpmodule/libgimpmodule.types
View File

@ -2,3 +2,5 @@
#include <libgimpmodule/gimpmodule.h>
gimp_module_get_type
gimp_module_db_get_type

6
devel-docs/libgimpmodule/tmpl/gimpmodule.sgml
View File

@ -68,9 +68,11 @@ Common definitions for creating a pluggable GIMP module.
</para>
@filename:
@inhibit_str:
@load_inhibit:
@verbose:
@Returns:
<!-- # Unused Parameters # -->
@inhibit_str:
<!-- ##### FUNCTION gimp_module_modified ##### -->
@ -87,6 +89,8 @@ Common definitions for creating a pluggable GIMP module.
</para>
@module:
@load_inhibit:
<!-- # Unused Parameters # -->
@inhibit_list:

91
devel-docs/libgimpmodule/tmpl/gimpmoduledb.sgml Normal file
View File

@ -0,0 +1,91 @@
<!-- ##### SECTION Title ##### -->
GimpModuleDB
<!-- ##### SECTION Short_Description ##### -->
<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
<!-- ##### STRUCT GimpModuleDB ##### -->
<para>
</para>
<!-- ##### FUNCTION gimp_module_db_new ##### -->
<para>
</para>
@verbose:
@Returns:
<!-- ##### FUNCTION gimp_module_db_set_load_inhibit ##### -->
<para>
</para>
@db:
@load_inhibit:
<!-- ##### FUNCTION gimp_module_db_get_load_inhibit ##### -->
<para>
</para>
@db:
@Returns:
<!-- ##### FUNCTION gimp_module_db_load ##### -->
<para>
</para>
@db:
@module_path:
<!-- ##### FUNCTION gimp_module_db_refresh ##### -->
<para>
</para>
@db:
@module_path:
<!-- ##### SIGNAL GimpModuleDB::add ##### -->
<para>
</para>
@gimpmoduledb: the object which received the signal.
@arg1:
<!-- ##### SIGNAL GimpModuleDB::module-modified ##### -->
<para>
</para>
@gimpmoduledb: the object which received the signal.
@arg1:
<!-- ##### SIGNAL GimpModuleDB::remove ##### -->
<para>
</para>
@gimpmoduledb: the object which received the signal.
@arg1:

1
devel-docs/libgimpwidgets/libgimpwidgets.types
View File

@ -6,6 +6,7 @@
gimp_chain_button_get_type
gimp_color_button_get_type
gimp_dialog_get_type
gimp_color_display_get_type
gimp_color_selector_get_type
gimp_color_select_get_type

7
devel-docs/libgimpwidgets/tmpl/gimpcolordisplay.sgml
View File

@ -83,17 +83,18 @@ display color correction module.
</para>
@display:
@Returns:
<!-- # Unused Parameters # -->
@ok_func:
@ok_data:
@cancel_func:
@cancel_data:
<!-- ##### FUNCTION gimp_color_display_configure_cancel ##### -->
<!-- ##### SIGNAL GimpColorDisplay::changed ##### -->
<para>
</para>
@display:
@gimpcolordisplay: the object which received the signal.

1
devel-docs/libgimpwidgets/tmpl/gimpdialog.sgml
View File

@ -20,7 +20,6 @@ dialog-related stuff.
</para>
@parent_instance:
<!-- ##### FUNCTION gimp_dialog_new ##### -->
<para>

23
libgimpbase/Makefile.am
View File

@ -69,32 +69,37 @@ lib_LTLIBRARIES = libgimpbase-1.3.la
libgimpbase_1_3_la_SOURCES = \
gimpbase.h \
gimpbasetypes.h \
gimplimits.h \
gimpunit.h \
gimpversion.h \
\
gimpdatafiles.c \
gimpdatafiles.h \
gimpenv.c \
gimpenv.h \
gimplimits.h \
gimpsignal.c \
gimpsignal.h \
gimpparasite.c \
gimpparasite.h \
gimpparasiteio.c \
gimpparasiteio.h \
gimpprotocol.c \
gimpprotocol.h \
gimpunit.h \
gimpversion.h \
gimpsignal.c \
gimpsignal.h \
gimpwire.c \
gimpwire.h
libgimpbaseinclude_HEADERS = \
gimpbase.h \
gimpbasetypes.h \
gimpenv.h \
gimplimits.h \
gimpsignal.h \
gimpunit.h \
gimpversion.h \
\
gimpdatafiles.h \
gimpenv.h \
gimpparasite.h \
gimpparasiteio.h \
gimpunit.h \
gimpversion.h
gimpsignal.h
EXTRA_HEADERS =

1
libgimpbase/gimpbase.h
View File

@ -23,6 +23,7 @@
#include <libgimpbase/gimpbasetypes.h>
#include <libgimpbase/gimpdatafiles.h>
#include <libgimpbase/gimpenv.h>
#include <libgimpbase/gimplimits.h>
#include <libgimpbase/gimpparasite.h>

6
libgimpbase/gimpbasetypes.h
View File

@ -29,7 +29,11 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
typedef struct _GimpParasite GimpParasite;
typedef struct _GimpParasite GimpParasite;
typedef struct _GimpDatafileData GimpDatafileData;
typedef void (* GimpDatafileLoaderFunc) (GimpDatafileData *file_data);
typedef enum

105
libgimpbase/gimpdatafiles.c
View File

@ -42,15 +42,10 @@
#endif
#endif /* G_OS_WIN32 */
#include "libgimpbase/gimpbase.h"
#include "core-types.h"
#include "gimpbasetypes.h"
#include "gimpdatafiles.h"
static gboolean filestat_valid = FALSE;
static struct stat filestat;
#include "gimpenv.h"
#ifdef G_OS_WIN32
@ -114,26 +109,30 @@ gimp_datafiles_check_extension (const gchar *filename,
if (! (name_len && ext_len && (name_len > ext_len)))
return FALSE;
return (strcmp (&filename[name_len - ext_len], extension) == 0);
return (g_ascii_strcasecmp (&filename[name_len - ext_len], extension) == 0);
}
void
gimp_datafiles_read_directories (const gchar *path_str,
GimpDataFileFlags flags,
GimpDataFileLoaderFunc loader_func,
gpointer loader_data)
GFileTest flags,
GimpDatafileLoaderFunc loader_func,
gpointer user_data)
{
gchar *local_path;
GList *path;
GList *list;
gchar *filename;
gint err;
GDir *dir;
const gchar *dir_ent;
GimpDatafileData file_data = { 0 };
struct stat filestat;
gchar *local_path;
GList *path;
GList *list;
gchar *filename;
gint err;
GDir *dir;
const gchar *dir_ent;
g_return_if_fail (path_str != NULL);
g_return_if_fail (loader_func != NULL);
file_data.user_data = user_data;
local_path = g_strdup (path_str);
#ifdef __EMX__
@ -150,10 +149,9 @@ gimp_datafiles_read_directories (const gchar *path_str,
for (list = path; list; list = g_list_next (list))
{
/* Open directory */
dir = g_dir_open ((gchar *) list->data, 0, NULL);
if (!dir)
if (! dir)
{
g_message ("error reading datafiles directory \"%s\"",
(gchar *) list->data);
@ -168,23 +166,41 @@ gimp_datafiles_read_directories (const gchar *path_str,
/* Check the file and see that it is not a sub-directory */
err = stat (filename, &filestat);
file_data.filename = filename;
file_data.atime = filestat.st_atime;
file_data.mtime = filestat.st_mtime;
file_data.ctime = filestat.st_ctime;
if (! err)
{
filestat_valid = TRUE;
if (S_ISDIR (filestat.st_mode) && (flags & TYPE_DIRECTORY))
if (flags & G_FILE_TEST_EXISTS)
{
(* loader_func) (&file_data);
}
else if ((flags & G_FILE_TEST_IS_REGULAR) &&
S_ISREG (filestat.st_mode))
{
(* loader_func) (&file_data);
}
else if ((flags & G_FILE_TEST_IS_DIR) &&
S_ISDIR (filestat.st_mode))
{
(* loader_func) (filename, loader_data);
(* loader_func) (&file_data);
}
else if (S_ISREG (filestat.st_mode) &&
(!(flags & MODE_EXECUTABLE) ||
(filestat.st_mode & S_IXUSR) ||
is_script (filename)))
#ifdef G_OS_WIN32
else if ((flags & G_FILE_TEST_IS_SYMLINK) &&
S_ISLINK (filestat.st_mode))
{
(* loader_func) (filename, loader_data);
(* loader_func) (&file_data);
}
#endif
else if ((flags & G_FILE_TEST_IS_EXECUTABLE) &&
((filestat.st_mode & S_IXUSR) ||
(S_ISREG (filestat.st_mode) &&
is_script (filename))))
{
(* loader_func) (&file_data);
}
filestat_valid = FALSE;
}
g_free (filename);
@ -197,30 +213,3 @@ gimp_datafiles_read_directories (const gchar *path_str,
gimp_path_free (path);
g_free (local_path);
}
time_t
gimp_datafile_atime (void)
{
if (filestat_valid)
return filestat.st_atime;
return 0;
}
time_t
gimp_datafile_mtime (void)
{
if (filestat_valid)
return filestat.st_mtime;
return 0;
}
time_t
gimp_datafile_ctime (void)
{
if (filestat_valid)
return filestat.st_ctime;
return 0;
}

28
libgimpbase/gimpdatafiles.h
View File

@ -25,29 +25,25 @@
#include <time.h>
typedef enum
struct _GimpDatafileData
{
MODE_EXECUTABLE = 1 << 0,
TYPE_DIRECTORY = 1 << 1
} GimpDataFileFlags;
const gchar *filename;
time_t atime;
time_t mtime;
time_t ctime;
gpointer user_data;
};
gboolean gimp_datafiles_check_extension (const gchar *filename,
const gchar *extension);
void gimp_datafiles_read_directories (const gchar *path_str,
GimpDataFileFlags flags,
GimpDataFileLoaderFunc loader_func,
gpointer loader_data);
/* Return the current datafiles access, modification
* or change time. The current datafile is the one for
* which the "DataFileLoaderFunc" function has been called
* on.
*/
time_t gimp_datafile_atime (void);
time_t gimp_datafile_mtime (void);
time_t gimp_datafile_ctime (void);
GFileTest flags,
GimpDatafileLoaderFunc loader_func,
gpointer user_data);
#endif /* __GIMP_DATAFILES_H__ */

11
libgimpmodule/Makefile.am
View File

@ -61,11 +61,14 @@ lib_LTLIBRARIES = libgimpmodule-1.3.la
libgimpmodule_1_3_la_SOURCES = \
gimpmoduletypes.h \
gimpmodule.c \
gimpmodule.h
gimpmodule.h \
gimpmoduledb.c \
gimpmoduledb.h
libgimpmoduleinclude_HEADERS = \
gimpmoduletypes.h \
gimpmodule.h
gimpmodule.h \
gimpmoduledb.h
EXTRA_HEADERS =
@ -76,7 +79,9 @@ libgimpmodule_1_3_la_LDFLAGS = \
libgimpmodule_1_3_la_DEPENDENCIES = $(gimpmodule_def)
libgimpmodule_1_3_la_LIBADD = $(GLIB_LIBS)
libgimpmodule_1_3_la_LIBADD = \
$(top_builddir)/libgimpbase/libgimpbase-$(LT_RELEASE).la \
$(GLIB_LIBS)
install-data-local: install-ms-lib install-libtool-import-lib

234
libgimpmodule/gimpmodule.c
View File

@ -45,6 +45,8 @@ static void gimp_module_finalize (GObject *object);
static gboolean gimp_module_load (GTypeModule *module);
static void gimp_module_unload (GTypeModule *module);
static gboolean gimp_module_open (GimpModule *module);
static gboolean gimp_module_close (GimpModule *module);
static void gimp_module_set_last_error (GimpModule *module,
const gchar *error_str);
@ -158,10 +160,9 @@ gimp_module_finalize (GObject *object)
static gboolean
gimp_module_load (GTypeModule *module)
{
GimpModule *gimp_module;
const GimpModuleInfo *info;
gpointer symbol;
gboolean retval;
GimpModule *gimp_module;
gpointer symbol;
gboolean retval;
g_return_val_if_fail (GIMP_IS_MODULE (module), FALSE);
@ -173,63 +174,11 @@ gimp_module_load (GTypeModule *module)
if (gimp_module->verbose)
g_print (_("Loading module: '%s'\n"), gimp_module->filename);
gimp_module->module = g_module_open (gimp_module->filename,
G_MODULE_BIND_LAZY);
if (! gimp_module_open (gimp_module))
return FALSE;
if (! gimp_module->module)
{
gimp_module->state = GIMP_MODULE_STATE_ERROR;
gimp_module_set_last_error (gimp_module, g_module_error ());
if (gimp_module->verbose)
g_message (_("Module '%s' load error:\n%s"),
gimp_module->filename, gimp_module->last_module_error);
return FALSE;
}
/* find the gimp_module_query symbol */
if (! g_module_symbol (gimp_module->module, "gimp_module_query", &symbol))
{
gimp_module->state = GIMP_MODULE_STATE_ERROR;
gimp_module_set_last_error (gimp_module,
"Missing gimp_module_query() symbol");
if (gimp_module->verbose)
g_print (_("Module '%s' load error:\n%s"),
gimp_module->filename, gimp_module->last_module_error);
g_module_close (gimp_module->module);
gimp_module->module = NULL;
return FALSE;
}
gimp_module->query_module = symbol;
info = gimp_module->query_module (module);
if (gimp_module->info)
{
gimp_module_info_free (gimp_module->info);
gimp_module->info = NULL;
}
if (! info)
{
gimp_module->state = GIMP_MODULE_STATE_ERROR;
gimp_module_set_last_error (gimp_module,
"gimp_module_query() returned NULL");
if (gimp_module->verbose)
g_message (_("Module '%s' load error:\n%s"),
gimp_module->filename, gimp_module->last_module_error);
g_module_close (gimp_module->module);
gimp_module->module = NULL;
gimp_module->query_module = NULL;
return FALSE;
}
gimp_module->info = gimp_module_info_copy (info);
if (! gimp_module_query_module (gimp_module))
return FALSE;
/* find the gimp_module_register symbol */
if (! g_module_symbol (gimp_module->module, "gimp_module_register", &symbol))
@ -270,17 +219,15 @@ gimp_module_unload (GTypeModule *module)
g_return_if_fail (gimp_module->module != NULL);
g_module_close (gimp_module->module); /* FIXME: error handling */
gimp_module->module = NULL;
gimp_module->query_module = NULL;
gimp_module->register_module = NULL;
gimp_module->state = GIMP_MODULE_STATE_UNLOADED_OK;
gimp_module_close (gimp_module);
}
/* public functions */
GimpModule *
gimp_module_new (const gchar *filename,
const gchar *inhibit_list,
gboolean load_inhibit,
gboolean verbose)
{
GimpModule *module;
@ -289,11 +236,10 @@ gimp_module_new (const gchar *filename,
module = g_object_new (GIMP_TYPE_MODULE, NULL);
module->filename = g_strdup (filename);
module->verbose = verbose ? TRUE : FALSE;
module->on_disk = TRUE;
gimp_module_set_load_inhibit (module, inhibit_list);
module->filename = g_strdup (filename);
module->load_inhibit = load_inhibit ? TRUE : FALSE;
module->verbose = verbose ? TRUE : FALSE;
module->on_disk = TRUE;
if (! module->load_inhibit)
{
@ -311,6 +257,71 @@ gimp_module_new (const gchar *filename,
return module;
}
gboolean
gimp_module_query_module (GimpModule *module)
{
const GimpModuleInfo *info;
gboolean close_module = FALSE;
gpointer symbol;
g_return_val_if_fail (GIMP_IS_MODULE (module), FALSE);
if (! module->module)
{
if (! gimp_module_open (module))
return FALSE;
close_module = TRUE;
}
/* find the gimp_module_query symbol */
if (! g_module_symbol (module->module, "gimp_module_query", &symbol))
{
module->state = GIMP_MODULE_STATE_ERROR;
gimp_module_set_last_error (module, "Missing gimp_module_query() symbol");
if (module->verbose)
g_print (_("Module '%s' load error:\n%s"),
module->filename, module->last_module_error);
gimp_module_close (module);
return FALSE;
}
module->query_module = symbol;
if (module->info)
{
gimp_module_info_free (module->info);
module->info = NULL;
}
info = module->query_module (G_TYPE_MODULE (module));
if (! info)
{
module->state = GIMP_MODULE_STATE_ERROR;
gimp_module_set_last_error (module, "gimp_module_query() returned NULL");
if (module->verbose)
g_message (_("Module '%s' load error:\n%s"),
module->filename, module->last_module_error);
gimp_module_close (module);
return FALSE;
}
module->info = gimp_module_info_copy (info);
if (close_module)
return gimp_module_close (module);
return TRUE;
}
void
gimp_module_modified (GimpModule *module)
{
@ -320,42 +331,69 @@ gimp_module_modified (GimpModule *module)
}
void
gimp_module_set_load_inhibit (GimpModule *module,
const gchar *inhibit_list)
gimp_module_set_load_inhibit (GimpModule *module,
gboolean load_inhibit)
{
gchar *p;
gint pathlen;
const gchar *start;
const gchar *end;
g_return_if_fail (GIMP_IS_MODULE (module));
g_return_if_fail (module->filename != NULL);
module->load_inhibit = FALSE;
if (load_inhibit != module->load_inhibit)
{
module->load_inhibit = load_inhibit ? TRUE : FALSE;
if (! inhibit_list || ! strlen (inhibit_list))
return;
gimp_module_modified (module);
}
}
p = strstr (inhibit_list, module->filename);
if (!p)
return;
/* we have a substring, but check for colons either side */
start = p;
while (start != inhibit_list && *start != G_SEARCHPATH_SEPARATOR)
start--;
/* private functions */
if (*start == G_SEARCHPATH_SEPARATOR)
start++;
const gchar *
gimp_module_state_name (GimpModuleState state)
{
static const gchar * const statenames[] =
{
N_("Module error"),
N_("Loaded OK"),
N_("Load failed"),
N_("Unloaded OK")
};
end = strchr (p, G_SEARCHPATH_SEPARATOR);
if (! end)
end = inhibit_list + strlen (inhibit_list);
g_return_val_if_fail (state >= GIMP_MODULE_STATE_ERROR &&
state <= GIMP_MODULE_STATE_UNLOADED_OK, NULL);
pathlen = strlen (module->filename);
return gettext (statenames[state]);
}
if ((end - start) == pathlen)
module->load_inhibit = TRUE;
static gboolean
gimp_module_open (GimpModule *module)
{
module->module = g_module_open (module->filename, G_MODULE_BIND_LAZY);
if (! module->module)
{
module->state = GIMP_MODULE_STATE_ERROR;
gimp_module_set_last_error (module, g_module_error ());
if (module->verbose)
g_message (_("Module '%s' load error:\n%s"),
module->filename, module->last_module_error);
return FALSE;
}
return TRUE;
}
static gboolean
gimp_module_close (GimpModule *module)
{
g_module_close (module->module); /* FIXME: error handling */
module->module = NULL;
module->query_module = NULL;
module->register_module = NULL;
module->state = GIMP_MODULE_STATE_UNLOADED_OK;
return TRUE;
}
static void

20
libgimpmodule/gimpmodule.h
View File

@ -26,6 +26,8 @@
#include <libgimpmodule/gimpmoduletypes.h>
#include <libgimpmodule/gimpmoduledb.h>
G_BEGIN_DECLS
@ -96,15 +98,19 @@ struct _GimpModuleClass
};
GType gimp_module_get_type (void) G_GNUC_CONST;
GType gimp_module_get_type (void) G_GNUC_CONST;
GimpModule * gimp_module_new (const gchar *filename,
const gchar *inhibit_str,
gboolean verbose);
GimpModule * gimp_module_new (const gchar *filename,
gboolean load_inhibit,
gboolean verbose);
void gimp_module_modified (GimpModule *module);
void gimp_module_set_load_inhibit (GimpModule *module,
const gchar *inhibit_list);
gboolean gimp_module_query_module (GimpModule *module);
void gimp_module_modified (GimpModule *module);
void gimp_module_set_load_inhibit (GimpModule *module,
gboolean load_inhibit);
const gchar * gimp_module_state_name (GimpModuleState state);
/* GimpModuleInfo functions */

386
libgimpmodule/gimpmoduledb.c
View File

@ -32,126 +32,286 @@
#include <glib-object.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpmodule/gimpmodule.h"
#include "core-types.h"
#include "gimpmoduletypes.h"
#include "gimp.h"
#include "gimpcoreconfig.h"
#include "gimpdatafiles.h"
#include "gimplist.h"
#include "gimpmodules.h"
#include "gimprc.h"
#include "gimpmodule.h"
#include "gimpmoduledb.h"
#include "libgimp/gimpintl.h"
enum
{
ADD,
REMOVE,
MODULE_MODIFIED,
LAST_SIGNAL
};
#define DUMP_DB 1
static void gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data);
static void gimp_module_db_class_init (GimpModuleDBClass *klass);
static void gimp_module_db_init (GimpModuleDB *db);
static GimpModule * gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath);
static void gimp_module_db_finalize (GObject *object);
static void gimp_module_db_module_initialize (GimpDatafileData *file_data);
static GimpModule * gimp_module_db_module_find_by_path (GimpModuleDB *db,
const char *fullpath);
#ifdef DUMP_DB
static void gimp_modules_dump_module (gpointer data,
gpointer user_data);
static void gimp_module_db_dump_module (gpointer data,
gpointer user_data);
#endif
static gboolean gimp_modules_write_modulerc (Gimp *gimp);
#if 0
static gboolean gimp_module_db_write_modulerc (GimpModuleDB *db);
#endif
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);
static void gimp_module_db_module_on_disk_func (gpointer data,
gpointer user_data);
static void gimp_module_db_module_remove_func (gpointer data,
gpointer user_data);
static void gimp_module_db_module_modified (GimpModule *module,
GimpModuleDB *db);
void
gimp_modules_init (Gimp *gimp)
static GObjectClass *parent_class = NULL;
static guint db_signals[LAST_SIGNAL] = { 0 };
GType
gimp_module_db_get_type (void)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
static GType db_type = 0;
gimp->modules = gimp_list_new (GIMP_TYPE_MODULE,
GIMP_CONTAINER_POLICY_STRONG);
gimp_object_set_name (GIMP_OBJECT (gimp->modules), "modules");
if (! db_type)
{
static const GTypeInfo db_info =
{
sizeof (GimpModuleDBClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) gimp_module_db_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GimpModuleDB),
0, /* n_preallocs */
(GInstanceInitFunc) gimp_module_db_init,
};
gimp->write_modulerc = FALSE;
db_type = g_type_register_static (G_TYPE_OBJECT,
"GimpModuleDB",
&db_info, 0);
}
return db_type;
}
static void
gimp_module_db_class_init (GimpModuleDBClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
db_signals[ADD] =
g_signal_new ("add",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpModuleDBClass, add),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_MODULE);
db_signals[REMOVE] =
g_signal_new ("remove",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpModuleDBClass, remove),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_MODULE);
db_signals[MODULE_MODIFIED] =
g_signal_new ("module_modified",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpModuleDBClass, module_modified),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GIMP_TYPE_MODULE);
object_class->finalize = gimp_module_db_finalize;
klass->add = NULL;
klass->remove = NULL;
}
static void
gimp_module_db_init (GimpModuleDB *db)
{
db->modules = NULL;
db->load_inhibit = NULL;
db->verbose = FALSE;
}
static void
gimp_module_db_finalize (GObject *object)
{
GimpModuleDB *db;
db = GIMP_MODULE_DB (object);
if (db->modules)
{
g_list_free (db->modules);
db->modules = NULL;
}
if (db->load_inhibit)
{
g_free (db->load_inhibit);
db->load_inhibit = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GimpModuleDB *
gimp_module_db_new (gboolean verbose)
{
GimpModuleDB *db;
db = g_object_new (GIMP_TYPE_MODULE_DB, NULL);
db->verbose = verbose ? TRUE : FALSE;
return db;
}
static gboolean
is_in_inhibit_list (const gchar *filename,
const gchar *inhibit_list)
{
gchar *p;
gint pathlen;
const gchar *start;
const gchar *end;
if (! inhibit_list || ! strlen (inhibit_list))
return FALSE;
p = strstr (inhibit_list, filename);
if (!p)
return FALSE;
/* 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 (filename);
if ((end - start) == pathlen)
return TRUE;
return FALSE;
}
void
gimp_modules_exit (Gimp *gimp)
gimp_module_db_set_load_inhibit (GimpModuleDB *db,
const gchar *load_inhibit)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
GimpModule *module;
GList *list;
if (gimp->modules)
g_return_if_fail (GIMP_IS_MODULE_DB (db));
if (db->load_inhibit)
g_free (db->load_inhibit);
db->load_inhibit = g_strdup (load_inhibit);
for (list = db->modules; list; list = g_list_next (list))
{
g_object_unref (G_OBJECT (gimp->modules));
gimp->modules = NULL;
module = (GimpModule *) list->data;
gimp_module_set_load_inhibit (module,
is_in_inhibit_list (module->filename,
load_inhibit));
}
}
void
gimp_modules_load (Gimp *gimp)
const gchar *
gimp_module_db_get_load_inhibit (GimpModuleDB *db)
{
gchar *filename;
g_return_val_if_fail (GIMP_IS_MODULE_DB (db), NULL);
g_return_if_fail (GIMP_IS_GIMP (gimp));
return db->load_inhibit;
}
filename = gimp_personal_rc_file ("modulerc");
gimprc_parse_file (filename);
g_free (filename);
void
gimp_module_db_load (GimpModuleDB *db,
const gchar *module_path)
{
g_return_if_fail (GIMP_IS_MODULE_DB (db));
g_return_if_fail (module_path != NULL);
if (g_module_supported ())
gimp_datafiles_read_directories (gimp->config->module_path,
0 /* no flags */,
gimp_modules_module_initialize,
gimp);
gimp_datafiles_read_directories (module_path,
G_FILE_TEST_EXISTS,
gimp_module_db_module_initialize,
db);
#ifdef DUMP_DB
gimp_container_foreach (gimp->modules, gimp_modules_dump_module, NULL);
g_list_foreach (db->modules, gimp_module_db_dump_module, 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;
}
}
}
void
gimp_modules_refresh (Gimp *gimp)
gimp_module_db_refresh (GimpModuleDB *db,
const gchar *module_path)
{
GList *kill_list = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_MODULE_DB (db));
g_return_if_fail (module_path != NULL);
/* 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 (db->modules,
gimp_module_db_module_on_disk_func,
&kill_list);
g_list_foreach (kill_list,
gimp_modules_module_remove_func,
gimp);
gimp_module_db_module_remove_func,
db);
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);
gimp_datafiles_read_directories (module_path,
G_FILE_TEST_EXISTS,
gimp_module_db_module_initialize,
db);
}
#if 0
static void
add_to_inhibit_string (gpointer data,
gpointer user_data)
@ -196,32 +356,24 @@ gimp_modules_write_modulerc (Gimp *gimp)
return saved;
}
#endif
/* 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"))
if (! gimp_datafiles_check_extension (basename, ".so"))
goto no_module;
#else
if (len < 1 + 4)
goto no_module;
if (g_strcasecmp (basename + len - 4, ".dll"))
if (! gimp_datafiles_check_extension (basename, ".dll"))
goto no_module;
#endif
@ -236,36 +388,44 @@ valid_module_name (const gchar *filename)
}
static void
gimp_modules_module_initialize (const gchar *filename,
gpointer loader_data)
gimp_module_db_module_initialize (GimpDatafileData *file_data)
{
GimpModule *module;
Gimp *gimp;
GimpModuleDB *db;
GimpModule *module;
gboolean load_inhibit;
gimp = GIMP (loader_data);
db = GIMP_MODULE_DB (file_data->user_data);
if (! valid_module_name (filename))
if (! valid_module_name (file_data->filename))
return;
/* don't load if we already know about it */
if (gimp_modules_module_find_by_path (gimp, filename))
if (gimp_module_db_module_find_by_path (db, file_data->filename))
return;
module = gimp_module_new (filename,
gimp->config->module_db_load_inhibit,
gimp->be_verbose);
load_inhibit = is_in_inhibit_list (file_data->filename,
db->load_inhibit);
gimp_container_add (gimp->modules, (GimpObject *) module);
module = gimp_module_new (file_data->filename,
load_inhibit,
db->verbose);
g_signal_connect (G_OBJECT (module), "modified",
G_CALLBACK (gimp_module_db_module_modified),
db);
db->modules = g_list_append (db->modules, module);
g_signal_emit (G_OBJECT (db), db_signals[ADD], 0, module);
}
static GimpModule *
gimp_modules_module_find_by_path (Gimp *gimp,
const char *fullpath)
gimp_module_db_module_find_by_path (GimpModuleDB *db,
const char *fullpath)
{
GimpModule *module;
GList *list;
for (list = GIMP_LIST (gimp->modules)->list; list; list = g_list_next (list))
for (list = db->modules; list; list = g_list_next (list))
{
module = (GimpModule *) list->data;
@ -278,14 +438,14 @@ gimp_modules_module_find_by_path (Gimp *gimp,
#ifdef DUMP_DB
static void
gimp_modules_dump_module (gpointer data,
gpointer user_data)
gimp_module_db_dump_module (gpointer data,
gpointer user_data)
{
GimpModule *i = data;
g_print ("\n%s: %i\n",
g_print ("\n%s: %s\n",
i->filename,
i->state /* statename[i->state] */);
gimp_module_state_name (i->state));
g_print (" module:%p lasterr:%s query:%p register:%p\n",
i->module,
@ -310,8 +470,8 @@ gimp_modules_dump_module (gpointer data,
#endif
static void
gimp_modules_module_on_disk_func (gpointer data,
gpointer user_data)
gimp_module_db_module_on_disk_func (gpointer data,
gpointer user_data)
{
GimpModule *module;
GList **kill_list;
@ -338,14 +498,26 @@ gimp_modules_module_on_disk_func (gpointer data,
}
static void
gimp_modules_module_remove_func (gpointer data,
gpointer user_data)
gimp_module_db_module_remove_func (gpointer data,
gpointer user_data)
{
GimpModule *module;
Gimp *gimp;
GimpModule *module;
GimpModuleDB *db;
module = (GimpModule *) data;
gimp = (Gimp *) user_data;
module = (GimpModule *) data;
db = (GimpModuleDB *) user_data;
gimp_container_remove (gimp->modules, (GimpObject *) module);
g_signal_handlers_disconnect_by_func (G_OBJECT (module),
gimp_module_db_module_modified,
db);
g_list_remove (db->modules, module);
g_signal_emit (G_OBJECT (db), db_signals[REMOVE], 0, module);
}
static void
gimp_module_db_module_modified (GimpModule *module,
GimpModuleDB *db)
{
g_signal_emit (G_OBJECT (db), db_signals[MODULE_MODIFIED], 0, module);
}

61
libgimpmodule/gimpmoduledb.h
View File

@ -19,17 +19,58 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_MODULES_H__
#define __GIMP_MODULES_H__
#ifndef __GIMP_MODULE_DB_H__
#define __GIMP_MODULE_DB_H__
G_BEGIN_DECLS
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);
#define GIMP_TYPE_MODULE_DB (gimp_module_db_get_type ())
#define GIMP_MODULE_DB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_MODULE_DB, GimpModuleDB))
#define GIMP_MODULE_DB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_MODULE_DB, GimpModuleDBClass))
#define GIMP_IS_MODULE_DB(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_MODULE_DB))
#define GIMP_IS_MODULE_DB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_MODULE_DB))
#define GIMP_MODULE_DB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_MODULE_DB, GimpModuleDBClass))
#endif /* __GIMP_MODULES_H__ */
typedef struct _GimpModuleDBClass GimpModuleDBClass;
struct _GimpModuleDB
{
GObject parent_instance;
GList *modules;
gchar *load_inhibit;
gboolean verbose;
};
struct _GimpModuleDBClass
{
GObjectClass parent_class;
void (* add) (GimpModuleDB *db,
GimpModule *module);
void (* remove) (GimpModuleDB *db,
GimpModule *module);
void (* module_modified) (GimpModuleDB *db,
GimpModule *module);
};
GType gimp_module_db_get_type (void) G_GNUC_CONST;
GimpModuleDB * gimp_module_db_new (gboolean verbose);
void gimp_module_db_set_load_inhibit (GimpModuleDB *db,
const gchar *load_inhibit);
const gchar * gimp_module_db_get_load_inhibit (GimpModuleDB *db);
void gimp_module_db_load (GimpModuleDB *db,
const gchar *module_path);
void gimp_module_db_refresh (GimpModuleDB *db,
const gchar *module_path);
G_END_DECLS
#endif /* __GIMP_MODULE_DB_H__ */

1
libgimpmodule/gimpmoduletypes.h
View File

@ -27,6 +27,7 @@ G_BEGIN_DECLS
typedef struct _GimpModule GimpModule;
typedef struct _GimpModuleInfo GimpModuleInfo;
typedef struct _GimpModuleDB GimpModuleDB;
G_END_DECLS

16
libgimpproxy/gimpobject.c
View File

@ -319,20 +319,30 @@ gimp_object_get_memsize (GimpObject *object)
return GIMP_OBJECT_GET_CLASS (object)->get_memsize (object);
}
static gsize
gimp_object_real_get_memsize (GimpObject *object)
gsize
gimp_g_object_get_memsize (GObject *object)
{
GTypeQuery type_query;
gsize memsize = 0;
g_return_val_if_fail (G_IS_OBJECT (object), 0);
g_type_query (G_TYPE_FROM_INSTANCE (object), &type_query);
memsize += type_query.instance_size;
return memsize;
}
static gsize
gimp_object_real_get_memsize (GimpObject *object)
{
gsize memsize = 0;
if (object->name)
memsize += strlen (object->name) + 1;
return memsize;
return memsize + gimp_g_object_get_memsize ((GObject *) object);
}
/* Generated data ends here */

13
libgimpproxy/gimpobject.h
View File

@ -55,14 +55,15 @@ struct _GimpObjectClass
};
GType gimp_object_get_type (void) G_GNUC_CONST;
GType gimp_object_get_type (void) G_GNUC_CONST;
void gimp_object_set_name (GimpObject *object,
const gchar *name);
const gchar * gimp_object_get_name (const GimpObject *object);
void gimp_object_name_changed (GimpObject *object);
void gimp_object_set_name (GimpObject *object,
const gchar *name);
const gchar * gimp_object_get_name (const GimpObject *object);
void gimp_object_name_changed (GimpObject *object);
gsize gimp_object_get_memsize (GimpObject *object);
gsize gimp_object_get_memsize (GimpObject *object);
gsize gimp_g_object_get_memsize (GObject *object);
#endif /* __GIMP_OBJECT_H__ */

60
libgimpwidgets/gimpcolordisplay.c
View File

@ -30,12 +30,21 @@
#include "gimpcolordisplay.h"
enum
{
CHANGED,
LAST_SIGNAL
};
static void gimp_color_display_class_init (GimpColorDisplayClass *klass);
static void gimp_color_display_init (GimpColorDisplay *display);
static GObjectClass *parent_class = NULL;
static guint display_signals[LAST_SIGNAL] = { 0 };
GType
gimp_color_display_get_type (void)
@ -70,12 +79,21 @@ gimp_color_display_class_init (GimpColorDisplayClass *klass)
{
parent_class = g_type_class_peek_parent (klass);
klass->clone = NULL;
klass->convert = NULL;
klass->load_state = NULL;
klass->save_state = NULL;
klass->configure = NULL;
klass->configure_cancel = NULL;
display_signals[CHANGED] =
g_signal_new ("changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpColorDisplayClass, changed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
klass->clone = NULL;
klass->convert = NULL;
klass->load_state = NULL;
klass->save_state = NULL;
klass->configure = NULL;
klass->configure_reset = NULL;
}
static void
@ -145,26 +163,30 @@ gimp_color_display_save_state (GimpColorDisplay *display)
return NULL;
}
void
gimp_color_display_configure (GimpColorDisplay *display,
GFunc ok_func,
gpointer ok_data,
GFunc cancel_func,
gpointer cancel_data)
GtkWidget *
gimp_color_display_configure (GimpColorDisplay *display)
{
g_return_if_fail (GIMP_IS_COLOR_DISPLAY (display));
g_return_val_if_fail (GIMP_IS_COLOR_DISPLAY (display), NULL);
if (GIMP_COLOR_DISPLAY_GET_CLASS (display)->configure)
GIMP_COLOR_DISPLAY_GET_CLASS (display)->configure (display,
ok_func, ok_data,
cancel_func, cancel_data);
return GIMP_COLOR_DISPLAY_GET_CLASS (display)->configure (display);
return NULL;
}
void
gimp_color_display_configure_cancel (GimpColorDisplay *display)
gimp_color_display_configure_reset (GimpColorDisplay *display)
{
g_return_if_fail (GIMP_IS_COLOR_DISPLAY (display));
if (GIMP_COLOR_DISPLAY_GET_CLASS (display)->configure_cancel)
GIMP_COLOR_DISPLAY_GET_CLASS (display)->configure_cancel (display);
if (GIMP_COLOR_DISPLAY_GET_CLASS (display)->configure_reset)
GIMP_COLOR_DISPLAY_GET_CLASS (display)->configure_reset (display);
}
void
gimp_color_display_changed (GimpColorDisplay *display)
{
g_return_if_fail (GIMP_IS_COLOR_DISPLAY (display));
g_signal_emit (G_OBJECT (display), display_signals[CHANGED], 0);
}

64
libgimpwidgets/gimpcolordisplay.h
View File

@ -47,46 +47,42 @@ struct _GimpColorDisplayClass
const gchar *help_page;
/* virtual functions */
GimpColorDisplay * (* clone) (GimpColorDisplay *display);
void (* convert) (GimpColorDisplay *display,
guchar *buf,
gint width,
gint height,
gint bpp,
gint bpl);
GimpColorDisplay * (* clone) (GimpColorDisplay *display);
void (* convert) (GimpColorDisplay *display,
guchar *buf,
gint width,
gint height,
gint bpp,
gint bpl);
void (* load_state) (GimpColorDisplay *display,
GimpParasite *state);
GimpParasite * (* save_state) (GimpColorDisplay *display);
GtkWidget * (* configure) (GimpColorDisplay *display);
void (* configure_reset) (GimpColorDisplay *display);
void (* load_state) (GimpColorDisplay *display,
GimpParasite *state);
GimpParasite * (* save_state) (GimpColorDisplay *display);
void (* configure) (GimpColorDisplay *display,
GFunc ok_func,
gpointer ok_data,
GFunc cancel_func,
gpointer cancel_data);
void (* configure_cancel) (GimpColorDisplay *display);
/* signals */
void (* changed) (GimpColorDisplay *display);
};
GType gimp_color_display_get_type (void) G_GNUC_CONST;
GimpColorDisplay * gimp_color_display_new (GType display_type);
GType gimp_color_display_get_type (void) G_GNUC_CONST;
GimpColorDisplay * gimp_color_display_new (GType display_type);
GimpColorDisplay * gimp_color_display_clone (GimpColorDisplay *display);
GimpColorDisplay * gimp_color_display_clone (GimpColorDisplay *display);
void gimp_color_display_convert (GimpColorDisplay *display,
guchar *buf,
gint width,
gint height,
gint bpp,
gint bpl);
void gimp_color_display_load_state (GimpColorDisplay *display,
GimpParasite *state);
GimpParasite * gimp_color_display_save_state (GimpColorDisplay *display);
void gimp_color_display_configure (GimpColorDisplay *display,
GFunc ok_func,
gpointer ok_data,
GFunc cancel_func,
gpointer cancel_data);
void gimp_color_display_configure_cancel (GimpColorDisplay *display);
void gimp_color_display_convert (GimpColorDisplay *display,
guchar *buf,
gint width,
gint height,
gint bpp,
gint bpl);
void gimp_color_display_load_state (GimpColorDisplay *display,
GimpParasite *state);
GimpParasite * gimp_color_display_save_state (GimpColorDisplay *display);
GtkWidget * gimp_color_display_configure (GimpColorDisplay *display);
void gimp_color_display_configure_reset (GimpColorDisplay *display);
void gimp_color_display_changed (GimpColorDisplay *display);
G_END_DECLS

142
modules/cdisplay_gamma.c
View File

@ -30,6 +30,9 @@
#include "libgimp/gimpintl.h"
#define DEFAULT_GAMMA 1.0
#define CDISPLAY_TYPE_GAMMA (cdisplay_gamma_type)
#define CDISPLAY_GAMMA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CDISPLAY_TYPE_GAMMA, CdisplayGamma))
#define CDISPLAY_GAMMA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CDISPLAY_TYPE_GAMMA, CdisplayGammaClass))
@ -44,16 +47,11 @@ struct _CdisplayGamma
{
GimpColorDisplay parent_instance;
GFunc ok_func;
gpointer ok_data;
GFunc cancel_func;
gpointer cancel_data;
gdouble gamma;
guchar *lookup;
GtkWidget *shell;
GtkWidget *spinner;
GtkWidget *hbox;
GtkObject *adjustment;
};
struct _CdisplayGammaClass
@ -78,17 +76,11 @@ static void cdisplay_gamma_convert (GimpColorDisplay *display,
static void cdisplay_gamma_load_state (GimpColorDisplay *display,
GimpParasite *state);
static GimpParasite * cdisplay_gamma_save_state (GimpColorDisplay *display);
static void cdisplay_gamma_configure (GimpColorDisplay *display,
GFunc ok_func,
gpointer ok_data,
GFunc cancel_func,
gpointer cancel_data);
static void cdisplay_gamma_configure_cancel (GimpColorDisplay *display);
static GtkWidget * cdisplay_gamma_configure (GimpColorDisplay *display);
static void cdisplay_gamma_configure_reset (GimpColorDisplay *display);
static void gamma_create_lookup_table (CdisplayGamma *gamma);
static void gamma_configure_ok_callback (GtkWidget *widget,
CdisplayGamma *gamma);
static void gamma_configure_cancel_callback (GtkWidget *widget,
static void gamma_configure_adj_callback (GtkAdjustment *adj,
CdisplayGamma *gamma);
@ -158,16 +150,16 @@ cdisplay_gamma_class_init (CdisplayGammaClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = cdisplay_gamma_finalize;
object_class->finalize = cdisplay_gamma_finalize;
display_class->name = _("Gamma");
display_class->help_page = "modules/gamma.html";
display_class->clone = cdisplay_gamma_clone;
display_class->convert = cdisplay_gamma_convert;
display_class->load_state = cdisplay_gamma_load_state;
display_class->save_state = cdisplay_gamma_save_state;
display_class->configure = cdisplay_gamma_configure;
display_class->configure_cancel = cdisplay_gamma_configure_cancel;
display_class->name = _("Gamma");
display_class->help_page = "modules/gamma.html";
display_class->clone = cdisplay_gamma_clone;
display_class->convert = cdisplay_gamma_convert;
display_class->load_state = cdisplay_gamma_load_state;
display_class->save_state = cdisplay_gamma_save_state;
display_class->configure = cdisplay_gamma_configure;
display_class->configure_reset = cdisplay_gamma_configure_reset;
}
static void
@ -175,7 +167,7 @@ cdisplay_gamma_init (CdisplayGamma *gamma)
{
gint i;
gamma->gamma = 1.0;
gamma->gamma = DEFAULT_GAMMA;
gamma->lookup = g_new (guchar, 256);
for (i = 0; i < 256; i++)
@ -189,11 +181,8 @@ cdisplay_gamma_finalize (GObject *object)
gamma = CDISPLAY_GAMMA (object);
if (gamma->shell)
{
gtk_widget_destroy (gamma->shell);
gamma->shell = NULL;
}
if (gamma->hbox)
gtk_widget_destroy (gamma->hbox);
if (gamma->lookup)
{
@ -309,74 +298,47 @@ cdisplay_gamma_save_state (GimpColorDisplay *display)
sizeof (double), &buf);
}
static void
cdisplay_gamma_configure (GimpColorDisplay *display,
GFunc ok_func,
gpointer ok_data,
GFunc cancel_func,
gpointer cancel_data)
static GtkWidget *
cdisplay_gamma_configure (GimpColorDisplay *display)
{
CdisplayGamma *gamma;
GtkWidget *hbox;
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *spinbutton;
gamma = CDISPLAY_GAMMA (display);
if (!gamma->shell)
{
gamma->ok_func = ok_func;
gamma->ok_data = ok_data;
gamma->cancel_func = cancel_func;
gamma->cancel_data = cancel_data;
if (gamma->hbox)
gtk_widget_destroy (gamma->hbox);
gamma->shell =
gimp_dialog_new (_("Gamma"), "gamma",
gimp_standard_help_func, "modules/gamma.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
gamma->hbox = gtk_hbox_new (FALSE, 4);
g_object_add_weak_pointer (G_OBJECT (gamma->hbox), (gpointer) &gamma->hbox);
GTK_STOCK_CANCEL, gamma_configure_cancel_callback,
gamma, NULL, NULL, FALSE, TRUE,
label = gtk_label_new ( _("Gamma:"));
gtk_box_pack_start (GTK_BOX (gamma->hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
GTK_STOCK_OK, gamma_configure_ok_callback,
gamma, NULL, NULL, TRUE, FALSE,
spinbutton = gimp_spin_button_new (&gamma->adjustment,
gamma->gamma, 0.01, 10.0, 0.01, 0.1, 0.0,
0.1, 3);
gtk_box_pack_start (GTK_BOX (gamma->hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
NULL);
g_signal_connect (G_OBJECT (gamma->adjustment), "value_changed",
G_CALLBACK (gamma_configure_adj_callback),
gamma);
hbox = gtk_hbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (gamma->shell)->vbox),
hbox, FALSE, FALSE, 0);
label = gtk_label_new ( _("Gamma:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
adjustment = gtk_adjustment_new (gamma->gamma, 0.01, 10.0, 0.01, 0.1, 0.0);
gamma->spinner = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment),
0.1, 3);
gtk_box_pack_start (GTK_BOX (hbox), gamma->spinner, FALSE, FALSE, 0);
}
gtk_widget_show_all (gamma->shell);
return gamma->hbox;
}
static void
cdisplay_gamma_configure_cancel (GimpColorDisplay *display)
cdisplay_gamma_configure_reset (GimpColorDisplay *display)
{
CdisplayGamma *gamma;
gamma = CDISPLAY_GAMMA (display);
if (gamma->shell)
{
gtk_widget_destroy (gamma->shell);
gamma->shell = NULL;
}
if (gamma->cancel_func)
gamma->cancel_func (gamma, gamma->cancel_data);
if (gamma->adjustment)
gtk_adjustment_set_value (GTK_ADJUSTMENT (gamma->adjustment), DEFAULT_GAMMA);
}
static void
@ -399,24 +361,12 @@ gamma_create_lookup_table (CdisplayGamma *gamma)
}
static void
gamma_configure_ok_callback (GtkWidget *widget,
CdisplayGamma *gamma)
gamma_configure_adj_callback (GtkAdjustment *adj,
CdisplayGamma *gamma)
{
gamma->gamma =
gtk_spin_button_get_value (GTK_SPIN_BUTTON (gamma->spinner));
gamma->gamma = adj->value;
gamma_create_lookup_table (gamma);
gtk_widget_destroy (GTK_WIDGET (gamma->shell));
gamma->shell = NULL;
if (gamma->ok_func)
gamma->ok_func (gamma, gamma->ok_data);
}
static void
gamma_configure_cancel_callback (GtkWidget *widget,
CdisplayGamma *gamma)
{
gimp_color_display_configure_cancel (GIMP_COLOR_DISPLAY (gamma));
gimp_color_display_changed (GIMP_COLOR_DISPLAY (gamma));
}

147
modules/cdisplay_highcontrast.c
View File

@ -30,6 +30,9 @@
#include "libgimp/gimpintl.h"
#define DEFAULT_CONTRAST 4.0
#define CDISPLAY_TYPE_CONTRAST (cdisplay_contrast_type)
#define CDISPLAY_CONTRAST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CDISPLAY_TYPE_CONTRAST, CdisplayContrast))
#define CDISPLAY_CONTRAST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CDISPLAY_TYPE_CONTRAST, CdisplayContrastClass))
@ -44,16 +47,11 @@ struct _CdisplayContrast
{
GimpColorDisplay parent_instance;
GFunc ok_func;
gpointer ok_data;
GFunc cancel_func;
gpointer cancel_data;
gdouble contrast;
guchar *lookup;
GtkWidget *shell;
GtkWidget *spinner;
GtkWidget *hbox;
GtkObject *adjustment;
};
struct _CdisplayContrastClass
@ -78,18 +76,12 @@ static void cdisplay_contrast_convert (GimpColorDisplay *display,
static void cdisplay_contrast_load_state (GimpColorDisplay *display,
GimpParasite *state);
static GimpParasite * cdisplay_contrast_save_state (GimpColorDisplay *display);
static void cdisplay_contrast_configure (GimpColorDisplay *display,
GFunc ok_func,
gpointer ok_data,
GFunc cancel_func,
gpointer cancel_data);
static void cdisplay_contrast_configure_cancel (GimpColorDisplay *display);
static GtkWidget * cdisplay_contrast_configure (GimpColorDisplay *display);
static void cdisplay_contrast_configure_reset (GimpColorDisplay *display);
static void contrast_create_lookup_table (CdisplayContrast *contrast);
static void contrast_configure_ok_callback (GtkWidget *widget,
CdisplayContrast *contrast);
static void contrast_configure_cancel_callback (GtkWidget *widget,
CdisplayContrast *contrast);
static void contrast_configure_adj_callback (GtkAdjustment *adj,
CdisplayContrast *contrast);
static const GimpModuleInfo cdisplay_contrast_info =
@ -158,22 +150,22 @@ cdisplay_contrast_class_init (CdisplayContrastClass *klass)
parent_class = g_type_class_peek_parent (klass);
object_class->finalize = cdisplay_contrast_finalize;
object_class->finalize = cdisplay_contrast_finalize;
display_class->name = _("Contrast");
display_class->help_page = "modules/contrast.html";
display_class->clone = cdisplay_contrast_clone;
display_class->convert = cdisplay_contrast_convert;
display_class->load_state = cdisplay_contrast_load_state;
display_class->save_state = cdisplay_contrast_save_state;
display_class->configure = cdisplay_contrast_configure;
display_class->configure_cancel = cdisplay_contrast_configure_cancel;
display_class->name = _("Contrast");
display_class->help_page = "modules/contrast.html";
display_class->clone = cdisplay_contrast_clone;
display_class->convert = cdisplay_contrast_convert;
display_class->load_state = cdisplay_contrast_load_state;
display_class->save_state = cdisplay_contrast_save_state;
display_class->configure = cdisplay_contrast_configure;
display_class->configure_reset = cdisplay_contrast_configure_reset;
}
static void
cdisplay_contrast_init (CdisplayContrast *contrast)
{
contrast->contrast = 4.0;
contrast->contrast = DEFAULT_CONTRAST;
contrast->lookup = g_new (guchar, 256);
contrast_create_lookup_table (contrast);
@ -186,11 +178,8 @@ cdisplay_contrast_finalize (GObject *object)
contrast = CDISPLAY_CONTRAST (object);
if (contrast->shell)
{
gtk_widget_destroy (contrast->shell);
contrast->shell = NULL;
}
if (contrast->hbox)
gtk_widget_destroy (contrast->hbox);
if (contrast->lookup)
{
@ -306,74 +295,50 @@ cdisplay_contrast_save_state (GimpColorDisplay *display)
sizeof (double), &buf);
}
static void
cdisplay_contrast_configure (GimpColorDisplay *display,
GFunc ok_func,
gpointer ok_data,
GFunc cancel_func,
gpointer cancel_data)
static GtkWidget *
cdisplay_contrast_configure (GimpColorDisplay *display)
{
CdisplayContrast *contrast;
GtkWidget *hbox;
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *spinbutton;
contrast = CDISPLAY_CONTRAST (display);
if (!contrast->shell)
{
contrast->ok_func = ok_func;
contrast->ok_data = ok_data;
contrast->cancel_func = cancel_func;
contrast->cancel_data = cancel_data;
if (contrast->hbox)
gtk_widget_destroy (contrast->hbox);
contrast->shell =
gimp_dialog_new (_("High Contrast"), "high_contrast",
gimp_standard_help_func, "modules/highcontrast.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
contrast->hbox = gtk_hbox_new (FALSE, 2);
g_object_add_weak_pointer (G_OBJECT (contrast->hbox),
(gpointer) &contrast->hbox);
GTK_STOCK_CANCEL, contrast_configure_cancel_callback,
contrast, NULL, NULL, FALSE, TRUE,
label = gtk_label_new ( _("Contrast Cycles:"));
gtk_box_pack_start (GTK_BOX (contrast->hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
GTK_STOCK_OK, contrast_configure_ok_callback,
contrast, NULL, NULL, TRUE, FALSE,
spinbutton = gimp_spin_button_new (&contrast->adjustment,
contrast->contrast,
0.01, 10.0, 0.01, 0.1, 0.0,
0.1, 3);
gtk_box_pack_start (GTK_BOX (contrast->hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
NULL);
g_signal_connect (G_OBJECT (contrast->adjustment), "value_changed",
G_CALLBACK (contrast_configure_adj_callback),
contrast);
hbox = gtk_hbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (contrast->shell)->vbox),
hbox, FALSE, FALSE, 0);
label = gtk_label_new ( _("Contrast Cycles:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
adjustment = gtk_adjustment_new (contrast->contrast, 0.01, 10.0, 0.01, 0.1, 0.0);
contrast->spinner = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment),
0.1, 3);
gtk_box_pack_start (GTK_BOX (hbox), contrast->spinner, FALSE, FALSE, 0);
}
gtk_widget_show_all (contrast->shell);
return contrast->hbox;
}
static void
cdisplay_contrast_configure_cancel (GimpColorDisplay *display)
cdisplay_contrast_configure_reset (GimpColorDisplay *display)
{
CdisplayContrast *contrast;
contrast = CDISPLAY_CONTRAST (display);
if (contrast->shell)
{
gtk_widget_destroy (contrast->shell);
contrast->shell = NULL;
}
if (contrast->cancel_func)
contrast->cancel_func (contrast, contrast->cancel_data);
if (contrast->adjustment)
gtk_adjustment_set_value (GTK_ADJUSTMENT (contrast->adjustment),
DEFAULT_CONTRAST);
}
static void
@ -392,24 +357,12 @@ contrast_create_lookup_table (CdisplayContrast *contrast)
}
static void
contrast_configure_ok_callback (GtkWidget *widget,
CdisplayContrast *contrast)
contrast_configure_adj_callback (GtkAdjustment *adj,
CdisplayContrast *contrast)
{
contrast->contrast =
gtk_spin_button_get_value (GTK_SPIN_BUTTON (contrast->spinner));
contrast->contrast = adj->value;
contrast_create_lookup_table (contrast);
gtk_widget_destroy (GTK_WIDGET (contrast->shell));
contrast->shell = NULL;
if (contrast->ok_func)
contrast->ok_func (contrast, contrast->ok_data);
}
static void
contrast_configure_cancel_callback (GtkWidget *widget,
CdisplayContrast *contrast)
{
gimp_color_display_configure_cancel (GIMP_COLOR_DISPLAY (contrast));
gimp_color_display_changed (GIMP_COLOR_DISPLAY (contrast));
}

2
modules/colorsel_triangle.c
View File

@ -107,7 +107,7 @@ static gboolean colorsel_triangle_event (GtkWidget *widget,
static const GimpModuleInfo colorsel_triangle_info =
{
N_("Painter-style color selector as a pluggable color selector"),
N_("Painter-style triangle color selector"),
"Simon Budig <Simon.Budig@unix-ag.org>",
"v0.03",
"(c) 1999, released under the GPL",

27
modules/colorsel_water.c
View File

@ -104,7 +104,7 @@ static void pressure_adjust_update (GtkAdjustment *adj,
static const GimpModuleInfo colorsel_water_info =
{
N_("Watercolor style color selector as a pluggable module"),
N_("Watercolor style color selector"),
"Raph Levien <raph@acm.org>, Sven Neumann <sven@gimp.org>",
"v0.3",
"(c) 1998-1999, released under the GPL",
@ -289,22 +289,6 @@ colorsel_water_update (ColorselWater *water)
&water->rgb, &hsv);
}
static gdouble
calc (gdouble x,
gdouble y,
@ -318,7 +302,6 @@ calc (gdouble x,
return 128 + (x - (IMAGE_SIZE >> 1)) * c - (y - (IMAGE_SIZE >> 1)) * s;
}
/* Initialize the preview */
static void
select_area_draw (GtkWidget *preview)
@ -352,7 +335,6 @@ select_area_draw (GtkWidget *preview)
}
}
static void
add_pigment (ColorselWater *colorsel,
gboolean erase,
@ -364,7 +346,7 @@ add_pigment (ColorselWater *colorsel,
much *= (gdouble) colorsel->pressure_adjust;
if (erase)
if (erase)
{
colorsel->rgb.r = 1 - (1 - colorsel->rgb.r) * (1 - much);
colorsel->rgb.g = 1 - (1 - colorsel->rgb.g) * (1 - much);
@ -429,7 +411,10 @@ button_press_event (GtkWidget *widget,
water->last_x = event->x;
water->last_y = event->y;
water->last_pressure = 1.0; /* FIXME: event->pressure */
water->last_pressure = 0.5;
gdk_event_get_axis ((GdkEvent *) event, GDK_AXIS_PRESSURE,
&water->last_pressure);
water->button_state |= 1 << event->button;