graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-20 07:57:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

app/Makefile.am app/apptypes.h new abstract base class for everything

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

	* app/Makefile.am
	* app/apptypes.h
	* app/gimpdata.[ch]: new abstract base class for everything
	(except images) which has a filename and can become dirty and must
	be saved.

	* app/gimpbrush.[ch]
	* app/gimpgradient.[ch]
	* app/gimppattern.[ch]: all derived from GimpData now.

	* app/gimpbrushgenerated.[ch]
	* app/brush_select.c
	* app/brushes.c
	* app/gimpbrushpipe.c
	* app/gradient_editor.c
	* app/gradients.c
	* app/patterns.c: removed lots of code duplication due to common
	file save magic.

	The gradient file format has changed: it now contains the
	gradient's name (no more ugly underscores). The files have the
	extension ".ggr".

	* app/gimpgradient.[ch]: save new gradients, load new and old
	gradients.

	* data/gradients/*: removed all old gradients and added the new
	ones.
This commit is contained in:
Michael Natterer 2001-02-11 01:39:24 +00:00 committed by Michael Natterer
parent e2db8600fc
commit e4bb2f938a
118 changed files with 2053 additions and 1665 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
ChangeLog
View file

@ -1,3 +1,34 @@
2001-02-11 Michael Natterer <mitch@gimp.org>
* app/Makefile.am
* app/apptypes.h
* app/gimpdata.[ch]: new abstract base class for everything
(except images) which has a filename and can become dirty and must
be saved.
* app/gimpbrush.[ch]
* app/gimpgradient.[ch]
* app/gimppattern.[ch]: all derived from GimpData now.
* app/gimpbrushgenerated.[ch]
* app/brush_select.c
* app/brushes.c
* app/gimpbrushpipe.c
* app/gradient_editor.c
* app/gradients.c
* app/patterns.c: removed lots of code duplication due to common
file save magic.
The gradient file format has changed: it now contains the
gradient's name (no more ugly underscores). The files have the
extension ".ggr".
* app/gimpgradient.[ch]: save new gradients, load new and old
gradients.
* data/gradients/*: removed all old gradients and added the new
ones.
2001-02-10 David Monniaux <monniaux@genievre.ens.fr>
MMX code for paint_funcs. Very partial so far.

6
app/Makefile.am
View file

@ -116,6 +116,8 @@ gimp_SOURCES = \
gimpcontext.h \
gimpcontextpreview.c \
gimpcontextpreview.h \
gimpdata.c \
gimpdata.h \
gimpdatalist.c \
gimpdatalist.h \
gimpdnd.c \
@ -267,6 +269,7 @@ gimp_SOURCES = \
\
paint_funcs.c \
paint_funcs.h \
paint_funcs_simd.S \
pixel_processor.c \
pixel_processor.h \
pixel_region.c \
@ -314,8 +317,7 @@ gimp_SOURCES = \
marching_ants.h \
pixmaps.h \
pixmaps2.h \
wilber.h \
paint_funcs_simd.S
wilber.h
EXTRA_DIST = \
makefile.mingw \

2
app/apptypes.h
View file

@ -58,6 +58,8 @@ typedef GimpImage GImage;
/* data objects */
typedef struct _GimpData GimpData;
typedef struct _GimpBrush GimpBrush;
typedef struct _GimpBrushGenerated GimpBrushGenerated;
typedef struct _GimpBrushPipe GimpBrushPipe;

3
app/brush_select.c
View file

@ -35,6 +35,7 @@
#include "gimpbrushgenerated.h"
#include "gimpbrushpipe.h"
#include "gimpcontext.h"
#include "gimpdata.h"
#include "gimpdnd.h"
#include "gimplist.h"
#include "gimprc.h"
@ -1878,7 +1879,7 @@ brush_select_delete_brush_callback (GtkWidget *widget,
if (GIMP_IS_BRUSH_GENERATED (brush))
{
gimp_brush_generated_delete (GIMP_BRUSH_GENERATED (brush));
gimp_data_delete_from_disk (GIMP_DATA (brush));
brush_select_freeze_all ();

25
app/brushes.c
View file

@ -128,29 +128,28 @@ brushes_brush_load (const gchar *filename)
void
brushes_free (void)
{
GList *vbr_path;
gchar *vbr_dir;
if (! global_brush_list)
return;
vbr_path = gimp_path_parse (brush_vbr_path, 16, TRUE, NULL);
vbr_dir = gimp_path_get_user_writable_dir (vbr_path);
gimp_path_free (vbr_path);
brush_select_freeze_all ();
while (GIMP_LIST (global_brush_list)->list)
{
GimpBrush *brush = GIMP_BRUSH (GIMP_LIST (global_brush_list)->list->data);
GimpData *data;
if (GIMP_IS_BRUSH_GENERATED (brush) && vbr_dir)
gimp_brush_generated_save (GIMP_BRUSH_GENERATED (brush), vbr_dir);
data = GIMP_DATA (GIMP_LIST (global_brush_list)->list->data);
gimp_container_remove (global_brush_list, GIMP_OBJECT (brush));
if (! GIMP_DATA (data)->filename)
gimp_data_create_filename (data,
GIMP_OBJECT (data)->name,
GIMP_BRUSH_GENERATED_FILE_EXTENSION,
brush_path);
if (data->dirty)
gimp_data_save (data);
gimp_container_remove (global_brush_list, GIMP_OBJECT (data));
}
brush_select_thaw_all ();
g_free (vbr_dir);
}

20
app/core/gimpbrush-load.c
View file

@ -89,7 +89,7 @@ gimp_brush_get_type (void)
(GtkClassInitFunc) NULL
};
type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &info);
type = gtk_type_unique (GIMP_TYPE_DATA, &info);
}
return type;
}
@ -103,7 +103,7 @@ gimp_brush_class_init (GimpBrushClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_brush_destroy;
@ -116,16 +116,14 @@ gimp_brush_class_init (GimpBrushClass *klass)
static void
gimp_brush_init (GimpBrush *brush)
{
brush->filename = NULL;
brush->mask = NULL;
brush->pixmap = NULL;
brush->spacing = 20;
brush->x_axis.x = 15.0;
brush->x_axis.y = 0.0;
brush->y_axis.x = 0.0;
brush->y_axis.y = 15.0;
brush->mask = NULL;
brush->pixmap = NULL;
}
static void
@ -135,8 +133,6 @@ gimp_brush_destroy (GtkObject *object)
brush = GIMP_BRUSH (object);
g_free (brush->filename);
if (brush->mask)
temp_buf_free (brush->mask);
@ -269,12 +265,16 @@ gimp_brush_load (const gchar *filename)
close (fd);
brush->filename = g_strdup (filename);
if (! brush)
return NULL;
gimp_data_set_filename (GIMP_DATA (brush), filename);
/* Swap the brush to disk (if we're being stingy with memory) */
if (stingy_memory_use)
{
temp_buf_swap (brush->mask);
if (brush->pixmap)
temp_buf_swap (brush->pixmap);
}
@ -429,7 +429,7 @@ gimp_brush_load_brush (gint fd,
}
}
break;
default:
g_message ("Unsupported brush depth: %d\n"
"in file \"%s\"\n"

20
app/core/gimpbrush.c
View file

@ -89,7 +89,7 @@ gimp_brush_get_type (void)
(GtkClassInitFunc) NULL
};
type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &info);
type = gtk_type_unique (GIMP_TYPE_DATA, &info);
}
return type;
}
@ -103,7 +103,7 @@ gimp_brush_class_init (GimpBrushClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_brush_destroy;
@ -116,16 +116,14 @@ gimp_brush_class_init (GimpBrushClass *klass)
static void
gimp_brush_init (GimpBrush *brush)
{
brush->filename = NULL;
brush->mask = NULL;
brush->pixmap = NULL;
brush->spacing = 20;
brush->x_axis.x = 15.0;
brush->x_axis.y = 0.0;
brush->y_axis.x = 0.0;
brush->y_axis.y = 15.0;
brush->mask = NULL;
brush->pixmap = NULL;
}
static void
@ -135,8 +133,6 @@ gimp_brush_destroy (GtkObject *object)
brush = GIMP_BRUSH (object);
g_free (brush->filename);
if (brush->mask)
temp_buf_free (brush->mask);
@ -269,12 +265,16 @@ gimp_brush_load (const gchar *filename)
close (fd);
brush->filename = g_strdup (filename);
if (! brush)
return NULL;
gimp_data_set_filename (GIMP_DATA (brush), filename);
/* Swap the brush to disk (if we're being stingy with memory) */
if (stingy_memory_use)
{
temp_buf_swap (brush->mask);
if (brush->pixmap)
temp_buf_swap (brush->pixmap);
}
@ -429,7 +429,7 @@ gimp_brush_load_brush (gint fd,
}
}
break;
default:
g_message ("Unsupported brush depth: %d\n"
"in file \"%s\"\n"

18
app/core/gimpbrush.h
View file

@ -20,7 +20,7 @@
#define __GIMP_BRUSH_H__
#include "gimpviewable.h"
#include "gimpdata.h"
#define GIMP_TYPE_BRUSH (gimp_brush_get_type ())
@ -34,19 +34,19 @@ typedef struct _GimpBrushClass GimpBrushClass;
struct _GimpBrush
{
GimpViewable parent_instance;
GimpData parent_instance;
gchar *filename; /* actual filename--brush's location on disk */
gint spacing; /* brush's spacing */
GimpVector2 x_axis; /* for calculating brush spacing */
GimpVector2 y_axis; /* for calculating brush spacing */
TempBuf *mask; /* the actual mask */
TempBuf *pixmap; /* optional pixmap data */
TempBuf *mask; /* the actual mask */
TempBuf *pixmap; /* optional pixmap data */
gint spacing; /* brush's spacing */
GimpVector2 x_axis; /* for calculating brush spacing */
GimpVector2 y_axis; /* for calculating brush spacing */
};
struct _GimpBrushClass
{
GimpViewableClass parent_class;
GimpDataClass parent_class;
/* FIXME: these are no virtual function pointers but bad hacks: */
GimpBrush * (* select_brush) (PaintCore *paint_core);

383
app/core/gimpbrushgenerated-load.c
View file

@ -47,42 +47,18 @@
#define OVERSAMPLING 5
static void gimp_brush_generated_generate (GimpBrushGenerated *brush);
/* local function prototypes */
static void gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass);
static void gimp_brush_generated_init (GimpBrushGenerated *brush);
static void gimp_brush_generated_destroy (GtkObject *object);
static gboolean gimp_brush_generated_save (GimpData *data);
static void gimp_brush_generated_dirty (GimpData *data);
static GimpBrushClass *parent_class = NULL;
static void
gimp_brush_generated_destroy (GtkObject *object)
{
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
object_class->destroy = gimp_brush_generated_destroy;
}
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
guint
GtkType
gimp_brush_generated_get_type (void)
{
static GtkType type = 0;
@ -107,162 +83,56 @@ gimp_brush_generated_get_type (void)
return type;
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GimpBrushGenerated *brush;
GtkObjectClass *object_class;
GimpDataClass *data_class;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
object_class = (GtkObjectClass *) klass;
data_class = (GimpDataClass *) klass;
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
GIMP_BRUSH (brush)->spacing = 20;
object_class->destroy = gimp_brush_generated_destroy;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_brush_generated_generate (brush);
return GIMP_BRUSH (brush);
data_class->save = gimp_brush_generated_save;
data_class->dirty = gimp_brush_generated_dirty;
}
GimpBrush *
gimp_brush_generated_load (const gchar *file_name)
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (file_name, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush =
GIMP_BRUSH_GENERATED (gtk_type_new (gimp_brush_generated_get_type ()));
GIMP_BRUSH (brush)->filename = g_strdup (file_name);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
void
gimp_brush_generated_save (GimpBrushGenerated *brush,
const gchar *directory)
static void
gimp_brush_generated_destroy (GtkObject *object)
{
FILE *fp;
gchar *filename = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
g_return_if_fail (directory != NULL);
static gboolean
gimp_brush_generated_save (GimpData *data)
{
GimpBrushGenerated *brush;
FILE *fp;
if (! GIMP_BRUSH (brush)->filename)
{
gchar *safe_name;
gint i;
gint unum = 1;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (data), FALSE);
/* make sure we don't create a naughty filename */
safe_name = g_strdup (GIMP_OBJECT (brush)->name);
if (safe_name[0] == '.')
safe_name[0] = '_';
for (i = 0; safe_name[i]; i++)
if (safe_name[i] == G_DIR_SEPARATOR || isspace (safe_name[i]))
safe_name[i] = '_';
filename = g_strdup_printf ("%s%s.vbr",
directory, safe_name);
while ((fp = fopen (filename, "r")))
{
/* make sure we don't overite an existing brush */
fclose (fp);
g_free (filename);
filename = g_strdup_printf ("%s%s_%d.vbr",
directory, safe_name, unum);
unum++;
}
g_free (safe_name);
}
else
{
filename = g_strdup (GIMP_BRUSH (brush)->filename);
if (strlen(filename) < 4 || strcmp (&filename[strlen (filename) - 4],
".vbr"))
{
/* we only want to save .vbr files, so set filename to null
* if this isn't a .vbr file
*/
g_free (filename);
filename = NULL;
}
}
if (! filename)
return;
brush = GIMP_BRUSH_GENERATED (data);
/* we are (finaly) ready to try to save the generated brush file */
if ((fp = fopen (filename, "wb")) == NULL)
if ((fp = fopen (data->filename, "wb")) == NULL)
{
g_warning ("Unable to save file %s", filename);
return;
g_warning ("Unable to save file %s", data->filename);
return FALSE;
}
/* write magic header */
@ -290,37 +160,8 @@ gimp_brush_generated_save (GimpBrushGenerated *brush,
fprintf (fp, "%f\n", brush->angle);
fclose (fp);
}
void
gimp_brush_generated_delete (GimpBrushGenerated *brush)
{
if (GIMP_BRUSH (brush)->filename)
{
unlink (GIMP_BRUSH (brush)->filename);
}
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_brush_generated_generate (brush);
return TRUE;
}
static double
@ -340,9 +181,10 @@ gauss (gdouble f)
return (2.0 * f*f);
}
void
gimp_brush_generated_generate (GimpBrushGenerated *brush)
static void
gimp_brush_generated_dirty (GimpData *data)
{
GimpBrushGenerated *brush;
register GimpBrush *gbrush = NULL;
register gint x, y;
register guchar *centerp;
@ -355,9 +197,8 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
gdouble buffer[OVERSAMPLING];
gint width, height;
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush = GIMP_BRUSH_GENERATED (data);
if (brush->freeze) /* if we are frozen defer rerendering till later */
return;
@ -368,7 +209,7 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
if (gbrush->mask)
{
temp_buf_free(gbrush->mask);
temp_buf_free (gbrush->mask);
}
/* compute the range of the brush. should do a better job than this? */
@ -462,9 +303,129 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
g_free (lookup);
if (GIMP_DATA_CLASS (parent_class)->dirty)
GIMP_DATA_CLASS (parent_class)->dirty (data);
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (brush));
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
{
GimpBrushGenerated *brush;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
GIMP_BRUSH (brush)->spacing = 20;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_data_dirty (GIMP_DATA (brush));
return GIMP_BRUSH (brush);
}
GimpBrush *
gimp_brush_generated_load (const gchar *filename)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (filename, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_data_set_filename (GIMP_DATA (brush), filename);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
GIMP_DATA (brush)->dirty = FALSE;
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_data_dirty (GIMP_DATA (brush));
}
gfloat
gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
gfloat radius)
@ -481,8 +442,8 @@ gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
brush->radius = radius;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
if (! brush->freeze)
gimp_data_dirty (GIMP_DATA (brush));
return brush->radius;
}
@ -504,7 +465,7 @@ gimp_brush_generated_set_hardness (GimpBrushGenerated *brush,
brush->hardness = hardness;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->hardness;
}
@ -526,7 +487,7 @@ gimp_brush_generated_set_angle (GimpBrushGenerated *brush,
brush->angle = angle;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->angle;
}
@ -548,7 +509,7 @@ gimp_brush_generated_set_aspect_ratio (GimpBrushGenerated *brush,
brush->aspect_ratio = ratio;
if (!brush->freeze)
gimp_brush_generated_generate(brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->aspect_ratio;
}

383
app/core/gimpbrushgenerated-save.c
View file

@ -47,42 +47,18 @@
#define OVERSAMPLING 5
static void gimp_brush_generated_generate (GimpBrushGenerated *brush);
/* local function prototypes */
static void gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass);
static void gimp_brush_generated_init (GimpBrushGenerated *brush);
static void gimp_brush_generated_destroy (GtkObject *object);
static gboolean gimp_brush_generated_save (GimpData *data);
static void gimp_brush_generated_dirty (GimpData *data);
static GimpBrushClass *parent_class = NULL;
static void
gimp_brush_generated_destroy (GtkObject *object)
{
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
object_class->destroy = gimp_brush_generated_destroy;
}
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
guint
GtkType
gimp_brush_generated_get_type (void)
{
static GtkType type = 0;
@ -107,162 +83,56 @@ gimp_brush_generated_get_type (void)
return type;
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GimpBrushGenerated *brush;
GtkObjectClass *object_class;
GimpDataClass *data_class;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
object_class = (GtkObjectClass *) klass;
data_class = (GimpDataClass *) klass;
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
GIMP_BRUSH (brush)->spacing = 20;
object_class->destroy = gimp_brush_generated_destroy;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_brush_generated_generate (brush);
return GIMP_BRUSH (brush);
data_class->save = gimp_brush_generated_save;
data_class->dirty = gimp_brush_generated_dirty;
}
GimpBrush *
gimp_brush_generated_load (const gchar *file_name)
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (file_name, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush =
GIMP_BRUSH_GENERATED (gtk_type_new (gimp_brush_generated_get_type ()));
GIMP_BRUSH (brush)->filename = g_strdup (file_name);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
void
gimp_brush_generated_save (GimpBrushGenerated *brush,
const gchar *directory)
static void
gimp_brush_generated_destroy (GtkObject *object)
{
FILE *fp;
gchar *filename = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
g_return_if_fail (directory != NULL);
static gboolean
gimp_brush_generated_save (GimpData *data)
{
GimpBrushGenerated *brush;
FILE *fp;
if (! GIMP_BRUSH (brush)->filename)
{
gchar *safe_name;
gint i;
gint unum = 1;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (data), FALSE);
/* make sure we don't create a naughty filename */
safe_name = g_strdup (GIMP_OBJECT (brush)->name);
if (safe_name[0] == '.')
safe_name[0] = '_';
for (i = 0; safe_name[i]; i++)
if (safe_name[i] == G_DIR_SEPARATOR || isspace (safe_name[i]))
safe_name[i] = '_';
filename = g_strdup_printf ("%s%s.vbr",
directory, safe_name);
while ((fp = fopen (filename, "r")))
{
/* make sure we don't overite an existing brush */
fclose (fp);
g_free (filename);
filename = g_strdup_printf ("%s%s_%d.vbr",
directory, safe_name, unum);
unum++;
}
g_free (safe_name);
}
else
{
filename = g_strdup (GIMP_BRUSH (brush)->filename);
if (strlen(filename) < 4 || strcmp (&filename[strlen (filename) - 4],
".vbr"))
{
/* we only want to save .vbr files, so set filename to null
* if this isn't a .vbr file
*/
g_free (filename);
filename = NULL;
}
}
if (! filename)
return;
brush = GIMP_BRUSH_GENERATED (data);
/* we are (finaly) ready to try to save the generated brush file */
if ((fp = fopen (filename, "wb")) == NULL)
if ((fp = fopen (data->filename, "wb")) == NULL)
{
g_warning ("Unable to save file %s", filename);
return;
g_warning ("Unable to save file %s", data->filename);
return FALSE;
}
/* write magic header */
@ -290,37 +160,8 @@ gimp_brush_generated_save (GimpBrushGenerated *brush,
fprintf (fp, "%f\n", brush->angle);
fclose (fp);
}
void
gimp_brush_generated_delete (GimpBrushGenerated *brush)
{
if (GIMP_BRUSH (brush)->filename)
{
unlink (GIMP_BRUSH (brush)->filename);
}
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_brush_generated_generate (brush);
return TRUE;
}
static double
@ -340,9 +181,10 @@ gauss (gdouble f)
return (2.0 * f*f);
}
void
gimp_brush_generated_generate (GimpBrushGenerated *brush)
static void
gimp_brush_generated_dirty (GimpData *data)
{
GimpBrushGenerated *brush;
register GimpBrush *gbrush = NULL;
register gint x, y;
register guchar *centerp;
@ -355,9 +197,8 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
gdouble buffer[OVERSAMPLING];
gint width, height;
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush = GIMP_BRUSH_GENERATED (data);
if (brush->freeze) /* if we are frozen defer rerendering till later */
return;
@ -368,7 +209,7 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
if (gbrush->mask)
{
temp_buf_free(gbrush->mask);
temp_buf_free (gbrush->mask);
}
/* compute the range of the brush. should do a better job than this? */
@ -462,9 +303,129 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
g_free (lookup);
if (GIMP_DATA_CLASS (parent_class)->dirty)
GIMP_DATA_CLASS (parent_class)->dirty (data);
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (brush));
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
{
GimpBrushGenerated *brush;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
GIMP_BRUSH (brush)->spacing = 20;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_data_dirty (GIMP_DATA (brush));
return GIMP_BRUSH (brush);
}
GimpBrush *
gimp_brush_generated_load (const gchar *filename)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (filename, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_data_set_filename (GIMP_DATA (brush), filename);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
GIMP_DATA (brush)->dirty = FALSE;
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_data_dirty (GIMP_DATA (brush));
}
gfloat
gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
gfloat radius)
@ -481,8 +442,8 @@ gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
brush->radius = radius;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
if (! brush->freeze)
gimp_data_dirty (GIMP_DATA (brush));
return brush->radius;
}
@ -504,7 +465,7 @@ gimp_brush_generated_set_hardness (GimpBrushGenerated *brush,
brush->hardness = hardness;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->hardness;
}
@ -526,7 +487,7 @@ gimp_brush_generated_set_angle (GimpBrushGenerated *brush,
brush->angle = angle;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->angle;
}
@ -548,7 +509,7 @@ gimp_brush_generated_set_aspect_ratio (GimpBrushGenerated *brush,
brush->aspect_ratio = ratio;
if (!brush->freeze)
gimp_brush_generated_generate(brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->aspect_ratio;
}

383
app/core/gimpbrushgenerated.c
View file

@ -47,42 +47,18 @@
#define OVERSAMPLING 5
static void gimp_brush_generated_generate (GimpBrushGenerated *brush);
/* local function prototypes */
static void gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass);
static void gimp_brush_generated_init (GimpBrushGenerated *brush);
static void gimp_brush_generated_destroy (GtkObject *object);
static gboolean gimp_brush_generated_save (GimpData *data);
static void gimp_brush_generated_dirty (GimpData *data);
static GimpBrushClass *parent_class = NULL;
static void
gimp_brush_generated_destroy (GtkObject *object)
{
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
object_class->destroy = gimp_brush_generated_destroy;
}
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
guint
GtkType
gimp_brush_generated_get_type (void)
{
static GtkType type = 0;
@ -107,162 +83,56 @@ gimp_brush_generated_get_type (void)
return type;
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GimpBrushGenerated *brush;
GtkObjectClass *object_class;
GimpDataClass *data_class;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
object_class = (GtkObjectClass *) klass;
data_class = (GimpDataClass *) klass;
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
GIMP_BRUSH (brush)->spacing = 20;
object_class->destroy = gimp_brush_generated_destroy;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_brush_generated_generate (brush);
return GIMP_BRUSH (brush);
data_class->save = gimp_brush_generated_save;
data_class->dirty = gimp_brush_generated_dirty;
}
GimpBrush *
gimp_brush_generated_load (const gchar *file_name)
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (file_name, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush =
GIMP_BRUSH_GENERATED (gtk_type_new (gimp_brush_generated_get_type ()));
GIMP_BRUSH (brush)->filename = g_strdup (file_name);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
void
gimp_brush_generated_save (GimpBrushGenerated *brush,
const gchar *directory)
static void
gimp_brush_generated_destroy (GtkObject *object)
{
FILE *fp;
gchar *filename = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
g_return_if_fail (directory != NULL);
static gboolean
gimp_brush_generated_save (GimpData *data)
{
GimpBrushGenerated *brush;
FILE *fp;
if (! GIMP_BRUSH (brush)->filename)
{
gchar *safe_name;
gint i;
gint unum = 1;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (data), FALSE);
/* make sure we don't create a naughty filename */
safe_name = g_strdup (GIMP_OBJECT (brush)->name);
if (safe_name[0] == '.')
safe_name[0] = '_';
for (i = 0; safe_name[i]; i++)
if (safe_name[i] == G_DIR_SEPARATOR || isspace (safe_name[i]))
safe_name[i] = '_';
filename = g_strdup_printf ("%s%s.vbr",
directory, safe_name);
while ((fp = fopen (filename, "r")))
{
/* make sure we don't overite an existing brush */
fclose (fp);
g_free (filename);
filename = g_strdup_printf ("%s%s_%d.vbr",
directory, safe_name, unum);
unum++;
}
g_free (safe_name);
}
else
{
filename = g_strdup (GIMP_BRUSH (brush)->filename);
if (strlen(filename) < 4 || strcmp (&filename[strlen (filename) - 4],
".vbr"))
{
/* we only want to save .vbr files, so set filename to null
* if this isn't a .vbr file
*/
g_free (filename);
filename = NULL;
}
}
if (! filename)
return;
brush = GIMP_BRUSH_GENERATED (data);
/* we are (finaly) ready to try to save the generated brush file */
if ((fp = fopen (filename, "wb")) == NULL)
if ((fp = fopen (data->filename, "wb")) == NULL)
{
g_warning ("Unable to save file %s", filename);
return;
g_warning ("Unable to save file %s", data->filename);
return FALSE;
}
/* write magic header */
@ -290,37 +160,8 @@ gimp_brush_generated_save (GimpBrushGenerated *brush,
fprintf (fp, "%f\n", brush->angle);
fclose (fp);
}
void
gimp_brush_generated_delete (GimpBrushGenerated *brush)
{
if (GIMP_BRUSH (brush)->filename)
{
unlink (GIMP_BRUSH (brush)->filename);
}
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_brush_generated_generate (brush);
return TRUE;
}
static double
@ -340,9 +181,10 @@ gauss (gdouble f)
return (2.0 * f*f);
}
void
gimp_brush_generated_generate (GimpBrushGenerated *brush)
static void
gimp_brush_generated_dirty (GimpData *data)
{
GimpBrushGenerated *brush;
register GimpBrush *gbrush = NULL;
register gint x, y;
register guchar *centerp;
@ -355,9 +197,8 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
gdouble buffer[OVERSAMPLING];
gint width, height;
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush = GIMP_BRUSH_GENERATED (data);
if (brush->freeze) /* if we are frozen defer rerendering till later */
return;
@ -368,7 +209,7 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
if (gbrush->mask)
{
temp_buf_free(gbrush->mask);
temp_buf_free (gbrush->mask);
}
/* compute the range of the brush. should do a better job than this? */
@ -462,9 +303,129 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
g_free (lookup);
if (GIMP_DATA_CLASS (parent_class)->dirty)
GIMP_DATA_CLASS (parent_class)->dirty (data);
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (brush));
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
{
GimpBrushGenerated *brush;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
GIMP_BRUSH (brush)->spacing = 20;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_data_dirty (GIMP_DATA (brush));
return GIMP_BRUSH (brush);
}
GimpBrush *
gimp_brush_generated_load (const gchar *filename)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (filename, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_data_set_filename (GIMP_DATA (brush), filename);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
GIMP_DATA (brush)->dirty = FALSE;
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_data_dirty (GIMP_DATA (brush));
}
gfloat
gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
gfloat radius)
@ -481,8 +442,8 @@ gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
brush->radius = radius;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
if (! brush->freeze)
gimp_data_dirty (GIMP_DATA (brush));
return brush->radius;
}
@ -504,7 +465,7 @@ gimp_brush_generated_set_hardness (GimpBrushGenerated *brush,
brush->hardness = hardness;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->hardness;
}
@ -526,7 +487,7 @@ gimp_brush_generated_set_angle (GimpBrushGenerated *brush,
brush->angle = angle;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->angle;
}
@ -548,7 +509,7 @@ gimp_brush_generated_set_aspect_ratio (GimpBrushGenerated *brush,
brush->aspect_ratio = ratio;
if (!brush->freeze)
gimp_brush_generated_generate(brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->aspect_ratio;
}

7
app/core/gimpbrushgenerated.h
View file

@ -25,6 +25,9 @@
#include "gimpbrush.h"
#define GIMP_BRUSH_GENERATED_FILE_EXTENSION ".vbr"
#define GIMP_TYPE_BRUSH_GENERATED (gimp_brush_generated_get_type ())
#define GIMP_BRUSH_GENERATED(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGenerated))
#define GIMP_BRUSH_GENERATED_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGeneratedClass))
@ -60,10 +63,6 @@ GimpBrush * gimp_brush_generated_new (gfloat radius,
gfloat aspect_ratio);
GimpBrush * gimp_brush_generated_load (const gchar *file_name);
void gimp_brush_generated_save (GimpBrushGenerated *brush,
const gchar *directory);
void gimp_brush_generated_delete (GimpBrushGenerated *brush);
void gimp_brush_generated_freeze (GimpBrushGenerated *brush);
void gimp_brush_generated_thaw (GimpBrushGenerated *brush);

3
app/core/gimpbrushpipe-load.c
View file

@ -396,8 +396,9 @@ gimp_brush_pipe_load (const gchar *filename)
/* Current brush is the first one. */
pipe->current = pipe->brushes[0];
gimp_data_set_filename (GIMP_DATA (pipe), filename);
/* just to satisfy the code that relies on this crap */
GIMP_BRUSH (pipe)->filename = g_strdup (filename);
GIMP_BRUSH (pipe)->spacing = pipe->current->spacing;
GIMP_BRUSH (pipe)->x_axis = pipe->current->x_axis;
GIMP_BRUSH (pipe)->y_axis = pipe->current->y_axis;

3
app/core/gimpbrushpipe.c
View file

@ -396,8 +396,9 @@ gimp_brush_pipe_load (const gchar *filename)
/* Current brush is the first one. */
pipe->current = pipe->brushes[0];
gimp_data_set_filename (GIMP_DATA (pipe), filename);
/* just to satisfy the code that relies on this crap */
GIMP_BRUSH (pipe)->filename = g_strdup (filename);
GIMP_BRUSH (pipe)->spacing = pipe->current->spacing;
GIMP_BRUSH (pipe)->x_axis = pipe->current->x_axis;
GIMP_BRUSH (pipe)->y_axis = pipe->current->y_axis;

254
app/core/gimpdata.c Normal file
View file

@ -0,0 +1,254 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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 <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <gtk/gtk.h>
#include "apptypes.h"
#include "gimpdata.h"
#include "libgimp/gimpenv.h"
enum
{
DIRTY,
SAVE,
LAST_SIGNAL
};
static void gimp_data_class_init (GimpDataClass *klass);
static void gimp_data_init (GimpData *data);
static void gimp_data_destroy (GtkObject *object);
static void gimp_data_real_dirty (GimpData *data);
static guint data_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
gimp_data_get_type (void)
{
static GtkType data_type = 0;
if (! data_type)
{
static const GtkTypeInfo data_info =
{
"GimpData",
sizeof (GimpData),
sizeof (GimpDataClass),
(GtkClassInitFunc) gimp_data_class_init,
(GtkObjectInitFunc) gimp_data_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL
};
data_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &data_info);
}
return data_type;
}
static void
gimp_data_class_init (GimpDataClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
data_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
data_signals[SAVE] =
gtk_signal_new ("save",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
save),
gtk_marshal_BOOL__NONE,
GTK_TYPE_BOOL, 0);
object_class->destroy = gimp_data_destroy;
klass->dirty = gimp_data_real_dirty;
klass->save = NULL;
}
static void
gimp_data_init (GimpData *data)
{
data->filename = NULL;
data->dirty = FALSE;
}
static void
gimp_data_destroy (GtkObject *object)
{
GimpData *data;
data = GIMP_DATA (object);
g_free (data->filename);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
gboolean
gimp_data_save (GimpData *data)
{
gboolean success = FALSE;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
if (! data->filename)
{
g_warning ("%s(): can't save data with NULL filename",
G_GNUC_FUNCTION);
return FALSE;
}
gtk_signal_emit (GTK_OBJECT (data), data_signals[SAVE],
&success);
if (success)
data->dirty = FALSE;
return success;
}
void
gimp_data_dirty (GimpData *data)
{
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
gtk_signal_emit (GTK_OBJECT (data), data_signals[DIRTY]);
}
static void
gimp_data_real_dirty (GimpData *data)
{
data->dirty = TRUE;
}
gboolean
gimp_data_delete_from_disk (GimpData *data)
{
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
g_return_val_if_fail (data->filename != NULL, FALSE);
if (unlink (data->filename) == -1)
{
g_message ("%s(): could not unlink() %s: %s",
G_GNUC_FUNCTION, data->filename, g_strerror (errno));
return FALSE;
}
return TRUE;
}
void
gimp_data_set_filename (GimpData *data,
const gchar *filename)
{
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
g_free (data->filename);
data->filename = g_strdup (filename);
}
void
gimp_data_create_filename (GimpData *data,
const gchar *basename,
const gchar *extension,
const gchar *data_path)
{
GList *path;
gchar *dir;
gchar *filename;
gchar *safe_name;
gint i;
gint unum = 1;
FILE *file;
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
g_return_if_fail (basename != NULL);
g_return_if_fail (extension != NULL);
g_return_if_fail (data_path != NULL);
path = gimp_path_parse (data_path, 16, TRUE, NULL);
dir = gimp_path_get_user_writable_dir (path);
gimp_path_free (path);
if (! dir)
return;
safe_name = g_strdup (basename);
if (safe_name[0] == '.')
safe_name[0] = '_';
for (i = 0; safe_name[i]; i++)
if (safe_name[i] == G_DIR_SEPARATOR || isspace (safe_name[i]))
safe_name[i] = '_';
filename = g_strdup_printf ("%s%s%s", dir, safe_name, extension);
while ((file = fopen (filename, "r")))
{
fclose (file);
g_free (filename);
filename = g_strdup_printf ("%s%s_%d%s", dir, safe_name, unum, extension);
unum++;
}
g_free (dir);
g_free (safe_name);
gimp_data_set_filename (data, filename);
g_free (filename);
}

67
app/core/gimpdata.h Normal file
View file

@ -0,0 +1,67 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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_DATA_H__
#define __GIMP_DATA_H__
#include "gimpviewable.h"
#define GIMP_TYPE_DATA (gimp_data_get_type ())
#define GIMP_DATA(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DATA, GimpData))
#define GIMP_DATA_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA, GimpDataClass))
#define GIMP_IS_DATA(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DATA))
#define GIMP_IS_DATA_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA))
typedef struct _GimpDataClass GimpDataClass;
struct _GimpData
{
GimpViewable parent_instance;
gchar *filename;
gboolean dirty;
};
struct _GimpDataClass
{
GimpViewableClass parent_class;
void (* dirty) (GimpData *data);
gboolean (* save) (GimpData *data);
};
GtkType gimp_data_get_type (void);
gboolean gimp_data_save (GimpData *data);
void gimp_data_dirty (GimpData *data);
gboolean gimp_data_delete_from_disk (GimpData *data);
void gimp_data_set_filename (GimpData *data,
const gchar *filename);
void gimp_data_create_filename (GimpData *data,
const gchar *filename,
const gchar *extension,
const gchar *data_path);
#endif /* __GIMP_DATA_H__ */

259
app/core/gimpgradient.c
View file

@ -18,28 +18,12 @@
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <fcntl.h>
#include <gtk/gtk.h>
#ifdef G_OS_WIN32
#include <io.h>
#endif
#ifndef _O_BINARY
#define _O_BINARY 0
#endif
#include "libgimpcolor/gimpcolor.h"
#include "libgimpmath/gimpmath.h"
@ -60,29 +44,28 @@
#define EPSILON 1e-10
static void gimp_gradient_class_init (GimpGradientClass *klass);
static void gimp_gradient_init (GimpGradient *gradient);
static void gimp_gradient_destroy (GtkObject *object);
static TempBuf * gimp_gradient_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static void gimp_gradient_class_init (GimpGradientClass *klass);
static void gimp_gradient_init (GimpGradient *gradient);
static void gimp_gradient_destroy (GtkObject *object);
static TempBuf * gimp_gradient_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static void gimp_gradient_dirty (GimpData *data);
static gboolean gimp_gradient_save (GimpData *data);
static void gimp_gradient_dump (GimpGradient *grad,
FILE *file);
static gdouble gimp_gradient_calc_linear_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_curved_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sine_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_increasing_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_decreasing_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_linear_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_curved_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sine_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_increasing_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_decreasing_factor (gdouble middle,
gdouble pos);
static GimpViewableClass *parent_class = NULL;
static GimpDataClass *parent_class = NULL;
GtkType
@ -104,7 +87,7 @@ gimp_gradient_get_type (void)
(GtkClassInitFunc) NULL
};
gradient_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &gradient_info);
gradient_type = gtk_type_unique (GIMP_TYPE_DATA, &gradient_info);
}
return gradient_type;
@ -115,23 +98,25 @@ gimp_gradient_class_init (GimpGradientClass *klass)
{
GtkObjectClass *object_class;
GimpViewableClass *viewable_class;
GimpDataClass *data_class;
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_gradient_destroy;
viewable_class->get_new_preview = gimp_gradient_get_new_preview;
data_class->dirty = gimp_gradient_dirty;
data_class->save = gimp_gradient_save;
}
static void
gimp_gradient_init (GimpGradient *gradient)
{
gradient->filename = NULL;
gradient->dirty = FALSE;
gradient->segments = NULL;
gradient->last_visited = NULL;
@ -145,8 +130,6 @@ gimp_gradient_destroy (GtkObject *object)
gradient = GIMP_GRADIENT (object);
g_free (gradient->filename);
if (gradient->segments)
gimp_gradient_segments_free (gradient->segments);
@ -232,39 +215,6 @@ gimp_gradient_get_new_preview (GimpViewable *viewable,
return temp_buf;
}
static void
gimp_gradient_dump (GimpGradient *gradient,
FILE *file)
{
GimpGradientSegment *seg;
g_return_if_fail (gradient != NULL);
g_return_if_fail (GIMP_IS_GRADIENT (gradient));
fprintf (file, "Name: \"%s\"\n", GIMP_OBJECT (gradient)->name);
fprintf (file, "Dirty: %d\n", gradient->dirty);
fprintf (file, "Filename: \"%s\"\n", gradient->filename);
for (seg = gradient->segments; seg; seg = seg->next)
{
fprintf (file, "%c%p | %f %f %f | %f %f %f %f | %f %f %f %f | %d %d | %p %p\n",
(seg == gradient->last_visited) ? '>' : ' ',
seg,
seg->left, seg->middle, seg->right,
seg->left_color.r,
seg->left_color.g,
seg->left_color.b,
seg->left_color.a,
seg->right_color.r,
seg->right_color.g,
seg->right_color.b,
seg->right_color.a,
(int) seg->type,
(int) seg->color,
seg->prev, seg->next);
}
}
GimpGradient *
gimp_gradient_new (const gchar *name)
{
@ -308,10 +258,20 @@ gimp_gradient_load (const gchar *filename)
gradient = GIMP_GRADIENT (gtk_type_new (GIMP_TYPE_GRADIENT));
gradient->filename = g_strdup (filename);
GIMP_OBJECT (gradient)->name = g_strdup (g_basename (filename));
gimp_data_set_filename (GIMP_DATA (gradient), filename);
fgets (line, 1024, file);
if (! strncmp (line, "Name: ", strlen ("Name: ")))
{
gimp_object_set_name (GIMP_OBJECT (gradient), &line[strlen ("Name: ")]);
fgets (line, 1024, file);
}
else /* old gradient format */
{
gimp_object_set_name (GIMP_OBJECT (gradient), g_basename (filename));
}
num_segments = atoi (line);
if (num_segments < 1)
@ -368,29 +328,35 @@ gimp_gradient_load (const gchar *filename)
return gradient;
}
void
gimp_gradient_save (GimpGradient *gradient)
static void
gimp_gradient_dirty (GimpData *data)
{
FILE *file;
gint num_segments;
GimpGradient *gradient;
gradient = GIMP_GRADIENT (data);
gradient->last_visited = NULL;
if (GIMP_DATA_CLASS (parent_class)->dirty)
GIMP_DATA_CLASS (parent_class)->dirty (data);
}
static gboolean
gimp_gradient_save (GimpData *data)
{
GimpGradient *gradient;
GimpGradientSegment *seg;
gint num_segments;
FILE *file;
g_return_if_fail (gradient != NULL);
g_return_if_fail (GIMP_IS_GRADIENT (gradient));
gradient = GIMP_GRADIENT (data);
if (! gradient->filename)
{
g_message ("%s(): can't save gradient with NULL filename",
G_GNUC_FUNCTION);
return;
}
file = fopen (gradient->filename, "wb");
file = fopen (data->filename, "wb");
if (! file)
{
g_message ("%s(): can't open \"%s\"",
G_GNUC_FUNCTION, gradient->filename);
return;
G_GNUC_FUNCTION, data->filename);
return FALSE;
}
/* File format is:
@ -404,6 +370,8 @@ gimp_gradient_save (GimpGradient *gradient)
fprintf (file, "GIMP Gradient\n");
fprintf (file, "Name: %s\n", GIMP_OBJECT (gradient)->name);
/* Count number of segments */
num_segments = 0;
seg = gradient->segments;
@ -435,7 +403,7 @@ gimp_gradient_save (GimpGradient *gradient)
fclose (file);
gradient->dirty = FALSE;
return TRUE;
}
void
@ -503,9 +471,8 @@ gimp_gradient_get_color_at (GimpGradient *gradient,
break;
default:
gimp_gradient_dump (gradient, stderr);
gimp_fatal_error ("gradient_get_color_at(): Unknown gradient type %d",
(int) seg->type);
gimp_fatal_error ("%s(): Unknown gradient type %d",
G_GNUC_FUNCTION, (gint) seg->type);
break;
}
@ -566,9 +533,8 @@ gimp_gradient_get_color_at (GimpGradient *gradient,
break;
default:
gimp_gradient_dump (gradient, stderr);
gimp_fatal_error ("gradient_get_color_at(): Unknown coloring mode %d",
(int) seg->color);
gimp_fatal_error ("%s(): Unknown coloring mode %d",
G_GNUC_FUNCTION, (gint) seg->color);
break;
}
@ -578,6 +544,50 @@ gimp_gradient_get_color_at (GimpGradient *gradient,
*color = rgb;
}
GimpGradientSegment *
gimp_gradient_get_segment_at (GimpGradient *gradient,
gdouble pos)
{
GimpGradientSegment *seg;
g_return_val_if_fail (gradient != NULL, NULL);
g_return_val_if_fail (GIMP_IS_GRADIENT (gradient), NULL);
/* handle FP imprecision at the edges of the gradient */
pos = CLAMP (pos, 0.0, 1.0);
if (gradient->last_visited)
seg = gradient->last_visited;
else
seg = gradient->segments;
while (seg)
{
if (pos >= seg->left)
{
if (pos <= seg->right)
{
gradient->last_visited = seg; /* for speed */
return seg;
}
else
{
seg = seg->next;
}
}
else
{
seg = seg->prev;
}
}
/* Oops: we should have found a segment, but we didn't */
gimp_fatal_error ("%s(): no matching segment for position %0.15f",
G_GNUC_FUNCTION, pos);
return NULL;
}
static gdouble
gimp_gradient_calc_linear_factor (gdouble middle,
gdouble pos)
@ -698,48 +708,3 @@ gimp_gradient_segment_get_last (GimpGradientSegment *seg)
return seg;
}
GimpGradientSegment *
gimp_gradient_get_segment_at (GimpGradient *gradient,
gdouble pos)
{
GimpGradientSegment *seg;
g_return_val_if_fail (gradient != NULL, NULL);
g_return_val_if_fail (GIMP_IS_GRADIENT (gradient), NULL);
/* handle FP imprecision at the edges of the gradient */
pos = CLAMP (pos, 0.0, 1.0);
if (gradient->last_visited)
seg = gradient->last_visited;
else
seg = gradient->segments;
while (seg)
{
if (pos >= seg->left)
{
if (pos <= seg->right)
{
gradient->last_visited = seg; /* for speed */
return seg;
}
else
{
seg = seg->next;
}
}
else
{
seg = seg->prev;
}
}
/* Oops: we should have found a segment, but we didn't */
gimp_gradient_dump (gradient, stderr);
gimp_fatal_error ("%s(): no matching segment for position %0.15f",
G_GNUC_FUNCTION, pos);
return NULL;
}

33
app/core/gimpgradient.h
View file

@ -20,7 +20,10 @@
#define __GIMP_GRADIENT_H__
#include "gimpviewable.h"
#include "gimpdata.h"
#define GIMP_GRADIENT_FILE_EXTENSION ".ggr"
typedef enum
@ -66,10 +69,7 @@ typedef struct _GimpGradientClass GimpGradientClass;
struct _GimpGradient
{
GimpViewable parent_instance;
gchar *filename;
gboolean dirty;
GimpData parent_instance;
GimpGradientSegment *segments;
@ -80,30 +80,29 @@ struct _GimpGradient
struct _GimpGradientClass
{
GimpViewableClass parent_class;
GimpDataClass parent_class;
};
GtkType gimp_gradient_get_type (void);
GimpGradient * gimp_gradient_new (const gchar *name);
GtkType gimp_gradient_get_type (void);
GimpGradient * gimp_gradient_new (const gchar *name);
GimpGradient * gimp_gradient_load (const gchar *filename);
void gimp_gradient_save (GimpGradient *gradient);
GimpGradient * gimp_gradient_load (const gchar *filename);
void gimp_gradient_get_color_at (GimpGradient *gradient,
gdouble pos,
GimpRGB *color);
void gimp_gradient_get_color_at (GimpGradient *gradient,
gdouble pos,
GimpRGB *color);
GimpGradientSegment * gimp_gradient_get_segment_at (GimpGradient *grad,
gdouble pos);
/* gradient segment functions */
GimpGradientSegment * gimp_gradient_segment_new (void);
GimpGradientSegment * gimp_gradient_get_segment_at (GimpGradient *grad,
gdouble pos);
GimpGradientSegment * gimp_gradient_segment_get_last (GimpGradientSegment *seg);
void gimp_gradient_segment_free (GimpGradientSegment *seg);
void gimp_gradient_segments_free (GimpGradientSegment *seg);
void gimp_gradient_segment_free (GimpGradientSegment *seg);
void gimp_gradient_segments_free (GimpGradientSegment *seg);
#endif /* __GIMP_GRADIENT_H__ */

17
app/core/gimppattern-load.c
View file

@ -60,7 +60,7 @@ static TempBuf * gimp_pattern_get_new_preview (GimpViewable *viewable,
gint height);
static GimpViewableClass *parent_class = NULL;
static GimpDataClass *parent_class = NULL;
GtkType
@ -82,7 +82,7 @@ gimp_pattern_get_type (void)
(GtkClassInitFunc) NULL
};
pattern_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &pattern_info);
pattern_type = gtk_type_unique (GIMP_TYPE_DATA, &pattern_info);
}
return pattern_type;
@ -97,7 +97,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_pattern_destroy;
@ -107,8 +107,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
static void
gimp_pattern_init (GimpPattern *pattern)
{
pattern->filename = NULL;
pattern->mask = NULL;
pattern->mask = NULL;
}
static void
@ -118,8 +117,6 @@ gimp_pattern_destroy (GtkObject *object)
pattern = GIMP_PATTERN (object);
g_free (pattern->filename);
if (pattern->mask)
temp_buf_free (pattern->mask);
@ -236,9 +233,11 @@ gimp_pattern_load (const gchar *filename)
close (fd);
GIMP_OBJECT (pattern)->name = name;
gimp_object_set_name (GIMP_OBJECT (pattern), name);
pattern->filename = g_strdup (filename);
g_free (name);
gimp_data_set_filename (GIMP_DATA (pattern), filename);
/* Swap the pattern to disk (if we're being stingy with memory) */
if (stingy_memory_use)

17
app/core/gimppattern.c
View file

@ -60,7 +60,7 @@ static TempBuf * gimp_pattern_get_new_preview (GimpViewable *viewable,
gint height);
static GimpViewableClass *parent_class = NULL;
static GimpDataClass *parent_class = NULL;
GtkType
@ -82,7 +82,7 @@ gimp_pattern_get_type (void)
(GtkClassInitFunc) NULL
};
pattern_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &pattern_info);
pattern_type = gtk_type_unique (GIMP_TYPE_DATA, &pattern_info);
}
return pattern_type;
@ -97,7 +97,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_pattern_destroy;
@ -107,8 +107,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
static void
gimp_pattern_init (GimpPattern *pattern)
{
pattern->filename = NULL;
pattern->mask = NULL;
pattern->mask = NULL;
}
static void
@ -118,8 +117,6 @@ gimp_pattern_destroy (GtkObject *object)
pattern = GIMP_PATTERN (object);
g_free (pattern->filename);
if (pattern->mask)
temp_buf_free (pattern->mask);
@ -236,9 +233,11 @@ gimp_pattern_load (const gchar *filename)
close (fd);
GIMP_OBJECT (pattern)->name = name;
gimp_object_set_name (GIMP_OBJECT (pattern), name);
pattern->filename = g_strdup (filename);
g_free (name);
gimp_data_set_filename (GIMP_DATA (pattern), filename);
/* Swap the pattern to disk (if we're being stingy with memory) */
if (stingy_memory_use)

9
app/core/gimppattern.h
View file

@ -20,7 +20,7 @@
#define __GIMP_PATTERN_H__
#include "gimpviewable.h"
#include "gimpdata.h"
#define GIMP_TYPE_PATTERN (gimp_pattern_get_type ())
@ -34,15 +34,14 @@ typedef struct _GimpPatternClass GimpPatternClass;
struct _GimpPattern
{
GimpViewable parent_instance;
GimpData parent_instance;
gchar *filename; /* actual filename--pattern's location on disk */
TempBuf *mask; /* the actual mask */
TempBuf *mask;
};
struct _GimpPatternClass
{
GimpViewableClass parent_class;
GimpDataClass parent_class;
};

20
app/gimpbrush.c
View file

@ -89,7 +89,7 @@ gimp_brush_get_type (void)
(GtkClassInitFunc) NULL
};
type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &info);
type = gtk_type_unique (GIMP_TYPE_DATA, &info);
}
return type;
}
@ -103,7 +103,7 @@ gimp_brush_class_init (GimpBrushClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_brush_destroy;
@ -116,16 +116,14 @@ gimp_brush_class_init (GimpBrushClass *klass)
static void
gimp_brush_init (GimpBrush *brush)
{
brush->filename = NULL;
brush->mask = NULL;
brush->pixmap = NULL;
brush->spacing = 20;
brush->x_axis.x = 15.0;
brush->x_axis.y = 0.0;
brush->y_axis.x = 0.0;
brush->y_axis.y = 15.0;
brush->mask = NULL;
brush->pixmap = NULL;
}
static void
@ -135,8 +133,6 @@ gimp_brush_destroy (GtkObject *object)
brush = GIMP_BRUSH (object);
g_free (brush->filename);
if (brush->mask)
temp_buf_free (brush->mask);
@ -269,12 +265,16 @@ gimp_brush_load (const gchar *filename)
close (fd);
brush->filename = g_strdup (filename);
if (! brush)
return NULL;
gimp_data_set_filename (GIMP_DATA (brush), filename);
/* Swap the brush to disk (if we're being stingy with memory) */
if (stingy_memory_use)
{
temp_buf_swap (brush->mask);
if (brush->pixmap)
temp_buf_swap (brush->pixmap);
}
@ -429,7 +429,7 @@ gimp_brush_load_brush (gint fd,
}
}
break;
default:
g_message ("Unsupported brush depth: %d\n"
"in file \"%s\"\n"

18
app/gimpbrush.h
View file

@ -20,7 +20,7 @@
#define __GIMP_BRUSH_H__
#include "gimpviewable.h"
#include "gimpdata.h"
#define GIMP_TYPE_BRUSH (gimp_brush_get_type ())
@ -34,19 +34,19 @@ typedef struct _GimpBrushClass GimpBrushClass;
struct _GimpBrush
{
GimpViewable parent_instance;
GimpData parent_instance;
gchar *filename; /* actual filename--brush's location on disk */
gint spacing; /* brush's spacing */
GimpVector2 x_axis; /* for calculating brush spacing */
GimpVector2 y_axis; /* for calculating brush spacing */
TempBuf *mask; /* the actual mask */
TempBuf *pixmap; /* optional pixmap data */
TempBuf *mask; /* the actual mask */
TempBuf *pixmap; /* optional pixmap data */
gint spacing; /* brush's spacing */
GimpVector2 x_axis; /* for calculating brush spacing */
GimpVector2 y_axis; /* for calculating brush spacing */
};
struct _GimpBrushClass
{
GimpViewableClass parent_class;
GimpDataClass parent_class;
/* FIXME: these are no virtual function pointers but bad hacks: */
GimpBrush * (* select_brush) (PaintCore *paint_core);

383
app/gimpbrushgenerated.c
View file

@ -47,42 +47,18 @@
#define OVERSAMPLING 5
static void gimp_brush_generated_generate (GimpBrushGenerated *brush);
/* local function prototypes */
static void gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass);
static void gimp_brush_generated_init (GimpBrushGenerated *brush);
static void gimp_brush_generated_destroy (GtkObject *object);
static gboolean gimp_brush_generated_save (GimpData *data);
static void gimp_brush_generated_dirty (GimpData *data);
static GimpBrushClass *parent_class = NULL;
static void
gimp_brush_generated_destroy (GtkObject *object)
{
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
object_class->destroy = gimp_brush_generated_destroy;
}
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
guint
GtkType
gimp_brush_generated_get_type (void)
{
static GtkType type = 0;
@ -107,162 +83,56 @@ gimp_brush_generated_get_type (void)
return type;
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
static void
gimp_brush_generated_class_init (GimpBrushGeneratedClass *klass)
{
GimpBrushGenerated *brush;
GtkObjectClass *object_class;
GimpDataClass *data_class;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
object_class = (GtkObjectClass *) klass;
data_class = (GimpDataClass *) klass;
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
parent_class = gtk_type_class (GIMP_TYPE_BRUSH);
GIMP_BRUSH (brush)->spacing = 20;
object_class->destroy = gimp_brush_generated_destroy;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_brush_generated_generate (brush);
return GIMP_BRUSH (brush);
data_class->save = gimp_brush_generated_save;
data_class->dirty = gimp_brush_generated_dirty;
}
GimpBrush *
gimp_brush_generated_load (const gchar *file_name)
static void
gimp_brush_generated_init (GimpBrushGenerated *brush)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (file_name, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush =
GIMP_BRUSH_GENERATED (gtk_type_new (gimp_brush_generated_get_type ()));
GIMP_BRUSH (brush)->filename = g_strdup (file_name);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
brush->radius = 5.0;
brush->hardness = 0.0;
brush->angle = 0.0;
brush->aspect_ratio = 1.0;
brush->freeze = 0;
}
void
gimp_brush_generated_save (GimpBrushGenerated *brush,
const gchar *directory)
static void
gimp_brush_generated_destroy (GtkObject *object)
{
FILE *fp;
gchar *filename = NULL;
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
g_return_if_fail (directory != NULL);
static gboolean
gimp_brush_generated_save (GimpData *data)
{
GimpBrushGenerated *brush;
FILE *fp;
if (! GIMP_BRUSH (brush)->filename)
{
gchar *safe_name;
gint i;
gint unum = 1;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_BRUSH_GENERATED (data), FALSE);
/* make sure we don't create a naughty filename */
safe_name = g_strdup (GIMP_OBJECT (brush)->name);
if (safe_name[0] == '.')
safe_name[0] = '_';
for (i = 0; safe_name[i]; i++)
if (safe_name[i] == G_DIR_SEPARATOR || isspace (safe_name[i]))
safe_name[i] = '_';
filename = g_strdup_printf ("%s%s.vbr",
directory, safe_name);
while ((fp = fopen (filename, "r")))
{
/* make sure we don't overite an existing brush */
fclose (fp);
g_free (filename);
filename = g_strdup_printf ("%s%s_%d.vbr",
directory, safe_name, unum);
unum++;
}
g_free (safe_name);
}
else
{
filename = g_strdup (GIMP_BRUSH (brush)->filename);
if (strlen(filename) < 4 || strcmp (&filename[strlen (filename) - 4],
".vbr"))
{
/* we only want to save .vbr files, so set filename to null
* if this isn't a .vbr file
*/
g_free (filename);
filename = NULL;
}
}
if (! filename)
return;
brush = GIMP_BRUSH_GENERATED (data);
/* we are (finaly) ready to try to save the generated brush file */
if ((fp = fopen (filename, "wb")) == NULL)
if ((fp = fopen (data->filename, "wb")) == NULL)
{
g_warning ("Unable to save file %s", filename);
return;
g_warning ("Unable to save file %s", data->filename);
return FALSE;
}
/* write magic header */
@ -290,37 +160,8 @@ gimp_brush_generated_save (GimpBrushGenerated *brush,
fprintf (fp, "%f\n", brush->angle);
fclose (fp);
}
void
gimp_brush_generated_delete (GimpBrushGenerated *brush)
{
if (GIMP_BRUSH (brush)->filename)
{
unlink (GIMP_BRUSH (brush)->filename);
}
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_brush_generated_generate (brush);
return TRUE;
}
static double
@ -340,9 +181,10 @@ gauss (gdouble f)
return (2.0 * f*f);
}
void
gimp_brush_generated_generate (GimpBrushGenerated *brush)
static void
gimp_brush_generated_dirty (GimpData *data)
{
GimpBrushGenerated *brush;
register GimpBrush *gbrush = NULL;
register gint x, y;
register guchar *centerp;
@ -355,9 +197,8 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
gdouble buffer[OVERSAMPLING];
gint width, height;
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush = GIMP_BRUSH_GENERATED (data);
if (brush->freeze) /* if we are frozen defer rerendering till later */
return;
@ -368,7 +209,7 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
if (gbrush->mask)
{
temp_buf_free(gbrush->mask);
temp_buf_free (gbrush->mask);
}
/* compute the range of the brush. should do a better job than this? */
@ -462,9 +303,129 @@ gimp_brush_generated_generate (GimpBrushGenerated *brush)
g_free (lookup);
if (GIMP_DATA_CLASS (parent_class)->dirty)
GIMP_DATA_CLASS (parent_class)->dirty (data);
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (brush));
}
GimpBrush *
gimp_brush_generated_new (gfloat radius,
gfloat hardness,
gfloat angle,
gfloat aspect_ratio)
{
GimpBrushGenerated *brush;
/* set up normal brush data */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_object_set_name (GIMP_OBJECT (brush), "Untitled");
GIMP_BRUSH (brush)->spacing = 20;
/* set up gimp_brush_generated data */
brush->radius = radius;
brush->hardness = hardness;
brush->angle = angle;
brush->aspect_ratio = aspect_ratio;
/* render brush mask */
gimp_data_dirty (GIMP_DATA (brush));
return GIMP_BRUSH (brush);
}
GimpBrush *
gimp_brush_generated_load (const gchar *filename)
{
GimpBrushGenerated *brush;
FILE *fp;
gchar string[256];
gfloat fl;
gfloat version;
if ((fp = fopen (filename, "rb")) == NULL)
return NULL;
/* make sure the file we are reading is the right type */
fgets (string, 255, fp);
if (strncmp (string, "GIMP-VBR", 8) != 0)
return NULL;
/* make sure we are reading a compatible version */
fgets (string, 255, fp);
sscanf (string, "%f", &version);
g_return_val_if_fail (version < 2.0, NULL);
/* create new brush */
brush = GIMP_BRUSH_GENERATED (gtk_type_new (GIMP_TYPE_BRUSH_GENERATED));
gimp_data_set_filename (GIMP_DATA (brush), filename);
gimp_brush_generated_freeze (brush);
/* read name */
fgets (string, 255, fp);
if (string[strlen (string) - 1] == '\n')
string[strlen (string) - 1] = 0;
gimp_object_set_name (GIMP_OBJECT (brush), string);
/* read brush spacing */
fscanf (fp, "%f", &fl);
GIMP_BRUSH (brush)->spacing = fl;
/* read brush radius */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_radius (brush, fl);
/* read brush hardness */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_hardness (brush, fl);
/* read brush aspect_ratio */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_aspect_ratio (brush, fl);
/* read brush angle */
fscanf (fp, "%f", &fl);
gimp_brush_generated_set_angle (brush, fl);
fclose (fp);
gimp_brush_generated_thaw (brush);
GIMP_DATA (brush)->dirty = FALSE;
if (stingy_memory_use)
temp_buf_swap (GIMP_BRUSH (brush)->mask);
return GIMP_BRUSH (brush);
}
void
gimp_brush_generated_freeze (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
brush->freeze++;
}
void
gimp_brush_generated_thaw (GimpBrushGenerated *brush)
{
g_return_if_fail (brush != NULL);
g_return_if_fail (GIMP_IS_BRUSH_GENERATED (brush));
if (brush->freeze > 0)
brush->freeze--;
if (brush->freeze == 0)
gimp_data_dirty (GIMP_DATA (brush));
}
gfloat
gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
gfloat radius)
@ -481,8 +442,8 @@ gimp_brush_generated_set_radius (GimpBrushGenerated *brush,
brush->radius = radius;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
if (! brush->freeze)
gimp_data_dirty (GIMP_DATA (brush));
return brush->radius;
}
@ -504,7 +465,7 @@ gimp_brush_generated_set_hardness (GimpBrushGenerated *brush,
brush->hardness = hardness;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->hardness;
}
@ -526,7 +487,7 @@ gimp_brush_generated_set_angle (GimpBrushGenerated *brush,
brush->angle = angle;
if (!brush->freeze)
gimp_brush_generated_generate (brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->angle;
}
@ -548,7 +509,7 @@ gimp_brush_generated_set_aspect_ratio (GimpBrushGenerated *brush,
brush->aspect_ratio = ratio;
if (!brush->freeze)
gimp_brush_generated_generate(brush);
gimp_data_dirty (GIMP_DATA (brush));
return brush->aspect_ratio;
}

7
app/gimpbrushgenerated.h
View file

@ -25,6 +25,9 @@
#include "gimpbrush.h"
#define GIMP_BRUSH_GENERATED_FILE_EXTENSION ".vbr"
#define GIMP_TYPE_BRUSH_GENERATED (gimp_brush_generated_get_type ())
#define GIMP_BRUSH_GENERATED(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGenerated))
#define GIMP_BRUSH_GENERATED_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_BRUSH_GENERATED, GimpBrushGeneratedClass))
@ -60,10 +63,6 @@ GimpBrush * gimp_brush_generated_new (gfloat radius,
gfloat aspect_ratio);
GimpBrush * gimp_brush_generated_load (const gchar *file_name);
void gimp_brush_generated_save (GimpBrushGenerated *brush,
const gchar *directory);
void gimp_brush_generated_delete (GimpBrushGenerated *brush);
void gimp_brush_generated_freeze (GimpBrushGenerated *brush);
void gimp_brush_generated_thaw (GimpBrushGenerated *brush);

3
app/gimpbrushpipe.c
View file

@ -396,8 +396,9 @@ gimp_brush_pipe_load (const gchar *filename)
/* Current brush is the first one. */
pipe->current = pipe->brushes[0];
gimp_data_set_filename (GIMP_DATA (pipe), filename);
/* just to satisfy the code that relies on this crap */
GIMP_BRUSH (pipe)->filename = g_strdup (filename);
GIMP_BRUSH (pipe)->spacing = pipe->current->spacing;
GIMP_BRUSH (pipe)->x_axis = pipe->current->x_axis;
GIMP_BRUSH (pipe)->y_axis = pipe->current->y_axis;

254
app/gimpdata.c Normal file
View file

@ -0,0 +1,254 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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 <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <gtk/gtk.h>
#include "apptypes.h"
#include "gimpdata.h"
#include "libgimp/gimpenv.h"
enum
{
DIRTY,
SAVE,
LAST_SIGNAL
};
static void gimp_data_class_init (GimpDataClass *klass);
static void gimp_data_init (GimpData *data);
static void gimp_data_destroy (GtkObject *object);
static void gimp_data_real_dirty (GimpData *data);
static guint data_signals[LAST_SIGNAL] = { 0 };
static GimpViewableClass *parent_class = NULL;
GtkType
gimp_data_get_type (void)
{
static GtkType data_type = 0;
if (! data_type)
{
static const GtkTypeInfo data_info =
{
"GimpData",
sizeof (GimpData),
sizeof (GimpDataClass),
(GtkClassInitFunc) gimp_data_class_init,
(GtkObjectInitFunc) gimp_data_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL
};
data_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &data_info);
}
return data_type;
}
static void
gimp_data_class_init (GimpDataClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
data_signals[DIRTY] =
gtk_signal_new ("dirty",
GTK_RUN_FIRST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
dirty),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
data_signals[SAVE] =
gtk_signal_new ("save",
GTK_RUN_LAST,
object_class->type,
GTK_SIGNAL_OFFSET (GimpDataClass,
save),
gtk_marshal_BOOL__NONE,
GTK_TYPE_BOOL, 0);
object_class->destroy = gimp_data_destroy;
klass->dirty = gimp_data_real_dirty;
klass->save = NULL;
}
static void
gimp_data_init (GimpData *data)
{
data->filename = NULL;
data->dirty = FALSE;
}
static void
gimp_data_destroy (GtkObject *object)
{
GimpData *data;
data = GIMP_DATA (object);
g_free (data->filename);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
gboolean
gimp_data_save (GimpData *data)
{
gboolean success = FALSE;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
if (! data->filename)
{
g_warning ("%s(): can't save data with NULL filename",
G_GNUC_FUNCTION);
return FALSE;
}
gtk_signal_emit (GTK_OBJECT (data), data_signals[SAVE],
&success);
if (success)
data->dirty = FALSE;
return success;
}
void
gimp_data_dirty (GimpData *data)
{
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
gtk_signal_emit (GTK_OBJECT (data), data_signals[DIRTY]);
}
static void
gimp_data_real_dirty (GimpData *data)
{
data->dirty = TRUE;
}
gboolean
gimp_data_delete_from_disk (GimpData *data)
{
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
g_return_val_if_fail (data->filename != NULL, FALSE);
if (unlink (data->filename) == -1)
{
g_message ("%s(): could not unlink() %s: %s",
G_GNUC_FUNCTION, data->filename, g_strerror (errno));
return FALSE;
}
return TRUE;
}
void
gimp_data_set_filename (GimpData *data,
const gchar *filename)
{
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
g_free (data->filename);
data->filename = g_strdup (filename);
}
void
gimp_data_create_filename (GimpData *data,
const gchar *basename,
const gchar *extension,
const gchar *data_path)
{
GList *path;
gchar *dir;
gchar *filename;
gchar *safe_name;
gint i;
gint unum = 1;
FILE *file;
g_return_if_fail (data != NULL);
g_return_if_fail (GIMP_IS_DATA (data));
g_return_if_fail (basename != NULL);
g_return_if_fail (extension != NULL);
g_return_if_fail (data_path != NULL);
path = gimp_path_parse (data_path, 16, TRUE, NULL);
dir = gimp_path_get_user_writable_dir (path);
gimp_path_free (path);
if (! dir)
return;
safe_name = g_strdup (basename);
if (safe_name[0] == '.')
safe_name[0] = '_';
for (i = 0; safe_name[i]; i++)
if (safe_name[i] == G_DIR_SEPARATOR || isspace (safe_name[i]))
safe_name[i] = '_';
filename = g_strdup_printf ("%s%s%s", dir, safe_name, extension);
while ((file = fopen (filename, "r")))
{
fclose (file);
g_free (filename);
filename = g_strdup_printf ("%s%s_%d%s", dir, safe_name, unum, extension);
unum++;
}
g_free (dir);
g_free (safe_name);
gimp_data_set_filename (data, filename);
g_free (filename);
}

67
app/gimpdata.h Normal file
View file

@ -0,0 +1,67 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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_DATA_H__
#define __GIMP_DATA_H__
#include "gimpviewable.h"
#define GIMP_TYPE_DATA (gimp_data_get_type ())
#define GIMP_DATA(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_DATA, GimpData))
#define GIMP_DATA_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_DATA, GimpDataClass))
#define GIMP_IS_DATA(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_DATA))
#define GIMP_IS_DATA_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_DATA))
typedef struct _GimpDataClass GimpDataClass;
struct _GimpData
{
GimpViewable parent_instance;
gchar *filename;
gboolean dirty;
};
struct _GimpDataClass
{
GimpViewableClass parent_class;
void (* dirty) (GimpData *data);
gboolean (* save) (GimpData *data);
};
GtkType gimp_data_get_type (void);
gboolean gimp_data_save (GimpData *data);
void gimp_data_dirty (GimpData *data);
gboolean gimp_data_delete_from_disk (GimpData *data);
void gimp_data_set_filename (GimpData *data,
const gchar *filename);
void gimp_data_create_filename (GimpData *data,
const gchar *filename,
const gchar *extension,
const gchar *data_path);
#endif /* __GIMP_DATA_H__ */

259
app/gimpgradient.c
View file

@ -18,28 +18,12 @@
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <fcntl.h>
#include <gtk/gtk.h>
#ifdef G_OS_WIN32
#include <io.h>
#endif
#ifndef _O_BINARY
#define _O_BINARY 0
#endif
#include "libgimpcolor/gimpcolor.h"
#include "libgimpmath/gimpmath.h"
@ -60,29 +44,28 @@
#define EPSILON 1e-10
static void gimp_gradient_class_init (GimpGradientClass *klass);
static void gimp_gradient_init (GimpGradient *gradient);
static void gimp_gradient_destroy (GtkObject *object);
static TempBuf * gimp_gradient_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static void gimp_gradient_class_init (GimpGradientClass *klass);
static void gimp_gradient_init (GimpGradient *gradient);
static void gimp_gradient_destroy (GtkObject *object);
static TempBuf * gimp_gradient_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
static void gimp_gradient_dirty (GimpData *data);
static gboolean gimp_gradient_save (GimpData *data);
static void gimp_gradient_dump (GimpGradient *grad,
FILE *file);
static gdouble gimp_gradient_calc_linear_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_curved_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sine_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_increasing_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_decreasing_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_linear_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_curved_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sine_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_increasing_factor (gdouble middle,
gdouble pos);
static gdouble gimp_gradient_calc_sphere_decreasing_factor (gdouble middle,
gdouble pos);
static GimpViewableClass *parent_class = NULL;
static GimpDataClass *parent_class = NULL;
GtkType
@ -104,7 +87,7 @@ gimp_gradient_get_type (void)
(GtkClassInitFunc) NULL
};
gradient_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &gradient_info);
gradient_type = gtk_type_unique (GIMP_TYPE_DATA, &gradient_info);
}
return gradient_type;
@ -115,23 +98,25 @@ gimp_gradient_class_init (GimpGradientClass *klass)
{
GtkObjectClass *object_class;
GimpViewableClass *viewable_class;
GimpDataClass *data_class;
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
data_class = (GimpDataClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_gradient_destroy;
viewable_class->get_new_preview = gimp_gradient_get_new_preview;
data_class->dirty = gimp_gradient_dirty;
data_class->save = gimp_gradient_save;
}
static void
gimp_gradient_init (GimpGradient *gradient)
{
gradient->filename = NULL;
gradient->dirty = FALSE;
gradient->segments = NULL;
gradient->last_visited = NULL;
@ -145,8 +130,6 @@ gimp_gradient_destroy (GtkObject *object)
gradient = GIMP_GRADIENT (object);
g_free (gradient->filename);
if (gradient->segments)
gimp_gradient_segments_free (gradient->segments);
@ -232,39 +215,6 @@ gimp_gradient_get_new_preview (GimpViewable *viewable,
return temp_buf;
}
static void
gimp_gradient_dump (GimpGradient *gradient,
FILE *file)
{
GimpGradientSegment *seg;
g_return_if_fail (gradient != NULL);
g_return_if_fail (GIMP_IS_GRADIENT (gradient));
fprintf (file, "Name: \"%s\"\n", GIMP_OBJECT (gradient)->name);
fprintf (file, "Dirty: %d\n", gradient->dirty);
fprintf (file, "Filename: \"%s\"\n", gradient->filename);
for (seg = gradient->segments; seg; seg = seg->next)
{
fprintf (file, "%c%p | %f %f %f | %f %f %f %f | %f %f %f %f | %d %d | %p %p\n",
(seg == gradient->last_visited) ? '>' : ' ',
seg,
seg->left, seg->middle, seg->right,
seg->left_color.r,
seg->left_color.g,
seg->left_color.b,
seg->left_color.a,
seg->right_color.r,
seg->right_color.g,
seg->right_color.b,
seg->right_color.a,
(int) seg->type,
(int) seg->color,
seg->prev, seg->next);
}
}
GimpGradient *
gimp_gradient_new (const gchar *name)
{
@ -308,10 +258,20 @@ gimp_gradient_load (const gchar *filename)
gradient = GIMP_GRADIENT (gtk_type_new (GIMP_TYPE_GRADIENT));
gradient->filename = g_strdup (filename);
GIMP_OBJECT (gradient)->name = g_strdup (g_basename (filename));
gimp_data_set_filename (GIMP_DATA (gradient), filename);
fgets (line, 1024, file);
if (! strncmp (line, "Name: ", strlen ("Name: ")))
{
gimp_object_set_name (GIMP_OBJECT (gradient), &line[strlen ("Name: ")]);
fgets (line, 1024, file);
}
else /* old gradient format */
{
gimp_object_set_name (GIMP_OBJECT (gradient), g_basename (filename));
}
num_segments = atoi (line);
if (num_segments < 1)
@ -368,29 +328,35 @@ gimp_gradient_load (const gchar *filename)
return gradient;
}
void
gimp_gradient_save (GimpGradient *gradient)
static void
gimp_gradient_dirty (GimpData *data)
{
FILE *file;
gint num_segments;
GimpGradient *gradient;
gradient = GIMP_GRADIENT (data);
gradient->last_visited = NULL;
if (GIMP_DATA_CLASS (parent_class)->dirty)
GIMP_DATA_CLASS (parent_class)->dirty (data);
}
static gboolean
gimp_gradient_save (GimpData *data)
{
GimpGradient *gradient;
GimpGradientSegment *seg;
gint num_segments;
FILE *file;
g_return_if_fail (gradient != NULL);
g_return_if_fail (GIMP_IS_GRADIENT (gradient));
gradient = GIMP_GRADIENT (data);
if (! gradient->filename)
{
g_message ("%s(): can't save gradient with NULL filename",
G_GNUC_FUNCTION);
return;
}
file = fopen (gradient->filename, "wb");
file = fopen (data->filename, "wb");
if (! file)
{
g_message ("%s(): can't open \"%s\"",
G_GNUC_FUNCTION, gradient->filename);
return;
G_GNUC_FUNCTION, data->filename);
return FALSE;
}
/* File format is:
@ -404,6 +370,8 @@ gimp_gradient_save (GimpGradient *gradient)
fprintf (file, "GIMP Gradient\n");
fprintf (file, "Name: %s\n", GIMP_OBJECT (gradient)->name);
/* Count number of segments */
num_segments = 0;
seg = gradient->segments;
@ -435,7 +403,7 @@ gimp_gradient_save (GimpGradient *gradient)
fclose (file);
gradient->dirty = FALSE;
return TRUE;
}
void
@ -503,9 +471,8 @@ gimp_gradient_get_color_at (GimpGradient *gradient,
break;
default:
gimp_gradient_dump (gradient, stderr);
gimp_fatal_error ("gradient_get_color_at(): Unknown gradient type %d",
(int) seg->type);
gimp_fatal_error ("%s(): Unknown gradient type %d",
G_GNUC_FUNCTION, (gint) seg->type);
break;
}
@ -566,9 +533,8 @@ gimp_gradient_get_color_at (GimpGradient *gradient,
break;
default:
gimp_gradient_dump (gradient, stderr);
gimp_fatal_error ("gradient_get_color_at(): Unknown coloring mode %d",
(int) seg->color);
gimp_fatal_error ("%s(): Unknown coloring mode %d",
G_GNUC_FUNCTION, (gint) seg->color);
break;
}
@ -578,6 +544,50 @@ gimp_gradient_get_color_at (GimpGradient *gradient,
*color = rgb;
}
GimpGradientSegment *
gimp_gradient_get_segment_at (GimpGradient *gradient,
gdouble pos)
{
GimpGradientSegment *seg;
g_return_val_if_fail (gradient != NULL, NULL);
g_return_val_if_fail (GIMP_IS_GRADIENT (gradient), NULL);
/* handle FP imprecision at the edges of the gradient */
pos = CLAMP (pos, 0.0, 1.0);
if (gradient->last_visited)
seg = gradient->last_visited;
else
seg = gradient->segments;
while (seg)
{
if (pos >= seg->left)
{
if (pos <= seg->right)
{
gradient->last_visited = seg; /* for speed */
return seg;
}
else
{
seg = seg->next;
}
}
else
{
seg = seg->prev;
}
}
/* Oops: we should have found a segment, but we didn't */
gimp_fatal_error ("%s(): no matching segment for position %0.15f",
G_GNUC_FUNCTION, pos);
return NULL;
}
static gdouble
gimp_gradient_calc_linear_factor (gdouble middle,
gdouble pos)
@ -698,48 +708,3 @@ gimp_gradient_segment_get_last (GimpGradientSegment *seg)
return seg;
}
GimpGradientSegment *
gimp_gradient_get_segment_at (GimpGradient *gradient,
gdouble pos)
{
GimpGradientSegment *seg;
g_return_val_if_fail (gradient != NULL, NULL);
g_return_val_if_fail (GIMP_IS_GRADIENT (gradient), NULL);
/* handle FP imprecision at the edges of the gradient */
pos = CLAMP (pos, 0.0, 1.0);
if (gradient->last_visited)
seg = gradient->last_visited;
else
seg = gradient->segments;
while (seg)
{
if (pos >= seg->left)
{
if (pos <= seg->right)
{
gradient->last_visited = seg; /* for speed */
return seg;
}
else
{
seg = seg->next;
}
}
else
{
seg = seg->prev;
}
}
/* Oops: we should have found a segment, but we didn't */
gimp_gradient_dump (gradient, stderr);
gimp_fatal_error ("%s(): no matching segment for position %0.15f",
G_GNUC_FUNCTION, pos);
return NULL;
}

33
app/gimpgradient.h
View file

@ -20,7 +20,10 @@
#define __GIMP_GRADIENT_H__
#include "gimpviewable.h"
#include "gimpdata.h"
#define GIMP_GRADIENT_FILE_EXTENSION ".ggr"
typedef enum
@ -66,10 +69,7 @@ typedef struct _GimpGradientClass GimpGradientClass;
struct _GimpGradient
{
GimpViewable parent_instance;
gchar *filename;
gboolean dirty;
GimpData parent_instance;
GimpGradientSegment *segments;
@ -80,30 +80,29 @@ struct _GimpGradient
struct _GimpGradientClass
{
GimpViewableClass parent_class;
GimpDataClass parent_class;
};
GtkType gimp_gradient_get_type (void);
GimpGradient * gimp_gradient_new (const gchar *name);
GtkType gimp_gradient_get_type (void);
GimpGradient * gimp_gradient_new (const gchar *name);
GimpGradient * gimp_gradient_load (const gchar *filename);
void gimp_gradient_save (GimpGradient *gradient);
GimpGradient * gimp_gradient_load (const gchar *filename);
void gimp_gradient_get_color_at (GimpGradient *gradient,
gdouble pos,
GimpRGB *color);
void gimp_gradient_get_color_at (GimpGradient *gradient,
gdouble pos,
GimpRGB *color);
GimpGradientSegment * gimp_gradient_get_segment_at (GimpGradient *grad,
gdouble pos);
/* gradient segment functions */
GimpGradientSegment * gimp_gradient_segment_new (void);
GimpGradientSegment * gimp_gradient_get_segment_at (GimpGradient *grad,
gdouble pos);
GimpGradientSegment * gimp_gradient_segment_get_last (GimpGradientSegment *seg);
void gimp_gradient_segment_free (GimpGradientSegment *seg);
void gimp_gradient_segments_free (GimpGradientSegment *seg);
void gimp_gradient_segment_free (GimpGradientSegment *seg);
void gimp_gradient_segments_free (GimpGradientSegment *seg);
#endif /* __GIMP_GRADIENT_H__ */

17
app/gimppattern.c
View file

@ -60,7 +60,7 @@ static TempBuf * gimp_pattern_get_new_preview (GimpViewable *viewable,
gint height);
static GimpViewableClass *parent_class = NULL;
static GimpDataClass *parent_class = NULL;
GtkType
@ -82,7 +82,7 @@ gimp_pattern_get_type (void)
(GtkClassInitFunc) NULL
};
pattern_type = gtk_type_unique (GIMP_TYPE_VIEWABLE, &pattern_info);
pattern_type = gtk_type_unique (GIMP_TYPE_DATA, &pattern_info);
}
return pattern_type;
@ -97,7 +97,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
object_class = (GtkObjectClass *) klass;
viewable_class = (GimpViewableClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_VIEWABLE);
parent_class = gtk_type_class (GIMP_TYPE_DATA);
object_class->destroy = gimp_pattern_destroy;
@ -107,8 +107,7 @@ gimp_pattern_class_init (GimpPatternClass *klass)
static void
gimp_pattern_init (GimpPattern *pattern)
{
pattern->filename = NULL;
pattern->mask = NULL;
pattern->mask = NULL;
}
static void
@ -118,8 +117,6 @@ gimp_pattern_destroy (GtkObject *object)
pattern = GIMP_PATTERN (object);
g_free (pattern->filename);
if (pattern->mask)
temp_buf_free (pattern->mask);
@ -236,9 +233,11 @@ gimp_pattern_load (const gchar *filename)
close (fd);
GIMP_OBJECT (pattern)->name = name;
gimp_object_set_name (GIMP_OBJECT (pattern), name);
pattern->filename = g_strdup (filename);
g_free (name);
gimp_data_set_filename (GIMP_DATA (pattern), filename);
/* Swap the pattern to disk (if we're being stingy with memory) */
if (stingy_memory_use)

9
app/gimppattern.h
View file

@ -20,7 +20,7 @@
#define __GIMP_PATTERN_H__
#include "gimpviewable.h"
#include "gimpdata.h"
#define GIMP_TYPE_PATTERN (gimp_pattern_get_type ())
@ -34,15 +34,14 @@ typedef struct _GimpPatternClass GimpPatternClass;
struct _GimpPattern
{
GimpViewable parent_instance;
GimpData parent_instance;
gchar *filename; /* actual filename--pattern's location on disk */
TempBuf *mask; /* the actual mask */
TempBuf *mask;
};
struct _GimpPatternClass
{
GimpViewableClass parent_class;
GimpDataClass parent_class;
};

146
app/gradient_editor.c
View file

@ -524,15 +524,10 @@ static void cpopup_blend_endpoints (GimpRGB *left,
/* Segment functions */
static void seg_get_closest_handle (GimpGradient *grad,
gdouble pos,
GimpGradientSegment **seg,
control_drag_mode_t *handle);
/* Files and paths functions */
static gchar * build_user_filename (gchar *name,
gchar *path_str);
static void seg_get_closest_handle (GimpGradient *grad,
gdouble pos,
GimpGradientSegment **seg,
control_drag_mode_t *handle);
/***** Local variables *****/
@ -923,9 +918,6 @@ gradient_editor_create (void)
curr_gradient = dnd_gradient = gimp_gradient_new (_("Default"));
curr_gradient->filename =
build_user_filename (GIMP_OBJECT (curr_gradient)->name, gradient_path);
gimp_container_add (global_gradient_list, GIMP_OBJECT (curr_gradient));
pos = gimp_container_get_child_index (global_gradient_list,
@ -1365,9 +1357,7 @@ ed_do_new_gradient_callback (GtkWidget *widget,
g_free (gradient_name);
grad->dirty = TRUE;
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name,
gradient_path);
gimp_data_dirty (GIMP_DATA (grad));
/* Put new gradient in list */
gimp_container_add (global_gradient_list, GIMP_OBJECT (grad));
@ -1431,10 +1421,11 @@ ed_do_copy_gradient_callback (GtkWidget *widget,
grad = GIMP_GRADIENT (gtk_type_new (GIMP_TYPE_GRADIENT));
GIMP_OBJECT (grad)->name = gradient_name; /* We don't need to copy since
this memory is ours */
grad->dirty = TRUE;
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name, gradient_path);
gimp_object_set_name (GIMP_OBJECT (grad), gradient_name);
g_free (gradient_name);
gimp_data_dirty (GIMP_DATA (grad));
prev = NULL;
orig = curr_gradient->segments;
@ -1506,27 +1497,18 @@ ed_do_rename_gradient_callback (GtkWidget *widget,
gpointer data)
{
GimpGradient *grad = (GimpGradient *) data;
gint row;
gint row;
g_return_if_fail (grad != NULL);
g_return_if_fail (gradient_name != NULL);
if (!gradient_name)
{
g_warning ("received NULL in call_data");
return;
}
gimp_object_set_name (GIMP_OBJECT (grad), gradient_name);
g_free (GIMP_OBJECT (grad)->name);
GIMP_OBJECT (grad)->name = gradient_name; /* We don't need to copy since
this memory is ours */
grad->dirty = TRUE;
g_free (gradient_name);
/* Delete file and free gradient */
unlink (grad->filename);
gimp_data_dirty (GIMP_DATA (grad));
g_free (grad->filename);
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name,
gradient_path);
gimp_data_set_filename (GIMP_DATA (grad), NULL);
row = gtk_clist_find_row_from_data (GTK_CLIST (g_editor->clist), grad);
if (row > -1)
@ -1600,7 +1582,7 @@ ed_do_delete_gradient_callback (GtkWidget *widget,
gtk_clist_remove (GTK_CLIST (g_editor->clist), row);
/* Delete gradient from gradients list */
unlink (delete_gradient->filename);
gimp_data_delete_from_disk (GIMP_DATA (delete_gradient));
gimp_container_remove (global_gradient_list, GIMP_OBJECT (delete_gradient));
@ -1751,9 +1733,7 @@ ed_refresh_grads_callback (GtkWidget *widget,
{
curr_gradient = dnd_gradient = gimp_gradient_new (_("Default"));
curr_gradient->filename =
build_user_filename (GIMP_OBJECT (curr_gradient)->name,
gradient_path);
gimp_data_dirty (GIMP_DATA (curr_gradient));
gimp_container_add (global_gradient_list, GIMP_OBJECT (curr_gradient));
@ -2700,7 +2680,7 @@ control_motion (gint x)
if (str)
g_free (str);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
if (g_editor->instant_update)
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
@ -3910,7 +3890,8 @@ cpopup_load_left_callback (GtkWidget *widget,
break;
}
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -3961,7 +3942,8 @@ cpopup_load_right_callback (GtkWidget *widget,
break;
}
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4054,7 +4036,7 @@ static void
cpopup_set_left_color_callback (GtkWidget *widget,
gpointer data)
{
g_editor->left_saved_dirty = curr_gradient->dirty;
g_editor->left_saved_dirty = GIMP_DATA (curr_gradient)->dirty;
g_editor->left_saved_segments = cpopup_save_selection ();
color_notebook_new (_("Left Endpoint Color"),
@ -4071,7 +4053,7 @@ static void
cpopup_set_right_color_callback (GtkWidget *widget,
gpointer data)
{
g_editor->right_saved_dirty = curr_gradient->dirty;
g_editor->right_saved_dirty = GIMP_DATA (curr_gradient)->dirty;
g_editor->right_saved_segments = cpopup_save_selection ();
color_notebook_new (_("Right Endpoint Color"),
@ -4097,7 +4079,7 @@ cpopup_left_color_changed (ColorNotebook *cnb,
&g_editor->control_sel_r->right_color,
TRUE, TRUE);
gimp_gradient_segments_free (g_editor->left_saved_segments);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4106,13 +4088,13 @@ cpopup_left_color_changed (ColorNotebook *cnb,
cpopup_blend_endpoints ((GimpRGB *) color,
&g_editor->control_sel_r->right_color,
TRUE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
break;
case COLOR_NOTEBOOK_CANCEL:
cpopup_replace_selection (g_editor->left_saved_segments);
ed_update_editor (GRAD_UPDATE_GRADIENT);
curr_gradient->dirty = g_editor->left_saved_dirty;
GIMP_DATA (curr_gradient)->dirty = g_editor->left_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4133,7 +4115,7 @@ cpopup_right_color_changed (ColorNotebook *cnb,
cpopup_blend_endpoints (&g_editor->control_sel_r->left_color,
(GimpRGB *) color,
TRUE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
break;
case COLOR_NOTEBOOK_OK:
@ -4141,14 +4123,14 @@ cpopup_right_color_changed (ColorNotebook *cnb,
(GimpRGB *) color,
TRUE, TRUE);
gimp_gradient_segments_free (g_editor->right_saved_segments);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
case COLOR_NOTEBOOK_CANCEL:
cpopup_replace_selection (g_editor->right_saved_segments);
curr_gradient->dirty = g_editor->right_saved_dirty;
GIMP_DATA (curr_gradient)->dirty = g_editor->right_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4223,7 +4205,8 @@ cpopup_blending_callback (GtkWidget *widget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4291,7 +4274,8 @@ cpopup_coloring_callback (GtkWidget *widget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4314,8 +4298,8 @@ cpopup_split_midpoint_callback (GtkWidget *widget,
g_editor->control_sel_r = rseg;
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4475,8 +4459,8 @@ cpopup_split_uniform_split_callback (GtkWidget *widget,
g_editor->control_sel_l = lsel;
g_editor->control_sel_r = rseg;
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4490,7 +4474,7 @@ cpopup_split_uniform_cancel_callback (GtkWidget *widget,
static void
cpopup_split_uniform (GimpGradientSegment *lseg,
int parts,
gint parts,
GimpGradientSegment **newl,
GimpGradientSegment **newr)
{
@ -4641,8 +4625,7 @@ cpopup_delete_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4666,7 +4649,8 @@ cpopup_recenter_callback (GtkWidget *wiodget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4720,7 +4704,8 @@ cpopup_redistribute_callback (GtkWidget *widget,
/* Done */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4914,8 +4899,7 @@ cpopup_flip_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -5102,8 +5086,7 @@ cpopup_do_replicate_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -5126,7 +5109,8 @@ cpopup_blend_colors (GtkWidget *widget,
&g_editor->control_sel_r->right_color,
TRUE, FALSE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -5138,7 +5122,8 @@ cpopup_blend_opacity (GtkWidget *widget,
&g_editor->control_sel_r->right_color,
FALSE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -5228,32 +5213,3 @@ seg_get_closest_handle (GimpGradient *grad,
}
}
}
/***** Files and paths functions *****/
static gchar *
build_user_filename (gchar *name,
gchar *path_str)
{
GList *grad_path;
gchar *grad_dir;
gchar *filename;
g_assert (name != NULL);
if (!path_str)
return NULL; /* Perhaps this is not a good idea */
grad_path = gimp_path_parse (path_str, 16, TRUE, NULL);
grad_dir = gimp_path_get_user_writable_dir (grad_path);
gimp_path_free (grad_path);
if (!grad_dir)
return NULL; /* Perhaps this is not a good idea */
filename = g_strdup_printf ("%s%s", grad_dir, name);
g_free (grad_dir);
return filename;
}

19
app/gradients.c
View file

@ -81,15 +81,20 @@ gradients_free (void)
while (GIMP_LIST (global_gradient_list)->list)
{
GimpGradient *gradient =
GIMP_GRADIENT (GIMP_LIST (global_gradient_list)->list->data);
GimpData *data;
if (gradient->dirty)
gimp_gradient_save (gradient);
data = GIMP_DATA (GIMP_LIST (global_gradient_list)->list->data);
gimp_container_remove
(global_gradient_list,
GIMP_OBJECT (GIMP_LIST (global_gradient_list)->list->data));
if (! data->filename)
gimp_data_create_filename (data,
GIMP_OBJECT (data)->name,
GIMP_GRADIENT_FILE_EXTENSION,
brush_path);
if (data->dirty)
gimp_data_save (data);
gimp_container_remove (global_gradient_list, GIMP_OBJECT (data));
}
gradient_select_thaw_all ();

3
app/gui/brush-select.c
View file

@ -35,6 +35,7 @@
#include "gimpbrushgenerated.h"
#include "gimpbrushpipe.h"
#include "gimpcontext.h"
#include "gimpdata.h"
#include "gimpdnd.h"
#include "gimplist.h"
#include "gimprc.h"
@ -1878,7 +1879,7 @@ brush_select_delete_brush_callback (GtkWidget *widget,
if (GIMP_IS_BRUSH_GENERATED (brush))
{
gimp_brush_generated_delete (GIMP_BRUSH_GENERATED (brush));
gimp_data_delete_from_disk (GIMP_DATA (brush));
brush_select_freeze_all ();

146
app/gui/gradient-editor.c
View file

@ -524,15 +524,10 @@ static void cpopup_blend_endpoints (GimpRGB *left,
/* Segment functions */
static void seg_get_closest_handle (GimpGradient *grad,
gdouble pos,
GimpGradientSegment **seg,
control_drag_mode_t *handle);
/* Files and paths functions */
static gchar * build_user_filename (gchar *name,
gchar *path_str);
static void seg_get_closest_handle (GimpGradient *grad,
gdouble pos,
GimpGradientSegment **seg,
control_drag_mode_t *handle);
/***** Local variables *****/
@ -923,9 +918,6 @@ gradient_editor_create (void)
curr_gradient = dnd_gradient = gimp_gradient_new (_("Default"));
curr_gradient->filename =
build_user_filename (GIMP_OBJECT (curr_gradient)->name, gradient_path);
gimp_container_add (global_gradient_list, GIMP_OBJECT (curr_gradient));
pos = gimp_container_get_child_index (global_gradient_list,
@ -1365,9 +1357,7 @@ ed_do_new_gradient_callback (GtkWidget *widget,
g_free (gradient_name);
grad->dirty = TRUE;
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name,
gradient_path);
gimp_data_dirty (GIMP_DATA (grad));
/* Put new gradient in list */
gimp_container_add (global_gradient_list, GIMP_OBJECT (grad));
@ -1431,10 +1421,11 @@ ed_do_copy_gradient_callback (GtkWidget *widget,
grad = GIMP_GRADIENT (gtk_type_new (GIMP_TYPE_GRADIENT));
GIMP_OBJECT (grad)->name = gradient_name; /* We don't need to copy since
this memory is ours */
grad->dirty = TRUE;
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name, gradient_path);
gimp_object_set_name (GIMP_OBJECT (grad), gradient_name);
g_free (gradient_name);
gimp_data_dirty (GIMP_DATA (grad));
prev = NULL;
orig = curr_gradient->segments;
@ -1506,27 +1497,18 @@ ed_do_rename_gradient_callback (GtkWidget *widget,
gpointer data)
{
GimpGradient *grad = (GimpGradient *) data;
gint row;
gint row;
g_return_if_fail (grad != NULL);
g_return_if_fail (gradient_name != NULL);
if (!gradient_name)
{
g_warning ("received NULL in call_data");
return;
}
gimp_object_set_name (GIMP_OBJECT (grad), gradient_name);
g_free (GIMP_OBJECT (grad)->name);
GIMP_OBJECT (grad)->name = gradient_name; /* We don't need to copy since
this memory is ours */
grad->dirty = TRUE;
g_free (gradient_name);
/* Delete file and free gradient */
unlink (grad->filename);
gimp_data_dirty (GIMP_DATA (grad));
g_free (grad->filename);
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name,
gradient_path);
gimp_data_set_filename (GIMP_DATA (grad), NULL);
row = gtk_clist_find_row_from_data (GTK_CLIST (g_editor->clist), grad);
if (row > -1)
@ -1600,7 +1582,7 @@ ed_do_delete_gradient_callback (GtkWidget *widget,
gtk_clist_remove (GTK_CLIST (g_editor->clist), row);
/* Delete gradient from gradients list */
unlink (delete_gradient->filename);
gimp_data_delete_from_disk (GIMP_DATA (delete_gradient));
gimp_container_remove (global_gradient_list, GIMP_OBJECT (delete_gradient));
@ -1751,9 +1733,7 @@ ed_refresh_grads_callback (GtkWidget *widget,
{
curr_gradient = dnd_gradient = gimp_gradient_new (_("Default"));
curr_gradient->filename =
build_user_filename (GIMP_OBJECT (curr_gradient)->name,
gradient_path);
gimp_data_dirty (GIMP_DATA (curr_gradient));
gimp_container_add (global_gradient_list, GIMP_OBJECT (curr_gradient));
@ -2700,7 +2680,7 @@ control_motion (gint x)
if (str)
g_free (str);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
if (g_editor->instant_update)
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
@ -3910,7 +3890,8 @@ cpopup_load_left_callback (GtkWidget *widget,
break;
}
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -3961,7 +3942,8 @@ cpopup_load_right_callback (GtkWidget *widget,
break;
}
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4054,7 +4036,7 @@ static void
cpopup_set_left_color_callback (GtkWidget *widget,
gpointer data)
{
g_editor->left_saved_dirty = curr_gradient->dirty;
g_editor->left_saved_dirty = GIMP_DATA (curr_gradient)->dirty;
g_editor->left_saved_segments = cpopup_save_selection ();
color_notebook_new (_("Left Endpoint Color"),
@ -4071,7 +4053,7 @@ static void
cpopup_set_right_color_callback (GtkWidget *widget,
gpointer data)
{
g_editor->right_saved_dirty = curr_gradient->dirty;
g_editor->right_saved_dirty = GIMP_DATA (curr_gradient)->dirty;
g_editor->right_saved_segments = cpopup_save_selection ();
color_notebook_new (_("Right Endpoint Color"),
@ -4097,7 +4079,7 @@ cpopup_left_color_changed (ColorNotebook *cnb,
&g_editor->control_sel_r->right_color,
TRUE, TRUE);
gimp_gradient_segments_free (g_editor->left_saved_segments);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4106,13 +4088,13 @@ cpopup_left_color_changed (ColorNotebook *cnb,
cpopup_blend_endpoints ((GimpRGB *) color,
&g_editor->control_sel_r->right_color,
TRUE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
break;
case COLOR_NOTEBOOK_CANCEL:
cpopup_replace_selection (g_editor->left_saved_segments);
ed_update_editor (GRAD_UPDATE_GRADIENT);
curr_gradient->dirty = g_editor->left_saved_dirty;
GIMP_DATA (curr_gradient)->dirty = g_editor->left_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4133,7 +4115,7 @@ cpopup_right_color_changed (ColorNotebook *cnb,
cpopup_blend_endpoints (&g_editor->control_sel_r->left_color,
(GimpRGB *) color,
TRUE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
break;
case COLOR_NOTEBOOK_OK:
@ -4141,14 +4123,14 @@ cpopup_right_color_changed (ColorNotebook *cnb,
(GimpRGB *) color,
TRUE, TRUE);
gimp_gradient_segments_free (g_editor->right_saved_segments);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
case COLOR_NOTEBOOK_CANCEL:
cpopup_replace_selection (g_editor->right_saved_segments);
curr_gradient->dirty = g_editor->right_saved_dirty;
GIMP_DATA (curr_gradient)->dirty = g_editor->right_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4223,7 +4205,8 @@ cpopup_blending_callback (GtkWidget *widget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4291,7 +4274,8 @@ cpopup_coloring_callback (GtkWidget *widget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4314,8 +4298,8 @@ cpopup_split_midpoint_callback (GtkWidget *widget,
g_editor->control_sel_r = rseg;
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4475,8 +4459,8 @@ cpopup_split_uniform_split_callback (GtkWidget *widget,
g_editor->control_sel_l = lsel;
g_editor->control_sel_r = rseg;
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4490,7 +4474,7 @@ cpopup_split_uniform_cancel_callback (GtkWidget *widget,
static void
cpopup_split_uniform (GimpGradientSegment *lseg,
int parts,
gint parts,
GimpGradientSegment **newl,
GimpGradientSegment **newr)
{
@ -4641,8 +4625,7 @@ cpopup_delete_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4666,7 +4649,8 @@ cpopup_recenter_callback (GtkWidget *wiodget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4720,7 +4704,8 @@ cpopup_redistribute_callback (GtkWidget *widget,
/* Done */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4914,8 +4899,7 @@ cpopup_flip_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -5102,8 +5086,7 @@ cpopup_do_replicate_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -5126,7 +5109,8 @@ cpopup_blend_colors (GtkWidget *widget,
&g_editor->control_sel_r->right_color,
TRUE, FALSE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -5138,7 +5122,8 @@ cpopup_blend_opacity (GtkWidget *widget,
&g_editor->control_sel_r->right_color,
FALSE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -5228,32 +5213,3 @@ seg_get_closest_handle (GimpGradient *grad,
}
}
}
/***** Files and paths functions *****/
static gchar *
build_user_filename (gchar *name,
gchar *path_str)
{
GList *grad_path;
gchar *grad_dir;
gchar *filename;
g_assert (name != NULL);
if (!path_str)
return NULL; /* Perhaps this is not a good idea */
grad_path = gimp_path_parse (path_str, 16, TRUE, NULL);
grad_dir = gimp_path_get_user_writable_dir (grad_path);
gimp_path_free (grad_path);
if (!grad_dir)
return NULL; /* Perhaps this is not a good idea */
filename = g_strdup_printf ("%s%s", grad_dir, name);
g_free (grad_dir);
return filename;
}

3
app/patterns.c
View file

@ -101,8 +101,7 @@ patterns_get_standard_pattern (void)
gimp_object_set_name (GIMP_OBJECT (standard_pattern), "Standard");
standard_pattern->filename = NULL;
standard_pattern->mask = temp_buf_new (32, 32, 3, 0, 0, NULL);
standard_pattern->mask = temp_buf_new (32, 32, 3, 0, 0, NULL);
data = temp_buf_data (standard_pattern->mask);

146
app/widgets/gimpgradienteditor.c
View file

@ -524,15 +524,10 @@ static void cpopup_blend_endpoints (GimpRGB *left,
/* Segment functions */
static void seg_get_closest_handle (GimpGradient *grad,
gdouble pos,
GimpGradientSegment **seg,
control_drag_mode_t *handle);
/* Files and paths functions */
static gchar * build_user_filename (gchar *name,
gchar *path_str);
static void seg_get_closest_handle (GimpGradient *grad,
gdouble pos,
GimpGradientSegment **seg,
control_drag_mode_t *handle);
/***** Local variables *****/
@ -923,9 +918,6 @@ gradient_editor_create (void)
curr_gradient = dnd_gradient = gimp_gradient_new (_("Default"));
curr_gradient->filename =
build_user_filename (GIMP_OBJECT (curr_gradient)->name, gradient_path);
gimp_container_add (global_gradient_list, GIMP_OBJECT (curr_gradient));
pos = gimp_container_get_child_index (global_gradient_list,
@ -1365,9 +1357,7 @@ ed_do_new_gradient_callback (GtkWidget *widget,
g_free (gradient_name);
grad->dirty = TRUE;
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name,
gradient_path);
gimp_data_dirty (GIMP_DATA (grad));
/* Put new gradient in list */
gimp_container_add (global_gradient_list, GIMP_OBJECT (grad));
@ -1431,10 +1421,11 @@ ed_do_copy_gradient_callback (GtkWidget *widget,
grad = GIMP_GRADIENT (gtk_type_new (GIMP_TYPE_GRADIENT));
GIMP_OBJECT (grad)->name = gradient_name; /* We don't need to copy since
this memory is ours */
grad->dirty = TRUE;
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name, gradient_path);
gimp_object_set_name (GIMP_OBJECT (grad), gradient_name);
g_free (gradient_name);
gimp_data_dirty (GIMP_DATA (grad));
prev = NULL;
orig = curr_gradient->segments;
@ -1506,27 +1497,18 @@ ed_do_rename_gradient_callback (GtkWidget *widget,
gpointer data)
{
GimpGradient *grad = (GimpGradient *) data;
gint row;
gint row;
g_return_if_fail (grad != NULL);
g_return_if_fail (gradient_name != NULL);
if (!gradient_name)
{
g_warning ("received NULL in call_data");
return;
}
gimp_object_set_name (GIMP_OBJECT (grad), gradient_name);
g_free (GIMP_OBJECT (grad)->name);
GIMP_OBJECT (grad)->name = gradient_name; /* We don't need to copy since
this memory is ours */
grad->dirty = TRUE;
g_free (gradient_name);
/* Delete file and free gradient */
unlink (grad->filename);
gimp_data_dirty (GIMP_DATA (grad));
g_free (grad->filename);
grad->filename = build_user_filename (GIMP_OBJECT (grad)->name,
gradient_path);
gimp_data_set_filename (GIMP_DATA (grad), NULL);
row = gtk_clist_find_row_from_data (GTK_CLIST (g_editor->clist), grad);
if (row > -1)
@ -1600,7 +1582,7 @@ ed_do_delete_gradient_callback (GtkWidget *widget,
gtk_clist_remove (GTK_CLIST (g_editor->clist), row);
/* Delete gradient from gradients list */
unlink (delete_gradient->filename);
gimp_data_delete_from_disk (GIMP_DATA (delete_gradient));
gimp_container_remove (global_gradient_list, GIMP_OBJECT (delete_gradient));
@ -1751,9 +1733,7 @@ ed_refresh_grads_callback (GtkWidget *widget,
{
curr_gradient = dnd_gradient = gimp_gradient_new (_("Default"));
curr_gradient->filename =
build_user_filename (GIMP_OBJECT (curr_gradient)->name,
gradient_path);
gimp_data_dirty (GIMP_DATA (curr_gradient));
gimp_container_add (global_gradient_list, GIMP_OBJECT (curr_gradient));
@ -2700,7 +2680,7 @@ control_motion (gint x)
if (str)
g_free (str);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
if (g_editor->instant_update)
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
@ -3910,7 +3890,8 @@ cpopup_load_left_callback (GtkWidget *widget,
break;
}
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -3961,7 +3942,8 @@ cpopup_load_right_callback (GtkWidget *widget,
break;
}
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4054,7 +4036,7 @@ static void
cpopup_set_left_color_callback (GtkWidget *widget,
gpointer data)
{
g_editor->left_saved_dirty = curr_gradient->dirty;
g_editor->left_saved_dirty = GIMP_DATA (curr_gradient)->dirty;
g_editor->left_saved_segments = cpopup_save_selection ();
color_notebook_new (_("Left Endpoint Color"),
@ -4071,7 +4053,7 @@ static void
cpopup_set_right_color_callback (GtkWidget *widget,
gpointer data)
{
g_editor->right_saved_dirty = curr_gradient->dirty;
g_editor->right_saved_dirty = GIMP_DATA (curr_gradient)->dirty;
g_editor->right_saved_segments = cpopup_save_selection ();
color_notebook_new (_("Right Endpoint Color"),
@ -4097,7 +4079,7 @@ cpopup_left_color_changed (ColorNotebook *cnb,
&g_editor->control_sel_r->right_color,
TRUE, TRUE);
gimp_gradient_segments_free (g_editor->left_saved_segments);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4106,13 +4088,13 @@ cpopup_left_color_changed (ColorNotebook *cnb,
cpopup_blend_endpoints ((GimpRGB *) color,
&g_editor->control_sel_r->right_color,
TRUE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
break;
case COLOR_NOTEBOOK_CANCEL:
cpopup_replace_selection (g_editor->left_saved_segments);
ed_update_editor (GRAD_UPDATE_GRADIENT);
curr_gradient->dirty = g_editor->left_saved_dirty;
GIMP_DATA (curr_gradient)->dirty = g_editor->left_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4133,7 +4115,7 @@ cpopup_right_color_changed (ColorNotebook *cnb,
cpopup_blend_endpoints (&g_editor->control_sel_r->left_color,
(GimpRGB *) color,
TRUE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
break;
case COLOR_NOTEBOOK_OK:
@ -4141,14 +4123,14 @@ cpopup_right_color_changed (ColorNotebook *cnb,
(GimpRGB *) color,
TRUE, TRUE);
gimp_gradient_segments_free (g_editor->right_saved_segments);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
case COLOR_NOTEBOOK_CANCEL:
cpopup_replace_selection (g_editor->right_saved_segments);
curr_gradient->dirty = g_editor->right_saved_dirty;
GIMP_DATA (curr_gradient)->dirty = g_editor->right_saved_dirty;
color_notebook_free (cnb);
gtk_widget_set_sensitive (g_editor->shell, TRUE);
break;
@ -4223,7 +4205,8 @@ cpopup_blending_callback (GtkWidget *widget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4291,7 +4274,8 @@ cpopup_coloring_callback (GtkWidget *widget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -4314,8 +4298,8 @@ cpopup_split_midpoint_callback (GtkWidget *widget,
g_editor->control_sel_r = rseg;
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4475,8 +4459,8 @@ cpopup_split_uniform_split_callback (GtkWidget *widget,
g_editor->control_sel_l = lsel;
g_editor->control_sel_r = rseg;
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4490,7 +4474,7 @@ cpopup_split_uniform_cancel_callback (GtkWidget *widget,
static void
cpopup_split_uniform (GimpGradientSegment *lseg,
int parts,
gint parts,
GimpGradientSegment **newl,
GimpGradientSegment **newr)
{
@ -4641,8 +4625,7 @@ cpopup_delete_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4666,7 +4649,8 @@ cpopup_recenter_callback (GtkWidget *wiodget,
}
while (aseg != g_editor->control_sel_r);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4720,7 +4704,8 @@ cpopup_redistribute_callback (GtkWidget *widget,
/* Done */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -4914,8 +4899,7 @@ cpopup_flip_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -5102,8 +5086,7 @@ cpopup_do_replicate_callback (GtkWidget *widget,
/* Done */
curr_gradient->last_visited = NULL; /* Force re-search */
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT | GRAD_UPDATE_CONTROL);
}
@ -5126,7 +5109,8 @@ cpopup_blend_colors (GtkWidget *widget,
&g_editor->control_sel_r->right_color,
TRUE, FALSE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -5138,7 +5122,8 @@ cpopup_blend_opacity (GtkWidget *widget,
&g_editor->control_sel_r->right_color,
FALSE, TRUE);
curr_gradient->dirty = TRUE;
gimp_data_dirty (GIMP_DATA (curr_gradient));
ed_update_editor (GRAD_UPDATE_GRADIENT);
}
@ -5228,32 +5213,3 @@ seg_get_closest_handle (GimpGradient *grad,
}
}
}
/***** Files and paths functions *****/
static gchar *
build_user_filename (gchar *name,
gchar *path_str)
{
GList *grad_path;
gchar *grad_dir;
gchar *filename;
g_assert (name != NULL);
if (!path_str)
return NULL; /* Perhaps this is not a good idea */
grad_path = gimp_path_parse (path_str, 16, TRUE, NULL);
grad_dir = gimp_path_get_user_writable_dir (grad_path);
gimp_path_free (grad_path);
if (!grad_dir)
return NULL; /* Perhaps this is not a good idea */
filename = g_strdup_printf ("%s%s", grad_dir, name);
g_free (grad_dir);
return filename;
}

1
data/gradients/Abstract_1 → data/gradients/Abstract_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Abstract 1
6
0.000000 0.286311 0.572621 0.269543 0.259267 1.000000 1.000000 0.215635 0.407414 0.984953 1.000000 0 0
0.572621 0.657763 0.716194 0.215635 0.407414 0.984953 1.000000 0.040368 0.833333 0.619375 1.000000 0 0

1
data/gradients/Abstract_2 → data/gradients/Abstract_2.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Abstract 2
6
0.000000 0.333532 0.570952 1.000000 0.000000 0.055296 1.000000 0.922731 0.452483 0.984953 1.000000 0 0
0.570952 0.616469 0.664441 0.922731 0.452483 0.984953 1.000000 0.122236 0.319840 0.583333 1.000000 0 0

1
data/gradients/Abstract_3 → data/gradients/Abstract_3.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Abstract 3
6
0.000000 0.050083 0.435726 0.000000 0.424242 0.070751 1.000000 1.000000 0.725647 0.428066 1.000000 0 0
0.435726 0.490818 0.590985 1.000000 0.725647 0.428066 1.000000 0.115248 0.249315 0.651515 1.000000 0 0

1
data/gradients/Aneurism → data/gradients/Aneurism.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Aneurism
8
0.000000 0.119571 0.235803 0.000000 0.000000 0.000000 0.000000 0.202999 0.003788 0.265152 1.000000 0 0
0.235803 0.306652 0.377501 0.202999 0.003788 0.265152 1.000000 0.300711 0.001894 0.393939 1.000000 0 0

1
data/gradients/Blinds → data/gradients/Blinds.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Blinds
9
0.000000 0.041667 0.166667 0.000000 0.000000 0.000000 1.000000 0.500000 0.500000 0.500000 1.000000 2 0
0.166667 0.186978 0.250000 0.500000 0.500000 0.500000 1.000000 1.000000 1.000000 1.000000 1.000000 2 0

1
data/gradients/Blue_Green → data/gradients/Blue_Green.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Blue Green
2
0.000000 0.135225 0.565943 0.000000 0.481711 1.000000 1.000000 0.283820 0.887055 1.000000 1.000000 0 0
0.565943 0.918197 1.000000 0.283820 0.887055 1.000000 1.000000 0.000000 1.000000 0.631509 1.000000 0 0

1
data/gradients/Browns → data/gradients/Browns.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Browns
11
0.000000 0.055092 0.116861 0.550000 0.353971 0.192500 1.000000 0.734848 0.461927 0.168587 1.000000 0 0
0.116861 0.176962 0.253756 0.734848 0.461927 0.168587 1.000000 0.550000 0.328592 0.022000 1.000000 0 0

1
data/gradients/Brushed_Aluminium → data/gradients/Brushed_Aluminium.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Brushed Aluminium
24
0.000000 0.031250 0.041736 0.435294 0.447059 0.411765 1.000000 0.498070 0.508364 0.477482 1.000000 0 0
0.041736 0.066308 0.072621 0.498070 0.508364 0.477482 1.000000 0.529458 0.539017 0.510340 1.000000 0 0

1
data/gradients/Burning_Paper → data/gradients/Burning_Paper.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Burning Paper
6
0.000000 0.264608 0.502504 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0
0.502504 0.601002 0.637730 1.000000 1.000000 1.000000 1.000000 0.000000 0.000000 0.000000 1.000000 1 0

1
data/gradients/Burning_Transparency → data/gradients/Burning_Transparency.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Burning Transparency
6
0.000000 0.264608 0.502504 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0 0
0.502504 0.601002 0.637730 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 1.000000 1 0

1
data/gradients/CD → data/gradients/CD.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: CD
18
0.000000 0.010566 0.023372 0.819999 0.820000 0.820000 1.000000 0.879999 0.880000 0.880000 1.000000 0 0
0.023372 0.045682 0.063439 0.879999 0.880000 0.880000 1.000000 0.999999 1.000000 1.000000 1.000000 0 0

1
data/gradients/CD_Half → data/gradients/CD_Half.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: CD Half
9
0.000000 0.021131 0.046745 0.819999 0.820000 0.820000 1.000000 0.879999 0.880000 0.880000 1.000000 0 0
0.046745 0.091364 0.126878 0.879999 0.880000 0.880000 1.000000 0.999999 1.000000 1.000000 1.000000 0 0

1
data/gradients/Caribbean_Blues → data/gradients/Caribbean_Blues.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Caribbean Blues
3
0.000000 0.403766 0.567613 0.000000 0.130219 0.583333 1.000000 0.200000 0.833333 0.726927 1.000000 0 0
0.567613 0.642738 0.681135 0.200000 0.833333 0.726927 1.000000 1.000000 0.988352 0.860000 1.000000 0 0

1
data/gradients/Coffee → data/gradients/Coffee.ggr
View file

@ -1,3 +1,4 @@
GIMP Gradient
Name: Coffee
1
0.000000 0.949917 1.000000 0.560606 0.435893 0.311332 0.000000 0.300000 0.233262 0.166605 1.000000 4 0

1
data/gradients/Cold_Steel → data/gradients/Cold_Steel.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Cold Steel
2
0.000000 0.208681 0.647746 1.000000 1.000000 1.000000 1.000000 0.047059 0.023529 0.137255 1.000000 0 0
0.647746 0.669449 1.000000 0.047059 0.023529 0.137255 1.000000 0.364706 0.733333 0.756863 1.000000 0 0

1
data/gradients/Cold_Steel_2 → data/gradients/Cold_Steel_2.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Cold Steel 2
3
0.000000 0.068447 0.101836 0.143939 0.013928 0.100000 1.000000 1.000000 1.000000 1.000000 1.000000 1 0
0.101836 0.501669 0.901503 1.000000 1.000000 1.000000 1.000000 0.088684 0.075143 0.174242 1.000000 1 0

1
data/gradients/Crown_molding → data/gradients/Crown_molding.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Crown molding
6
0.000000 0.155120 0.238453 0.000000 0.000000 0.000000 1.000000 0.840000 0.840000 0.840000 1.000000 0 0
0.238453 0.287145 0.288815 0.840000 0.840000 0.840000 1.000000 0.333333 0.333333 0.333333 1.000000 4 0

7
data/gradients/Danish_flag
View file

@ -1,7 +0,0 @@
/* color_map file created by the GIMP */
/* http://www.gimp.org/ */
color_map {
[0.000000 color rgbt <1.000000, 0.000000, 0.000000, 0.000000>]
[0.395659 color rgbt <1.000000, 0.500000, 0.500000, 0.000000>]
[1.000000 color rgbt <1.000000, 1.000000, 1.000000, 0.000000>]
} /* color_map */

1
data/gradients/Dark_1 → data/gradients/Dark_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Dark 1
3
0.000000 0.315713 0.560935 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 1.000000 0 0
0.560935 0.677796 0.774624 0.000000 0.000000 0.000000 1.000000 0.636364 0.280000 0.280000 1.000000 0 0

1
data/gradients/Deep_Sea → data/gradients/Deep_Sea.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Deep Sea
2
0.000000 0.580968 0.764608 0.000000 0.009040 0.166667 1.000000 0.179032 0.390004 0.621212 1.000000 0 0
0.764608 0.888147 1.000000 0.179032 0.390004 0.621212 1.000000 0.000000 0.969697 0.969697 1.000000 0 0

1
data/gradients/Default → data/gradients/Default.ggr
View file

@ -1,3 +1,4 @@
GIMP Gradient
Name: Default
1
0.000000 0.500000 1.000000 0.000000 0.000000 0.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0

1
data/gradients/Flare_Glow_Angular_1 → data/gradients/Flare_Glow_Angular_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Glow Angular 1
46
0.000000 0.006944 0.013889 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0.120000 0 0
0.013889 0.025598 0.038954 1.000000 1.000000 1.000000 0.120000 1.000000 1.000000 1.000000 0.860000 0 0

1
data/gradients/Flare_Glow_Radial_1 → data/gradients/Flare_Glow_Radial_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Glow Radial 1
4
0.000000 0.353923 0.535893 1.000000 1.000000 1.000000 0.940000 0.780303 0.560606 1.000000 0.480000 1 0
0.535893 0.595400 0.616550 0.780303 0.560606 1.000000 0.480000 0.900000 0.800000 1.000000 0.860000 1 0

1
data/gradients/Flare_Glow_Radial_2 → data/gradients/Flare_Glow_Radial_2.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Glow Radial 2
5
0.000000 0.260896 0.530885 0.500000 1.000000 1.000000 0.000000 0.653680 0.728264 0.846320 0.000000 1 2
0.530885 0.567758 0.646077 0.653680 0.728264 0.846320 0.000000 0.622773 0.921464 0.578536 0.250000 1 2

1
data/gradients/Flare_Glow_Radial_3 → data/gradients/Flare_Glow_Radial_3.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Glow Radial 3
5
0.000000 0.173623 0.350584 1.000000 0.920000 0.920000 0.809524 1.000000 0.737255 0.737255 0.306122 2 0
0.350584 0.375626 0.400668 1.000000 0.737255 0.737255 0.306122 1.000000 0.636060 0.636060 0.306122 0 0

1
data/gradients/Flare_Glow_Radial_4 → data/gradients/Flare_Glow_Radial_4.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Glow Radial 4
3
0.000000 0.737896 0.878130 1.000000 0.999999 0.999999 0.100000 1.000000 0.755000 0.755000 0.550000 1 0
0.878130 0.920520 0.943039 1.000000 0.755000 0.755000 0.550000 1.000000 0.510000 0.510000 1.000000 1 0

1
data/gradients/Flare_Radial_101 → data/gradients/Flare_Radial_101.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Radial 101
7
0.000000 0.050918 0.101836 1.000000 0.999999 0.999999 1.000000 1.000000 0.999999 0.999999 1.000000 0 0
0.101836 0.151085 0.200334 1.000000 0.999999 0.999999 1.000000 1.000000 0.691315 0.691315 0.650000 0 0

1
data/gradients/Flare_Radial_102 → data/gradients/Flare_Radial_102.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Radial 102
6
0.000000 0.024937 0.058431 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0.900000 0 0
0.058431 0.083751 0.105175 1.000000 1.000000 1.000000 0.900000 1.000000 0.490000 0.490000 0.820000 0 0

1
data/gradients/Flare_Radial_103 → data/gradients/Flare_Radial_103.ggr
View file

@ -1,3 +1,4 @@
GIMP Gradient
Name: Flare Radial 103
1
0.000000 0.517529 1.000000 1.000000 1.000000 1.000000 0.490000 1.000000 0.510000 0.510000 1.000000 0 0

1
data/gradients/Flare_Rays_Radial_1 → data/gradients/Flare_Rays_Radial_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Rays Radial 1
2
0.000000 0.514267 0.657763 1.000000 1.000000 1.000000 0.000000 1.000000 1.000000 1.000000 0.500000 1 0
0.657763 0.938230 1.000000 1.000000 1.000000 1.000000 0.500000 1.000000 1.000000 1.000000 0.000000 1 0

1
data/gradients/Flare_Rays_Radial_2 → data/gradients/Flare_Rays_Radial_2.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Rays Radial 2
2
0.000000 0.181970 0.434057 1.000000 1.000000 1.000000 0.000000 1.000000 0.600000 0.600000 0.600000 1 0
0.434057 0.582638 1.000000 1.000000 0.600000 0.600000 0.600000 1.000000 1.000000 1.000000 0.000000 1 0

1
data/gradients/Flare_Rays_Size_1 → data/gradients/Flare_Rays_Size_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Flare Rays Size 1
16
0.000000 0.031250 0.062500 1.000000 1.000000 1.000000 1.000000 0.240000 0.240000 0.240000 1.000000 0 0
0.062500 0.117659 0.153589 0.240000 0.240000 0.240000 1.000000 0.860000 0.860000 0.860000 1.000000 0 0

1
data/gradients/Flare_Sizefac_101 → data/gradients/Flare_Sizefac_101.ggr
View file

@ -1,3 +1,4 @@
GIMP Gradient
Name: Flare Sizefac 101
1
0.000000 0.500000 1.000000 0.370000 0.370000 0.370000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0

1
data/gradients/Four_bars → data/gradients/Four_bars.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Four bars
8
0.000000 0.062500 0.125000 0.000000 0.000000 0.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0
0.125000 0.187500 0.250000 1.000000 1.000000 1.000000 1.000000 0.000000 0.000000 0.000000 1.000000 0 0

1
data/gradients/French_flag → data/gradients/French_flag.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: French flag
3
0.000000 0.166667 0.333333 0.000000 0.000000 1.000000 1.000000 0.000000 0.000000 1.000000 1.000000 0 0
0.333333 0.500000 0.666667 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0

1
data/gradients/French_flag_smooth → data/gradients/French_flag_smooth.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: French flag smooth
2
0.000000 0.250000 0.500000 0.000000 0.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0
0.500000 0.750000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0.000000 0.000000 1.000000 0 0

1
data/gradients/Full_saturation_spectrum_CCW → data/gradients/Full_saturation_spectrum_CCW.ggr
View file

@ -1,3 +1,4 @@
GIMP Gradient
Name: Full saturation spectrum CCW
1
0.000000 0.500000 1.000000 1.000000 0.000000 0.000000 1.000000 1.000000 0.000000 0.000000 1.000000 0 1

1
data/gradients/Full_saturation_spectrum_CW → data/gradients/Full_saturation_spectrum_CW.ggr
View file

@ -1,3 +1,4 @@
GIMP Gradient
Name: Full saturation spectrum CW
1
0.000000 0.500000 1.000000 1.000000 0.000000 0.000000 1.000000 1.000000 0.000000 0.000000 1.000000 0 2

1
data/gradients/German_flag → data/gradients/German_flag.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: German flag
3
0.000000 0.166667 0.333333 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 1.000000 0 0
0.333333 0.500000 0.666667 1.000000 0.000000 0.000000 1.000000 1.000000 0.000000 0.000000 1.000000 0 0

1
data/gradients/German_flag_smooth → data/gradients/German_flag_smooth.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: German flag smooth
2
0.000000 0.250000 0.500000 0.000000 0.000000 0.000000 1.000000 1.000000 0.000000 0.000000 1.000000 0 0
0.500000 0.750000 1.000000 1.000000 0.000000 0.000000 1.000000 1.000000 1.000000 0.000000 1.000000 0 0

1
data/gradients/Golden → data/gradients/Golden.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Golden
14
0.000000 0.080316 0.163606 0.137255 0.156863 0.011760 1.000000 0.533330 0.415600 0.086270 1.000000 0 0
0.163606 0.193879 0.224151 0.533330 0.415600 0.086270 1.000000 0.650000 0.550000 0.161000 1.000000 0 0

1
data/gradients/Greens → data/gradients/Greens.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Greens
9
0.000000 0.062500 0.086811 0.146341 0.393939 0.133992 1.000000 0.198883 0.300000 0.135000 1.000000 0 0
0.086811 0.200334 0.250000 0.198883 0.300000 0.135000 1.000000 0.406805 0.613636 0.276136 1.000000 0 0

1
data/gradients/Horizon_1 → data/gradients/Horizon_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Horizon 1
5
0.000000 0.348915 0.532554 0.047059 0.360784 0.572549 1.000000 1.000000 0.984314 0.984314 1.000000 0 0
0.532554 0.542571 0.555927 1.000000 0.984314 0.984314 1.000000 0.258824 0.121569 0.035294 1.000000 3 0

1
data/gradients/Horizon_2 → data/gradients/Horizon_2.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Horizon 2
5
0.000000 0.290484 0.348915 0.047059 0.360784 0.572549 1.000000 0.370303 0.628966 0.787879 1.000000 0 0
0.348915 0.470785 0.532554 0.370303 0.628966 0.787879 1.000000 1.000000 0.984314 0.984314 1.000000 0 0

1
data/gradients/Incandescent → data/gradients/Incandescent.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Incandescent
4
0.000000 0.459098 0.594324 0.000000 0.000000 0.000000 1.000000 0.729412 0.000000 0.000000 1.000000 0 0
0.594324 0.677796 0.809683 0.729412 0.000000 0.000000 1.000000 1.000000 0.545098 0.196078 1.000000 0 0

1
data/gradients/Land_1 → data/gradients/Land_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Land 1
5
0.000000 0.348915 0.532554 0.047059 0.360784 0.572549 1.000000 1.000000 0.984314 0.984314 1.000000 0 0
0.532554 0.542571 0.555927 1.000000 0.984314 0.984314 1.000000 0.258824 0.121569 0.035294 1.000000 3 0

1
data/gradients/Land_and_Sea → data/gradients/Land_and_Sea.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Land and Sea
5
0.000000 0.081803 0.166945 1.000000 1.000000 1.000000 1.000000 0.560606 0.560606 0.560606 1.000000 0 0
0.166945 0.212020 0.265442 0.560606 0.560606 0.560606 1.000000 0.083243 0.462121 0.112054 1.000000 0 0

157
data/gradients/Makefile.am
View file

@ -12,82 +12,81 @@ EXTRA_DIST = $(gradientdata_DATA)
.PHONY: files
FILES = \
Abstract_1 \
Abstract_2 \
Abstract_3 \
Aneurism \
Blinds \
Blue_Green \
Browns \
Brushed_Aluminium \
Burning_Paper \
Burning_Transparency \
CD \
CD_Half \
Caribbean_Blues \
Coffee \
Cold_Steel \
Cold_Steel_2 \
Crown_molding \
Danish_flag \
Dark_1 \
Deep_Sea \
Default \
Flare_Glow_Angular_1 \
Flare_Glow_Radial_1 \
Flare_Glow_Radial_2 \
Flare_Glow_Radial_3 \
Flare_Glow_Radial_4 \
Flare_Radial_101 \
Flare_Radial_102 \
Flare_Radial_103 \
Flare_Rays_Radial_1 \
Flare_Rays_Radial_2 \
Flare_Rays_Size_1 \
Flare_Sizefac_101 \
Four_bars \
French_flag \
French_flag_smooth \
Full_saturation_spectrum_CCW \
Full_saturation_spectrum_CW \
German_flag \
German_flag_smooth \
Golden \
Greens \
Horizon_1 \
Horizon_2 \
Incandescent \
Land_1 \
Land_and_Sea \
Metallic_Something \
Mexican_flag \
Mexican_flag_smooth \
Nauseating_Headache \
Neon_Cyan \
Neon_Green \
Neon_Yellow \
Pastels \
Pastel_Rainbow \
Purples \
Radial_Eyeball_Blue \
Radial_Eyeball_Brown \
Radial_Eyeball_Green \
Radial_Glow_1 \
Radial_Rainbow_Hoop \
Romanian_flag \
Romanian_flag_smooth \
Rounded_edge \
Shadows_1 \
Shadows_2 \
Shadows_3 \
Skyline \
Skyline_polluted \
Square_Wood_Frame \
Sunrise \
Three_bars_sin \
Tropical_Colors \
Tube_Red \
Wood_1 \
Wood_2 \
Yellow_Contrast \
Yellow_Orange
Abstract_1.ggr \
Abstract_2.ggr \
Abstract_3.ggr \
Aneurism.ggr \
Blinds.ggr \
Blue_Green.ggr \
Browns.ggr \
Brushed_Aluminium.ggr \
Burning_Paper.ggr \
Burning_Transparency.ggr \
CD.ggr \
CD_Half.ggr \
Caribbean_Blues.ggr \
Coffee.ggr \
Cold_Steel.ggr \
Cold_Steel_2.ggr \
Crown_molding.ggr \
Dark_1.ggr \
Deep_Sea.ggr \
Default.ggr \
Flare_Glow_Angular_1.ggr \
Flare_Glow_Radial_1.ggr \
Flare_Glow_Radial_2.ggr \
Flare_Glow_Radial_3.ggr \
Flare_Glow_Radial_4.ggr \
Flare_Radial_101.ggr \
Flare_Radial_102.ggr \
Flare_Radial_103.ggr \
Flare_Rays_Radial_1.ggr \
Flare_Rays_Radial_2.ggr \
Flare_Rays_Size_1.ggr \
Flare_Sizefac_101.ggr \
Four_bars.ggr \
French_flag.ggr \
French_flag_smooth.ggr \
Full_saturation_spectrum_CCW.ggr \
Full_saturation_spectrum_CW.ggr \
German_flag.ggr \
German_flag_smooth.ggr \
Golden.ggr \
Greens.ggr \
Horizon_1.ggr \
Horizon_2.ggr \
Incandescent.ggr \
Land_1.ggr \
Land_and_Sea.ggr \
Metallic_Something.ggr \
Mexican_flag.ggr \
Mexican_flag_smooth.ggr \
Nauseating_Headache.ggr \
Neon_Cyan.ggr \
Neon_Green.ggr \
Neon_Yellow.ggr \
Pastels.ggr \
Pastel_Rainbow.ggr \
Purples.ggr \
Radial_Eyeball_Blue.ggr \
Radial_Eyeball_Brown.ggr \
Radial_Eyeball_Green.ggr \
Radial_Glow_1.ggr \
Radial_Rainbow_Hoop.ggr \
Romanian_flag.ggr \
Romanian_flag_smooth.ggr \
Rounded_edge.ggr \
Shadows_1.ggr \
Shadows_2.ggr \
Shadows_3.ggr \
Skyline.ggr \
Skyline_polluted.ggr \
Square_Wood_Frame.ggr \
Sunrise.ggr \
Three_bars_sin.ggr \
Tropical_Colors.ggr \
Tube_Red.ggr \
Wood_1.ggr \
Wood_2.ggr \
Yellow_Contrast.ggr \
Yellow_Orange.ggr

1
data/gradients/Metallic_Something → data/gradients/Metallic_Something.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Metallic Something
8
0.000000 0.036728 0.096828 0.020000 0.050000 0.080000 1.000000 0.142500 0.168750 0.195000 1.000000 2 0
0.096828 0.163606 0.220367 0.142500 0.168750 0.195000 1.000000 0.317326 0.344269 0.371212 1.000000 2 0

1
data/gradients/Mexican_flag → data/gradients/Mexican_flag.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Mexican flag
3
0.000000 0.166667 0.333333 0.000000 1.000000 0.000000 1.000000 0.000000 1.000000 0.000000 1.000000 0 0
0.333333 0.500000 0.666667 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0

1
data/gradients/Mexican_flag_smooth → data/gradients/Mexican_flag_smooth.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Mexican flag smooth
2
0.000000 0.250000 0.500000 0.000000 1.000000 0.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0
0.500000 0.750000 1.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0.000000 0.000000 1.000000 0 0

1
data/gradients/Nauseating_Headache → data/gradients/Nauseating_Headache.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Nauseating Headache
25
0.000000 0.058431 0.098497 0.391197 0.651515 0.409796 1.000000 0.495110 0.916667 0.865009 1.000000 0 1
0.098497 0.100167 0.101836 0.495110 0.916667 0.865009 1.000000 0.451393 0.807720 0.778663 1.000000 0 0

1
data/gradients/Neon_Cyan → data/gradients/Neon_Cyan.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Neon Cyan
4
0.000000 0.672788 0.699499 0.000000 1.000000 0.949020 0.000000 0.000000 1.000000 0.933333 0.901961 1 0
0.699499 0.737062 0.774624 0.000000 1.000000 0.913725 0.901961 0.827451 1.000000 0.988235 1.000000 1 0

1
data/gradients/Neon_Green → data/gradients/Neon_Green.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Neon Green
4
0.000000 0.672788 0.699499 0.000000 1.000000 0.000000 0.000000 0.129412 1.000000 0.000000 0.901961 1 0
0.699499 0.737062 0.774624 0.129412 1.000000 0.000000 0.901961 0.823529 1.000000 0.807843 1.000000 1 0

1
data/gradients/Neon_Yellow → data/gradients/Neon_Yellow.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Neon Yellow
4
0.000000 0.672788 0.699499 1.000000 0.949020 0.000000 0.000000 1.000000 0.933333 0.000000 0.901961 1 0
0.699499 0.737062 0.774624 1.000000 0.933333 0.000000 0.901961 0.996078 1.000000 0.819608 1.000000 1 0

1
data/gradients/Pastel_Rainbow → data/gradients/Pastel_Rainbow.ggr
View file

@ -1,3 +1,4 @@
GIMP Gradient
Name: Pastel Rainbow
1
0.000000 0.500000 1.000000 1.000000 0.749020 0.749020 1.000000 1.000000 0.749020 0.749020 1.000000 0 1

1
data/gradients/Pastels → data/gradients/Pastels.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Pastels
14
0.000000 0.035714 0.091462 0.960000 0.880000 0.690000 1.000000 0.962857 0.741400 0.930894 1.000000 0 0
0.091462 0.127176 0.137849 0.962857 0.741400 0.930894 1.000000 0.761897 0.812851 0.965714 1.000000 0 0

1
data/gradients/Purples → data/gradients/Purples.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Purples
7
0.000000 0.057596 0.098497 0.303030 0.109635 0.273088 1.000000 0.514411 0.279242 0.734848 1.000000 0 0
0.098497 0.176962 0.228715 0.514411 0.279242 0.734848 1.000000 0.604602 0.331500 0.650000 1.000000 0 0

1
data/gradients/Radial_Eyeball_Blue → data/gradients/Radial_Eyeball_Blue.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Radial Eyeball Blue
5
0.000000 0.105175 0.198664 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 1.000000 0 0
0.198664 0.352254 0.492487 0.000000 0.035294 0.729412 1.000000 0.000000 0.015686 0.376471 1.000000 0 0

1
data/gradients/Radial_Eyeball_Brown → data/gradients/Radial_Eyeball_Brown.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Radial Eyeball Brown
5
0.000000 0.105175 0.198664 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 1.000000 0 0
0.198664 0.352254 0.492487 0.478431 0.380392 0.000000 1.000000 0.298039 0.227451 0.000000 1.000000 0 0

1
data/gradients/Radial_Eyeball_Green → data/gradients/Radial_Eyeball_Green.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Radial Eyeball Green
5
0.000000 0.105175 0.198664 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 1.000000 0 0
0.198664 0.352254 0.492487 0.000000 0.709804 0.423529 1.000000 0.000000 0.356863 0.094118 1.000000 0 0

1
data/gradients/Radial_Glow_1 → data/gradients/Radial_Glow_1.ggr
View file

@ -1,4 +1,5 @@
GIMP Gradient
Name: Radial Glow 1
5
0.000000 0.173623 0.350584 1.000000 1.000000 1.000000 0.809524 1.000000 0.737255 0.737255 0.306122 2 0
0.350584 0.375626 0.400668 1.000000 0.737255 0.737255 0.306122 1.000000 0.636060 0.636060 0.306122 0 0

Some files were not shown because too many files have changed in this diff Show more