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

register GIMP_TYPE_DASH_PATTERN as boxed type. Added "new" to function 

2007-01-12  Michael Natterer  <mitch@gimp.org>

	* app/core/gimpdashpattern.[ch]: register GIMP_TYPE_DASH_PATTERN
	as boxed type. Added "new" to function names which create dash
	patterns. Changed and renamed GValue functions to functions which
	convert the dash pattern between GArray and GValueArray.

	* app/core/gimpstrokeoptions.c
	* app/widgets/gimpcellrendererdashes.c
	* app/widgets/gimpstrokeeditor.c: changed accordingly.

	* app/widgets/gimpdasheditor.c: ditto. Get rid of the recently
	added manual memory management. The list store manages boxed types
	all by itself.


svn path=/trunk/; revision=21698
This commit is contained in:
Michael Natterer 2007-01-12 20:27:40 +00:00 committed by Michael Natterer
parent 517b0c35ab
commit 09f47a0aec
7 changed files with 129 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
ChangeLog
View File

@ -1,3 +1,18 @@
2007-01-12 Michael Natterer <mitch@gimp.org>
* app/core/gimpdashpattern.[ch]: register GIMP_TYPE_DASH_PATTERN
as boxed type. Added "new" to function names which create dash
patterns. Changed and renamed GValue functions to functions which
convert the dash pattern between GArray and GValueArray.
* app/core/gimpstrokeoptions.c
* app/widgets/gimpcellrendererdashes.c
* app/widgets/gimpstrokeeditor.c: changed accordingly.
* app/widgets/gimpdasheditor.c: ditto. Get rid of the recently
added manual memory management. The list store manages boxed types
all by itself.
2007-01-12 Sven Neumann <sven@gimp.org> 2007-01-12 Sven Neumann <sven@gimp.org>
* tools/pdbgen/pdb/display.pdb * tools/pdbgen/pdb/display.pdb

66
app/core/gimpdashpattern.c
View File

@ -29,8 +29,21 @@
#include "gimpdashpattern.h" #include "gimpdashpattern.h"
GType
gimp_dash_pattern_get_type (void)
{
static GType type = 0;
if (! type)
type = g_boxed_type_register_static ("GimpDashPattern",
(GBoxedCopyFunc) gimp_dash_pattern_copy,
(GBoxedFreeFunc) gimp_dash_pattern_free);
return type;
}
GArray * GArray *
gimp_dash_pattern_from_preset (GimpDashPreset preset) gimp_dash_pattern_new_from_preset (GimpDashPreset preset)
{ {
GArray *pattern; GArray *pattern;
gdouble dash; gdouble dash;
@ -110,7 +123,7 @@ gimp_dash_pattern_from_preset (GimpDashPreset preset)
if (pattern->len < 2) if (pattern->len < 2)
{ {
g_array_free (pattern, TRUE); gimp_dash_pattern_free (pattern);
return NULL; return NULL;
} }
@ -118,9 +131,9 @@ gimp_dash_pattern_from_preset (GimpDashPreset preset)
} }
GArray * GArray *
gimp_dash_pattern_from_segments (const gboolean *segments, gimp_dash_pattern_new_from_segments (const gboolean *segments,
gint n_segments, gint n_segments,
gdouble dash_length) gdouble dash_length)
{ {
GArray *pattern; GArray *pattern;
gint i; gint i;
@ -150,7 +163,7 @@ gimp_dash_pattern_from_segments (const gboolean *segments,
if (pattern->len < 2) if (pattern->len < 2)
{ {
g_array_free (pattern, TRUE); gimp_dash_pattern_free (pattern);
return NULL; return NULL;
} }
@ -158,9 +171,9 @@ gimp_dash_pattern_from_segments (const gboolean *segments,
} }
void void
gimp_dash_pattern_segments_set (GArray *pattern, gimp_dash_pattern_fill_segments (GArray *pattern,
gboolean *segments, gboolean *segments,
gint n_segments) gint n_segments)
{ {
gdouble factor; gdouble factor;
gdouble sum; gdouble sum;
@ -201,16 +214,10 @@ gimp_dash_pattern_segments_set (GArray *pattern,
} }
} }
GArray * GArray *
gimp_dash_pattern_from_value (const GValue *value) gimp_dash_pattern_from_value_array (GValueArray *value_array)
{ {
GValueArray *val_array; if (value_array == NULL || value_array->n_values == 0)
g_return_val_if_fail (G_VALUE_HOLDS_BOXED (value), NULL);
val_array = g_value_get_boxed (value);
if (val_array == NULL || val_array->n_values == 0)
{ {
return NULL; return NULL;
} }
@ -220,11 +227,11 @@ gimp_dash_pattern_from_value (const GValue *value)
gint i; gint i;
pattern = g_array_sized_new (FALSE, FALSE, pattern = g_array_sized_new (FALSE, FALSE,
sizeof (gdouble), val_array->n_values); sizeof (gdouble), value_array->n_values);
for (i = 0; i < val_array->n_values; i++) for (i = 0; i < value_array->n_values; i++)
{ {
GValue *item = g_value_array_get_nth (val_array, i); GValue *item = g_value_array_get_nth (value_array, i);
gdouble val; gdouble val;
g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (item), NULL); g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (item), NULL);
@ -238,20 +245,17 @@ gimp_dash_pattern_from_value (const GValue *value)
} }
} }
void GValueArray *
gimp_dash_pattern_value_set (GArray *pattern, gimp_dash_pattern_to_value_array (GArray *pattern)
GValue *value)
{ {
g_return_if_fail (G_VALUE_HOLDS_BOXED (value));
if (pattern == NULL || pattern->len == 0) if (pattern == NULL || pattern->len == 0)
{ {
g_value_set_boxed (value, NULL); return NULL;
} }
else else
{ {
GValueArray *val_array = g_value_array_new (pattern->len); GValueArray *value_array = g_value_array_new (pattern->len);
GValue item = { 0, }; GValue item = { 0, };
gint i; gint i;
g_value_init (&item, G_TYPE_DOUBLE); g_value_init (&item, G_TYPE_DOUBLE);
@ -259,10 +263,12 @@ gimp_dash_pattern_value_set (GArray *pattern,
for (i = 0; i < pattern->len; i++) for (i = 0; i < pattern->len; i++)
{ {
g_value_set_double (&item, g_array_index (pattern, gdouble, i)); g_value_set_double (&item, g_array_index (pattern, gdouble, i));
g_value_array_append (val_array, &item); g_value_array_append (value_array, &item);
} }
g_value_set_boxed (value, val_array); g_value_unset (&item);
return value_array;
} }
} }

29
app/core/gimpdashpattern.h
View File

@ -24,21 +24,26 @@
#define __GIMP_DASH_PATTERN_H__ #define __GIMP_DASH_PATTERN_H__
GArray * gimp_dash_pattern_from_preset (GimpDashPreset preset); #define GIMP_TYPE_DASH_PATTERN (gimp_dash_pattern_get_type ())
#define GIMP_VALUE_HOLDS_DASH_PATTERN(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_DASH_PATTERN))
GArray * gimp_dash_pattern_from_segments (const gboolean *segments,
gint n_segments,
gdouble dash_length);
void gimp_dash_pattern_segments_set (GArray *pattern,
gboolean *segments,
gint n_segments);
GArray * gimp_dash_pattern_from_value (const GValue *value); GType gimp_dash_pattern_get_type (void) G_GNUC_CONST;
void gimp_dash_pattern_value_set (GArray *pattern,
GValue *value);
GArray * gimp_dash_pattern_copy (GArray *pattern); GArray * gimp_dash_pattern_new_from_preset (GimpDashPreset preset);
void gimp_dash_pattern_free (GArray *pattern); GArray * gimp_dash_pattern_new_from_segments (const gboolean *segments,
gint n_segments,
gdouble dash_length);
void gimp_dash_pattern_fill_segments (GArray *pattern,
gboolean *segments,
gint n_segments);
GArray * gimp_dash_pattern_from_value_array (GValueArray *value_array);
GValueArray * gimp_dash_pattern_to_value_array (GArray *pattern);
GArray * gimp_dash_pattern_copy (GArray *pattern);
void gimp_dash_pattern_free (GArray *pattern);
#endif /* __GIMP_DASH_PATTERN_H__ */ #endif /* __GIMP_DASH_PATTERN_H__ */

25
app/core/gimpstrokeoptions.c
View File

@ -181,9 +181,14 @@ gimp_stroke_options_set_property (GObject *object,
options->dash_offset = g_value_get_double (value); options->dash_offset = g_value_get_double (value);
break; break;
case PROP_DASH_INFO: case PROP_DASH_INFO:
gimp_stroke_options_set_dash_pattern (options, {
GIMP_DASH_CUSTOM, GValueArray *value_array = g_value_get_boxed (value);
gimp_dash_pattern_from_value (value)); GArray *pattern;
pattern = gimp_dash_pattern_from_value_array (value_array);
gimp_stroke_options_set_dash_pattern (options, GIMP_DASH_CUSTOM,
pattern);
}
break; break;
default: default:
@ -227,7 +232,12 @@ gimp_stroke_options_get_property (GObject *object,
g_value_set_double (value, options->dash_offset); g_value_set_double (value, options->dash_offset);
break; break;
case PROP_DASH_INFO: case PROP_DASH_INFO:
gimp_dash_pattern_value_set (options->dash_info, value); {
GValueArray *value_array;
value_array = gimp_dash_pattern_to_value_array (options->dash_info);
g_value_take_boxed (value, value_array);
}
break; break;
default: default:
@ -256,16 +266,15 @@ gimp_stroke_options_set_dash_pattern (GimpStrokeOptions *options,
g_return_if_fail (preset == GIMP_DASH_CUSTOM || pattern == NULL); g_return_if_fail (preset == GIMP_DASH_CUSTOM || pattern == NULL);
if (preset != GIMP_DASH_CUSTOM) if (preset != GIMP_DASH_CUSTOM)
pattern = gimp_dash_pattern_from_preset (preset); pattern = gimp_dash_pattern_new_from_preset (preset);
if (options->dash_info) if (options->dash_info)
g_array_free (options->dash_info, TRUE); gimp_dash_pattern_free (options->dash_info);
options->dash_info = pattern; options->dash_info = pattern;
g_object_notify (G_OBJECT (options), "dash-info"); g_object_notify (G_OBJECT (options), "dash-info");
g_signal_emit (options, g_signal_emit (options, stroke_options_signals [DASH_INFO_CHANGED], 0,
stroke_options_signals [DASH_INFO_CHANGED], 0,
preset); preset);
} }

9
app/widgets/gimpcellrendererdashes.c
View File

@ -89,8 +89,9 @@ gimp_cell_renderer_dashes_class_init (GimpCellRendererDashesClass *klass)
cell_class->render = gimp_cell_renderer_dashes_render; cell_class->render = gimp_cell_renderer_dashes_render;
g_object_class_install_property (object_class, PROP_PATTERN, g_object_class_install_property (object_class, PROP_PATTERN,
g_param_spec_pointer ("pattern", NULL, NULL, g_param_spec_boxed ("pattern", NULL, NULL,
GIMP_PARAM_WRITABLE)); GIMP_TYPE_DASH_PATTERN,
GIMP_PARAM_WRITABLE));
} }
static void static void
@ -129,8 +130,8 @@ gimp_cell_renderer_dashes_set_property (GObject *object,
switch (param_id) switch (param_id)
{ {
case PROP_PATTERN: case PROP_PATTERN:
gimp_dash_pattern_segments_set (g_value_get_pointer (value), gimp_dash_pattern_fill_segments (g_value_get_boxed (value),
dashes->segments, N_SEGMENTS); dashes->segments, N_SEGMENTS);
break; break;
default: default:

10
app/widgets/gimpdasheditor.c
View File

@ -448,16 +448,16 @@ update_segments_from_options (GimpDashEditor *editor)
gtk_widget_queue_draw (GTK_WIDGET (editor)); gtk_widget_queue_draw (GTK_WIDGET (editor));
gimp_dash_pattern_segments_set (editor->stroke_options->dash_info, gimp_dash_pattern_fill_segments (editor->stroke_options->dash_info,
editor->segments, editor->n_segments); editor->segments, editor->n_segments);
} }
static void static void
update_options_from_segments (GimpDashEditor *editor) update_options_from_segments (GimpDashEditor *editor)
{ {
GArray *pattern = gimp_dash_pattern_from_segments (editor->segments, GArray *pattern = gimp_dash_pattern_new_from_segments (editor->segments,
editor->n_segments, editor->n_segments,
editor->dash_length); editor->dash_length);
gimp_stroke_options_set_dash_pattern (editor->stroke_options, gimp_stroke_options_set_dash_pattern (editor->stroke_options,
GIMP_DASH_CUSTOM, pattern); GIMP_DASH_CUSTOM, pattern);

78
app/widgets/gimpstrokeeditor.c
View File

@ -63,7 +63,6 @@ static void gimp_stroke_editor_dash_preset (GtkWidget *widget,
static void gimp_stroke_editor_combo_fill (GimpStrokeOptions *options, static void gimp_stroke_editor_combo_fill (GimpStrokeOptions *options,
GtkComboBox *box); GtkComboBox *box);
static void gimp_stroke_editor_combo_void (GtkComboBox *box);
G_DEFINE_TYPE (GimpStrokeEditor, gimp_stroke_editor, GTK_TYPE_VBOX) G_DEFINE_TYPE (GimpStrokeEditor, gimp_stroke_editor, GTK_TYPE_VBOX)
@ -86,6 +85,7 @@ gimp_stroke_editor_class_init (GimpStrokeEditorClass *klass)
GIMP_TYPE_STROKE_OPTIONS, GIMP_TYPE_STROKE_OPTIONS,
GIMP_PARAM_READWRITE | GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY)); G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (object_class, PROP_RESOLUTION, g_object_class_install_property (object_class, PROP_RESOLUTION,
g_param_spec_double ("resolution", NULL, NULL, g_param_spec_double ("resolution", NULL, NULL,
GIMP_MIN_RESOLUTION, GIMP_MIN_RESOLUTION,
@ -113,7 +113,7 @@ gimp_stroke_editor_set_property (GObject *object,
case PROP_OPTIONS: case PROP_OPTIONS:
if (editor->options) if (editor->options)
g_object_unref (editor->options); g_object_unref (editor->options);
editor->options = GIMP_STROKE_OPTIONS (g_value_dup_object (value)); editor->options = g_value_dup_object (value);
break; break;
case PROP_RESOLUTION: case PROP_RESOLUTION:
editor->resolution = g_value_get_double (value); editor->resolution = g_value_get_double (value);
@ -154,6 +154,8 @@ gimp_stroke_editor_constructor (GType type,
GObjectConstructParam *params) GObjectConstructParam *params)
{ {
GimpStrokeEditor *editor; GimpStrokeEditor *editor;
GimpEnumStore *store;
GEnumValue *value;
GtkWidget *box; GtkWidget *box;
GtkWidget *size; GtkWidget *size;
GtkWidget *label; GtkWidget *label;
@ -270,7 +272,28 @@ gimp_stroke_editor_constructor (GType type,
NULL); NULL);
box = gimp_enum_combo_box_new (GIMP_TYPE_DASH_PRESET); store = g_object_new (GIMP_TYPE_ENUM_STORE,
"enum-type", GIMP_TYPE_DASH_PRESET,
"user-data-type", GIMP_TYPE_DASH_PATTERN,
NULL);
for (value = store->enum_class->values; value->value_name; value++)
{
GtkTreeIter iter;
const gchar *desc;
desc = gimp_enum_value_get_desc (store->enum_class, value);
gtk_list_store_append (GTK_LIST_STORE (store), &iter);
gtk_list_store_set (GTK_LIST_STORE (store), &iter,
GIMP_INT_STORE_VALUE, value->value,
GIMP_INT_STORE_LABEL, desc,
-1);
}
box = gimp_enum_combo_box_new_with_model (store);
g_object_unref (store);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (box), GIMP_DASH_CUSTOM); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (box), GIMP_DASH_CUSTOM);
gimp_table_attach_aligned (GTK_TABLE (table), 0, row++, gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
_("Dash _preset:"), 0.0, 0.5, _("Dash _preset:"), 0.0, 0.5,
@ -285,9 +308,6 @@ gimp_stroke_editor_constructor (GType type,
gimp_stroke_editor_combo_fill (editor->options, GTK_COMBO_BOX (box)); gimp_stroke_editor_combo_fill (editor->options, GTK_COMBO_BOX (box));
g_signal_connect (box, "destroy",
G_CALLBACK (gimp_stroke_editor_combo_void),
NULL);
g_signal_connect (box, "changed", g_signal_connect (box, "changed",
G_CALLBACK (gimp_stroke_editor_dash_preset), G_CALLBACK (gimp_stroke_editor_dash_preset),
editor->options); editor->options);
@ -368,20 +388,12 @@ gimp_stroke_editor_combo_update (GtkTreeModel *model,
GParamSpec *pspec, GParamSpec *pspec,
GimpStrokeOptions *options) GimpStrokeOptions *options)
{ {
GtkTreeIter iter; GtkTreeIter iter;
if (gimp_int_store_lookup_by_value (model, GIMP_DASH_CUSTOM, &iter)) if (gimp_int_store_lookup_by_value (model, GIMP_DASH_CUSTOM, &iter))
{ {
GArray *pattern;
gtk_tree_model_get (model, &iter,
GIMP_INT_STORE_USER_DATA, &pattern,
-1);
gimp_dash_pattern_free (pattern);
pattern = gimp_dash_pattern_copy (options->dash_info);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, gtk_list_store_set (GTK_LIST_STORE (model), &iter,
GIMP_INT_STORE_USER_DATA, pattern, GIMP_INT_STORE_USER_DATA, options->dash_info,
-1); -1);
} }
} }
@ -398,8 +410,7 @@ gimp_stroke_editor_combo_fill (GimpStrokeOptions *options,
iter_valid; iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter)) iter_valid = gtk_tree_model_iter_next (model, &iter))
{ {
GArray *pattern; gint value;
gint value;
gtk_tree_model_get (model, &iter, gtk_tree_model_get (model, &iter,
GIMP_INT_STORE_VALUE, &value, GIMP_INT_STORE_VALUE, &value,
@ -407,7 +418,9 @@ gimp_stroke_editor_combo_fill (GimpStrokeOptions *options,
if (value == GIMP_DASH_CUSTOM) if (value == GIMP_DASH_CUSTOM)
{ {
pattern = gimp_dash_pattern_copy (options->dash_info); gtk_list_store_set (GTK_LIST_STORE (model), &iter,
GIMP_INT_STORE_USER_DATA, options->dash_info,
-1);
g_signal_connect_object (options, "notify::dash-info", g_signal_connect_object (options, "notify::dash-info",
G_CALLBACK (gimp_stroke_editor_combo_update), G_CALLBACK (gimp_stroke_editor_combo_update),
@ -415,35 +428,12 @@ gimp_stroke_editor_combo_fill (GimpStrokeOptions *options,
} }
else else
{ {
pattern = gimp_dash_pattern_from_preset (value); GArray *pattern = gimp_dash_pattern_new_from_preset (value);
}
if (pattern)
{
gtk_list_store_set (GTK_LIST_STORE (model), &iter, gtk_list_store_set (GTK_LIST_STORE (model), &iter,
GIMP_INT_STORE_USER_DATA, pattern, GIMP_INT_STORE_USER_DATA, pattern,
-1); -1);
gimp_dash_pattern_free (pattern);
} }
} }
} }
static void
gimp_stroke_editor_combo_void (GtkComboBox *box)
{
GtkTreeModel *model = gtk_combo_box_get_model (box);
GtkTreeIter iter;
gboolean iter_valid;
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter))
{
GArray *pattern;
gtk_tree_model_get (model, &iter,
GIMP_INT_STORE_USER_DATA, &pattern,
-1);
gimp_dash_pattern_free (pattern);
}
}