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

Seal GimpData completely and add the missing accessors

This commit is contained in:
Michael Natterer 2009-10-31 18:48:38 +01:00
parent 7abcfbf237
commit 22767ca7b8
26 changed files with 301 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/actions/brushes-actions.c
View File

@ -130,7 +130,7 @@ brushes_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("brushes-open-as-image", brush && filename && ! GIMP_IS_BRUSH_GENERATED (brush));
SET_SENSITIVE ("brushes-duplicate", brush && GIMP_DATA_GET_CLASS (data)->duplicate);
SET_SENSITIVE ("brushes-copy-location", brush && filename);
SET_SENSITIVE ("brushes-delete", brush && data->deletable);
SET_SENSITIVE ("brushes-delete", brush && gimp_data_is_deletable (data));
#undef SET_SENSITIVE
}

20
app/actions/context-commands.c
View File

@ -511,7 +511,7 @@ context_brush_spacing_cmd_callback (GtkAction *action,
brush = gimp_context_get_brush (context);
if (GIMP_IS_BRUSH (brush) && GIMP_DATA (brush)->writable)
if (GIMP_IS_BRUSH (brush) && gimp_data_is_writable (GIMP_DATA (brush)))
{
action_select_property ((GimpActionSelectType) value,
action_data_get_display (data),
@ -532,7 +532,8 @@ context_brush_shape_cmd_callback (GtkAction *action,
brush = gimp_context_get_brush (context);
if (GIMP_IS_BRUSH_GENERATED (brush) && GIMP_DATA (brush)->writable)
if (GIMP_IS_BRUSH_GENERATED (brush) &&
gimp_data_is_writable (GIMP_DATA (brush)))
{
GimpBrushGenerated *generated = GIMP_BRUSH_GENERATED (brush);
GimpDisplay *display;
@ -564,7 +565,8 @@ context_brush_radius_cmd_callback (GtkAction *action,
brush = gimp_context_get_brush (context);
if (GIMP_IS_BRUSH_GENERATED (brush) && GIMP_DATA (brush)->writable)
if (GIMP_IS_BRUSH_GENERATED (brush) &&
gimp_data_is_writable (GIMP_DATA (brush)))
{
GimpBrushGenerated *generated = GIMP_BRUSH_GENERATED (brush);
GimpDisplay *display;
@ -623,7 +625,8 @@ context_brush_spikes_cmd_callback (GtkAction *action,
brush = gimp_context_get_brush (context);
if (GIMP_IS_BRUSH_GENERATED (brush) && GIMP_DATA (brush)->writable)
if (GIMP_IS_BRUSH_GENERATED (brush) &&
gimp_data_is_writable (GIMP_DATA (brush)))
{
action_select_property ((GimpActionSelectType) value,
action_data_get_display (data),
@ -644,7 +647,8 @@ context_brush_hardness_cmd_callback (GtkAction *action,
brush = gimp_context_get_brush (context);
if (GIMP_IS_BRUSH_GENERATED (brush) && GIMP_DATA (brush)->writable)
if (GIMP_IS_BRUSH_GENERATED (brush) &&
gimp_data_is_writable (GIMP_DATA (brush)))
{
action_select_property ((GimpActionSelectType) value,
action_data_get_display (data),
@ -665,7 +669,8 @@ context_brush_aspect_cmd_callback (GtkAction *action,
brush = gimp_context_get_brush (context);
if (GIMP_IS_BRUSH_GENERATED (brush) && GIMP_DATA (brush)->writable)
if (GIMP_IS_BRUSH_GENERATED (brush) &&
gimp_data_is_writable (GIMP_DATA (brush)))
{
action_select_property ((GimpActionSelectType) value,
action_data_get_display (data),
@ -686,7 +691,8 @@ context_brush_angle_cmd_callback (GtkAction *action,
brush = gimp_context_get_brush (context);
if (GIMP_IS_BRUSH_GENERATED (brush) && GIMP_DATA (brush)->writable)
if (GIMP_IS_BRUSH_GENERATED (brush) &&
gimp_data_is_writable (GIMP_DATA (brush)))
{
GimpBrushGenerated *generated = GIMP_BRUSH_GENERATED (brush);
GimpDisplay *display;

4
app/actions/data-commands.c
View File

@ -220,8 +220,8 @@ data_delete_cmd_callback (GtkAction *action,
gimp_context_get_by_type (context,
gimp_data_factory_view_get_children_type (view));
if (data &&
data->deletable &&
if (data &&
gimp_data_is_deletable (data) &&
gimp_data_factory_view_have (view,
GIMP_OBJECT (data)))
{

2
app/actions/dynamics-actions.c
View File

@ -123,7 +123,7 @@ dynamics_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("dynamics-edit", dynamics);
SET_SENSITIVE ("dynamics-duplicate", dynamics && GIMP_DATA_GET_CLASS (data)->duplicate);
SET_SENSITIVE ("dynamics-copy-location", dynamics && filename);
SET_SENSITIVE ("dynamics-delete", dynamics && data->deletable);
SET_SENSITIVE ("dynamics-delete", dynamics && gimp_data_is_deletable (data));
#undef SET_SENSITIVE
}

10
app/actions/gradient-editor-commands.c
View File

@ -76,7 +76,7 @@ gradient_editor_left_color_cmd_callback (GtkAction *action,
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
editor->left_saved_dirty = GIMP_DATA (gradient)->dirty;
editor->left_saved_dirty = gimp_data_is_dirty (GIMP_DATA (gradient));
editor->left_saved_segments = gradient_editor_save_selection (editor);
editor->color_dialog =
@ -227,7 +227,7 @@ gradient_editor_right_color_cmd_callback (GtkAction *action,
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
editor->right_saved_dirty = GIMP_DATA (gradient)->dirty;
editor->right_saved_dirty = gimp_data_is_dirty (GIMP_DATA (gradient));
editor->right_saved_segments = gradient_editor_save_selection (editor);
editor->color_dialog =
@ -749,7 +749,8 @@ gradient_editor_left_color_update (GimpColorDialog *dialog,
case GIMP_COLOR_DIALOG_CANCEL:
gradient_editor_replace_selection (editor, editor->left_saved_segments);
GIMP_DATA (gradient)->dirty = editor->left_saved_dirty;
if (! editor->left_saved_dirty)
gimp_data_clean (GIMP_DATA (gradient));
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gradient));
gtk_widget_destroy (editor->color_dialog);
editor->color_dialog = NULL;
@ -796,7 +797,8 @@ gradient_editor_right_color_update (GimpColorDialog *dialog,
case GIMP_COLOR_DIALOG_CANCEL:
gradient_editor_replace_selection (editor, editor->right_saved_segments);
GIMP_DATA (gradient)->dirty = editor->right_saved_dirty;
if (! editor->right_saved_dirty)
gimp_data_clean (GIMP_DATA (gradient));
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gradient));
gtk_widget_destroy (editor->color_dialog);
editor->color_dialog = NULL;

2
app/actions/gradients-actions.c
View File

@ -131,7 +131,7 @@ gradients_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("gradients-duplicate", gradient);
SET_SENSITIVE ("gradients-save-as-pov", gradient);
SET_SENSITIVE ("gradients-copy-location", gradient && filename);
SET_SENSITIVE ("gradients-delete", gradient && data->deletable);
SET_SENSITIVE ("gradients-delete", gradient && gimp_data_is_deletable (data));
#undef SET_SENSITIVE
}

2
app/actions/palettes-actions.c
View File

@ -137,7 +137,7 @@ palettes_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("palettes-duplicate", palette && GIMP_DATA_GET_CLASS (data)->duplicate);
SET_SENSITIVE ("palettes-merge", FALSE); /* FIXME palette && GIMP_IS_CONTAINER_LIST_VIEW (editor->view)); */
SET_SENSITIVE ("palettes-copy-location", palette && filename);
SET_SENSITIVE ("palettes-delete", palette && data->deletable);
SET_SENSITIVE ("palettes-delete", palette && gimp_data_is_deletable (data));
#undef SET_SENSITIVE
}

2
app/actions/patterns-actions.c
View File

@ -130,7 +130,7 @@ patterns_actions_update (GimpActionGroup *group,
SET_SENSITIVE ("patterns-open-as-image", pattern && filename);
SET_SENSITIVE ("patterns-duplicate", pattern && GIMP_DATA_GET_CLASS (data)->duplicate);
SET_SENSITIVE ("patterns-copy-location", pattern && filename);
SET_SENSITIVE ("patterns-delete", pattern && data->deletable);
SET_SENSITIVE ("patterns-delete", pattern && gimp_data_is_deletable (data));
#undef SET_SENSITIVE
}

6
app/core/gimpbrush.c
View File

@ -417,11 +417,9 @@ gimp_brush_get_standard (void)
{
standard_brush = gimp_brush_new ("Standard");
standard_brush->dirty = FALSE;
gimp_data_make_internal (standard_brush,
"gimp-brush-standard");
gimp_data_clean (standard_brush);
gimp_data_make_internal (standard_brush, "gimp-brush-standard");
/* set ref_count to 2 --> never swap the standard brush */
g_object_ref (standard_brush);
}

4
app/core/gimpcurve.c
View File

@ -532,7 +532,7 @@ gimp_curve_get_standard (void)
{
standard_curve = gimp_curve_new ("Standard");
standard_curve->dirty = FALSE;
gimp_data_clean (standard_curve);
gimp_data_make_internal (standard_curve,
"gimp-curve-standard");
@ -887,7 +887,7 @@ gimp_curve_calculate (GimpCurve *curve)
gint num_pts;
gint p1, p2, p3, p4;
if (GIMP_DATA (curve)->freeze_count > 0)
if (gimp_data_is_frozen (GIMP_DATA (curve)))
return;
points = g_newa (gint, curve->n_points);

304
app/core/gimpdata.c
View File

@ -67,7 +67,21 @@ typedef struct _GimpDataPrivate GimpDataPrivate;
struct _GimpDataPrivate
{
gchar *filename;
gchar *filename;
GQuark mime_type;
guint writable : 1;
guint deletable : 1;
guint dirty : 1;
guint internal : 1;
gint freeze_count;
time_t mtime;
/* Identifies the GimpData object across sessions. Used when there
* is not a filename associated with the object.
*/
gchar *identifier;
GList *tags;
};
#define GIMP_DATA_GET_PRIVATE(data) \
@ -217,21 +231,17 @@ static void
gimp_data_init (GimpData *data,
GimpDataClass *data_class)
{
data->mime_type = 0;
data->writable = TRUE;
data->deletable = TRUE;
data->dirty = TRUE;
data->internal = FALSE;
data->freeze_count = 0;
data->mtime = 0;
data->tags = NULL;
data->identifier = NULL;
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (data);
private->writable = TRUE;
private->deletable = TRUE;
private->dirty = TRUE;
/* look at the passed class pointer, not at GIMP_DATA_GET_CLASS(data)
* here, because the latter is always GimpDataClass itself
*/
if (! data_class->save)
data->writable = FALSE;
private->writable = FALSE;
/* freeze the data object during construction */
gimp_data_freeze (data);
@ -254,8 +264,7 @@ gimp_data_constructor (GType type,
static void
gimp_data_finalize (GObject *object)
{
GimpData *data = GIMP_DATA (object);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (data);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (object);
if (private->filename)
{
@ -263,16 +272,16 @@ gimp_data_finalize (GObject *object)
private->filename = NULL;
}
if (data->tags)
if (private->tags)
{
g_list_free (data->tags);
data->tags = NULL;
g_list_free (private->tags);
private->tags = NULL;
}
if (data->identifier)
if (private->identifier)
{
g_free (data->identifier);
data->identifier = NULL;
g_free (private->identifier);
private->identifier = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
@ -284,30 +293,31 @@ gimp_data_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
GimpData *data = GIMP_DATA (object);
GimpData *data = GIMP_DATA (object);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (data);
switch (property_id)
{
case PROP_FILENAME:
gimp_data_set_filename (data,
g_value_get_string (value),
data->writable,
data->deletable);
private->writable,
private->deletable);
break;
case PROP_WRITABLE:
data->writable = g_value_get_boolean (value);
private->writable = g_value_get_boolean (value);
break;
case PROP_DELETABLE:
data->deletable = g_value_get_boolean (value);
private->deletable = g_value_get_boolean (value);
break;
case PROP_MIME_TYPE:
if (g_value_get_string (value))
data->mime_type = g_quark_from_string (g_value_get_string (value));
private->mime_type = g_quark_from_string (g_value_get_string (value));
else
data->mime_type = 0;
private->mime_type = 0;
break;
default:
@ -322,8 +332,7 @@ gimp_data_get_property (GObject *object,
GValue *value,
GParamSpec *pspec)
{
GimpData *data = GIMP_DATA (object);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (data);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (object);
switch (property_id)
{
@ -332,15 +341,15 @@ gimp_data_get_property (GObject *object,
break;
case PROP_WRITABLE:
g_value_set_boolean (value, data->writable);
g_value_set_boolean (value, private->writable);
break;
case PROP_DELETABLE:
g_value_set_boolean (value, data->deletable);
g_value_set_boolean (value, private->deletable);
break;
case PROP_MIME_TYPE:
g_value_set_string (value, g_quark_to_string (data->mime_type));
g_value_set_string (value, g_quark_to_string (private->mime_type));
break;
default:
@ -353,8 +362,7 @@ static gint64
gimp_data_get_memsize (GimpObject *object,
gint64 *gui_size)
{
GimpData *data = GIMP_DATA (object);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (data);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (object);
gint64 memsize = 0;
memsize += gimp_string_get_memsize (private->filename);
@ -366,7 +374,9 @@ gimp_data_get_memsize (GimpObject *object,
static void
gimp_data_real_dirty (GimpData *data)
{
data->dirty = TRUE;
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (data);
private->dirty = TRUE;
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (data));
@ -378,10 +388,10 @@ static gboolean
gimp_data_add_tag (GimpTagged *tagged,
GimpTag *tag)
{
GimpData *data = GIMP_DATA (tagged);
GList *list;
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (tagged);
GList *list;
for (list = data->tags; list; list = list->next)
for (list = private->tags; list; list = g_list_next (list))
{
GimpTag *this = GIMP_TAG (list->data);
@ -389,8 +399,7 @@ gimp_data_add_tag (GimpTagged *tagged,
return FALSE;
}
g_object_ref (tag);
data->tags = g_list_prepend (data->tags, tag);
private->tags = g_list_prepend (private->tags, g_object_ref (tag));
return TRUE;
}
@ -399,16 +408,16 @@ static gboolean
gimp_data_remove_tag (GimpTagged *tagged,
GimpTag *tag)
{
GimpData *data = GIMP_DATA (tagged);
GList *list;
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (tagged);
GList *list;
for (list = data->tags; list; list = list->next)
for (list = private->tags; list; list = g_list_next (list))
{
GimpTag *this = GIMP_TAG (list->data);
if (gimp_tag_equals (tag, this))
{
data->tags = g_list_delete_link (data->tags, list);
private->tags = g_list_delete_link (private->tags, list);
g_object_unref (tag);
return TRUE;
}
@ -420,14 +429,15 @@ gimp_data_remove_tag (GimpTagged *tagged,
static GList *
gimp_data_get_tags (GimpTagged *tagged)
{
return GIMP_DATA (tagged)->tags;
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (tagged);
return private->tags;
}
static gchar *
gimp_data_get_identifier (GimpTagged *tagged)
{
GimpData *data = GIMP_DATA (tagged);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (data);
GimpDataPrivate *private = GIMP_DATA_GET_PRIVATE (tagged);
gchar *identifier = NULL;
if (private->filename)
@ -440,9 +450,9 @@ gimp_data_get_identifier (GimpTagged *tagged)
identifier = g_strdup (private->filename);
}
}
else if (data->internal)
else if (private->internal)
{
identifier = g_strdup (data->identifier);
identifier = g_strdup (private->identifier);
}
return identifier;
@ -475,14 +485,15 @@ gimp_data_save (GimpData *data,
gboolean success = FALSE;
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
g_return_val_if_fail (data->writable == TRUE, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
private = GIMP_DATA_GET_PRIVATE (data);
if (data->internal)
g_return_val_if_fail (private->writable == TRUE, FALSE);
if (private->internal)
{
data->dirty = FALSE;
private->dirty = FALSE;
return TRUE;
}
@ -497,8 +508,8 @@ gimp_data_save (GimpData *data,
g_stat (private->filename, &filestat);
data->mtime = filestat.st_mtime;
data->dirty = FALSE;
private->mtime = filestat.st_mtime;
private->dirty = FALSE;
}
return success;
@ -515,12 +526,40 @@ gimp_data_save (GimpData *data,
void
gimp_data_dirty (GimpData *data)
{
GimpDataPrivate *private;
g_return_if_fail (GIMP_IS_DATA (data));
if (data->freeze_count == 0)
private = GIMP_DATA_GET_PRIVATE (data);
if (private->freeze_count == 0)
g_signal_emit (data, data_signals[DIRTY], 0);
}
void
gimp_data_clean (GimpData *data)
{
GimpDataPrivate *private;
g_return_if_fail (GIMP_IS_DATA (data));
private = GIMP_DATA_GET_PRIVATE (data);
private->dirty = FALSE;
}
gboolean
gimp_data_is_dirty (GimpData *data)
{
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
private = GIMP_DATA_GET_PRIVATE (data);
return private->dirty;
}
/**
* gimp_data_freeze:
* @data: a #GimpData object.
@ -532,9 +571,13 @@ gimp_data_dirty (GimpData *data)
void
gimp_data_freeze (GimpData *data)
{
GimpDataPrivate *private;
g_return_if_fail (GIMP_IS_DATA (data));
data->freeze_count++;
private = GIMP_DATA_GET_PRIVATE (data);
private->freeze_count++;
}
/**
@ -549,15 +592,32 @@ gimp_data_freeze (GimpData *data)
void
gimp_data_thaw (GimpData *data)
{
GimpDataPrivate *private;
g_return_if_fail (GIMP_IS_DATA (data));
g_return_if_fail (data->freeze_count > 0);
data->freeze_count--;
private = GIMP_DATA_GET_PRIVATE (data);
if (data->freeze_count == 0)
g_return_if_fail (private->freeze_count > 0);
private->freeze_count--;
if (private->freeze_count == 0)
gimp_data_dirty (data);
}
gboolean
gimp_data_is_frozen (GimpData *data)
{
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
private = GIMP_DATA_GET_PRIVATE (data);
return private->freeze_count > 0;
}
/**
* gimp_data_delete_from_disk:
* @data: a #GimpData object.
@ -578,14 +638,14 @@ gimp_data_delete_from_disk (GimpData *data,
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
g_return_val_if_fail (data->deletable == TRUE, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
private = GIMP_DATA_GET_PRIVATE (data);
g_return_val_if_fail (private->filename != NULL, FALSE);
g_return_val_if_fail (private->deletable == TRUE, FALSE);
if (data->internal)
if (private->internal)
return TRUE;
if (g_unlink (private->filename) == -1)
@ -638,15 +698,15 @@ gimp_data_set_filename (GimpData *data,
private = GIMP_DATA_GET_PRIVATE (data);
if (data->internal)
if (private->internal)
return;
if (private->filename)
g_free (private->filename);
private->filename = g_strdup (filename);
data->writable = FALSE;
data->deletable = FALSE;
private->filename = g_strdup (filename);
private->writable = FALSE;
private->deletable = FALSE;
/* if the data is supposed to be writable or deletable,
* still check if it really is
@ -660,15 +720,15 @@ gimp_data_set_filename (GimpData *data,
(g_access (filename, F_OK) != 0 && /* OR doesn't exist */
g_access (dirname, W_OK) == 0)) /* and we can write to its dir */
{
data->writable = writable ? TRUE : FALSE;
data->deletable = deletable ? TRUE : FALSE;
private->writable = writable ? TRUE : FALSE;
private->deletable = deletable ? TRUE : FALSE;
}
g_free (dirname);
/* if we can't save, we are not writable */
if (! GIMP_DATA_GET_CLASS (data)->save)
data->writable = FALSE;
private->writable = FALSE;
}
}
@ -687,18 +747,21 @@ void
gimp_data_create_filename (GimpData *data,
const gchar *dest_dir)
{
gchar *safename;
gchar *filename;
gchar *fullpath;
gint i;
gint unum = 1;
GError *error = NULL;
GimpDataPrivate *private;
gchar *safename;
gchar *filename;
gchar *fullpath;
gint i;
gint unum = 1;
GError *error = NULL;
g_return_if_fail (GIMP_IS_DATA (data));
g_return_if_fail (dest_dir != NULL);
g_return_if_fail (g_path_is_absolute (dest_dir));
if (data->internal)
private = GIMP_DATA_GET_PRIVATE (data);
if (private->internal)
return;
safename = g_filename_from_utf8 (gimp_object_get_name (data),
@ -761,9 +824,62 @@ gimp_data_get_filename (GimpData *data)
const gchar *
gimp_data_get_mime_type (GimpData *data)
{
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), NULL);
return g_quark_to_string (data->mime_type);
private = GIMP_DATA_GET_PRIVATE (data);
return g_quark_to_string (private->mime_type);
}
gboolean
gimp_data_is_writable (GimpData *data)
{
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
private = GIMP_DATA_GET_PRIVATE (data);
return private->writable;
}
gboolean
gimp_data_is_deletable (GimpData *data)
{
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
private = GIMP_DATA_GET_PRIVATE (data);
return private->deletable;
}
void
gimp_data_set_mtime (GimpData *data,
time_t mtime)
{
GimpDataPrivate *private;
g_return_if_fail (GIMP_IS_DATA (data));
private = GIMP_DATA_GET_PRIVATE (data);
private->mtime = mtime;
}
time_t
gimp_data_get_mtime (GimpData *data)
{
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), 0);
private = GIMP_DATA_GET_PRIVATE (data);
return private->mtime;
}
/**
@ -800,8 +916,8 @@ gimp_data_duplicate (GimpData *data)
* that identifies the internal object across sessions.
**/
void
gimp_data_make_internal (GimpData *data,
const gchar *identifier)
gimp_data_make_internal (GimpData *data,
const gchar *identifier)
{
GimpDataPrivate *private;
@ -815,11 +931,22 @@ gimp_data_make_internal (GimpData *data,
private->filename = NULL;
}
data->identifier = g_strdup (identifier);
private->identifier = g_strdup (identifier);
private->writable = FALSE;
private->deletable = FALSE;
private->internal = TRUE;
}
data->internal = TRUE;
data->writable = FALSE;
data->deletable = FALSE;
gboolean
gimp_data_is_internal (GimpData *data)
{
GimpDataPrivate *private;
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
private = GIMP_DATA_GET_PRIVATE (data);
return private->internal;
}
/**
@ -840,13 +967,16 @@ gint
gimp_data_compare (GimpData *data1,
GimpData *data2)
{
/* move the internal objects (like the FG -> BG) gradient) to the top */
if (data1->internal != data2->internal)
return data1->internal ? -1 : 1;
GimpDataPrivate *private1 = GIMP_DATA_GET_PRIVATE (data1);
GimpDataPrivate *private2 = GIMP_DATA_GET_PRIVATE (data2);
/* keep user-writable objects about system resource files */
if (data1->writable != data2->writable)
return data1->writable ? -1 : 1;
/* move the internal objects (like the FG -> BG) gradient) to the top */
if (private1->internal != private2->internal)
return private1->internal ? -1 : 1;
/* keep user-writable objects above system resource files */
if (private1->writable != private2->writable)
return private1->writable ? -1 : 1;
return gimp_object_name_collate ((GimpObject *) data1,
(GimpObject *) data2);

27
app/core/gimpdata.h
View File

@ -48,21 +48,6 @@ typedef struct _GimpDataClass GimpDataClass;
struct _GimpData
{
GimpViewable parent_instance;
GQuark mime_type;
guint writable : 1;
guint deletable : 1;
guint dirty : 1;
guint internal : 1;
gint freeze_count;
time_t mtime;
/* Identifies the GimpData object across sessions. Used when there
* is not a filename associated with the object.
*/
gchar *identifier;
GList *tags;
};
struct _GimpDataClass
@ -86,8 +71,12 @@ gboolean gimp_data_save (GimpData *data,
GError **error);
void gimp_data_dirty (GimpData *data);
void gimp_data_clean (GimpData *data);
gboolean gimp_data_is_dirty (GimpData *data);
void gimp_data_freeze (GimpData *data);
void gimp_data_thaw (GimpData *data);
gboolean gimp_data_is_frozen (GimpData *data);
gboolean gimp_data_delete_from_disk (GimpData *data,
GError **error);
@ -104,10 +93,18 @@ const gchar * gimp_data_get_filename (GimpData *data);
const gchar * gimp_data_get_mime_type (GimpData *data);
gboolean gimp_data_is_writable (GimpData *data);
gboolean gimp_data_is_deletable (GimpData *data);
void gimp_data_set_mtime (GimpData *data,
time_t mtime);
time_t gimp_data_get_mtime (GimpData *data);
GimpData * gimp_data_duplicate (GimpData *data);
void gimp_data_make_internal (GimpData *data,
const gchar *identifier);
gboolean gimp_data_is_internal (GimpData *data);
gint gimp_data_compare (GimpData *data1,
GimpData *data2);

17
app/core/gimpdatafactory.c
View File

@ -287,7 +287,7 @@ gimp_data_factory_data_foreach (GimpDataFactory *factory,
if (skip_internal)
{
while (list && GIMP_DATA (list->data)->internal)
while (list && gimp_data_is_internal (GIMP_DATA (list->data)))
list = g_list_next (list);
}
@ -431,7 +431,8 @@ gimp_data_factory_data_save (GimpDataFactory *factory)
if (! gimp_data_get_filename (data))
gimp_data_create_filename (data, writable_dir);
if (data->dirty && data->writable)
if (gimp_data_is_dirty (data) &&
gimp_data_is_writable (data))
{
GError *error = NULL;
@ -592,7 +593,7 @@ gimp_data_factory_data_save_single (GimpDataFactory *factory,
g_return_val_if_fail (GIMP_IS_DATA (data), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! data->dirty)
if (! gimp_data_is_dirty (data))
return TRUE;
if (! gimp_data_get_filename (data))
@ -617,7 +618,7 @@ gimp_data_factory_data_save_single (GimpDataFactory *factory,
g_free (writable_dir);
}
if (! data->writable)
if (! gimp_data_is_writable (data))
return FALSE;
if (! gimp_data_save (data, error))
@ -810,7 +811,8 @@ gimp_data_factory_load_data (const GimpDatafileData *file_data,
{
GimpData *data = cached_data->data;
load_from_disk = (data->mtime == 0 || data->mtime != file_data->mtime);
load_from_disk = (gimp_data_get_mtime (data) == 0 ||
gimp_data_get_mtime (data) != file_data->mtime);
if (! load_from_disk)
{
@ -850,8 +852,9 @@ gimp_data_factory_load_data (const GimpDatafileData *file_data,
gimp_data_set_filename (data, file_data->filename,
writable, deletable);
data->mtime = file_data->mtime;
data->dirty = FALSE;
gimp_data_set_mtime (data, file_data->mtime);
gimp_data_clean (data);
if (strstr (file_data->dirname, GIMP_OBSOLETE_DATA_DIR_NAME))
gimp_container_add (factory->priv->container_obsolete,

5
app/core/gimpdynamics.c
View File

@ -347,9 +347,8 @@ gimp_dynamics_get_standard (void)
{
standard_dynamics = gimp_dynamics_new ("Standard dynamics");
standard_dynamics->dirty = FALSE;
gimp_data_make_internal (standard_dynamics,
"gimp-dynamics-standard");
gimp_data_clean (standard_dynamics);
gimp_data_make_internal (standard_dynamics, "gimp-dynamics-standard");
g_object_ref (standard_dynamics);
}

5
app/core/gimpgradient.c
View File

@ -328,9 +328,8 @@ gimp_gradient_get_standard (void)
{
standard_gradient = gimp_gradient_new ("Standard");
standard_gradient->dirty = FALSE;
gimp_data_make_internal (standard_gradient,
"gimp-gradient-standard");
gimp_data_clean (standard_gradient);
gimp_data_make_internal (standard_gradient, "gimp-gradient-standard");
g_object_ref (standard_gradient);
}

5
app/core/gimppalette.c
View File

@ -291,9 +291,8 @@ gimp_palette_get_standard (void)
{
standard_palette = gimp_palette_new ("Standard");
standard_palette->dirty = FALSE;
gimp_data_make_internal (standard_palette,
"gimp-palette-standard");
gimp_data_clean (standard_palette);
gimp_data_make_internal (standard_palette, "gimp-palette-standard");
g_object_ref (standard_palette);
}

6
app/core/gimppattern.c
View File

@ -244,11 +244,9 @@ gimp_pattern_get_standard (void)
{
standard_pattern = gimp_pattern_new ("Standard");
standard_pattern->dirty = FALSE;
gimp_data_make_internal (standard_pattern,
"gimp-pattern-standard");
gimp_data_clean (standard_pattern);
gimp_data_make_internal (standard_pattern, "gimp-pattern-standard");
/* set ref_count to 2 --> never swap the standard pattern */
g_object_ref (standard_pattern);
}

4
app/pdb/brush-cmds.c
View File

@ -206,7 +206,7 @@ brush_delete_invoker (GimpProcedure *procedure,
{
GimpBrush *brush = gimp_pdb_get_brush (gimp, name, FALSE, error);
if (brush && GIMP_DATA (brush)->deletable)
if (brush && gimp_data_is_deletable (GIMP_DATA (brush)))
success = gimp_data_factory_data_delete (gimp->brush_factory,
GIMP_DATA (brush),
TRUE, error);
@ -238,7 +238,7 @@ brush_is_editable_invoker (GimpProcedure *procedure,
GimpBrush *brush = gimp_pdb_get_brush (gimp, name, FALSE, error);
if (brush)
editable = GIMP_DATA (brush)->writable;
editable = gimp_data_is_writable (GIMP_DATA (brush));
else
success = FALSE;
}

6
app/pdb/gimppdb-utils.c
View File

@ -81,7 +81,7 @@ gimp_pdb_get_brush (Gimp *gimp,
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Brush '%s' not found"), name);
}
else if (writable && ! GIMP_DATA (brush)->writable)
else if (writable && ! gimp_data_is_writable (GIMP_DATA (brush)))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Brush '%s' is not editable"), name);
@ -170,7 +170,7 @@ gimp_pdb_get_gradient (Gimp *gimp,
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Gradient '%s' not found"), name);
}
else if (writable && ! GIMP_DATA (gradient)->writable)
else if (writable && ! gimp_data_is_writable (GIMP_DATA (gradient)))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Gradient '%s' is not editable"), name);
@ -205,7 +205,7 @@ gimp_pdb_get_palette (Gimp *gimp,
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Palette '%s' not found"), name);
}
else if (writable && ! GIMP_DATA (palette)->writable)
else if (writable && ! gimp_data_is_writable (GIMP_DATA (palette)))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Palette '%s' is not editable"), name);

6
app/pdb/gradient-cmds.c
View File

@ -185,7 +185,7 @@ gradient_is_editable_invoker (GimpProcedure *procedure,
GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, FALSE, error);
if (gradient)
editable = GIMP_DATA (gradient)->writable;
editable = gimp_data_is_writable (GIMP_DATA (gradient));
else
success = FALSE;
}
@ -255,7 +255,7 @@ gradient_delete_invoker (GimpProcedure *procedure,
{
GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, FALSE, error);
if (gradient && GIMP_DATA (gradient)->deletable)
if (gradient && gimp_data_is_deletable (GIMP_DATA (gradient)))
success = gimp_data_factory_data_delete (gimp->gradient_factory,
GIMP_DATA (gradient),
TRUE, error);
@ -1098,7 +1098,7 @@ gradient_segment_range_replicate_invoker (GimpProcedure *procedure,
gradient = gradient_get_range (gimp, name, start_segment, end_segment,
&start_seg, &end_seg, error);
if (start_seg && GIMP_DATA (gradient)->writable)
if (start_seg && gimp_data_is_writable (GIMP_DATA (gradient)))
{
gimp_gradient_segment_range_replicate (gradient,
start_seg, end_seg,

4
app/pdb/palette-cmds.c
View File

@ -172,7 +172,7 @@ palette_delete_invoker (GimpProcedure *procedure,
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);
if (palette && GIMP_DATA (palette)->deletable)
if (palette && gimp_data_is_deletable (GIMP_DATA (palette)))
success = gimp_data_factory_data_delete (gimp->palette_factory,
GIMP_DATA (palette),
TRUE, error);
@ -204,7 +204,7 @@ palette_is_editable_invoker (GimpProcedure *procedure,
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);
if (palette)
editable = GIMP_DATA (palette)->writable;
editable = gimp_data_is_writable (GIMP_DATA (palette));
else
success = FALSE;
}

9
app/widgets/gimpdataeditor.c
View File

@ -476,7 +476,7 @@ gimp_data_editor_real_set_data (GimpDataEditor *editor,
gtk_entry_set_text (GTK_ENTRY (editor->name_entry), "");
}
editable = (editor->data && editor->data->writable);
editable = (editor->data && gimp_data_is_writable (editor->data));
if (editor->data_editable != editable)
{
@ -637,14 +637,17 @@ gimp_data_editor_save_dirty (GimpDataEditor *editor)
{
GimpData *data = editor->data;
if (data && data->dirty && data->writable)
if (data &&
gimp_data_is_dirty (data) &&
gimp_data_is_writable (data))
{
GError *error = NULL;
if (! gimp_data_factory_data_save_single (editor->data_factory, data,
&error))
{
gimp_message_literal (gimp_data_factory_get_gimp (editor->data_factory), G_OBJECT (editor),
gimp_message_literal (gimp_data_factory_get_gimp (editor->data_factory),
G_OBJECT (editor),
GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);

2
app/widgets/gimpdatafactoryview.c
View File

@ -402,7 +402,7 @@ gimp_data_factory_view_tree_name_edited (GtkCellRendererText *cell,
name = g_strstrip (g_strdup (new_name));
if (data->writable && strlen (name))
if (gimp_data_is_writable (data) && strlen (name))
{
gimp_object_take_name (GIMP_OBJECT (data), name);
}

4
tools/pdbgen/pdb/brush.pdb
View File

@ -137,7 +137,7 @@ sub brush_is_editable {
GimpBrush *brush = gimp_pdb_get_brush (gimp, name, FALSE, error);
if (brush)
editable = GIMP_DATA (brush)->writable;
editable = gimp_data_is_writable (GIMP_DATA (brush));
else
success = FALSE;
}
@ -196,7 +196,7 @@ sub brush_delete {
{
GimpBrush *brush = gimp_pdb_get_brush (gimp, name, FALSE, error);
if (brush && GIMP_DATA (brush)->deletable)
if (brush && gimp_data_is_deletable (GIMP_DATA (brush)))
success = gimp_data_factory_data_delete (gimp->brush_factory,
GIMP_DATA (brush),
TRUE, error);

6
tools/pdbgen/pdb/gradient.pdb
View File

@ -105,7 +105,7 @@ sub gradient_is_editable {
GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, FALSE, error);
if (gradient)
editable = GIMP_DATA (gradient)->writable;
editable = gimp_data_is_writable (GIMP_DATA (gradient));
else
success = FALSE;
}
@ -164,7 +164,7 @@ sub gradient_delete {
{
GimpGradient *gradient = gimp_pdb_get_gradient (gimp, name, FALSE, error);
if (gradient && GIMP_DATA (gradient)->deletable)
if (gradient && gimp_data_is_deletable (GIMP_DATA (gradient)))
success = gimp_data_factory_data_delete (gimp->gradient_factory,
GIMP_DATA (gradient),
TRUE, error);
@ -1035,7 +1035,7 @@ HELP
gradient = gradient_get_range (gimp, name, start_segment, end_segment,
&start_seg, &end_seg, error);
if (start_seg && GIMP_DATA (gradient)->writable)
if (start_seg && gimp_data_is_writable (GIMP_DATA (gradient)))
{
gimp_gradient_segment_range_replicate (gradient,
start_seg, end_seg,

4
tools/pdbgen/pdb/palette.pdb
View File

@ -68,7 +68,7 @@ sub palette_is_editable {
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);
if (palette)
editable = GIMP_DATA (palette)->writable;
editable = gimp_data_is_writable (GIMP_DATA (palette));
else
success = FALSE;
}
@ -166,7 +166,7 @@ sub palette_delete {
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);
if (palette && GIMP_DATA (palette)->deletable)
if (palette && gimp_data_is_deletable (GIMP_DATA (palette)))
success = gimp_data_factory_data_delete (gimp->palette_factory,
GIMP_DATA (palette),
TRUE, error);