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

added the datafile loader_func typedefs. 

2001-02-11  Michael Natterer  <mitch@gimp.org>

	* app/apptypes.h: added the datafile loader_func typedefs.

	* app/datafiles.h: removed from here.

	* app/gimpcontainer.[ch]: emit "freeze" and "thaw" signals to get
	rid of those blah_select_[freeze|thaw]_all() stuff.

	* app/gimpdatalist.[ch]: new function gimp_data_list_load() which
	takes a va_list of GimpDataObjectLoaderFuncs and file extensions
	and is almost a replacement for the four files below.

	* app/brushes.c
	* app/gradients.c
	* app/palettes.c
	* app/patterns.c: very simple now. It may be worth thinking about
	making all GimpData subclasses managed by a descriptive array in
	the context_manager.
This commit is contained in:
Michael Natterer 2001-02-11 21:08:04 +00:00 committed by Michael Natterer
parent 68216c6ff9
commit 6fc9702bb3
17 changed files with 454 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
ChangeLog
View File

@ -1,3 +1,23 @@
2001-02-11 Michael Natterer <mitch@gimp.org>
* app/apptypes.h: added the datafile loader_func typedefs.
* app/datafiles.h: removed from here.
* app/gimpcontainer.[ch]: emit "freeze" and "thaw" signals to get
rid of those blah_select_[freeze|thaw]_all() stuff.
* app/gimpdatalist.[ch]: new function gimp_data_list_load() which
takes a va_list of GimpDataObjectLoaderFuncs and file extensions
and is almost a replacement for the four files below.
* app/brushes.c
* app/gradients.c
* app/palettes.c
* app/patterns.c: very simple now. It may be worth thinking about
making all GimpData subclasses managed by a descriptive array in
the context_manager.
2001-02-11 Michael Natterer <mitch@gimp.org>
Made a GimpContainer out of the palette list:

24
app/apptypes.h
View File

@ -173,19 +173,23 @@ typedef GSList PathUndo;
/* functions */
typedef void (* TileValidateProc) (TileManager *tm,
Tile *tile);
typedef void (* TileValidateProc) (TileManager *tm,
Tile *tile);
typedef void (* ToolOptionsResetFunc) (void);
typedef void (* ToolOptionsResetFunc) (void);
typedef void (* GimpProgressFunc) (gint min,
gint max,
gint current,
gpointer data);
typedef void (* GimpProgressFunc) (gint min,
gint max,
gint current,
gpointer data);
typedef void (* ImageMapApplyFunc) (PixelRegion *srcPR,
PixelRegion *destPR,
gpointer data);
typedef void (* ImageMapApplyFunc) (PixelRegion *srcPR,
PixelRegion *destPR,
gpointer data);
typedef void (* GimpDataFileLoaderFunc) (const gchar *filename,
gpointer loader_data);
typedef GimpData * (* GimpDataObjectLoaderFunc) (const gchar *filename);
#endif /* __APPTYPES_H__ */

87
app/brushes.c
View File

@ -18,33 +18,18 @@
#include "config.h"
#include <string.h>
#include <sys/types.h>
#include <gtk/gtk.h>
#include "apptypes.h"
#include "brush_select.h"
#include "brushes.h"
#include "gimpbrush.h"
#include "gimpbrushgenerated.h"
#include "gimpbrushpipe.h"
#include "brush_header.h"
#include "brush_select.h"
#include "datafiles.h"
#include "gimpcontext.h"
#include "gimprc.h"
#include "gimplist.h"
#include "gimpbrush.h"
#include "gimpdatalist.h"
#include "libgimp/gimpenv.h"
#include "libgimp/gimpintl.h"
/* local function prototypes */
static void brushes_brush_load (const gchar *filename,
gpointer loader_data);
#include "gimprc.h"
/* global variables */
@ -63,13 +48,33 @@ brushes_init (gboolean no_data)
if (brush_path != NULL && !no_data)
{
gchar *common_brush_path;
brush_select_freeze_all ();
datafiles_read_directories (brush_path, 0,
brushes_brush_load, global_brush_list);
common_brush_path = g_strconcat (brush_path,
G_SEARCHPATH_SEPARATOR_S,
brush_vbr_path,
NULL);
datafiles_read_directories (brush_vbr_path, 0,
brushes_brush_load, global_brush_list);
gimp_data_list_load (GIMP_DATA_LIST (global_brush_list),
common_brush_path,
(GimpDataObjectLoaderFunc) gimp_brush_load,
GIMP_BRUSH_FILE_EXTENSION,
(GimpDataObjectLoaderFunc) gimp_brush_load,
GIMP_BRUSH_PIXMAP_FILE_EXTENSION,
(GimpDataObjectLoaderFunc) gimp_brush_generated_load,
GIMP_BRUSH_GENERATED_FILE_EXTENSION,
(GimpDataObjectLoaderFunc) gimp_brush_pipe_load,
GIMP_BRUSH_PIPE_FILE_EXTENSION,
NULL);
g_free (common_brush_path);
brush_select_thaw_all ();
}
@ -112,41 +117,3 @@ brushes_get_standard_brush (void)
return standard_brush;
}
/* private functions */
static void
brushes_brush_load (const gchar *filename,
gpointer loader_data)
{
GimpBrush *brush = NULL;
if (datafiles_check_extension (filename, GIMP_BRUSH_FILE_EXTENSION) ||
datafiles_check_extension (filename, GIMP_BRUSH_PIXMAP_FILE_EXTENSION))
{
brush = gimp_brush_load (filename);
if (! brush)
g_message (_("Warning: Failed to load brush\n\"%s\""), filename);
}
else if (datafiles_check_extension (filename,
GIMP_BRUSH_GENERATED_FILE_EXTENSION))
{
brush = gimp_brush_generated_load (filename);
if (! brush)
g_message (_("Warning: Failed to load brush\n\"%s\""), filename);
}
else if (datafiles_check_extension (filename,
GIMP_BRUSH_PIPE_FILE_EXTENSION))
{
brush = gimp_brush_pipe_load (filename);
if (! brush)
g_message (_("Warning: Failed to load brush pipe\n\"%s\""), filename);
}
if (brush)
gimp_container_add (GIMP_CONTAINER (loader_data), GIMP_OBJECT (brush));
}

43
app/core/gimpcontainer.c
View File

@ -45,6 +45,8 @@ enum
GET_CHILD_BY_NAME,
GET_CHILD_BY_INDEX,
GET_CHILD_INDEX,
FREEZE,
THAW,
LAST_SIGNAL
};
@ -58,7 +60,8 @@ static void gimp_container_child_destroy_callback (GtkObject *object,
gpointer data);
static guint container_signals[LAST_SIGNAL] = { 0 };
static guint container_signals[LAST_SIGNAL] = { 0 };
static GimpObjectClass *parent_class = NULL;
@ -177,6 +180,24 @@ gimp_container_class_init (GimpContainerClass* klass)
GTK_TYPE_INT, 1,
GIMP_TYPE_OBJECT);
container_signals[FREEZE] =
gtk_signal_new ("freeze",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
freeze),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
container_signals[THAW] =
gtk_signal_new ("thaw",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
thaw),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, container_signals, LAST_SIGNAL);
object_class->destroy = gimp_container_destroy;
@ -188,6 +209,8 @@ gimp_container_class_init (GimpContainerClass* klass)
klass->get_child_by_name = NULL;
klass->get_child_by_index = NULL;
klass->get_child_index = NULL;
klass->freeze = NULL;
klass->thaw = NULL;
}
static void
@ -437,6 +460,24 @@ gimp_container_get_child_index (const GimpContainer *container,
return index;
}
void
gimp_container_freeze (GimpContainer *container)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GIMP_IS_CONTAINER (container));
gtk_signal_emit (GTK_OBJECT (container), container_signals[FREEZE]);
}
void
gimp_container_thaw (GimpContainer *container)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GIMP_IS_CONTAINER (container));
gtk_signal_emit (GTK_OBJECT (container), container_signals[THAW]);
}
static void
gimp_container_add_handler_foreach_func (GimpObject *object,
GimpContainerHandler *handler)

5
app/core/gimpcontainer.h
View File

@ -71,6 +71,8 @@ struct _GimpContainerClass
gint index);
gint (* get_child_index) (GimpContainer *container,
GimpObject *object);
void (* freeze) (GimpContainer *container);
void (* thaw) (GimpContainer *container);
};
@ -98,6 +100,9 @@ GimpObject * gimp_container_get_child_by_index (const GimpContainer *container,
gint gimp_container_get_child_index (const GimpContainer *container,
const GimpObject *object);
void gimp_container_freeze (GimpContainer *container);
void gimp_container_thaw (GimpContainer *container);
GQuark gimp_container_add_handler (GimpContainer *container,
const gchar *signame,
GtkSignalFunc handler,

4
app/core/gimpdatafiles.h
View File

@ -24,15 +24,13 @@
#include <time.h>
typedef enum
{
INCLUDE_TEMP_DIR = 1 << 0,
MODE_EXECUTABLE = 1 << 1
} GimpDataFileFlags;
typedef void (* GimpDataFileLoaderFunc) (const gchar *filename,
gpointer loader_data);
gboolean datafiles_check_extension (const gchar *filename,
const gchar *extension);

125
app/core/gimpdatalist.c
View File

@ -28,9 +28,12 @@
#include "apptypes.h"
#include "appenv.h"
#include "datafiles.h"
#include "gimpdata.h"
#include "gimpdatalist.h"
#include "libgimp/gimpintl.h"
static void gimp_data_list_class_init (GimpDataListClass *klass);
static void gimp_data_list_init (GimpDataList *list);
@ -142,6 +145,124 @@ gimp_data_list_new (GtkType children_type)
return list;
}
typedef struct _GimpDataListLoaderData GimpDataListLoaderData;
struct _GimpDataListLoaderData
{
GimpDataList *data_list;
GSList *loader_funcs;
GSList *extensions;
};
void
gimp_data_list_load_callback (const gchar *filename,
gpointer callback_data)
{
GimpDataListLoaderData *loader_data;
GSList *func_list;
GSList *ext_list;
GimpDataObjectLoaderFunc loader_func;
const gchar *extension;
loader_data = (GimpDataListLoaderData *) callback_data;
for (func_list = loader_data->loader_funcs, ext_list = loader_data->extensions;
func_list && ext_list;
func_list = func_list->next, ext_list = ext_list->next)
{
loader_func = (GimpDataObjectLoaderFunc) func_list->data;
extension = (const gchar *) ext_list->data;
if (extension)
{
if (datafiles_check_extension (filename, extension))
{
goto insert;
}
}
else
{
g_warning ("%s(): trying legacy loader on file with unknown "
"extension: %s",
G_GNUC_FUNCTION, filename);
goto insert;
}
}
return;
insert:
{
GimpData *data;
data = (GimpData *) (* loader_func) (filename);
if (! data)
g_message (_("Warning: Failed to load data from\n\"%s\""), filename);
else
gimp_container_add (GIMP_CONTAINER (loader_data->data_list),
GIMP_OBJECT (data));
}
}
void
gimp_data_list_load (GimpDataList *data_list,
const gchar *data_path,
GimpDataObjectLoaderFunc loader_func,
const gchar *extension,
...)
{
GimpDataListLoaderData *loader_data;
va_list args;
g_return_if_fail (data_list != NULL);
g_return_if_fail (GIMP_IS_DATA_LIST (data_list));
g_return_if_fail (data_path != NULL);
g_return_if_fail (loader_func != NULL);
loader_data = g_new0 (GimpDataListLoaderData, 1);
loader_data->data_list = data_list;
loader_data->loader_funcs = g_slist_append (loader_data->loader_funcs,
loader_func);
loader_data->extensions = g_slist_append (loader_data->extensions,
(gpointer) extension);
va_start (args, extension);
while (extension)
{
loader_func = va_arg (args, GimpDataObjectLoaderFunc);
if (loader_func)
{
extension = va_arg (args, const gchar *);
loader_data->loader_funcs = g_slist_append (loader_data->loader_funcs,
loader_func);
loader_data->extensions = g_slist_append (loader_data->extensions,
(gpointer) extension);
}
else
{
extension = NULL;
}
}
va_end (args);
gimp_container_freeze (GIMP_CONTAINER (data_list));
datafiles_read_directories (data_path, 0,
gimp_data_list_load_callback, loader_data);
gimp_container_thaw (GIMP_CONTAINER (data_list));
g_slist_free (loader_data->loader_funcs);
g_slist_free (loader_data->extensions);
g_free (loader_data);
}
void
gimp_data_list_save_and_clear (GimpDataList *data_list,
const gchar *data_path,
@ -154,6 +275,8 @@ gimp_data_list_save_and_clear (GimpDataList *data_list,
list = GIMP_LIST (data_list);
gimp_container_freeze (GIMP_CONTAINER (data_list));
while (list->list)
{
GimpData *data;
@ -171,6 +294,8 @@ gimp_data_list_save_and_clear (GimpDataList *data_list,
gimp_container_remove (GIMP_CONTAINER (data_list), GIMP_OBJECT (data));
}
gimp_container_thaw (GIMP_CONTAINER (data_list));
}
static void

16
app/core/gimpdatalist.h
View File

@ -43,12 +43,18 @@ struct _GimpDataListClass
};
GtkType gimp_data_list_get_type (void);
GimpDataList * gimp_data_list_new (GtkType children_type);
GtkType gimp_data_list_get_type (void);
GimpDataList * gimp_data_list_new (GtkType children_type);
void gimp_data_list_save_and_clear (GimpDataList *data_liat,
const gchar *data_path,
const gchar *extension);
void gimp_data_list_load (GimpDataList *data_list,
const gchar *data_path,
GimpDataObjectLoaderFunc loader_func,
const gchar *extension,
...);
void gimp_data_list_save_and_clear (GimpDataList *data_list,
const gchar *data_path,
const gchar *extension);
#endif /* __GIMP_DATA_LIST_H__ */

4
app/datafiles.h
View File

@ -24,15 +24,13 @@
#include <time.h>
typedef enum
{
INCLUDE_TEMP_DIR = 1 << 0,
MODE_EXECUTABLE = 1 << 1
} GimpDataFileFlags;
typedef void (* GimpDataFileLoaderFunc) (const gchar *filename,
gpointer loader_data);
gboolean datafiles_check_extension (const gchar *filename,
const gchar *extension);

43
app/gimpcontainer.c
View File

@ -45,6 +45,8 @@ enum
GET_CHILD_BY_NAME,
GET_CHILD_BY_INDEX,
GET_CHILD_INDEX,
FREEZE,
THAW,
LAST_SIGNAL
};
@ -58,7 +60,8 @@ static void gimp_container_child_destroy_callback (GtkObject *object,
gpointer data);
static guint container_signals[LAST_SIGNAL] = { 0 };
static guint container_signals[LAST_SIGNAL] = { 0 };
static GimpObjectClass *parent_class = NULL;
@ -177,6 +180,24 @@ gimp_container_class_init (GimpContainerClass* klass)
GTK_TYPE_INT, 1,
GIMP_TYPE_OBJECT);
container_signals[FREEZE] =
gtk_signal_new ("freeze",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
freeze),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
container_signals[THAW] =
gtk_signal_new ("thaw",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpContainerClass,
thaw),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
gtk_object_class_add_signals (object_class, container_signals, LAST_SIGNAL);
object_class->destroy = gimp_container_destroy;
@ -188,6 +209,8 @@ gimp_container_class_init (GimpContainerClass* klass)
klass->get_child_by_name = NULL;
klass->get_child_by_index = NULL;
klass->get_child_index = NULL;
klass->freeze = NULL;
klass->thaw = NULL;
}
static void
@ -437,6 +460,24 @@ gimp_container_get_child_index (const GimpContainer *container,
return index;
}
void
gimp_container_freeze (GimpContainer *container)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GIMP_IS_CONTAINER (container));
gtk_signal_emit (GTK_OBJECT (container), container_signals[FREEZE]);
}
void
gimp_container_thaw (GimpContainer *container)
{
g_return_if_fail (container != NULL);
g_return_if_fail (GIMP_IS_CONTAINER (container));
gtk_signal_emit (GTK_OBJECT (container), container_signals[THAW]);
}
static void
gimp_container_add_handler_foreach_func (GimpObject *object,
GimpContainerHandler *handler)

5
app/gimpcontainer.h
View File

@ -71,6 +71,8 @@ struct _GimpContainerClass
gint index);
gint (* get_child_index) (GimpContainer *container,
GimpObject *object);
void (* freeze) (GimpContainer *container);
void (* thaw) (GimpContainer *container);
};
@ -98,6 +100,9 @@ GimpObject * gimp_container_get_child_by_index (const GimpContainer *container,
gint gimp_container_get_child_index (const GimpContainer *container,
const GimpObject *object);
void gimp_container_freeze (GimpContainer *container);
void gimp_container_thaw (GimpContainer *container);
GQuark gimp_container_add_handler (GimpContainer *container,
const gchar *signame,
GtkSignalFunc handler,

125
app/gimpdatalist.c
View File

@ -28,9 +28,12 @@
#include "apptypes.h"
#include "appenv.h"
#include "datafiles.h"
#include "gimpdata.h"
#include "gimpdatalist.h"
#include "libgimp/gimpintl.h"
static void gimp_data_list_class_init (GimpDataListClass *klass);
static void gimp_data_list_init (GimpDataList *list);
@ -142,6 +145,124 @@ gimp_data_list_new (GtkType children_type)
return list;
}
typedef struct _GimpDataListLoaderData GimpDataListLoaderData;
struct _GimpDataListLoaderData
{
GimpDataList *data_list;
GSList *loader_funcs;
GSList *extensions;
};
void
gimp_data_list_load_callback (const gchar *filename,
gpointer callback_data)
{
GimpDataListLoaderData *loader_data;
GSList *func_list;
GSList *ext_list;
GimpDataObjectLoaderFunc loader_func;
const gchar *extension;
loader_data = (GimpDataListLoaderData *) callback_data;
for (func_list = loader_data->loader_funcs, ext_list = loader_data->extensions;
func_list && ext_list;
func_list = func_list->next, ext_list = ext_list->next)
{
loader_func = (GimpDataObjectLoaderFunc) func_list->data;
extension = (const gchar *) ext_list->data;
if (extension)
{
if (datafiles_check_extension (filename, extension))
{
goto insert;
}
}
else
{
g_warning ("%s(): trying legacy loader on file with unknown "
"extension: %s",
G_GNUC_FUNCTION, filename);
goto insert;
}
}
return;
insert:
{
GimpData *data;
data = (GimpData *) (* loader_func) (filename);
if (! data)
g_message (_("Warning: Failed to load data from\n\"%s\""), filename);
else
gimp_container_add (GIMP_CONTAINER (loader_data->data_list),
GIMP_OBJECT (data));
}
}
void
gimp_data_list_load (GimpDataList *data_list,
const gchar *data_path,
GimpDataObjectLoaderFunc loader_func,
const gchar *extension,
...)
{
GimpDataListLoaderData *loader_data;
va_list args;
g_return_if_fail (data_list != NULL);
g_return_if_fail (GIMP_IS_DATA_LIST (data_list));
g_return_if_fail (data_path != NULL);
g_return_if_fail (loader_func != NULL);
loader_data = g_new0 (GimpDataListLoaderData, 1);
loader_data->data_list = data_list;
loader_data->loader_funcs = g_slist_append (loader_data->loader_funcs,
loader_func);
loader_data->extensions = g_slist_append (loader_data->extensions,
(gpointer) extension);
va_start (args, extension);
while (extension)
{
loader_func = va_arg (args, GimpDataObjectLoaderFunc);
if (loader_func)
{
extension = va_arg (args, const gchar *);
loader_data->loader_funcs = g_slist_append (loader_data->loader_funcs,
loader_func);
loader_data->extensions = g_slist_append (loader_data->extensions,
(gpointer) extension);
}
else
{
extension = NULL;
}
}
va_end (args);
gimp_container_freeze (GIMP_CONTAINER (data_list));
datafiles_read_directories (data_path, 0,
gimp_data_list_load_callback, loader_data);
gimp_container_thaw (GIMP_CONTAINER (data_list));
g_slist_free (loader_data->loader_funcs);
g_slist_free (loader_data->extensions);
g_free (loader_data);
}
void
gimp_data_list_save_and_clear (GimpDataList *data_list,
const gchar *data_path,
@ -154,6 +275,8 @@ gimp_data_list_save_and_clear (GimpDataList *data_list,
list = GIMP_LIST (data_list);
gimp_container_freeze (GIMP_CONTAINER (data_list));
while (list->list)
{
GimpData *data;
@ -171,6 +294,8 @@ gimp_data_list_save_and_clear (GimpDataList *data_list,
gimp_container_remove (GIMP_CONTAINER (data_list), GIMP_OBJECT (data));
}
gimp_container_thaw (GIMP_CONTAINER (data_list));
}
static void

16
app/gimpdatalist.h
View File

@ -43,12 +43,18 @@ struct _GimpDataListClass
};
GtkType gimp_data_list_get_type (void);
GimpDataList * gimp_data_list_new (GtkType children_type);
GtkType gimp_data_list_get_type (void);
GimpDataList * gimp_data_list_new (GtkType children_type);
void gimp_data_list_save_and_clear (GimpDataList *data_liat,
const gchar *data_path,
const gchar *extension);
void gimp_data_list_load (GimpDataList *data_list,
const gchar *data_path,
GimpDataObjectLoaderFunc loader_func,
const gchar *extension,
...);
void gimp_data_list_save_and_clear (GimpDataList *data_list,
const gchar *data_path,
const gchar *extension);
#endif /* __GIMP_DATA_LIST_H__ */

49
app/gradients.c
View File

@ -18,27 +18,16 @@
#include "config.h"
#include <string.h>
#include <gtk/gtk.h>
#include "apptypes.h"
#include "datafiles.h"
#include "gimpcontext.h"
#include "gimpdatalist.h"
#include "gimpgradient.h"
#include "gimprc.h"
#include "gradients.h"
#include "gradient_select.h"
#include "temp_buf.h"
#include "libgimp/gimpintl.h"
/* local function prototypes */
static void gradients_load_gradient (const gchar *filename,
gpointer loader_data);
#include "gradients.h"
/* global variables */
@ -60,8 +49,14 @@ gradients_init (gint no_data)
{
gradient_select_freeze_all ();
datafiles_read_directories (gradient_path, 0,
gradients_load_gradient, global_gradient_list);
gimp_data_list_load (GIMP_DATA_LIST (global_gradient_list),
gradient_path,
(GimpDataObjectLoaderFunc) gimp_gradient_load,
GIMP_GRADIENT_FILE_EXTENSION,
(GimpDataObjectLoaderFunc) gimp_gradient_load,
NULL /* legacy loader */);
gradient_select_thaw_all ();
}
@ -99,29 +94,3 @@ gradients_get_standard_gradient (void)
return standard_gradient;
}
/* private functions */
static void
gradients_load_gradient (const gchar *filename,
gpointer loader_data)
{
GimpGradient *gradient = NULL;
g_return_if_fail (filename != NULL);
if (! datafiles_check_extension (filename, GIMP_GRADIENT_FILE_EXTENSION))
{
g_warning ("%s(): trying old gradient file format on file with "
"unknown extension: %s",
G_GNUC_FUNCTION, filename);
}
gradient = gimp_gradient_load (filename);
if (! gradient)
g_message (_("Warning: Failed to load gradient\n\"%s\""), filename);
else
gimp_container_add (GIMP_CONTAINER (loader_data), GIMP_OBJECT (gradient));
}

44
app/palettes.c
View File

@ -22,7 +22,6 @@
#include "apptypes.h"
#include "datafiles.h"
#include "gimpcontext.h"
#include "gimpdatalist.h"
#include "gimppalette.h"
@ -31,13 +30,6 @@
#include "palette_select.h"
#include "palettes.h"
#include "libgimp/gimpintl.h"
/* local function prototypes */
static void palettes_load_palette (const gchar *filename,
gpointer loader_data);
/* global variables */
GimpContainer *global_palette_list = NULL;
@ -58,8 +50,14 @@ palettes_init (gboolean no_data)
{
palette_select_freeze_all ();
datafiles_read_directories (palette_path, 0,
palettes_load_palette, global_palette_list);
gimp_data_list_load (GIMP_DATA_LIST (global_palette_list),
palette_path,
(GimpDataObjectLoaderFunc) gimp_palette_load,
GIMP_PALETTE_FILE_EXTENSION,
(GimpDataObjectLoaderFunc) gimp_palette_load,
NULL /* legacy loader */);
palette_select_thaw_all ();
}
@ -96,29 +94,3 @@ palettes_get_standard_palette (void)
return standard_palette;
}
/* private functions */
static void
palettes_load_palette (const gchar *filename,
gpointer loader_data)
{
GimpPalette *palette;
g_return_if_fail (filename != NULL);
if (! datafiles_check_extension (filename, GIMP_PALETTE_FILE_EXTENSION))
{
g_warning ("%s(): trying old palette file format on file with "
"unknown extension: %s",
G_GNUC_FUNCTION, filename);
}
palette = gimp_palette_load (filename);
if (! palette)
g_message (_("Warning: Failed to load palette\n\"%s\""), filename);
else
gimp_container_add (GIMP_CONTAINER (loader_data), GIMP_OBJECT (palette));
}

42
app/patterns.c
View File

@ -18,14 +18,10 @@
#include "config.h"
#include <string.h>
#include <sys/types.h>
#include <gtk/gtk.h>
#include "apptypes.h"
#include "datafiles.h"
#include "gimpcontext.h"
#include "gimpdatalist.h"
#include "gimppattern.h"
@ -34,13 +30,6 @@
#include "pattern_select.h"
#include "temp_buf.h"
#include "libgimp/gimpintl.h"
/* local function prototypes */
static void patterns_load_pattern (const gchar *filename,
gpointer loader_data);
/* global variables */
GimpContainer *global_pattern_list = NULL;
@ -61,8 +50,13 @@ patterns_init (gboolean no_data)
{
pattern_select_freeze_all ();
datafiles_read_directories (pattern_path, 0,
patterns_load_pattern, global_pattern_list);
gimp_data_list_load (GIMP_DATA_LIST (global_pattern_list),
pattern_path,
(GimpDataObjectLoaderFunc) gimp_pattern_load,
GIMP_PATTERN_FILE_EXTENSION,
NULL);
pattern_select_thaw_all ();
}
@ -118,25 +112,3 @@ patterns_get_standard_pattern (void)
return standard_pattern;
}
/* private functions */
static void
patterns_load_pattern (const gchar *filename,
gpointer loader_data)
{
GimpPattern *pattern;
g_return_if_fail (filename != NULL);
if (datafiles_check_extension (filename, GIMP_PATTERN_FILE_EXTENSION))
{
pattern = gimp_pattern_load (filename);
if (! pattern)
g_message (_("Warning: Failed to load pattern\n\"%s\""), filename);
else
gimp_container_add (GIMP_CONTAINER (loader_data), GIMP_OBJECT (pattern));
}
}

4
libgimpbase/gimpdatafiles.h
View File

@ -24,15 +24,13 @@
#include <time.h>
typedef enum
{
INCLUDE_TEMP_DIR = 1 << 0,
MODE_EXECUTABLE = 1 << 1
} GimpDataFileFlags;
typedef void (* GimpDataFileLoaderFunc) (const gchar *filename,
gpointer loader_data);
gboolean datafiles_check_extension (const gchar *filename,
const gchar *extension);